private void append(int channel, Object element) { BlockBuilder blockBuilder = builders.get(channel); Type type = types.get(channel); appendToBlockBuilder(type, element, blockBuilder); } }
public static Block arrayBlockOf(Type elementType, Object... values) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, 1024); for (Object value : values) { appendToBlockBuilder(elementType, value, blockBuilder); } return blockBuilder.build(); }
public static Block mapBlockOf(Type keyType, Type valueType, Object[] keys, Object[] values) { checkArgument(keys.length == values.length, "keys/values must have the same length"); MapType mapType = mapType(keyType, valueType); BlockBuilder blockBuilder = mapType.createBlockBuilder(null, 10); BlockBuilder singleMapBlockWriter = blockBuilder.beginBlockEntry(); for (int i = 0; i < keys.length; i++) { Object key = keys[i]; Object value = values[i]; appendToBlockBuilder(keyType, key, singleMapBlockWriter); appendToBlockBuilder(valueType, value, singleMapBlockWriter); } blockBuilder.closeEntry(); return mapType.getObject(blockBuilder, 0); }
public static Block mapBlockOf(Type keyType, Type valueType, Object key, Object value) { MapType mapType = mapType(keyType, valueType); BlockBuilder blockBuilder = mapType.createBlockBuilder(null, 10); BlockBuilder singleMapBlockWriter = blockBuilder.beginBlockEntry(); appendToBlockBuilder(keyType, key, singleMapBlockWriter); appendToBlockBuilder(valueType, value, singleMapBlockWriter); blockBuilder.closeEntry(); return mapType.getObject(blockBuilder, 0); }
public static Block rowBlockOf(List<Type> parameterTypes, Object... values) { RowType rowType = RowType.anonymous(parameterTypes); BlockBuilder blockBuilder = rowType.createBlockBuilder(null, 1); BlockBuilder singleRowBlockWriter = blockBuilder.beginBlockEntry(); for (int i = 0; i < values.length; i++) { appendToBlockBuilder(parameterTypes.get(i), values[i], singleRowBlockWriter); } blockBuilder.closeEntry(); return rowType.getObject(blockBuilder, 0); }
public static Block mapBlockOf(Type keyType, Type valueType, Map<?, ?> value) { MapType mapType = mapType(keyType, valueType); BlockBuilder mapArrayBuilder = mapType.createBlockBuilder(null, 1); BlockBuilder singleMapWriter = mapArrayBuilder.beginBlockEntry(); for (Map.Entry<?, ?> entry : value.entrySet()) { appendToBlockBuilder(keyType, entry.getKey(), singleMapWriter); appendToBlockBuilder(valueType, entry.getValue(), singleMapWriter); } mapArrayBuilder.closeEntry(); return mapType.getObject(mapArrayBuilder, 0); }
public static Block arrayBlockOf(Type elementType, Object... values) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, values.length); for (Object value : values) { appendToBlockBuilder(elementType, value, blockBuilder); } return blockBuilder.build(); }
public static Block toRow(List<Type> parameterTypes, Object... values) { checkArgument(parameterTypes.size() == values.length, "parameterTypes.size(" + parameterTypes.size() + ") does not equal to values.length(" + values.length + ")"); RowType rowType = RowType.anonymous(parameterTypes); BlockBuilder blockBuilder = new RowBlockBuilder(parameterTypes, null, 1); BlockBuilder singleRowBlockWriter = blockBuilder.beginBlockEntry(); for (int i = 0; i < values.length; i++) { appendToBlockBuilder(parameterTypes.get(i), values[i], singleRowBlockWriter); } blockBuilder.closeEntry(); return rowType.getObject(blockBuilder, 0); }
private void assertMapHashOperator(String inputString, Type keyType, Type valueType, List<Object> elements) { checkArgument(elements.size() % 2 == 0, "the size of elements should be even number"); MapType mapType = mapType(keyType, valueType); BlockBuilder mapArrayBuilder = mapType.createBlockBuilder(null, 1); BlockBuilder singleMapWriter = mapArrayBuilder.beginBlockEntry(); for (int i = 0; i < elements.size(); i += 2) { appendToBlockBuilder(keyType, elements.get(i), singleMapWriter); appendToBlockBuilder(valueType, elements.get(i + 1), singleMapWriter); } mapArrayBuilder.closeEntry(); long hashResult = mapType.hash(mapArrayBuilder.build(), 0); assertOperator(HASH_CODE, inputString, BIGINT, hashResult); }
private void assertRowHashOperator(String inputString, List<Type> types, List<Object> elements) { checkArgument(types.size() == elements.size(), "types and elements must have the same size"); RowType rowType = RowType.anonymous(types); BlockBuilder blockBuilder = rowType.createBlockBuilder(null, 1); BlockBuilder singleRowBlockWriter = blockBuilder.beginBlockEntry(); for (int i = 0; i < types.size(); i++) { appendToBlockBuilder(types.get(i), elements.get(i), singleRowBlockWriter); } blockBuilder.closeEntry(); assertOperator(HASH_CODE, inputString, BIGINT, rowType.hash(blockBuilder.build(), 0)); }
private void assertArrayHashOperator(String inputArray, Type elementType, List<Object> elements) { ArrayType arrayType = new ArrayType(elementType); BlockBuilder arrayArrayBuilder = arrayType.createBlockBuilder(null, 1); BlockBuilder arrayBuilder = elementType.createBlockBuilder(null, elements.size()); for (Object element : elements) { appendToBlockBuilder(elementType, element, arrayBuilder); } arrayType.writeObject(arrayArrayBuilder, arrayBuilder.build()); assertOperator(HASH_CODE, inputArray, BIGINT, arrayType.hash(arrayArrayBuilder.build(), 0)); }
BlockBuilder subBlockBuilder = blockBuilder.beginBlockEntry(); for (Object subElement : (Iterable<?>) element) { appendToBlockBuilder(type.getTypeParameters().get(0), subElement, subBlockBuilder); int field = 0; for (Object subElement : (Iterable<?>) element) { appendToBlockBuilder(type.getTypeParameters().get(field), subElement, subBlockBuilder); field++; BlockBuilder subBlockBuilder = blockBuilder.beginBlockEntry(); for (Map.Entry<?, ?> entry : ((Map<?, ?>) element).entrySet()) { appendToBlockBuilder(type.getTypeParameters().get(0), entry.getKey(), subBlockBuilder); appendToBlockBuilder(type.getTypeParameters().get(1), entry.getValue(), subBlockBuilder);
public static Block arrayBlockOf(Type elementType, Object... values) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, 1024); for (Object value : values) { appendToBlockBuilder(elementType, value, blockBuilder); } return blockBuilder.build(); }
public static Block mapBlockOf(Type keyType, Type valueType, Object[] keys, Object[] values) { checkArgument(keys.length == values.length, "keys/values must have the same length"); MapType mapType = mapType(keyType, valueType); BlockBuilder blockBuilder = mapType.createBlockBuilder(null, 10); BlockBuilder singleMapBlockWriter = blockBuilder.beginBlockEntry(); for (int i = 0; i < keys.length; i++) { Object key = keys[i]; Object value = values[i]; appendToBlockBuilder(keyType, key, singleMapBlockWriter); appendToBlockBuilder(valueType, value, singleMapBlockWriter); } blockBuilder.closeEntry(); return mapType.getObject(blockBuilder, 0); }
public static Block mapBlockOf(Type keyType, Type valueType, Object key, Object value) { MapType mapType = mapType(keyType, valueType); BlockBuilder blockBuilder = mapType.createBlockBuilder(null, 10); BlockBuilder singleMapBlockWriter = blockBuilder.beginBlockEntry(); appendToBlockBuilder(keyType, key, singleMapBlockWriter); appendToBlockBuilder(valueType, value, singleMapBlockWriter); blockBuilder.closeEntry(); return mapType.getObject(blockBuilder, 0); }
public static Block rowBlockOf(List<Type> parameterTypes, Object... values) { RowType rowType = RowType.anonymous(parameterTypes); BlockBuilder blockBuilder = rowType.createBlockBuilder(null, 1); BlockBuilder singleRowBlockWriter = blockBuilder.beginBlockEntry(); for (int i = 0; i < values.length; i++) { appendToBlockBuilder(parameterTypes.get(i), values[i], singleRowBlockWriter); } blockBuilder.closeEntry(); return rowType.getObject(blockBuilder, 0); }