basicSqlType.isNullable() ? 1 : 0, true, basicSqlType.getPrecision(), columnName, columnName, null, null, null, basicSqlType.getPrecision(), basicSqlType.getScale() < 0 ? 0 : basicSqlType.getScale(), basicSqlType.getSqlTypeName().getJdbcOrdinal(), basicSqlType.getSqlTypeName().getName(), true, false, false));
/** * Constructs a type with nullablity. */ BasicSqlType createWithNullability(boolean nullable) { if (nullable == this.isNullable) { return this; } return new BasicSqlType(this.typeSystem, this.typeName, nullable, this.precision, this.scale, this.collation, this.wrappedCharset); }
sb.append(getPrecision()); if (printScale) { sb.append(", "); sb.append(getScale());
/** * Constructs a type with nullablity */ BasicSqlType createWithNullability(boolean nullable) { BasicSqlType ret; try { ret = (BasicSqlType) this.clone(); } catch (CloneNotSupportedException e) { throw new AssertionError(e); } ret.isNullable = nullable; ret.computeDigest(); return ret; }
private List<Object> getValues(BasicSqlType type, boolean inBound) { List<Object> values = new ArrayList<Object>(); for (boolean sign : FALSE_TRUE) { for (SqlTypeName.Limit limit : SqlTypeName.Limit.values()) { Object o = type.getLimit(sign, limit, !inBound); if (o == null) { continue; } if (!values.contains(o)) { values.add(o); } } } return values; }
/** Internal constructor. */ private BasicSqlType( RelDataTypeSystem typeSystem, SqlTypeName typeName, boolean nullable, int precision, int scale, SqlCollation collation, SerializableCharset wrappedCharset) { super(typeName, nullable, null); this.typeSystem = Objects.requireNonNull(typeSystem); this.precision = precision; this.scale = scale; this.collation = collation; this.wrappedCharset = wrappedCharset; computeDigest(); }
@Override public RelDataType createTypeWithNullability( final RelDataType type, final boolean nullable) { final RelDataType newType; if (type instanceof BasicSqlType) { newType = ((BasicSqlType) type).createWithNullability(nullable); } else if (type instanceof MapSqlType) { newType = copyMapType(type, nullable); } else if (type instanceof ArraySqlType) { newType = copyArrayType(type, nullable); } else if (type instanceof MultisetSqlType) { newType = copyMultisetType(type, nullable); } else if (type instanceof IntervalSqlType) { newType = copyIntervalType(type, nullable); } else if (type instanceof ObjectSqlType) { newType = copyObjectType(type, nullable); } else { return super.createTypeWithNullability(type, nullable); } return canonize(newType); }
public RelDataType createTypeWithCharsetAndCollation( RelDataType type, Charset charset, SqlCollation collation) { assert SqlTypeUtil.inCharFamily(type) : type; assert charset != null; assert collation != null; RelDataType newType; if (type instanceof BasicSqlType) { BasicSqlType sqlType = (BasicSqlType) type; newType = sqlType.createWithCharsetAndCollation(charset, collation); } else if (type instanceof JavaType) { JavaType javaType = (JavaType) type; newType = new JavaType( javaType.getJavaClass(), javaType.isNullable(), charset, collation); } else { throw Util.needToImplement("need to implement " + type); } return canonize(newType); }
private static Object safeValue(Object value3, RelDataType relDataType, SqlTypeName sqlTypeName) { if (value3 instanceof BigDecimal) { if (relDataType instanceof BasicSqlType) { sqlTypeName = ((BasicSqlType) relDataType).getSqlTypeName(); } if (sqlTypeName == SqlTypeName.DECIMAL) { return ((BigDecimal) value3).doubleValue(); } return ((BigDecimal) value3).longValue(); } return value3; } }
/** * Constructs a type with charset and collation. * * <p>This must be a character type. */ BasicSqlType createWithCharsetAndCollation(Charset charset, SqlCollation collation) { Preconditions.checkArgument(SqlTypeUtil.inCharFamily(this)); return new BasicSqlType(this.typeSystem, this.typeName, this.isNullable, this.precision, this.scale, collation, SerializableCharset.forCharset(charset)); }
sb.append(getPrecision()); if (printScale) { sb.append(", "); sb.append(getScale());
/** * Constructs a type with precision/length and scale. * * @param typeName Type name */ public BasicSqlType(RelDataTypeSystem typeSystem, SqlTypeName typeName, int precision, int scale) { this(typeSystem, typeName, false, precision, scale); assert typeName.allowsPrecScale(true, true); computeDigest(); }
private List<Object> getValues(BasicSqlType type, boolean inBound) { List<Object> values = new ArrayList<Object>(); for (boolean sign : FALSE_TRUE) { for (SqlTypeName.Limit limit : SqlTypeName.Limit.values()) { Object o = type.getLimit(sign, limit, !inBound); if (o == null) { continue; } if (!values.contains(o)) { values.add(o); } } } return values; }
@Override public RelDataType createTypeWithNullability( final RelDataType type, final boolean nullable) { RelDataType newType; if (type instanceof BasicSqlType) { BasicSqlType sqlType = (BasicSqlType) type; newType = sqlType.createWithNullability(nullable); } else if (type instanceof MapSqlType) { newType = copyMapType(type, nullable); } else if (type instanceof ArraySqlType) { newType = copyArrayType(type, nullable); } else if (type instanceof MultisetSqlType) { newType = copyMultisetType(type, nullable); } else if (type instanceof IntervalSqlType) { newType = copyIntervalType(type, nullable); } else if (type instanceof ObjectSqlType) { newType = copyObjectType(type, nullable); } else { return super.createTypeWithNullability(type, nullable); } return canonize(newType); }
public RelDataType createTypeWithCharsetAndCollation( RelDataType type, Charset charset, SqlCollation collation) { assert SqlTypeUtil.inCharFamily(type) : type; assert charset != null; assert collation != null; RelDataType newType; if (type instanceof BasicSqlType) { BasicSqlType sqlType = (BasicSqlType) type; newType = sqlType.createWithCharsetAndCollation(charset, collation); } else if (type instanceof JavaType) { JavaType javaType = (JavaType) type; newType = new JavaType( javaType.getJavaClass(), javaType.isNullable(), charset, collation); } else { throw Util.needToImplement("need to implement " + type); } return canonize(newType); }
private RelOptTable createVirtualRelOptTable() { List<String> names = createVirtualTableName(); RelDataTypeSystem relDataTypeSystem = new VirtualTypeSystem(); RelDataTypeFieldImpl relDataTypeField = new RelDataTypeFieldImpl( "columnName", 0, new BasicSqlType(relDataTypeSystem, SqlTypeName.ANY)); List<RelDataTypeField> relDataTypeFieldList = new ArrayList<>(); relDataTypeFieldList.add(relDataTypeField); return RelOptTableImpl.create(null, new RelRecordType(relDataTypeFieldList), new VirtualTable(names.get(0)), names, null); }
SqlTypeName.Limit limit, boolean beyond) { int precision = typeName.allowsPrec() ? this.getPrecision() : -1; int scale = typeName.allowsScale() ? this.getScale() : -1; return typeName.getLimit( sign,
/** * Constructs a type with precision/length but no scale. * * @param typeName Type name */ public BasicSqlType(RelDataTypeSystem typeSystem, SqlTypeName typeName, int precision) { this(typeSystem, typeName, false, precision, SCALE_NOT_SPECIFIED); assert typeName.allowsPrecScale(true, false) : "typeName.allowsPrecScale(true, false)"; computeDigest(); }
SqlTypeName.Limit limit, boolean beyond) { Object o = ((BasicSqlType) type).getLimit(sign, limit, beyond); if (o == null) { return;
public RelDataType createSqlType( SqlTypeName typeName, int precision, int scale) { assertBasic(typeName); assert (precision >= 0) || (precision == RelDataType.PRECISION_NOT_SPECIFIED); final int maxPrecision = typeSystem.getMaxPrecision(typeName); if (maxPrecision >= 0 && precision > maxPrecision) { precision = maxPrecision; } RelDataType newType = new BasicSqlType(typeSystem, typeName, precision, scale); newType = SqlTypeUtil.addCharsetAndCollation(newType, this); return canonize(newType); }