protected static TableRule getTableRule(TableFilter filter) throws NullPointerException { TableMate tableMate = getTableMate(filter); TableRule tableRule = tableMate.getTableRule(); return tableRule; }
private void setConsistencyTableNodes(ObjectNode[] selectNodes, List<TableFilter> filters) { this.consistencyTableNodes = New.hashMapNonRehash(selectNodes.length); for (ObjectNode target : selectNodes) { HashMap<TableFilter, ObjectNode> tableNodeMapping = New.hashMapNonRehash(filters.size()); for (TableFilter tf : filters) { TableMate table = getTableMate(tf); ObjectNode consistencyNode = getConsistencyNode(table.getTableRule(), target); tableNodeMapping.put(tf, consistencyNode); } consistencyTableNodes.put(target, tableNodeMapping); } }
private boolean isGropTableFilter(TableFilter filter) { TableMate table1 = (TableMate) filter.getTable(); for (TableFilter item : filters) { if (item == filter || isNestedJoinTable(item)) { continue; } TableMate table2 = (TableMate) item.getTable(); TableRule rule1 = table1.getTableRule(); TableRule rule2 = table2.getTableRule(); if (!rule1.isNodeComparable(rule2)) { return false; } } return true; }
protected Map<ObjectNode, List<Row>> batchForRoutingNode(TableMate table, List<Row> rows) { Map<ObjectNode, List<Row>> batches = New.hashMap(); for (Row row : rows) { RoutingResult result; if (table.getTableRule().getType() == TableRule.GLOBAL_NODE_TABLE) { GlobalTableRule rule = (GlobalTableRule) table.getTableRule(); result = rule.getBroadcastsRoutingResult(); } else { result = routingHandler.doRoute(table, row); } ObjectNode[] selectNodes = result.getSelectNodes(); for (ObjectNode objectNode : selectNodes) { List<Row> batch = batches.get(objectNode); if (batch == null) { batch = New.arrayList(10); batches.put(objectNode, batch); } batch.add(row); } } return batches; }
@Override public RoutingResult doRoute(TableMate table, SearchRow row) { TableRule tr = table.getTableRule(); switch (tr.getType()) { case TableRule.SHARDED_NODE_TABLE: try { return getRoutingResult(table, row); } catch (TableRoutingException e) { throw e; } catch (Exception e) { throw new TableRoutingException(table.getName() + " routing error.", e); } default: throw new TableRoutingException(table.getName() + " does not support routing"); } }
private RoutingResult getRoutingResult(TableMate table, SearchRow row) { ShardedTableRule tr = (ShardedTableRule) table.getTableRule(); Column[] ruleCols = table.getRuleColumns(); List<RoutingArgument> args = New.arrayList(ruleCols.length); for (Column ruleCol : ruleCols) { Value v = row.getValue(ruleCol.getColumnId()); v = ruleCol.convert(v); RoutingArgument arg = new RoutingArgument(ruleCol.getName(), v); args.add(arg); } RoutingResult rr; if (args.size() == 1) { RoutingArgument argument = args.get(0); rr = trc.calculate(tr, argument); } else { rr = trc.calculate(tr, args); } if (rr.isMultipleNode()) { throw new TableRoutingException(table.getName() + " routing error."); } return rr; }
protected static boolean isConsistencyNodeForReferential(TableMate table, TableMate refTable) { TableRule t1 = table.getTableRule(); TableRule t2 = refTable.getTableRule(); if (t1.getType() != t2.getType()) { return false;
@Override public RoutingResult doRoute(TableMate table) { TableRule tr = table.getTableRule(); switch (tr.getType()) { case TableRule.SHARDED_NODE_TABLE: return fixedRoutingResult(((ShardedTableRule) tr).getObjectNodes()); case TableRule.GLOBAL_NODE_TABLE: return ((GlobalTableRule) tr).getBroadcastsRoutingResult(); case TableRule.FIXED_NODE_TABLE: return fixedRoutingResult(tr.getMetadataNode()); default: throw new TableRoutingException(table.getName() + " does not support routing"); } }
for (TableFilter tf : filters) { TableMate table = getTableMate(tf); switch (table.getTableRule().getType()) { case TableRule.SHARDED_NODE_TABLE: shards.add(tf);
private RoutingResult doRoute(TableMate tableMate, ConditionExtractor extractor) { RoutingResult result; TableRule tableRule = tableMate.getTableRule(); switch (tableRule.getType()) { case TableRule.FIXED_NODE_TABLE: result = RoutingResult.fixedResult(tableRule.getMetadataNode()); break; case TableRule.GLOBAL_NODE_TABLE: GlobalTableRule gt = (GlobalTableRule) tableRule; result = gt.getRandomRoutingResult(); break; case TableRule.SHARDED_NODE_TABLE: result = routingHandler.doRoute(tableMate, extractor.getStart(), extractor.getStart(), extractor.getInColumns()); break; default: throw DbException.throwInternalError("table type:" + tableRule.getType()); } return result; }
@Override public RoutingResult doRoute(TableMate table, SearchRow first, SearchRow last, Map<Column, Set<Value>> inColumns) { TableRule tr = table.getTableRule(); if (tr instanceof ShardedTableRule) try {
ObjectNode refTableNode = null; if (refTable != null) { refTableNode = getConsistencyNode(refTable.getTableRule(), objectNode);
int type2 = ((TableMate) table).getTableRule().getType(); switch (type2) { case TableRule.FIXED_NODE_TABLE: TableRule tableRule = tableMate.getTableRule(); int type2 = tableRule.getType(); switch (type2) { break; case TableRule.GLOBAL_NODE_TABLE: GlobalTableRule globalRule = (GlobalTableRule) tableMate.getTableRule(); for (ObjectNode i : globalRule.getBroadcasts()) { add(rows, ShardedTableRule shardRule = (ShardedTableRule) tableMate.getTableRule(); for (ObjectNode i : shardRule.getObjectNodes()) { add(rows,
ObjectNode refTableNode = null; if (refTable != null) { refTableNode = getConsistencyNode(refTable.getTableRule(), objectNode);