private SqlNode maybeCast(SqlNode node, RelDataType currentType, RelDataType desiredType) { return currentType.equals(desiredType) || (currentType.isNullable() != desiredType.isNullable() && typeFactory.createTypeWithNullability(currentType, desiredType.isNullable()).equals(desiredType)) ? node : SqlStdOperatorTable.CAST.createCall(SqlParserPos.ZERO, node, SqlTypeUtil.convertTypeToSpec(desiredType)); }
final RelDataType type1 = field1.getValue(); final boolean nullable = type.isNullable() && type1.isNullable(); final RelDataType type2 = SqlTypeUtil.leastRestrictiveForComparison(typeFactory, type,
@Override public RelDataType deriveSumType(RelDataTypeFactory typeFactory, RelDataType argumentType) { if (argumentType instanceof BasicSqlType) { switch (argumentType.getSqlTypeName()) { case INTEGER: case SMALLINT: case TINYINT: return typeFactory.createTypeWithNullability(typeFactory.createSqlType(SqlTypeName.BIGINT), argumentType.isNullable()); case DECIMAL: return typeFactory.createTypeWithNullability( typeFactory.createSqlType(SqlTypeName.DECIMAL, 19, argumentType.getScale()), argumentType.isNullable()); default: break; } } return argumentType; }
@Override public Void visitCall(RexCall call) { if(AnnotationUtils.getAnnotation(GenericUDFOPNotNull.class, Description.class).name().equals(call.getOperator().getName())) { if(call.getOperands().get(0) instanceof RexInputRef && !types.get(((RexInputRef)call.getOperands().get(0)).getIndex()).getType().isNullable()) { // No need to add not null filter for a constant. throw new Util.FoundOne(call); } } return super.visitCall(call); }
@Override public Object[] apply(final RelDataTypeField field) { final RelDataType type = field.getType(); boolean isNumeric = SqlTypeName.NUMERIC_TYPES.contains(type.getSqlTypeName()); boolean isCharacter = SqlTypeName.CHAR_TYPES.contains(type.getSqlTypeName()); boolean isDateTime = SqlTypeName.DATETIME_TYPES.contains(type.getSqlTypeName()); return new Object[]{ CATALOG_NAME, // TABLE_CATALOG schemaName, // TABLE_SCHEMA tableName, // TABLE_NAME field.getName(), // COLUMN_NAME String.valueOf(field.getIndex()), // ORDINAL_POSITION "", // COLUMN_DEFAULT type.isNullable() ? "YES" : "NO", // IS_NULLABLE type.getSqlTypeName().toString(), // DATA_TYPE null, // CHARACTER_MAXIMUM_LENGTH null, // CHARACTER_OCTET_LENGTH isNumeric ? String.valueOf(type.getPrecision()) : null, // NUMERIC_PRECISION isNumeric ? "10" : null, // NUMERIC_PRECISION_RADIX isNumeric ? String.valueOf(type.getScale()) : null, // NUMERIC_SCALE isDateTime ? String.valueOf(type.getPrecision()) : null, // DATETIME_PRECISION isCharacter ? type.getCharset().name() : null, // CHARACTER_SET_NAME isCharacter ? type.getCollation().getCollationName() : null, // COLLATION_NAME Long.valueOf(type.getSqlTypeName().getJdbcOrdinal()) // JDBC_TYPE (Druid extension) }; } }
@Override public Void visitCall(RexCall call) { if(AnnotationUtils.getAnnotation(GenericUDFOPNotNull.class, Description.class).name().equals(call.getOperator().getName())) { if(call.getOperands().get(0) instanceof RexInputRef && !types.get(((RexInputRef)call.getOperands().get(0)).getIndex()).getType().isNullable()) { // No need to add not null filter for a constant. throw new Util.FoundOne(call); } } return super.visitCall(call); } }
private static List<RexNode> getNotNullConditions(RelOptCluster cluster, RexBuilder rexBuilder, RelNode input, Set<Integer> inputKeyPositions, Set<String> pushedPredicates) { final List<RexNode> newConditions = Lists.newArrayList(); for (int pos : inputKeyPositions) { RelDataType keyType = input.getRowType().getFieldList().get(pos).getType(); // Nothing to do if key cannot be null if (!keyType.isNullable()) { continue; } RexNode cond = rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, rexBuilder.makeInputRef(input, pos)); String digest = cond.toString(); if (pushedPredicates.add(digest)) { newConditions.add(cond); } } return newConditions; }
@Override public RelDataType toSql(RelDataType type) { if (type instanceof JavaType) { JavaType javaType = (JavaType) type; SqlTypeName sqlTypeName = JavaToSqlTypeConversionRules.instance().lookup(javaType.getJavaClass()); if (sqlTypeName == null) { sqlTypeName = SqlTypeName.ANY; } return createTypeWithNullability(createSqlType(sqlTypeName), type.isNullable()); } return super.toSql(type); } }
/** 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)); }
sources.add(source.appendAll(source2)); final boolean nullable = (f.getType().isNullable() || join.getJoinType().generatesNullsOnLeft()) && (f2.getType().isNullable() || join.getJoinType().generatesNullsOnRight()); b.add(f).nullable(nullable);
if (operand instanceof RexInputRef) { RexInputRef inputRef = (RexInputRef) operand; if (!inputRef.getType().isNullable()) { if (alwaysTrue) { call.transformTo(filter.getInput());
final boolean nullable = rowType.getFieldList().get(i).getType().isNullable();
if (operand instanceof RexInputRef) { RexInputRef inputRef = (RexInputRef) operand; if (!inputRef.getType().isNullable()) { if (alwaysTrue) { call.transformTo(filter.getInput());
/** 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)); }
switch (strategies.get(field.getIndex())) { case NOT_NULLABLE: assert !field.getType().isNullable(); if (targetField == null) { throw newValidationError(node, assert field.getType().isNullable(); break; case VIRTUAL:
false, // searchable false, // currency field.getType().isNullable() ? DatabaseMetaData.columnNullable
); if (rexNode.getType().isNullable()) { final DimFilter nonNullFilter = Expressions.toFilter( plannerContext,
if (!constExp.getType().isNullable() && exprResult.isNumericNull()) { throw new IAE("Illegal DATE constant: %s", constExp); if (!constExp.getType().isNullable() && exprResult.isNumericNull()) { throw new IAE("Illegal TIMESTAMP constant: %s", constExp);
: Pair.zip(rowConstructor.getOperandList(), targetRowType.getFieldList())) { if (!pair.right.getType().isNullable() && SqlUtil.isNullLiteral(pair.left, false)) { throw newValidationError(node,
Assert.assertTrue(relDataType.getComponentType() instanceof BasicSqlType); Assert.assertEquals(SqlTypeName.VARCHAR, relDataType.getComponentType().getSqlTypeName()); Assert.assertTrue(relDataType.isNullable());