public ColumnDefinition(Field<?> field) { DataType<?> dataType = field.getDataType(); setPk(dataType.identity()); DataType<?> defaultType = dataType.getSQLDataType(); if (defaultType == null) { defaultType = DefaultDataType.getDefaultDataType(dataType.getTypeName()); } setType(defaultType.getTypeName()); if (dataType.hasLength()) { setLength(dataType.length()); } if (dataType.hasPrecision()) { setPrecision(dataType.precision()); } if (dataType.hasScale()) { setScale(dataType.scale()); } setNullable(dataType.nullable()); }
public DefaultDataType(SQLDialect dialect, DataType<T> sqlDataType, String typeName) { this(dialect, sqlDataType, sqlDataType.getType(), typeName, typeName, sqlDataType.precision(), sqlDataType.scale(), sqlDataType.length(), sqlDataType.nullability(), sqlDataType.defaultValue()); }
@Override public int getSQLType() { return delegate.getSQLType(); }
private DataType<?> mapJavaTimeTypes(DataType<?> dataType) { DataType<?> result = dataType; // [#4429] [#5713] This logic should be implemented in Configuration if (dataType.isDateTime() && generateJavaTimeTypes) { if (dataType.getType() == Date.class) result = SQLDataType.LOCALDATE; else if (dataType.getType() == Time.class) result = SQLDataType.LOCALTIME; else if (dataType.getType() == Timestamp.class) result = SQLDataType.LOCALDATETIME; } return result; }
public ArrayDataType(DataType<T> elementType) { super(null, elementType.getArrayType(), elementType.getTypeName(), elementType.getCastTypeName()); this.elementType = elementType; }
if (type.identity()) { switch (ctx.family()) { case POSTGRES: ctx.visit(type.getType() == Long.class ? K_SERIAL8 : K_SERIAL); return; if (EnumType.class.isAssignableFrom(type.getType())) { if (type.getType() == UUID.class) { switch (ctx.family()) { case MARIADB: String typeName = type.getTypeName(ctx.configuration()); if (type.hasLength() || elementType.hasLength()) { if (type.isBinary() && NO_SUPPORT_BINARY_TYPE_LENGTH.contains(ctx.family())) ctx.sql(typeName); else if (type.length() > 0) ctx.sql(typeName).sql('(').sql(type.length()).sql(')'); String castTypeName = type.getCastTypeName(ctx.configuration()); else if (type.hasPrecision() && type.precision() > 0) { if (type.hasScale()) ctx.sql(typeName).sql('(').sql(type.precision()).sql(", ").sql(type.scale()).sql(')'); else ctx.sql(typeName).sql('(').sql(type.precision()).sql(')'); else if (type.identity() && ctx.family() == SQLITE && type.isNumeric()) {
db, schema, DefaultDataType.getDataType(db.getDialect(), String.class).getTypeName(), l, p, s, n, d, (Name) null ))); sb.append(".asEnumDataType("); dataType = SQLDataType.OTHER.nullable(n).identity(i); .nullable(n) .identity(i); dataType = dataType.defaultValue((Field) DSL.field(d, dataType)); if (dataType.getSQLDataType() != null && sb.length() == 0) { DataType<?> sqlDataType = dataType.getSQLDataType(); String literal = SQLDATATYPE_LITERAL_LOOKUP.get(sqlDataType); sqlDataTypeRef = if (dataType.hasPrecision() && p > 0) { if (dataType.hasScale() && s > 0) sb.append(", ").append(s); if (dataType.hasLength() && l > 0) if (!dataType.nullable()) sb.append(".nullable(false)"); if (dataType.identity()) sb.append(".identity(true)");
ic.setColumnName(f.getName()); ic.setComment(f.getComment()); ic.setDataType(f.getDataType().getTypeName(configuration)); if (f.getDataType().hasLength()) ic.setCharacterMaximumLength(f.getDataType().length()); if (f.getDataType().hasPrecision()) ic.setNumericPrecision(f.getDataType().precision()); if (f.getDataType().hasScale()) ic.setNumericScale(f.getDataType().scale()); ic.setColumnDefault(DSL.using(configuration).render(f.getDataType().defaultValue())); ic.setIsNullable(f.getDataType().nullable()); ic.setOrdinalPosition(i + 1);
public DataType<?> getDataType(DSLContext dsl) { override(dsl); DataType<?> result = DefaultDataType.getDataType(SQLDialect.DEFAULT, type); if (result.isNumeric() && !result.hasScale()) { result = result.identity(pk); } if (length >= 0) { result = result.length(length); } if (precision >= 0) { result = result.precision(precision); } if (scale >= 0) { result = result.scale(scale); } result = result.nullable(nullable); return result; }
DataType<T> sqlDataType = dataType.getSQLDataType(); SQLDialect family = ctx.family(); else if (( POSTGRES == family) && (sqlDataType == null || (!sqlDataType.isTemporal() && sqlDataType != SQLDataType.UUID))) sql(ctx, converted); sqlCast(ctx, converted, Tools.emulateEnumType((DataType<EnumType>) dataType), dataType.length(), dataType.precision(), dataType.scale()); sqlCast(ctx, converted, dataType, dataType.length(), dataType.precision(), dataType.scale());
@Override public String getTypeName(Configuration configuration) { return delegate.getTypeName(configuration); }
private final <U> Condition equal(Field<U> pk, Collection<T> ids) { if (ids.size() == 1) { return equal(pk, ids.iterator().next()); } else { return pk.in(pk.getDataType().convert(ids)); } }
if (SQLDataType.DATE.equals(dataType.getSQLDataType())) { DataType<?> forcedDataType = getDataType(db, SQLDataType.TIMESTAMP.getTypeName(), 0, 0); result = new DefaultDataTypeDefinition(db, child.getSchema(), forcedDataType.getTypeName(), 0, 0, 0, result.isNullable(), result.getDefaultValue(), (Name) null, null, DateAsTimestampBinding.class.getName()); try { tType = getDataType(db, definedType.getType(), definedType.getPrecision(), definedType.getScale()) .getType() .getName();
boolean standardOverlaps = type0.isDateTime() && type1.isTemporal(); boolean intervalOverlaps = type0.isDateTime() && (type1.isInterval() || type1.isNumeric());
private String getSqlType(Field<?> field, Configuration conf) { if (field.getConverter() != null) { Class<?> fieldType = field.getDataType().getType(); if (fieldType.equals(ScalarArray.class)) { return GreenplumScalarTypeToSqlType.ARRAY_TYPE; } if (fieldType.equals(ScalarMongoObjectId.class)) { return GreenplumScalarTypeToSqlType.FULL_MONGO_OBJECT_ID_TYPE; } if (fieldType.equals(ScalarMongoTimestamp.class)) { return GreenplumScalarTypeToSqlType.FULL_MONGO_TIMESTAMP_TYPE; } } return field.getDataType().getTypeName(conf); }
lhs.getDataType().isDateTime() && (rhs.get(0).getDataType().isNumeric() || rhs.get(0).getDataType().isInterval())) {
ConvertedDataType(DataType<T> delegate, Converter<? super T, U> converter) { super(null, converter.toType(), delegate.getTypeName(), delegate.getCastTypeName()); this.delegate = delegate; this.converter = converter; DataTypes.registerConverter(converter.toType(), converter); }