/** * Returns the flat field descriptors for the given field expression. * * @param fieldExpression The field expression for which the flat field descriptors are computed. * @return The list of descriptors for the flat fields which are specified by the field expression. */ @PublicEvolving public List<FlatFieldDescriptor> getFlatFields(String fieldExpression) { List<FlatFieldDescriptor> result = new ArrayList<FlatFieldDescriptor>(); this.getFlatFields(fieldExpression, 0, result); return result; }
private static List<FlatFieldDescriptor> getFlatFields(String fieldStr, TypeInformation<?> typeInfo) { if (typeInfo instanceof CompositeType<?>) { return ((CompositeType<?>) typeInfo).getFlatFields(fieldStr); } else { Matcher wildcardMatcher = PATTERN_WILDCARD.matcher(fieldStr); if (wildcardMatcher.matches()) { return Collections.singletonList(new FlatFieldDescriptor(0, typeInfo)); } else { throw new InvalidFieldReferenceException("Nested field expression \"" + fieldStr + "\" not possible on atomic type (" + typeInfo + ")."); } } }
public SelectorFunctionKeys(KeySelector<T, K> keyExtractor, TypeInformation<T> inputType, TypeInformation<K> keyType) { if (keyExtractor == null) { throw new NullPointerException("Key extractor must not be null."); } if (keyType == null) { throw new NullPointerException("Key type must not be null."); } if (!keyType.isKeyType()) { throw new InvalidProgramException("Return type "+keyType+" of KeySelector "+keyExtractor.getClass()+" is not a valid key type"); } this.keyExtractor = keyExtractor; this.inputType = inputType; this.keyType = keyType; this.originalKeyTypes = new TypeInformation[] {keyType}; if (keyType instanceof CompositeType) { this.keyFields = ((CompositeType<T>)keyType).getFlatFields(ExpressionKeys.SELECT_ALL_CHAR); } else { this.keyFields = new ArrayList<>(1); this.keyFields.add(new FlatFieldDescriptor(0, keyType)); } }
if (fType instanceof CompositeType) { CompositeType<?> cType = (CompositeType<?>) fType; cType.getFlatFields(ExpressionKeys.SELECT_ALL_CHAR, offset + keyPosition, result); keyPosition += cType.getTotalFields() - 1; } else { ((CompositeType) fieldType).getFlatFields("*", offset, result); } else { result.add(new FlatFieldDescriptor(offset, fieldType)); ((CompositeType) fieldType).getFlatFields(tail, offset, result); } else { throw new InvalidFieldReferenceException(
if (type instanceof CompositeType) { CompositeType<?> cType = (CompositeType<?>) type; cType.getFlatFields(String.valueOf(ExpressionKeys.SELECT_ALL_CHAR), offset + keyPosition, result); keyPosition += cType.getTotalFields() - 1; } else { ((CompositeType<?>) fieldType).getFlatFields("*", offset, result); } else { offset += this.getTypeAt(i).getTotalFields(); ((CompositeType<?>) fieldType).getFlatFields(tail, offset, result); } else { throw new InvalidFieldReferenceException("Nested field expression \"" + tail + "\" not possible on atomic type " + fieldType + ".");
List<FlatFieldDescriptor> flatFields = cType.getFlatFields(keyExpr);
if(pField.getTypeInformation() instanceof CompositeType) { CompositeType<?> cType = (CompositeType<?>)pField.getTypeInformation(); cType.getFlatFields(String.valueOf(ExpressionKeys.SELECT_ALL_CHAR), offset + keyPosition, result); keyPosition += cType.getTotalFields()-1; } else { ((CompositeType<?>) fieldType).getFlatFields("*", offset, result); } else { offset += this.getTypeAt(i).getTotalFields(); ((CompositeType<?>) fieldType).getFlatFields(tail, offset, result); } else { throw new InvalidFieldReferenceException("Nested field expression \""+tail+"\" not possible on atomic type "+fieldType+".");
cType.getFlatFields(fieldNames[keyPos], 0, tmpList);
/** * Returns the flat field descriptors for the given field expression. * * @param fieldExpression The field expression for which the flat field descriptors are computed. * @return The list of descriptors for the flat fields which are specified by the field expression. */ @PublicEvolving public List<FlatFieldDescriptor> getFlatFields(String fieldExpression) { List<FlatFieldDescriptor> result = new ArrayList<FlatFieldDescriptor>(); this.getFlatFields(fieldExpression, 0, result); return result; }
/** * Returns the flat field descriptors for the given field expression. * * @param fieldExpression The field expression for which the flat field descriptors are computed. * @return The list of descriptors for the flat fields which are specified by the field expression. */ @PublicEvolving public List<FlatFieldDescriptor> getFlatFields(String fieldExpression) { List<FlatFieldDescriptor> result = new ArrayList<FlatFieldDescriptor>(); this.getFlatFields(fieldExpression, 0, result); return result; }
private static List<FlatFieldDescriptor> getFlatFields(String fieldStr, TypeInformation<?> typeInfo) { if (typeInfo instanceof CompositeType<?>) { return ((CompositeType<?>) typeInfo).getFlatFields(fieldStr); } else { Matcher wildcardMatcher = PATTERN_WILDCARD.matcher(fieldStr); if (wildcardMatcher.matches()) { return Collections.singletonList(new FlatFieldDescriptor(0, typeInfo)); } else { throw new InvalidFieldReferenceException("Nested field expression \"" + fieldStr + "\" not possible on atomic type (" + typeInfo + ")."); } } }
private static List<FlatFieldDescriptor> getFlatFields(String fieldStr, TypeInformation<?> typeInfo) { if (typeInfo instanceof CompositeType<?>) { return ((CompositeType<?>) typeInfo).getFlatFields(fieldStr); } else { Matcher wildcardMatcher = PATTERN_WILDCARD.matcher(fieldStr); if (wildcardMatcher.matches()) { return Collections.singletonList(new FlatFieldDescriptor(0, typeInfo)); } else { throw new InvalidFieldReferenceException("Nested field expression \"" + fieldStr + "\" not possible on atomic type (" + typeInfo + ")."); } } }
public SelectorFunctionKeys(KeySelector<T, K> keyExtractor, TypeInformation<T> inputType, TypeInformation<K> keyType) { if (keyExtractor == null) { throw new NullPointerException("Key extractor must not be null."); } if (keyType == null) { throw new NullPointerException("Key type must not be null."); } if (!keyType.isKeyType()) { throw new InvalidProgramException("Return type "+keyType+" of KeySelector "+keyExtractor.getClass()+" is not a valid key type"); } this.keyExtractor = keyExtractor; this.inputType = inputType; this.keyType = keyType; this.originalKeyTypes = new TypeInformation[] {keyType}; if (keyType instanceof CompositeType) { this.keyFields = ((CompositeType<T>)keyType).getFlatFields(ExpressionKeys.SELECT_ALL_CHAR); } else { this.keyFields = new ArrayList<>(1); this.keyFields.add(new FlatFieldDescriptor(0, keyType)); } }
public SelectorFunctionKeys(KeySelector<T, K> keyExtractor, TypeInformation<T> inputType, TypeInformation<K> keyType) { if (keyExtractor == null) { throw new NullPointerException("Key extractor must not be null."); } if (keyType == null) { throw new NullPointerException("Key type must not be null."); } if (!keyType.isKeyType()) { throw new InvalidProgramException("Return type "+keyType+" of KeySelector "+keyExtractor.getClass()+" is not a valid key type"); } this.keyExtractor = keyExtractor; this.inputType = inputType; this.keyType = keyType; this.originalKeyTypes = new TypeInformation[] {keyType}; if (keyType instanceof CompositeType) { this.keyFields = ((CompositeType<T>)keyType).getFlatFields(ExpressionKeys.SELECT_ALL_CHAR); } else { this.keyFields = new ArrayList<>(1); this.keyFields.add(new FlatFieldDescriptor(0, keyType)); } }
if (fType instanceof CompositeType) { CompositeType<?> cType = (CompositeType<?>) fType; cType.getFlatFields(ExpressionKeys.SELECT_ALL_CHAR, offset + keyPosition, result); keyPosition += cType.getTotalFields() - 1; } else { ((CompositeType) fieldType).getFlatFields("*", offset, result); } else { result.add(new FlatFieldDescriptor(offset, fieldType)); ((CompositeType) fieldType).getFlatFields(tail, offset, result); } else { throw new InvalidFieldReferenceException(
if (fType instanceof CompositeType) { CompositeType<?> cType = (CompositeType<?>) fType; cType.getFlatFields(ExpressionKeys.SELECT_ALL_CHAR, offset + keyPosition, result); keyPosition += cType.getTotalFields() - 1; } else { ((CompositeType) fieldType).getFlatFields("*", offset, result); } else { result.add(new FlatFieldDescriptor(offset, fieldType)); ((CompositeType) fieldType).getFlatFields(tail, offset, result); } else { throw new InvalidFieldReferenceException(
if (type instanceof CompositeType) { CompositeType<?> cType = (CompositeType<?>) type; cType.getFlatFields(String.valueOf(ExpressionKeys.SELECT_ALL_CHAR), offset + keyPosition, result); keyPosition += cType.getTotalFields() - 1; } else { ((CompositeType<?>) fieldType).getFlatFields("*", offset, result); } else { offset += this.getTypeAt(i).getTotalFields(); ((CompositeType<?>) fieldType).getFlatFields(tail, offset, result); } else { throw new InvalidFieldReferenceException("Nested field expression \"" + tail + "\" not possible on atomic type " + fieldType + ".");
List<FlatFieldDescriptor> flatFields = cType.getFlatFields(keyExpr);
cType.getFlatFields(fieldNames[keyPos], 0, tmpList);
cType.getFlatFields(fieldNames[keyPos], 0, tmpList);