public ConstantPageProjection(Object value, Type type) { this.type = type; BlockBuilder blockBuilder = type.createBlockBuilder(null, 1); writeNativeValue(type, blockBuilder, value); this.value = blockBuilder.build(); }
static Object blockToNativeValue(Type type, Block block) { return readNativeValue(type, block, 0); } }
@Override public boolean equalTo(Block leftBlock, int leftPosition, Block rightBlock, int rightPosition) { Block leftArray = leftBlock.getObject(leftPosition, Block.class); Block rightArray = rightBlock.getObject(rightPosition, Block.class); if (leftArray.getPositionCount() != rightArray.getPositionCount()) { return false; } for (int i = 0; i < leftArray.getPositionCount(); i++) { checkElementNotNull(leftArray.isNull(i), ARRAY_NULL_ELEMENT_MSG); checkElementNotNull(rightArray.isNull(i), ARRAY_NULL_ELEMENT_MSG); if (!elementType.equalTo(leftArray, i, rightArray, i)) { return false; } } return true; }
Object key = readNativeValue(keyType, leftMapBlock, leftKeyPosition); Object leftValue = readNativeValue(leftValueType, leftMapBlock, leftKeyPosition + 1); rightValue = readNativeValue(rightValueType, rightMapBlock, rightValuePosition); keyFound[rightValuePosition / 2] = true; writeNativeValue(outputValueType, blockBuilder, outputValue); Object key = readNativeValue(keyType, rightMapBlock, rightKeyPosition); Object rightValue = readNativeValue(rightValueType, rightMapBlock, rightKeyPosition + 1); writeNativeValue(outputValueType, blockBuilder, outputValue);
@Override public long hash(Block block, int position) { Block mapBlock = getObject(block, position); long result = 0; for (int i = 0; i < mapBlock.getPositionCount(); i += 2) { result += hashPosition(keyType, mapBlock, i) ^ hashPosition(valueType, mapBlock, i + 1); } return result; }
Object left = position < leftPositionCount ? readNativeValue(leftElementType, leftBlock, position) : null; Object right = position < rightPositionCount ? readNativeValue(rightElementType, rightBlock, position) : null; Object output; try { throw new RuntimeException(throwable); writeNativeValue(outputElementType, blockBuilder, output);
@Override public long hash(Block block, int position) { Block array = getObject(block, position); long hash = 0; for (int i = 0; i < array.getPositionCount(); i++) { hash = 31 * hash + hashPosition(elementType, array, i); } return hash; }
@UsedByGeneratedCode public static Object elementAt(MethodHandle keyEqualsMethod, Type keyType, Type valueType, Block map, double key) { SingleMapBlock mapBlock = (SingleMapBlock) map; int valuePosition = mapBlock.seekKeyExact(key); if (valuePosition == -1) { return null; } return readNativeValue(valueType, mapBlock, valuePosition); }
public Builder add(Object... values) { pageBuilder.declarePosition(); for (int i = 0; i < types.size(); i++) { writeNativeValue(types.get(i), pageBuilder.getBlockBuilder(i), values[i]); } if (pageBuilder.isFull()) { flushPage(); } return this; }
@Override public long hash(Block block, int position) { Block arrayBlock = block.getObject(position, Block.class); long result = 1; for (int i = 0; i < arrayBlock.getPositionCount(); i++) { Type elementType = fields.get(i).getType(); result = 31 * result + TypeUtils.hashPosition(elementType, arrayBlock, i); } return result; }
@Override public boolean equalTo(Block leftBlock, int leftPosition, Block rightBlock, int rightPosition) { Block leftMapBlock = leftBlock.getObject(leftPosition, Block.class); Block rightMapBlock = rightBlock.getObject(rightPosition, Block.class); if (leftMapBlock.getPositionCount() != rightMapBlock.getPositionCount()) { return false; } Map<KeyWrapper, Integer> wrappedLeftMap = new HashMap<>(); for (int position = 0; position < leftMapBlock.getPositionCount(); position += 2) { wrappedLeftMap.put(new KeyWrapper(keyType, leftMapBlock, position), position + 1); } for (int position = 0; position < rightMapBlock.getPositionCount(); position += 2) { KeyWrapper key = new KeyWrapper(keyType, rightMapBlock, position); Integer leftValuePosition = wrappedLeftMap.get(key); if (leftValuePosition == null) { return false; } int rightValuePosition = position + 1; checkElementNotNull(leftMapBlock.isNull(leftValuePosition), MAP_NULL_ELEMENT_MSG); checkElementNotNull(rightMapBlock.isNull(rightValuePosition), MAP_NULL_ELEMENT_MSG); if (!valueType.equalTo(leftMapBlock, leftValuePosition, rightMapBlock, rightValuePosition)) { return false; } } return true; }
@UsedByGeneratedCode public static Object elementAt(MethodHandle keyEqualsMethod, Type keyType, Type valueType, Block map, Slice key) { SingleMapBlock mapBlock = (SingleMapBlock) map; int valuePosition = mapBlock.seekKeyExact(key); if (valuePosition == -1) { return null; } return readNativeValue(valueType, mapBlock, valuePosition); }
public static Block nativeValueToBlock(Type type, Object object) { if (object != null && !Primitives.wrap(type.getJavaType()).isInstance(object)) { throw new IllegalArgumentException(String.format("Object '%s' does not match type %s", object, type.getJavaType())); } BlockBuilder blockBuilder = type.createBlockBuilder(null, 1); writeNativeValue(type, blockBuilder, object); return blockBuilder.build(); }
@Override public long hash(Block block, int position) { Block mapBlock = getObject(block, position); long result = 0; for (int i = 0; i < mapBlock.getPositionCount(); i += 2) { result += hashPosition(keyType, mapBlock, i) ^ hashPosition(valueType, mapBlock, i + 1); } return result; }
@Override public int compareTo(Block leftBlock, int leftPosition, Block rightBlock, int rightPosition) { if (!elementType.isOrderable()) { throw new UnsupportedOperationException(getTypeSignature() + " type is not orderable"); } Block leftArray = leftBlock.getObject(leftPosition, Block.class); Block rightArray = rightBlock.getObject(rightPosition, Block.class); int len = Math.min(leftArray.getPositionCount(), rightArray.getPositionCount()); int index = 0; while (index < len) { checkElementNotNull(leftArray.isNull(index), ARRAY_NULL_ELEMENT_MSG); checkElementNotNull(rightArray.isNull(index), ARRAY_NULL_ELEMENT_MSG); int comparison = elementType.compareTo(leftArray, index, rightArray, index); if (comparison != 0) { return comparison; } index++; } if (index == len) { return leftArray.getPositionCount() - rightArray.getPositionCount(); } return 0; }
@UsedByGeneratedCode public static Object elementAt(MethodHandle keyEqualsMethod, Type keyType, Type valueType, Block map, Object key) { SingleMapBlock mapBlock = (SingleMapBlock) map; int valuePosition = mapBlock.seekKeyExact((Block) key); if (valuePosition == -1) { return null; } return readNativeValue(valueType, mapBlock, valuePosition); } }
private static void writeEntries(int expectedEntries, BlockBuilder blockBuilder, Type type) { for (int i = 0; i < expectedEntries; i++) { writeNativeValue(type, blockBuilder, castIntegerToObject(i, type)); } }
@Override public long hash(Block block, int position) { Block array = getObject(block, position); long hash = 0; for (int i = 0; i < array.getPositionCount(); i++) { hash = 31 * hash + hashPosition(elementType, array, i); } return hash; }
@Override public boolean equalTo(Block leftBlock, int leftPosition, Block rightBlock, int rightPosition) { Block leftArray = leftBlock.getObject(leftPosition, Block.class); Block rightArray = rightBlock.getObject(rightPosition, Block.class); if (leftArray.getPositionCount() != rightArray.getPositionCount()) { return false; } for (int i = 0; i < leftArray.getPositionCount(); i++) { checkElementNotNull(leftArray.isNull(i), ARRAY_NULL_ELEMENT_MSG); checkElementNotNull(rightArray.isNull(i), ARRAY_NULL_ELEMENT_MSG); if (!elementType.equalTo(leftArray, i, rightArray, i)) { return false; } } return true; }
@UsedByGeneratedCode public static Object elementAt(MethodHandle keyEqualsMethod, Type keyType, Type valueType, Block map, boolean key) { SingleMapBlock mapBlock = (SingleMapBlock) map; int valuePosition = mapBlock.seekKeyExact(key); if (valuePosition == -1) { return null; } return readNativeValue(valueType, mapBlock, valuePosition); }