public Fields getOutGroupingValueFields() { return getOutValuesFields().subtract( getOutGroupingFields() ); }
protected Fields resolveRemainderFields( Set<Scope> incomingScopes, Fields argumentFields ) { Fields fields = resolveIncomingOperationArgumentFields( getFirst( incomingScopes ) ); if( fields.isUnknown() ) return fields; return fields.subtract( argumentFields ); }
@Override public void prepare( FlowProcess flowProcess, OperationCall<Context> operationCall ) { operationCall.setContext( new Context( Tuple.size( 1 ), operationCall.getArgumentFields().subtract( Fields.FIRST ) ) ); }
throw new IllegalArgumentException( "columnFields must contain updateByFields column names" ); this.updateValueFields = columnFields.subtract( updateByFields ).append( updateByFields ); this.updateIfTuple = Tuple.size( updateByFields.size() ); // all nulls
private Map<String, Fields> resolveSelectorsAgainstIncoming( Set<Scope> incomingScopes, Map<String, Fields> selectors, String type ) { Map<String, Fields> resolvedFields = new HashMap<String, Fields>(); for( Scope incomingScope : incomingScopes ) { Fields selector = selectors.get( incomingScope.getName() ); if( selector == null ) throw new OperatorException( this, "no " + type + " selector found for: " + incomingScope.getName() ); Fields incomingFields; if( selector.isNone() ) incomingFields = Fields.NONE; else if( selector.isAll() ) incomingFields = incomingScope.getIncomingSpliceFields(); else if( selector.isGroup() ) incomingFields = incomingScope.getOutGroupingFields(); else if( selector.isValues() ) incomingFields = incomingScope.getOutValuesFields().subtract( incomingScope.getOutGroupingFields() ); else incomingFields = incomingScope.getIncomingSpliceFields().select( selector ); resolvedFields.put( incomingScope.getName(), incomingFields ); } return resolvedFields; }
@Test public void testDiff3() { Fields fieldA = new Fields( "a", "b" ); Fields fieldB = new Fields( 0, 4 ); try { Fields diff = fieldA.subtract( fieldB ); fail( "did not throw exception" ); } catch( Exception exception ) { // ignore } }
@Test public void testDiffSame() { Fields fieldA = new Fields( "a", "b" ); Fields fieldB = new Fields( "b", "a" ); Fields diff = fieldA.subtract( fieldB ); assertEquals( "not equal: ", 0, diff.size() ); }
@Test public void testDiff() { Fields fieldA = new Fields( "a", "b" ); Fields fieldB = new Fields( "a" ); Fields diff = fieldA.subtract( fieldB ); assertEquals( "not equal: ", 1, diff.size() ); assertEquals( "not equal: ", "b", diff.get( 0 ) ); }
@Test public void testDiffIndex() { Fields fieldA = new Fields( "a", "b" ); Fields fieldB = new Fields( 0 ); Fields diff = fieldA.subtract( fieldB ); assertEquals( "not equal: ", 1, diff.size() ); assertEquals( "not equal: ", "b", diff.get( 0 ) ); }
@Test public void testDiffIndex2() { Fields fieldA = new Fields( "a", "b" ); Fields fieldB = new Fields( 1 ); Fields diff = fieldA.subtract( fieldB ); assertEquals( "not equal: ", 1, diff.size() ); assertEquals( "not equal: ", "a", diff.get( 0 ) ); }
@Test public void testDiff2() { Fields fieldA = new Fields( "a", "b" ); Fields fieldB = Fields.NONE; Fields diff = fieldA.subtract( fieldB ); assertEquals( "not equal: ", 2, diff.size() ); assertEquals( "not equal: ", "a", diff.get( 0 ) ); assertEquals( "not equal: ", "b", diff.get( 1 ) ); }
@Test public void testTypedDiff() { Fields fieldA = new Fields( names( "a", "b" ), types( int.class, String.class ) ); Fields fieldB = new Fields( "a" ); Fields diff = fieldA.subtract( fieldB ); assertEquals( "not equal: ", 1, diff.size() ); assertEquals( "not equal: ", String.class, diff.getType( 0 ) ); }
Fields resolveOutgoingSelector( Set<Scope> incomingScopes, Fields argumentFields, Fields declaredFields ) { Scope incomingScope = getFirst( incomingScopes ); Fields outputSelector = getOutputSelector(); if( outputSelector.isResults() ) return declaredFields; if( outputSelector.isArguments() ) return argumentFields; if( outputSelector.isGroup() ) return incomingScope.getOutGroupingFields(); if( outputSelector.isValues() ) return incomingScope.getOutGroupingValueFields(); Fields incomingFields = resolveIncomingOperationPassThroughFields( incomingScope ); // not part of resolve as we need the argumentFields if( outputSelector.isSwap() ) return Fields.asDeclaration( incomingFields.subtract( argumentFields ) ).append( declaredFields ); try { return Fields.resolve( outputSelector, Fields.asDeclaration( incomingFields ), declaredFields ); } catch( TupleException exception ) { throw new OperatorException( this, incomingFields, declaredFields, outputSelector, exception ); } }
@Test public void testRemove() { Fields aFields = new Fields( "one" ); Tuple aTuple = tuple.remove( fields, aFields ); assertEquals( "not equal: aTuple.size()", 1, aTuple.size() ); assertEquals( "not equal: aTuple.get( 0 )", "a", aTuple.getObject( 0 ) ); fields = fields.subtract( aFields ); assertEquals( "not equal: tuple.size()", 4, tuple.size() ); assertEquals( "not equal: tuple.get( 0 )", "b", tuple.get( fields, new Fields( "two" ) ).getObject( 0 ) ); assertEquals( "not equal: tuple.get( 1 )", "c", tuple.get( fields, new Fields( "three" ) ).getObject( 0 ) ); }
@Test public void testSelectorSwap2() { Fields incomingFields = new Fields( "0", "1", 2, 3 ); Tuple incoming = new Tuple( 0, 1, 2, 3 ); Fields resultFields = new Fields( "0", "1" ); Tuple result = new Tuple( 0, 1 ); Fields remainderFields = incomingFields.subtract( resultFields ); Tuple remainderView = createNarrow( incomingFields.getPos( remainderFields ) ); Tuple outgoingTuple = createComposite( Fields.asDeclaration( remainderFields ), resultFields ); TupleViews.reset( remainderView, incoming ); TupleViews.reset( outgoingTuple, remainderView, result ); assertEquals( new Tuple( 2, 3, 0, 1 ), outgoingTuple ); assertEquals( new Tuple( 2, 3, 0, 1 ), new Tuple( outgoingTuple ) ); } }