Java LiquibaseDataType类代码示例

import liquibase.datatype.LiquibaseDataType; //导入依赖的package包/类
@Override
public Sql[] generateSql(final CreateTableStatement statement, final Database database,
      final SqlGeneratorChain sqlGeneratorChain) {
   final List<Sql> list = new ArrayList<Sql>(Arrays.asList(sqlGeneratorChain.generateSql(
         statement, database)));
   for (final Entry<String, LiquibaseDataType> entry : statement.getColumnTypes().entrySet()) {
      if (entry.getValue() instanceof GeometryType) {
         final String columnName = entry.getKey();
         final GeometryType geometryType = (GeometryType) entry.getValue();
         final AddGeometryColumnGeneratorGeoDB generator = new AddGeometryColumnGeneratorGeoDB();
         final AddColumnStatement addColumnStatement = new AddColumnStatement(
               statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(),
               columnName, geometryType.toString(), null);
         @SuppressWarnings("rawtypes")
         final SqlGeneratorChain emptyChain = new SqlGeneratorChain(new TreeSet<SqlGenerator>());
         final Sql[] addGeometryColumnSql = generator.generateSql(addColumnStatement, database,
               emptyChain);
         list.addAll(Arrays.asList(addGeometryColumnSql));
      }
   }
   return list.toArray(new Sql[list.size()]);
}
 

import liquibase.datatype.LiquibaseDataType; //导入依赖的package包/类
@Override
public ValidationErrors validate(final AddColumnStatement statement,
      final Database database, final SqlGeneratorChain sqlGeneratorChain) {
   final ValidationErrors errors = new ValidationErrors();
   final LiquibaseDataType dataType = DataTypeFactory.getInstance()
         .fromDescription(statement.getColumnType(), database);

   // Ensure that the SRID parameter is provided.
   if (dataType instanceof GeometryType) {
      final GeometryType geometryType = (GeometryType) dataType;
      if (geometryType.getSRID() == null) {
         errors.addError("The SRID parameter is required on the geometry type");
      }
   }
   final ValidationErrors chainErrors = sqlGeneratorChain.validate(
         statement, database);
   if (chainErrors != null) {
      errors.addAll(chainErrors);
   }
   return errors;
}
 

import liquibase.datatype.LiquibaseDataType; //导入依赖的package包/类
@Test
public void timestampAliases() throws Exception {
    LiquibaseDataType liquibaseDataType = DataTypeFactory.getInstance().fromDescription("datetime", snowflakeDatabase);
    String[] aliases = liquibaseDataType.getAliases();
    assertEquals(2, aliases.length);
    assertThat(aliases, hasItemInArray("datetime"));
    assertThat(aliases, hasItemInArray("java.sql.Types.DATETIME"));
}
 

import liquibase.datatype.LiquibaseDataType; //导入依赖的package包/类
@Override
public ValidationErrors validate(final CreateTableStatement statement, final Database database,
      final SqlGeneratorChain sqlGeneratorChain) {
   final ValidationErrors validationErrors = new ValidationErrors();
   for (final Entry<String, LiquibaseDataType> entry : statement.getColumnTypes().entrySet()) {
      if (entry.getValue() instanceof GeometryType) {
         final GeometryType geometryType = (GeometryType) entry.getValue();
         if (geometryType.getSRID() == null) {
            validationErrors.addError("The SRID parameter is required on the geometry type");
         }
      }
   }
   validationErrors.addAll(sqlGeneratorChain.validate(statement, database));
   return validationErrors;
}
 

import liquibase.datatype.LiquibaseDataType; //导入依赖的package包/类
/**
 * @see liquibase.sqlgenerator.core.AddDefaultValueGenerator#generateSql(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, liquibase.sqlgenerator.SqlGeneratorChain)
 */
@Override
public Sql[] generateSql(AddDefaultValueStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
	Object defaultValue = statement.getDefaultValue();
       LiquibaseDataType defaultValueType = DataTypeFactory.getInstance().fromObject(defaultValue, database);
	return new Sql[]{
			new UnparsedSql("ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
					+ " ADD  "
                       + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName())
                       + " DEFAULT "
					+ (defaultValueType instanceof DateTimeType ?" TIMESTAMP ":(defaultValueType instanceof DateType ?" DATE ":(defaultValueType instanceof TimeType ?" TIME ":"")))
					+ defaultValueType.objectToSql(defaultValue, database),
					new Column().setRelation(new Table().setName(statement.getTableName()).setSchema(new Schema(statement.getCatalogName(), statement.getSchemaName())).setName(statement.getColumnName())))
	};
}
 

import liquibase.datatype.LiquibaseDataType; //导入依赖的package包/类
/**
 * has <code>dataType</code> auto increment property ?
 */
   //FIXME remove if will be accepted  https://github.com/liquibase/liquibase/pull/247
private boolean isAutoIncrement(LiquibaseDataType dataType) {
	boolean retVal = false;
	String methodName = "isAutoIncrement";
	Method[] methods = dataType.getClass().getMethods();
	for (Method method : methods) {
		if (method.getName().equals(methodName)
				&& method.getParameterTypes().length == 0) {
			retVal = true;
			break;
		}
	}
	return retVal;
}
 

import liquibase.datatype.LiquibaseDataType; //导入依赖的package包/类
@Test
public void datetimeConvertsToTimestamp() throws Exception {
    LiquibaseDataType liquibaseDataType = DataTypeFactory.getInstance().fromDescription("datetime", snowflakeDatabase);
    assertEquals("liquibase.ext.snowflake.datatype.TimestampNTZType", liquibaseDataType.getClass().getName());
}
 

import liquibase.datatype.LiquibaseDataType; //导入依赖的package包/类
@Override
public Sql[] generateSql(final AddColumnStatement statement,
      final Database database, final SqlGeneratorChain sqlGeneratorChain) {

   GeometryType geometryType = null;
   final LiquibaseDataType dataType = DataTypeFactory.getInstance()
         .fromDescription(statement.getColumnType(), database);
   if (dataType instanceof GeometryType) {
      geometryType = (GeometryType) dataType;
   }

   final boolean isGeometryColumn = geometryType != null;

   // The AddGeometryColumn procedure handles the column already being
   // present, so let a
   // downstream SQL generator handle the typical column addition logic (e.g.
   // placement in the
   // table) then invoke the procedure.
   final List<Sql> list = new ArrayList<Sql>();
   list.addAll(Arrays.asList(sqlGeneratorChain.generateSql(statement,
         database)));
   if (isGeometryColumn) {
      String schemaName = statement.getSchemaName();
      if (schemaName == null) {
         schemaName = database.getDefaultSchemaName();
      }
      final String tableName = statement.getTableName();
      final String columnName = statement.getColumnName();

      final int srid = geometryType.getSRID();
      final String geomType = StringUtils.trimToNull(geometryType
            .getGeometryType()) == null ? "'Geometry'" : "'"
            + database.escapeStringForDatabase(geometryType
                  .getGeometryType()) + "'";
      final String sql = "CALL AddGeometryColumn('" + schemaName + "', '"
            + tableName + "', '" + columnName + "', " + srid + ", "
            + geomType + ", 2)";
      final Sql addGeometryColumn = new UnparsedSql(sql);
      list.add(addGeometryColumn);
   }
   return list.toArray(new Sql[list.size()]);
}
 

import liquibase.datatype.LiquibaseDataType; //导入依赖的package包/类
@Override
public Sql[] generateSql(AddColumnStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
	String alterTable = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) +
               " ADD " +
               database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName())
               + " " + DataTypeFactory.getInstance().fromDescription(statement.getColumnType() + (statement.isAutoIncrement() ? "{autoIncrement:true}" : ""), database).toDatabaseDataType(database);

	if (statement.isAutoIncrement() && database.supportsAutoIncrement()) {
		alterTable += " " + database.getAutoIncrementClause(null, null);
	}

	if (!statement.isNullable()) {
		alterTable += " NOT NULL";
	} else {
		if (database instanceof SybaseDatabase || database instanceof SybaseASADatabase) {
			alterTable += " NULL";
		}
	}

	if (statement.getDefaultValue()!=null){
		alterTable += " DEFAULT ";
		LiquibaseDataType defaultValueType = DataTypeFactory.getInstance().fromDescription(statement.getColumnType() + (statement.isAutoIncrement() ? "{autoIncrement:true}" : ""), database);
		alterTable +=(defaultValueType instanceof DateTimeType ?" TIMESTAMP ":(defaultValueType instanceof DateType ?" DATE ":(defaultValueType instanceof TimeType ?" TIME ":"")));
		alterTable += DataTypeFactory.getInstance().fromObject(statement.getDefaultValue(), database).objectToSql(statement.getDefaultValue(), database);
	}

	List<Sql> returnSql = new ArrayList<Sql>();
	returnSql.add(new UnparsedSql(alterTable, new Column().setRelation(new Table().setName(statement.getTableName()).setSchema(new Schema(statement.getCatalogName(), statement.getSchemaName())).setName(statement.getColumnName()))));

	if (statement.isPrimaryKey()) {
		returnSql.addAll(Arrays.asList(SqlGeneratorFactory.getInstance().generateSql(new AddPrimaryKeyStatement(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName(), null) , database)));
	}

	if (statement.isUnique()) {
		returnSql.addAll(Arrays.asList(SqlGeneratorFactory.getInstance().generateSql(new AddUniqueConstraintStatement(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), new ColumnConfig[] { new ColumnConfig().setName(statement.getColumnName())}, null) , database)));
	}
	//	if (statement.getDefaultValue()!=null)
	//		returnSql.addAll(Arrays.asList(SqlGeneratorFactory.getInstance().generateSql(new AddDefaultValueStatement(statement.getSchemaName(), statement.getTableName(), statement.getColumnName(), statement.getColumnType(), statement.getDefaultValue()) , database)));

	addForeignKeyStatements(statement, database, returnSql);

	return returnSql.toArray(new Sql[returnSql.size()]);
}
 

import liquibase.datatype.LiquibaseDataType; //导入依赖的package包/类
@Override
protected DatabaseObject snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot) throws DatabaseException, InvalidExampleException {
    HibernateDatabase database = (HibernateDatabase) snapshot.getDatabase();
    Configuration cfg = database.getConfiguration();

    Dialect dialect = database.getDialect();
    Mapping mapping = cfg.buildMapping();

    org.hibernate.mapping.Table hibernateTable = findHibernateTable(example, snapshot);
    if (hibernateTable == null) {
        return null;
    }

    Table table = new Table().setName(hibernateTable.getName());
    PrimaryKey primaryKey = null;
    int pkColumnPosition = 0;
    LOG.info("Found table " + table.getName());

    table.setSchema(example.getSchema());

    Iterator columnIterator = hibernateTable.getColumnIterator();
    while (columnIterator.hasNext()) {
        org.hibernate.mapping.Column hibernateColumn = (org.hibernate.mapping.Column) columnIterator.next();
        Column column = new Column();
        column.setName(hibernateColumn.getName());

        String hibernateType = hibernateColumn.getSqlType(dialect, mapping);
        DataType dataType = toDataType(hibernateType, hibernateColumn.getSqlTypeCode());
        if (dataType == null) {
            throw new DatabaseException("Unable to find column data type for column " + hibernateColumn.getName());
        }

        column.setType(dataType);
        LOG.info("Found column " + column.getName() + " " + column.getType().toString());

        column.setRemarks(hibernateColumn.getComment());
        column.setDefaultValue(hibernateColumn.getDefaultValue());
        column.setNullable(hibernateColumn.isNullable());
        column.setCertainDataType(false);

        org.hibernate.mapping.PrimaryKey hibernatePrimaryKey = hibernateTable.getPrimaryKey();
        if (hibernatePrimaryKey != null) {
            boolean isPrimaryKeyColumn = false;
            //noinspection unchecked
            for (org.hibernate.mapping.Column pkColumn : (List<org.hibernate.mapping.Column>) hibernatePrimaryKey.getColumns()) {
                if (pkColumn.getName().equals(hibernateColumn.getName())) {
                    isPrimaryKeyColumn = true;
                    break;
                }
            }

            if (isPrimaryKeyColumn) {
                if (primaryKey == null) {
                    primaryKey = new PrimaryKey();
                    primaryKey.setName(hibernatePrimaryKey.getName());
                }
                primaryKey.addColumnName(pkColumnPosition++, column.getName());

                LiquibaseDataType liquibaseDataType = DataTypeFactory
			.getInstance().from(column.getType());
	// only columns types supporting auto increment -
	// DataTypeFactory
	if (isAutoIncrement(liquibaseDataType)) {

		if (dialect.getNativeIdentifierGeneratorClass().equals(
				IdentityGenerator.class)) {
			column.setAutoIncrementInformation(new Column.AutoIncrementInformation());
		}
	}
            }
        }
        column.setRelation(table);

        table.setPrimaryKey(primaryKey);
        table.getColumns().add(column);

    }

    return table;
}