private Table diffWorker(Table tableLeft, Table tableRight) { QueryIterator left = tableLeft.iterator(execCxt) ; TableN r = new TableN() ; for ( ; left.hasNext() ; ) { Binding b = left.nextBinding() ; if ( tableRight.contains(b) ) r.addBinding(b) ; } tableLeft.close() ; tableRight.close() ; return r ; }
private static void dump(Table table) { System.out.println("Table: "+Utils.className(table)) ; QueryIterator qIter = table.iterator(null) ; ResultSet rs = new ResultSetStream(table.getVarNames(), null, table.iterator(null)) ; ResultSetFormatter.out(rs) ; } }
@Override public void visit(OpTable opTable) { // Only the variables with values in the tables // (When building, undefs didn't get into bindings so no variable mentioned) Table t = opTable.getTable() ; acc.addAll(t.getVars()); }
public QueryIterJoinBase(QueryIterator left, Table right, ExprList exprs, ExecutionContext execCxt) { super(left, right.iterator(execCxt), execCxt) ; this.tableRight = right ; this.exprs = exprs ; }
private Table joinWorker(Table tableLeft, Table tableRight, boolean leftJoin, ExprList conditions) { // Conditional LeftJoin is (left, Filter(expr, Join(left, right))) // This is done in matchRightLeft // Have an iterator that yields one-by-one. QueryIterator left = tableLeft.iterator(execCxt) ; QueryIterConcat output = new QueryIterConcat(execCxt) ; for ( ; left.hasNext() ; ) { Binding b = left.nextBinding() ; QueryIterator x = tableRight.matchRightLeft(b, leftJoin, conditions, execCxt) ; if ( x == null ) continue ; output.add(x) ; } tableLeft.close() ; tableRight.close() ; return new TableN(output) ; }
@Override public Op transform(OpTable opTable) { if ( opTable.isJoinIdentity() ) return opTable ; Table table = opTable.getTable() ; if ( table.isEmpty() ) return opTable ; if ( TableUnit.isTableUnit(table) ) return opTable ; if ( table.getVars().size() == 0 ) return opTable ; Table table2 = NodeTransformLib.transform(table, transform) ; return OpTable.create(table2) ; }
@Override public boolean equals(Object other) { if ( this == other ) return true ; if ( ! ( other instanceof Table) ) return false ; Table table = (Table)other ; if ( table.size() != this.size() ) return false ; QueryIterator qIter1 = iterator(null) ; QueryIterator qIter2 = table.iterator(null) ; try { for ( ; qIter1.hasNext() ; ) { Binding bind1 = qIter1.nextBinding() ; Binding bind2 = qIter2.nextBinding() ; if ( ! BindingBase.equals(bind1, bind2) ) return false ; } return true ; } finally { qIter1.close() ; qIter2.close() ;} }
table.addBinding(b) ; lastBinding = b ; count++ ; if ( table.size() == 1 )
@Override protected void requestSubCancel() { tableRight.close() ; }
@Override public void visit(OpTable opTable) { // This will go in a group so simply forget it. if ( opTable.isJoinIdentity() ) return ; // Put in a VALUES // This may be related to the grpup of the overall query. ElementData el = new ElementData() ; el.getVars().addAll(opTable.getTable().getVars()) ; QueryIterator qIter = opTable.getTable().iterator(null) ; while(qIter.hasNext()) el.getRows().add(qIter.next()) ; qIter.close() ; currentGroup().addElement(el) ; }
public static Table transform(Table table, NodeTransform transform) { // Non-streaming rewrite List<Var> vars = transformVars(transform, table.getVars()) ; Iterator<Binding> iter = table.rows() ; List<Binding> newRows = new ArrayList<Binding>() ; for ( ; iter.hasNext() ; ) { Binding b = iter.next() ; Binding b2 = transform(b, transform) ; newRows.add(b2) ; } return new TableData(vars, newRows) ; }
protected QueryIterator leftJoinWorker() { if ( !getLeft().hasNext() ) return null ; Binding b = getLeft().nextBinding() ; QueryIterator x = tableRight.matchRightLeft(b, true, exprs, getExecContext()) ; return x ; }
private static Table buildTable(Map<Var, Set<NodeValue>> possibleValues) { if (possibleValues.size() == 0) return TableFactory.createEmpty(); Table table = TableFactory.create(); // Although each filter condition must apply for a row to be accepted // they are actually independent since only one condition needs to fail // for the filter to reject the row. Thus for each unique variable/value // combination a single row must be produced for (Var v : possibleValues.keySet()) { for (NodeValue value : possibleValues.get(v)) { BindingMap b = BindingFactory.create(); b.add(v, value.asNode()); table.addBinding(b); } } return table; } }
private boolean isTableEmpty(Op op) { if (op instanceof OpTable) { return ((OpTable) op).getTable().isEmpty(); } else { return false; } }
public QueryIterJoinBase(QueryIterator left, Table right, ExprList exprs, ExecutionContext execCxt) { super(left, right.iterator(execCxt), execCxt) ; this.tableRight = right ; this.exprs = exprs ; }
private Table joinWorker(Table tableLeft, Table tableRight, boolean leftJoin, ExprList conditions) { // Conditional LeftJoin is (left, Filter(expr, Join(left, right))) // This is done in matchRightLeft // Have an iterator that yields one-by-one. QueryIterator left = tableLeft.iterator(execCxt) ; QueryIterConcat output = new QueryIterConcat(execCxt) ; for ( ; left.hasNext() ; ) { Binding b = left.nextBinding() ; QueryIterator x = tableRight.matchRightLeft(b, leftJoin, conditions, execCxt) ; if ( x == null ) continue ; output.add(x) ; } tableLeft.close() ; tableRight.close() ; return new TableN(output) ; }
@Override public void visit(OpTable opTable) { if ( TableUnit.isTableUnit(opTable.getTable()) ) { start(opTable, NoNL) ; out.print("unit") ; finish(opTable) ; return ; } if ( opTable.getTable().isEmpty() ) { start(opTable, NoNL) ; out.print("empty") ; finish(opTable) ; return ; } start(opTable, NoNL) ; WriterNode.outputVars(out, opTable.getTable().getVars(), sContext) ; out.println() ; WriterTable.outputPlain(out, opTable.getTable(), sContext); finish(opTable) ; }
@Override public boolean equals(Object other) { if ( this == other ) return true ; if ( !(other instanceof Table) ) return false ; Table table = (Table)other ; if ( table.size() != this.size() ) return false ; QueryIterator qIter1 = iterator(null) ; QueryIterator qIter2 = table.iterator(null) ; try { for (; qIter1.hasNext();) { Binding bind1 = qIter1.nextBinding() ; Binding bind2 = qIter2.nextBinding() ; if ( !BindingBase.equals(bind1, bind2) ) return false ; } return true ; } finally { qIter1.close() ; qIter2.close() ; } }