Refine search
private static boolean convertibleToDoubleWithCast(Type type) { return type instanceof DecimalType || DoubleType.DOUBLE.equals(type) || RealType.REAL.equals(type) || BigintType.BIGINT.equals(type) || IntegerType.INTEGER.equals(type) || SmallintType.SMALLINT.equals(type) || TinyintType.TINYINT.equals(type) || BooleanType.BOOLEAN.equals(type); } }
public static Block createTestBlock() { BlockBuilder blockBuilder = BOOLEAN.createBlockBuilder(null, 15); BOOLEAN.writeBoolean(blockBuilder, true); BOOLEAN.writeBoolean(blockBuilder, true); BOOLEAN.writeBoolean(blockBuilder, true); BOOLEAN.writeBoolean(blockBuilder, false); BOOLEAN.writeBoolean(blockBuilder, false); BOOLEAN.writeBoolean(blockBuilder, false); BOOLEAN.writeBoolean(blockBuilder, false); BOOLEAN.writeBoolean(blockBuilder, false); BOOLEAN.writeBoolean(blockBuilder, true); BOOLEAN.writeBoolean(blockBuilder, true); BOOLEAN.writeBoolean(blockBuilder, false); return blockBuilder.build(); }
private static RowExpression ifExpression(RowExpression condition, long trueValue, long falseValue) { Signature signature = new Signature("IF", SCALAR, BIGINT.getTypeSignature(), BOOLEAN.getTypeSignature(), BIGINT.getTypeSignature(), BIGINT.getTypeSignature()); return new CallExpression(signature, BIGINT, ImmutableList.of(condition, constant(trueValue, BIGINT), constant(falseValue, BIGINT))); } }
public static Block createBooleanSequenceBlock(int start, int end) { BlockBuilder builder = BOOLEAN.createFixedSizeBlockBuilder(end - start); for (int i = start; i < end; i++) { BOOLEAN.writeBoolean(builder, i % 2 == 0); } return builder.build(); }
private static void serializePrimitive(Type type, BlockBuilder builder, Object object) { requireNonNull(builder, "parent builder is null"); if (object == null) { builder.appendNull(); return; } if (BOOLEAN.equals(type)) { BOOLEAN.writeBoolean(builder, (Boolean) object); } else if (BIGINT.equals(type) || INTEGER.equals(type) || SMALLINT.equals(type) || TINYINT.equals(type) || REAL.equals(type) || DATE.equals(type) || TIMESTAMP.equals(type)) { type.writeLong(builder, getLongExpressedValue(object)); } else if (DOUBLE.equals(type)) { DOUBLE.writeDouble(builder, ((Number) object).doubleValue()); } else if (isVarcharType(type) || VARBINARY.equals(type) || isCharType(type)) { type.writeSlice(builder, getSliceExpressedValue(object, type)); } else { throw new UnsupportedOperationException("Unsupported primitive type: " + type); } }
BooleanType.BOOLEAN.writeBoolean(builder, ((BooleanObjectInspector) inspector).get(object)); return; case BYTE: return; case INT: IntegerType.INTEGER.writeLong(builder, ((IntObjectInspector) inspector).get(object)); return; case LONG: BigintType.BIGINT.writeLong(builder, ((LongObjectInspector) inspector).get(object)); return; case FLOAT: return; case DOUBLE: DoubleType.DOUBLE.writeDouble(builder, ((DoubleObjectInspector) inspector).get(object)); return; case STRING: return; case DATE: DateType.DATE.writeLong(builder, formatDateAsLong(object, (DateObjectInspector) inspector)); return; case TIMESTAMP: TimestampType.TIMESTAMP.writeLong(builder, formatTimestampAsLong(object, (TimestampObjectInspector) inspector)); return; case BINARY:
typeSignature = BIGINT.getTypeSignature(); typeSignature = BOOLEAN.getTypeSignature(); typeSignature = DOUBLE.getTypeSignature(); typeSignature = TIMESTAMP.getTypeSignature();
@Override public InternalAggregationFunction getAggregationFunction() { return metadata.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("approx_distinct", AGGREGATE, BIGINT.getTypeSignature(), BOOLEAN.getTypeSignature(), DOUBLE.getTypeSignature())); }
@Override public Block toBlock(Type desiredType) { checkArgument(BOOLEAN.equals(desiredType), "type doesn't match: %s", desiredType); int numberOfRecords = numberOfRecords(); return new ByteArrayBlock( numberOfRecords, Optional.ofNullable(nulls), booleans == null ? new byte[numberOfRecords] : toByteArray(booleans)); }
@Override public GroupByIdBlock getGroupIds(Page page) { int positionCount = page.getPositionCount(); // we know the exact size required for the block BlockBuilder blockBuilder = BIGINT.createFixedSizeBlockBuilder(positionCount); Block maskBlock = null; if (maskChannel >= 0) { maskBlock = page.getBlock(maskChannel); } // get the group id for each position Block block = page.getBlock(hashChannel); for (int position = 0; position < positionCount; position++) { // skip masked rows if (maskBlock != null && !BOOLEAN.getBoolean(maskBlock, position)) { blockBuilder.appendNull(); continue; } // get the group for the current row int groupId = putIfAbsent(position, block); // output the group id for this row BIGINT.writeLong(blockBuilder, groupId); } return new GroupByIdBlock(nextGroupId, blockBuilder.build()); }
public static boolean testMask(@Nullable Block masks, int index) { if (masks != null) { return BOOLEAN.getBoolean(masks, index); } return true; } }
@Override void writeNextRandomValue(Random random, BlockBuilder builder) { BOOLEAN.writeBoolean(builder, random.nextBoolean()); } }
public static long computeSampleWeight(@Nullable Block masks, @Nullable Block sampleWeights, int index) { if (masks != null) { // TODO: support for DISTINCT should be removed from sampled aggregations, // since it doesn't make sense to try to process distinct rows when the data is sampled. // DISTINCT is enabled, so ignore the sample weight return BOOLEAN.getBoolean(masks, index) ? 1 : 0; } else { return sampleWeights != null ? BIGINT.getLong(sampleWeights, index) : 1; } } }
private RowIndeterminateOperator() { super(INDETERMINATE, ImmutableList.of(withVariadicBound("T", "row")), ImmutableList.of(), BOOLEAN.getTypeSignature(), ImmutableList.of(parseTypeSignature("T"))); }
private static void testIsFull(PageBuilderStatus pageBuilderStatus) { FixedWidthBlockBuilder blockBuilder = new FixedWidthBlockBuilder(BOOLEAN.getFixedSize(), pageBuilderStatus.createBlockBuilderStatus(), 1024); assertTrue(pageBuilderStatus.isEmpty()); while (!pageBuilderStatus.isFull()) { BOOLEAN.writeBoolean(blockBuilder, true); } assertEquals(blockBuilder.getPositionCount(), EXPECTED_ENTRY_COUNT); assertEquals(pageBuilderStatus.isFull(), true); } }
@Override public BlockBuilder createBlockBuilder(BlockBuilderStatus blockBuilderStatus, int expectedEntries) { return createBlockBuilder(blockBuilderStatus, expectedEntries, Byte.BYTES); }
@Override protected List<? extends OperatorFactory> createOperatorFactories() { OperatorFactory tableScanOperator = createTableScanOperator(0, new PlanNodeId("test"), "orders", "totalprice"); RowExpression filter = call( internalOperator(GREATER_THAN_OR_EQUAL, BOOLEAN.getTypeSignature(), ImmutableList.of(DOUBLE.getTypeSignature(), DOUBLE.getTypeSignature())), BOOLEAN, field(0, DOUBLE), constant(50000.0, DOUBLE)); ExpressionCompiler expressionCompiler = new ExpressionCompiler(localQueryRunner.getMetadata(), new PageFunctionCompiler(localQueryRunner.getMetadata(), 0)); Supplier<PageProcessor> pageProcessor = expressionCompiler.compilePageProcessor(Optional.of(filter), ImmutableList.of(field(0, DOUBLE))); FilterAndProjectOperator.FilterAndProjectOperatorFactory filterAndProjectOperator = new FilterAndProjectOperator.FilterAndProjectOperatorFactory( 1, new PlanNodeId("test"), pageProcessor, ImmutableList.of(DOUBLE), new DataSize(0, BYTE), 0); return ImmutableList.of(tableScanOperator, filterAndProjectOperator); }
BlockBuilder blockBuilder = BOOLEAN.createFixedSizeBlockBuilder(page.getPositionCount()); if (probeJoinPage.getBlock(0).isNull(position)) { if (channelSet.isEmpty()) { BOOLEAN.writeBoolean(blockBuilder, false); BOOLEAN.writeBoolean(blockBuilder, contains);
@Override Object extractValue(Block block, int position) { return BOOLEAN.getBoolean(block, position); }
@Override public void append(JsonParser parser, BlockBuilder blockBuilder) throws IOException { Boolean result = currentTokenAsBoolean(parser); if (result == null) { blockBuilder.appendNull(); } else { BOOLEAN.writeBoolean(blockBuilder, result); } } }