protected Column createColumnFromConstant(String columnName, String constantValue) { ColumnEditor column = Column.editor().name(columnName); try { if (constantValue.startsWith("'") || constantValue.startsWith("\"")) { column.type("CHAR"); column.jdbcType(Types.CHAR); column.length(constantValue.length() - 2); } else if (constantValue.equalsIgnoreCase("TRUE") || constantValue.equalsIgnoreCase("FALSE")) { column.type("BOOLEAN"); column.jdbcType(Types.BOOLEAN); } else { setTypeInfoForConstant(constantValue, column); } } catch (Throwable t) { logger.debug("Unable to create an artificial column for the constant: " + constantValue); } return column.create(); }
@Override public void enterAutoIncrementColumnConstraint(MySqlParser.AutoIncrementColumnConstraintContext ctx) { columnEditor.autoIncremented(true); columnEditor.generated(true); super.enterAutoIncrementColumnConstraint(ctx); }
/** * Returns a {@link ColumnEditor} representing the current record of the given result set of column metadata, if * included in the column whitelist. */ protected Optional<ColumnEditor> readTableColumn(ResultSet columnMetadata, TableId tableId, ColumnNameFilter columnFilter) throws SQLException { final String columnName = columnMetadata.getString(4); if (columnFilter == null || columnFilter.matches(tableId.catalog(), tableId.schema(), tableId.table(), columnName)) { final ColumnEditor column = Column.editor().name(columnName); column.jdbcType(columnMetadata.getInt(5)); column.type(columnMetadata.getString(6)); column.length(columnMetadata.getInt(7)); if (columnMetadata.getObject(9) != null) { column.scale(columnMetadata.getInt(9)); } column.optional(isNullable(columnMetadata.getInt(11))); column.position(columnMetadata.getInt(17)); column.autoIncremented("YES".equalsIgnoreCase(columnMetadata.getString(23))); String autogenerated = null; try { autogenerated = columnMetadata.getString(24); } catch (SQLException e) { // ignore, some drivers don't have this index - e.g. Postgres } column.generated("YES".equalsIgnoreCase(autogenerated)); column.nativeType(resolveNativeType(column.typeName())); return Optional.of(column); } return Optional.empty(); }
protected void setTypeInfoForConstant(String constantValue, ColumnEditor column) { try { Integer.parseInt(constantValue); column.type("INTEGER"); column.jdbcType(Types.INTEGER); column.type("BIGINT"); column.jdbcType(Types.BIGINT); column.type("FLOAT"); column.jdbcType(Types.FLOAT); column.type("DOUBLE"); column.jdbcType(Types.DOUBLE); int precision = 0; int scale = 0; column.length(precision); column.scale(scale); column.type("DECIMAL"); column.jdbcType(Types.DECIMAL); column.length(decimal.precision()); column.scale(decimal.precision());
column.unsetDefaultValue(); column.jdbcType(dataType.jdbcType()); column.type(dataType.name(), dataType.expression()); if ("ENUM".equals(dataType.name())) { column.length(1); } else if ("SET".equals(dataType.name())) { List<String> options = parseSetAndEnumOptions(dataType.expression()); column.length(Math.max(0, options.size() * 2 - 1)); // number of options + number of commas } else { if (dataType.length() > -1) column.length((int) dataType.length()); if (dataType.scale() > -1) column.scale(dataType.scale()); column.charsetName("utf8"); column.length(10); column.scale(0); column.charsetName(charsetName); column.optional(false); } else if (tokens.canConsume("NULL")) { column.optional(true); column.autoIncremented(true); column.autoIncremented(true);
final ColumnEditor ce = column.edit().optional(false); if (ce.hasDefaultValue() && ce.defaultValue() == null) { ce.unsetDefaultValue(); tableEditor.addColumn(ce.create());
@Override public void enterPrimaryKeyColumnConstraint(MySqlParser.PrimaryKeyColumnConstraintContext ctx) { // this rule will be parsed only if no primary key is set in a table // otherwise the statement can't be executed due to multiple primary key error columnEditor.optional(false); tableEditor.addColumn(columnEditor.create()); tableEditor.setPrimaryKeyNames(columnEditor.name()); super.enterPrimaryKeyColumnConstraint(ctx); }
protected void updatePositions() { AtomicInteger position = new AtomicInteger(1); sortedColumns.replaceAll((name, defn) -> { // Decrement the position ... int nextPosition = position.getAndIncrement(); if (defn.position() != nextPosition) { return defn.edit().position(nextPosition).create(); } return defn; }); }
public Column getColumn() { return columnEditor.create(); }
protected void parseIdentityColumnSpec(Marker start, ColumnEditor column) { column.generated(true); column.autoIncremented(true); column.optional(false); tokens.consume("GENERATED"); if (tokens.canConsume("BY")) { tokens.consume("DEFAULT"); } else { tokens.consume("ALWAYS"); if (tokens.canConsume("AS", "(")) { // Consume everything (we don't care what it is) ... tokens.consumeThrough(')', '('); return; } } tokens.consume("AS", "IDENTITY"); if (tokens.canConsume('(')) { // Consume everything (we don't care what it is) ... tokens.consumeThrough(')', '('); } }
private void convertDefaultValueToSchemaType(ColumnEditor columnEditor) { final Column column = columnEditor.create(); // if converters is not null and the default value is not null, we need to convert default value if (converters != null && columnEditor.defaultValue() != null) { Object defaultValue = columnEditor.defaultValue(); final SchemaBuilder schemaBuilder = converters.schemaBuilder(column); if (schemaBuilder == null) { return; } final Schema schema = schemaBuilder.build(); //In order to get the valueConverter for this column, we have to create a field; //The index value -1 in the field will never used when converting default value; //So we can set any number here; final Field field = new Field(column.name(), -1, schema); final ValueConverter valueConverter = converters.converter(column, field); if (defaultValue instanceof String) { defaultValue = defaultValuePreConverter.convert(column, (String)defaultValue); } defaultValue = valueConverter.convert(defaultValue); columnEditor.defaultValue(defaultValue); } }
@Override public Table create() { if (id == null) throw new IllegalStateException("Unable to create a table from an editor that has no table ID"); List<Column> columns = new ArrayList<>(); sortedColumns.values().forEach(column->{ column = column.edit().charsetNameOfTable(defaultCharsetName).create(); columns.add(column); }); return new TableImpl(id, columns, primaryKeyColumnNames(), defaultCharsetName); } }
@Override public void enterNullNotnull(MySqlParser.NullNotnullContext ctx) { columnEditor.optional(ctx.NOT() == null); super.enterNullNotnull(ctx); }
@Override public void enterAlterByAddColumns(MySqlParser.AlterByAddColumnsContext ctx) { // multiple columns are added. Initialize a list of column editors for them parser.runIfNotNull(() -> { columnEditors = new ArrayList<>(ctx.uid().size()); for (MySqlParser.UidContext uidContext : ctx.uid()) { String columnName = parser.parseName(uidContext); columnEditors.add(Column.editor().name(columnName)); } columnDefinitionListener = new ColumnDefinitionParserListener(tableEditor, columnEditors.get(0), parser.dataTypeResolver(), parser.getConverters()); listeners.add(columnDefinitionListener); }, tableEditor); super.enterAlterByAddColumns(ctx); }
private void setScale(Precision_partContext precisionPart, ColumnEditor columnEditor) { if (precisionPart.numeric().size() > 1) { columnEditor.scale(Integer.valueOf(precisionPart.numeric(1).getText())); } else if (precisionPart.numeric_negative() != null) { columnEditor.scale(Integer.valueOf(precisionPart.numeric_negative().getText())); } else { columnEditor.scale(0); } }
private void setPrecision(Precision_partContext precisionPart, ColumnEditor columnEditor) { columnEditor.length(Integer.valueOf(precisionPart.numeric(0).getText())); }
@Override public void enterAlterByChangeDefault(MySqlParser.AlterByChangeDefaultContext ctx) { parser.runIfNotNull(() -> { String columnName = parser.parseName(ctx.uid()); Column column = tableEditor.columnWithName(columnName); if (column != null) { ColumnEditor columnEditor = column.edit(); columnEditor.generated(ctx.DROP() != null); } }, tableEditor); super.enterAlterByChangeDefault(ctx); }