private static boolean hasNull(Block keys) { for (int position = 0; position < keys.getPositionCount(); position++) { if (keys.isNull(position)) { return true; } } return false; }
@Override public void appendTo(Block block, int position, BlockBuilder blockBuilder) { if (block.isNull(position)) { blockBuilder.appendNull(); } else { block.writePositionTo(position, blockBuilder); } }
@TypeParameter("T") @SqlType(StandardTypes.BIGINT) public static long hash( @OperatorDependency(operator = HASH_CODE, returnType = StandardTypes.BIGINT, argumentTypes = {"T"}) MethodHandle hashFunction, @TypeParameter("T") Type type, @SqlType("array(T)") Block block) { try { long hash = 0; for (int i = 0; i < block.getPositionCount(); i++) { hash = CombineHashFunction.getHash(hash, block.isNull(i) ? NULL_HASH_CODE : (long) hashFunction.invoke(readNativeValue(type, block, i))); } return hash; } catch (Throwable t) { throw internalError(t); } }
@Override public Block apply(Block block) { BlockBuilder blockBuilder = DOUBLE.createBlockBuilder(null, block.getPositionCount()); for (int i = 0; i < block.getPositionCount(); i++) { if (block.isNull(i)) { blockBuilder.appendNull(); continue; } DOUBLE.writeDouble(blockBuilder, intBitsToFloat((int) REAL.getLong(block, i))); } return blockBuilder.build(); } }
@TypeParameter("E") @SqlNullable @SqlType("E") public static Slice sliceElementAt(@TypeParameter("E") Type elementType, @SqlType("array(E)") Block array, @SqlType("bigint") long index) { int position = checkedIndexToBlockPosition(array, index); if (position == -1) { return null; } if (array.isNull(position)) { return null; } return elementType.getSlice(array, position); }
@SqlType(StandardTypes.BOOLEAN) public static boolean isDistinctFrom( @BlockPosition @SqlType(value = StandardTypes.DATE, nativeContainerType = long.class) Block left, @BlockIndex int leftPosition, @BlockPosition @SqlType(value = StandardTypes.DATE, nativeContainerType = long.class) Block right, @BlockIndex int rightPosition) { if (left.isNull(leftPosition) != right.isNull(rightPosition)) { return true; } if (left.isNull(leftPosition)) { return false; } return notEqual(DATE.getLong(left, leftPosition), DATE.getLong(right, rightPosition)); } }
@TypeParameter("T") @SqlType(StandardTypes.BIGINT) public static long arrayPosition( @TypeParameter("T") Type type, @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle equalMethodHandle, @SqlType("array(T)") Block array, @SqlType("T") long element) { int size = array.getPositionCount(); for (int i = 0; i < size; i++) { if (!array.isNull(i)) { long arrayValue = type.getLong(array, i); try { Boolean result = (Boolean) equalMethodHandle.invokeExact(arrayValue, element); checkNotIndeterminate(result); if (result) { return i + 1; // result is 1-based (instead of 0) } } catch (Throwable t) { throw internalError(t); } } } return 0; }
@Override public void appendTo(Block block, int position, BlockBuilder blockBuilder) { if (block.isNull(position)) { blockBuilder.appendNull(); } else { block.writePositionTo(position, blockBuilder); } }
@Override public void addBlock(Type type, Block block) { for (int position = 0; position < block.getPositionCount(); position++) { if (!block.isNull(position)) { rowCount++; } } }
@Override public Block apply(Block block) { BlockBuilder blockBuilder = toType.createBlockBuilder(null, block.getPositionCount()); for (int i = 0; i < block.getPositionCount(); i++) { if (block.isNull(i)) { blockBuilder.appendNull(); continue; } toType.writeLong(blockBuilder, fromType.getLong(block, i)); } return blockBuilder.build(); } }
@TypeParameter("E") @SqlNullable @SqlType("E") public static Boolean booleanElementAt(@TypeParameter("E") Type elementType, @SqlType("array(E)") Block array, @SqlType("bigint") long index) { int position = checkedIndexToBlockPosition(array, index); if (position == -1) { return null; } if (array.isNull(position)) { return null; } return elementType.getBoolean(array, position); }
@SqlType(StandardTypes.BOOLEAN) public static boolean isDistinctFrom( @BlockPosition @SqlType(value = StandardTypes.BIGINT, nativeContainerType = long.class) Block left, @BlockIndex int leftPosition, @BlockPosition @SqlType(value = StandardTypes.BIGINT, nativeContainerType = long.class) Block right, @BlockIndex int rightPosition) { if (left.isNull(leftPosition) != right.isNull(rightPosition)) { return true; } if (left.isNull(leftPosition)) { return false; } return notEqual(BIGINT.getLong(left, leftPosition), BIGINT.getLong(right, rightPosition)); } }
@TypeParameter("T") @SqlType(StandardTypes.BIGINT) public static long arrayPosition( @TypeParameter("T") Type type, @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle equalMethodHandle, @SqlType("array(T)") Block array, @SqlType("T") Slice element) { int size = array.getPositionCount(); for (int i = 0; i < size; i++) { if (!array.isNull(i)) { Slice arrayValue = type.getSlice(array, i); try { Boolean result = (Boolean) equalMethodHandle.invokeExact(arrayValue, element); checkNotIndeterminate(result); if (result) { return i + 1; // result is 1-based (instead of 0) } } catch (Throwable t) { throw internalError(t); } } } return 0; }
@Override public void appendTo(Block block, int position, BlockBuilder blockBuilder) { if (block.isNull(position)) { blockBuilder.appendNull(); } else { block.writePositionTo(position, blockBuilder); } }
private static Double mapL2Norm(Block map) { double norm = 0.0; for (int i = 1; i < map.getPositionCount(); i += 2) { if (map.isNull(i)) { return null; } norm += DOUBLE.getDouble(map, i) * DOUBLE.getDouble(map, i); } return Math.sqrt(norm); } }
private static Block copyBlockViaWritePositionTo(Block block, Supplier<BlockBuilder> newBlockBuilder) { BlockBuilder blockBuilder = newBlockBuilder.get(); for (int i = 0; i < block.getPositionCount(); i++) { if (block.isNull(i)) { blockBuilder.appendNull(); } else { block.writePositionTo(i, blockBuilder); } } return blockBuilder.build(); }
@TypeParameter("E") @SqlNullable @SqlType("E") public static Long longElementAt(@TypeParameter("E") Type elementType, @SqlType("array(E)") Block array, @SqlType("bigint") long index) { int position = checkedIndexToBlockPosition(array, index); if (position == -1) { return null; } if (array.isNull(position)) { return null; } return elementType.getLong(array, position); }
@SqlType(StandardTypes.BOOLEAN) public static boolean isDistinctFrom( @BlockPosition @SqlType(value = StandardTypes.TIME_WITH_TIME_ZONE, nativeContainerType = long.class) Block left, @BlockIndex int leftPosition, @BlockPosition @SqlType(value = StandardTypes.TIME_WITH_TIME_ZONE, nativeContainerType = long.class) Block right, @BlockIndex int rightPosition) { if (left.isNull(leftPosition) && right.isNull(rightPosition)) { return false; } if (left.isNull(leftPosition)) { return false; } return notEqual(TIME_WITH_TIME_ZONE.getLong(left, leftPosition), TIME_WITH_TIME_ZONE.getLong(right, rightPosition)); } }
@TypeParameter("T") @SqlType(StandardTypes.BIGINT) public static long arrayPosition( @TypeParameter("T") Type type, @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle equalMethodHandle, @SqlType("array(T)") Block array, @SqlType("T") boolean element) { int size = array.getPositionCount(); for (int i = 0; i < size; i++) { if (!array.isNull(i)) { boolean arrayValue = type.getBoolean(array, i); try { Boolean result = (Boolean) equalMethodHandle.invokeExact(arrayValue, element); checkNotIndeterminate(result); if (result) { return i + 1; // result is 1-based (instead of 0) } } catch (Throwable t) { throw internalError(t); } } } return 0; }
@Override public void appendTo(Block block, int position, BlockBuilder blockBuilder) { if (block.isNull(position)) { blockBuilder.appendNull(); } else { block.writeBytesTo(position, 0, block.getSliceLength(position), blockBuilder); blockBuilder.closeEntry(); } }