/** * Checks if a RexNode is a literal int or not. If this returns true, then {@code RexLiteral.intValue(literal)} can be * used to get the value of the literal. * * @param rexNode the node * * @return true if this is an int */ public static boolean isIntLiteral(final RexNode rexNode) { return rexNode instanceof RexLiteral && SqlTypeName.INT_TYPES.contains(rexNode.getType().getSqlTypeName()); }
private boolean areTypesCompatible(RelDataType type1, RelDataType type2) { if (type1.equals(type2)) { return true; } SqlTypeName sqlType1 = type1.getSqlTypeName(); if (sqlType1 != null) { return sqlType1.equals(type2.getSqlTypeName()); } return false; } }
/** Returns whether one type is just a widening of another. * * <p>For example:<ul> * <li>{@code VARCHAR(10)} is a widening of {@code VARCHAR(5)}. * <li>{@code VARCHAR(10)} is a widening of {@code VARCHAR(10) NOT NULL}. * </ul> */ private boolean isWidening(RelDataType type, RelDataType type1) { return type.getSqlTypeName() == type1.getSqlTypeName() && type.getPrecision() >= type1.getPrecision(); }
@Override public RelDataType deriveSumType(final RelDataTypeFactory typeFactory, final RelDataType argumentType) { // Widen all sums to 64-bits regardless of the size of the inputs. if (SqlTypeName.INT_TYPES.contains(argumentType.getSqlTypeName())) { return Calcites.createSqlType(typeFactory, SqlTypeName.BIGINT); } else { return Calcites.createSqlType(typeFactory, SqlTypeName.DOUBLE); } }
/** Returns whether one type is just a widening of another. * * <p>For example:<ul> * <li>{@code VARCHAR(10)} is a widening of {@code VARCHAR(5)}. * <li>{@code VARCHAR(10)} is a widening of {@code VARCHAR(10) NOT NULL}. * </ul> */ private boolean isWidening(RelDataType type, RelDataType type1) { return type.getSqlTypeName() == type1.getSqlTypeName() && type.getPrecision() >= type1.getPrecision(); }
@Override public Object[] apply(final Result<TimeseriesResultValue> result) { final Map<String, Object> row = result.getValue().getBaseObject(); final Object[] retVal = new Object[fieldList.size()]; for (final RelDataTypeField field : fieldList) { final String outputName = druidQuery.getOutputRowSignature().getRowOrder().get(field.getIndex()); if (outputName.equals(timeOutputName)) { retVal[field.getIndex()] = coerce(result.getTimestamp(), field.getType().getSqlTypeName()); } else { retVal[field.getIndex()] = coerce(row.get(outputName), field.getType().getSqlTypeName()); } } return retVal; } }
@Override public Object[] apply(final Row row) { final Object[] retVal = new Object[fieldList.size()]; for (RelDataTypeField field : fieldList) { retVal[field.getIndex()] = coerce( row.getRaw(druidQuery.getOutputRowSignature().getRowOrder().get(field.getIndex())), field.getType().getSqlTypeName() ); } return retVal; } }
@Override public Sequence<Object[]> apply(final Result<TopNResultValue> result) { final List<DimensionAndMetricValueExtractor> rows = result.getValue().getValue(); final List<Object[]> retVals = new ArrayList<>(rows.size()); for (DimensionAndMetricValueExtractor row : rows) { final Object[] retVal = new Object[fieldList.size()]; for (final RelDataTypeField field : fieldList) { final String outputName = druidQuery.getOutputRowSignature().getRowOrder().get(field.getIndex()); retVal[field.getIndex()] = coerce(row.getMetric(outputName), field.getType().getSqlTypeName()); } retVals.add(retVal); } return Sequences.simple(retVals); } }
private SqlTypeName getAggTypeForScalarSub(RexSubQuery e) { assert(e.getKind() == SqlKind.SCALAR_QUERY); assert(e.rel.getInputs().size() == 1); Aggregate relAgg = (Aggregate)e.rel.getInput(0); assert(relAgg.getAggCallList().size() == 1); //should only have one aggregate return relAgg.getAggCallList().get(0).getType().getSqlTypeName(); }
public static RowSignature from(final List<String> rowOrder, final RelDataType rowType) { if (rowOrder.size() != rowType.getFieldCount()) { throw new IAE("Field count %d != %d", rowOrder.size(), rowType.getFieldCount()); } final RowSignature.Builder rowSignatureBuilder = builder(); for (int i = 0; i < rowOrder.size(); i++) { final RelDataTypeField field = rowType.getFieldList().get(i); final SqlTypeName sqlTypeName = field.getType().getSqlTypeName(); final ValueType valueType; valueType = Calcites.getValueTypeForSqlTypeName(sqlTypeName); if (valueType == null) { throw new ISE("Cannot translate sqlTypeName[%s] to Druid type for field[%s]", sqlTypeName, rowOrder.get(i)); } rowSignatureBuilder.add(rowOrder.get(i), valueType); } return rowSignatureBuilder.build(); }
private static CalciteUDFInfo getUDFInfo(String hiveUdfName, ImmutableList<RelDataType> calciteArgTypes, RelDataType calciteRetType) { CalciteUDFInfo udfInfo = new CalciteUDFInfo(); udfInfo.udfName = hiveUdfName; udfInfo.returnTypeInference = ReturnTypes.explicit(calciteRetType); udfInfo.operandTypeInference = InferTypes.explicit(calciteArgTypes); ImmutableList.Builder<SqlTypeFamily> typeFamilyBuilder = new ImmutableList.Builder<SqlTypeFamily>(); for (RelDataType at : calciteArgTypes) { typeFamilyBuilder.add(Util.first(at.getSqlTypeName().getFamily(), SqlTypeFamily.ANY)); } udfInfo.operandTypeChecker = OperandTypes.family(typeFamilyBuilder.build()); return udfInfo; }
private SqlTypeName getAggTypeForScalarSub(RexSubQuery e) { assert(e.getKind() == SqlKind.SCALAR_QUERY); assert(e.rel.getInputs().size() == 1); Aggregate relAgg = (Aggregate)e.rel.getInput(0); assert( relAgg.getAggCallList().size() == 1); //should only have one aggregate return relAgg.getAggCallList().get(0).getType().getSqlTypeName(); }
/** * utility function to extract timezone id from Druid query * @param query Druid Rel * @return time zone */ private static TimeZone timezoneId(final DruidQuery query, final RexNode arg) { return arg.getType().getSqlTypeName() == SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE ? TimeZone.getTimeZone( query.getTopNode().getCluster().getPlanner().getContext().unwrap(CalciteConnectionConfig.class).timeZone()) : TimeZone.getTimeZone("UTC"); }
/** Creates a call to an aggregate function. */ public AggCall aggregateCall(SqlAggFunction aggFunction, boolean distinct, RexNode filter, String alias, Iterable<? extends RexNode> operands) { if (filter != null) { if (filter.getType().getSqlTypeName() != SqlTypeName.BOOLEAN) { throw Static.RESOURCE.filterMustBeBoolean().ex(); } if (filter.getType().isNullable()) { filter = call(SqlStdOperatorTable.IS_TRUE, filter); } } return new AggCallImpl(aggFunction, distinct, filter, alias, ImmutableList.copyOf(operands)); }
@Test public void testGetTableMapFoo2() { final DruidTable fooTable = (DruidTable) schema.getTableMap().get("foo2"); final RelDataType rowType = fooTable.getRowType(new JavaTypeFactoryImpl()); final List<RelDataTypeField> fields = rowType.getFieldList(); Assert.assertEquals(3, fields.size()); Assert.assertEquals("__time", fields.get(0).getName()); Assert.assertEquals(SqlTypeName.TIMESTAMP, fields.get(0).getType().getSqlTypeName()); Assert.assertEquals("dim2", fields.get(1).getName()); Assert.assertEquals(SqlTypeName.VARCHAR, fields.get(1).getType().getSqlTypeName()); Assert.assertEquals("m1", fields.get(2).getName()); Assert.assertEquals(SqlTypeName.BIGINT, fields.get(2).getType().getSqlTypeName()); } }
@Test public void testGetTableMapFoo() { final DruidTable fooTable = (DruidTable) schema.getTableMap().get("foo"); final RelDataType rowType = fooTable.getRowType(new JavaTypeFactoryImpl()); final List<RelDataTypeField> fields = rowType.getFieldList(); Assert.assertEquals(6, fields.size()); Assert.assertEquals("__time", fields.get(0).getName()); Assert.assertEquals(SqlTypeName.TIMESTAMP, fields.get(0).getType().getSqlTypeName()); Assert.assertEquals("cnt", fields.get(1).getName()); Assert.assertEquals(SqlTypeName.BIGINT, fields.get(1).getType().getSqlTypeName()); Assert.assertEquals("dim1", fields.get(2).getName()); Assert.assertEquals(SqlTypeName.VARCHAR, fields.get(2).getType().getSqlTypeName()); Assert.assertEquals("dim2", fields.get(3).getName()); Assert.assertEquals(SqlTypeName.VARCHAR, fields.get(3).getType().getSqlTypeName()); Assert.assertEquals("m1", fields.get(4).getName()); Assert.assertEquals(SqlTypeName.BIGINT, fields.get(4).getType().getSqlTypeName()); Assert.assertEquals("unique_dim1", fields.get(5).getName()); Assert.assertEquals(SqlTypeName.OTHER, fields.get(5).getType().getSqlTypeName()); }
@Test public void testGetTableMap() { Assert.assertEquals(ImmutableSet.of("segments", "servers", "server_segments", "tasks"), schema.getTableNames()); final Map<String, Table> tableMap = schema.getTableMap(); Assert.assertEquals(ImmutableSet.of("segments", "servers", "server_segments", "tasks"), tableMap.keySet()); final SystemSchema.SegmentsTable segmentsTable = (SystemSchema.SegmentsTable) schema.getTableMap().get("segments"); final RelDataType rowType = segmentsTable.getRowType(new JavaTypeFactoryImpl()); final List<RelDataTypeField> fields = rowType.getFieldList(); Assert.assertEquals(13, fields.size()); final SystemSchema.TasksTable tasksTable = (SystemSchema.TasksTable) schema.getTableMap().get("tasks"); final RelDataType sysRowType = tasksTable.getRowType(new JavaTypeFactoryImpl()); final List<RelDataTypeField> sysFields = sysRowType.getFieldList(); Assert.assertEquals(13, sysFields.size()); Assert.assertEquals("task_id", sysFields.get(0).getName()); Assert.assertEquals(SqlTypeName.VARCHAR, sysFields.get(0).getType().getSqlTypeName()); final SystemSchema.ServersTable serversTable = (SystemSchema.ServersTable) schema.getTableMap().get("servers"); final RelDataType serverRowType = serversTable.getRowType(new JavaTypeFactoryImpl()); final List<RelDataTypeField> serverFields = serverRowType.getFieldList(); Assert.assertEquals(8, serverFields.size()); Assert.assertEquals("server", serverFields.get(0).getName()); Assert.assertEquals(SqlTypeName.VARCHAR, serverFields.get(0).getType().getSqlTypeName()); }
/** * Translates "literal" (a TIMESTAMP or DATE literal) to milliseconds since the epoch using the provided * session time zone. * * @param literal TIMESTAMP or DATE literal * @param timeZone session time zone * * @return milliseconds time */ public static DateTime calciteDateTimeLiteralToJoda(final RexNode literal, final DateTimeZone timeZone) { final SqlTypeName typeName = literal.getType().getSqlTypeName(); if (literal.getKind() != SqlKind.LITERAL || (typeName != SqlTypeName.TIMESTAMP && typeName != SqlTypeName.DATE)) { throw new IAE("Expected literal but got[%s]", literal.getKind()); } if (typeName == SqlTypeName.TIMESTAMP) { final TimestampString timestampString = (TimestampString) RexLiteral.value(literal); return CALCITE_TIMESTAMP_PARSER.parse(timestampString.toString()).withZoneRetainFields(timeZone); } else if (typeName == SqlTypeName.DATE) { final DateString dateString = (DateString) RexLiteral.value(literal); return CALCITE_DATE_PARSER.parse(dateString.toString()).withZoneRetainFields(timeZone); } else { throw new IAE("Expected TIMESTAMP or DATE but got[%s]", typeName); } }
@Test public void testLegalDecimalType() { RelDataTypeSystem typeSystem = new KylinRelDataTypeSystem(); RelDataTypeFactory typeFactory = new SqlTypeFactoryImpl(typeSystem); DataType dataType = DataType.getType("decimal(30, 10)"); RelDataType relDataType = OLAPTable.createSqlType(typeFactory, dataType, true); Assert.assertTrue(relDataType instanceof BasicSqlType); Assert.assertEquals(relDataType.getSqlTypeName(), SqlTypeName.DECIMAL); Assert.assertEquals(relDataType.getPrecision(), 30); Assert.assertTrue(relDataType.getPrecision() <= typeSystem.getMaxNumericPrecision()); Assert.assertEquals(relDataType.getScale(), 10); Assert.assertTrue(relDataType.getScale() <= typeSystem.getMaxNumericScale()); }
@Test public void testIllegalDecimalType() { RelDataTypeSystem typeSystem = new KylinRelDataTypeSystem(); RelDataTypeFactory typeFactory = new SqlTypeFactoryImpl(typeSystem); DataType dataType = DataType.getType("decimal(40, 10)"); RelDataType relDataType = OLAPTable.createSqlType(typeFactory, dataType, true); Assert.assertTrue(relDataType instanceof BasicSqlType); Assert.assertEquals(relDataType.getSqlTypeName(), SqlTypeName.DECIMAL); Assert.assertTrue(typeSystem.getMaxNumericPrecision() < 40); Assert.assertEquals(relDataType.getPrecision(), typeSystem.getMaxNumericPrecision()); Assert.assertEquals(relDataType.getScale(), 10); Assert.assertTrue(relDataType.getScale() <= typeSystem.getMaxNumericScale()); } }