Ejemplo n.º 1
0
  @Override
  public void init() throws DatabaseException {

    boolean createdTable = false;
    Executor executor = ExecutorService.getInstance().getExecutor(database);
    if (!hasDatabaseChangeLogLockTable()) {

      executor.comment("Create Database Lock Table");
      executor.execute(new CreateDatabaseChangeLogLockTableStatement());
      database.commit();
      LogFactory.getLogger()
          .debug(
              "Created database lock table with name: "
                  + database.escapeTableName(
                      database.getLiquibaseCatalogName(),
                      database.getLiquibaseSchemaName(),
                      database.getDatabaseChangeLogLockTableName()));
      this.hasDatabaseChangeLogLockTable = true;
      createdTable = true;
    }

    if (!isDatabaseChangeLogLockTableInitialized(createdTable)) {
      executor.comment("Initialize Database Lock Table");
      executor.execute(new InitializeDatabaseChangeLogLockTableStatement());
      database.commit();
    }

    if (database instanceof DerbyDatabase
        && ((DerbyDatabase) database)
            .supportsBooleanDataType()) { // check if the changelog table is of an old smallint vs.
                                          // boolean format
      String lockTable =
          database.escapeTableName(
              database.getLiquibaseCatalogName(),
              database.getLiquibaseSchemaName(),
              database.getDatabaseChangeLogLockTableName());
      Object obj =
          executor.queryForObject(
              new RawSqlStatement(
                  "select min(locked) as test from " + lockTable + " fetch first row only"),
              Object.class);
      if (!(obj instanceof Boolean)) { // wrong type, need to recreate table
        executor.execute(
            new DropTableStatement(
                database.getLiquibaseCatalogName(),
                database.getLiquibaseSchemaName(),
                database.getDatabaseChangeLogLockTableName(),
                false));
        executor.execute(new CreateDatabaseChangeLogLockTableStatement());
        executor.execute(new InitializeDatabaseChangeLogLockTableStatement());
      }
    }
  }
Ejemplo n.º 2
0
  public Sql[] generateSql(
      DropIndexStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
    List<String> associatedWith = StringUtils.splitAndTrim(statement.getAssociatedWith(), ",");
    if (associatedWith != null) {
      if (associatedWith.contains(Index.MARK_PRIMARY_KEY)
          || associatedWith.contains(Index.MARK_UNIQUE_CONSTRAINT)) {
        return new Sql[0];
      } else if (associatedWith.contains(Index.MARK_FOREIGN_KEY)) {
        if (!(database instanceof OracleDatabase || database instanceof MSSQLDatabase)) {
          return new Sql[0];
        }
      }
    }

    String schemaName = statement.getTableSchemaName();

    if (database instanceof MySQLDatabase) {
      return new Sql[] {
        new UnparsedSql(
            "DROP INDEX "
                + database.escapeIndexName(null, null, statement.getIndexName())
                + " ON "
                + database.escapeTableName(
                    statement.getTableCatalogName(), schemaName, statement.getTableName()))
      };
    } else if (database instanceof MSSQLDatabase) {
      return new Sql[] {
        new UnparsedSql(
            "DROP INDEX "
                + database.escapeTableName(null, schemaName, statement.getTableName())
                + "."
                + database.escapeIndexName(null, null, statement.getIndexName()))
      };
    } else if (database instanceof PostgresDatabase) {
      return new Sql[] {
        new UnparsedSql(
            "DROP INDEX "
                + database.escapeIndexName(
                    statement.getTableCatalogName(), schemaName, statement.getIndexName()))
      };
    }

    return new Sql[] {
      new UnparsedSql(
          "DROP INDEX "
              + database.escapeIndexName(
                  statement.getTableCatalogName(), schemaName, statement.getIndexName()))
    };
  }
  @Override
  public Sql[] generateSql(
      AddDefaultValueStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {

    Object defaultValue = statement.getDefaultValue();
    StringBuffer sql = new StringBuffer("ALTER TABLE ");
    sql.append(
        database.escapeTableName(
            statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()));
    sql.append(" MODIFY (");
    sql.append(
        database.escapeColumnName(
            statement.getCatalogName(),
            statement.getSchemaName(),
            statement.getTableName(),
            statement.getColumnName()));
    sql.append(" ");
    sql.append(
        DataTypeFactory.getInstance().fromDescription(statement.getColumnDataType(), database));
    sql.append(" DEFAULT ");
    sql.append(
        DataTypeFactory.getInstance()
            .fromObject(defaultValue, database)
            .objectToSql(defaultValue, database));
    sql.append(")");
    UnparsedSql unparsedSql = new UnparsedSql(sql.toString(), getAffectedColumn(statement));
    return new Sql[] {unparsedSql};
  }
Ejemplo n.º 4
0
  public boolean isDatabaseChangeLogLockTableInitialized(final boolean tableJustCreated)
      throws DatabaseException {
    if (!isDatabaseChangeLogLockTableInitialized) {
      Executor executor = ExecutorService.getInstance().getExecutor(database);

      try {
        isDatabaseChangeLogLockTableInitialized =
            executor.queryForInt(
                    new RawSqlStatement(
                        "select count(*) from "
                            + database.escapeTableName(
                                database.getLiquibaseCatalogName(),
                                database.getLiquibaseSchemaName(),
                                database.getDatabaseChangeLogLockTableName())))
                > 0;
      } catch (LiquibaseException e) {
        if (executor.updatesDatabase()) {
          throw new UnexpectedLiquibaseException(e);
        } else {
          // probably didn't actually create the table yet.
          isDatabaseChangeLogLockTableInitialized = !tableJustCreated;
        }
      }
    }
    return isDatabaseChangeLogLockTableInitialized;
  }
Ejemplo n.º 5
0
 @Override
 public void check(Database database, DatabaseChangeLog changeLog, ChangeSet changeSet)
     throws PreconditionFailedException, PreconditionErrorException {
   String currentSchemaName;
   String currentCatalogName;
   try {
     currentCatalogName = getCatalogName();
     currentSchemaName = getSchemaName();
     if (!SnapshotGeneratorFactory.getInstance()
         .has(
             new View()
                 .setName(getViewName())
                 .setSchema(new Schema(currentCatalogName, currentSchemaName)),
             database)) {
       throw new PreconditionFailedException(
           "View "
               + database.escapeTableName(currentCatalogName, currentSchemaName, getViewName())
               + " does not exist",
           changeLog,
           this);
     }
   } catch (PreconditionFailedException e) {
     throw e;
   } catch (Exception e) {
     throw new PreconditionErrorException(e, changeLog, this);
   }
 }
  public Sql[] generateSql(
      SelectFromDatabaseChangeLogStatement statement,
      Database database,
      SqlGeneratorChain sqlGeneratorChain) {
    String sql =
        "SELECT "
            + StringUtils.join(statement.getColumnsToSelect(), ",").toUpperCase()
            + " FROM "
            + database.escapeTableName(
                database.getLiquibaseSchemaName(), database.getDatabaseChangeLogTableName());

    SelectFromDatabaseChangeLogStatement.WhereClause whereClause = statement.getWhereClause();
    if (whereClause != null) {
      if (whereClause instanceof SelectFromDatabaseChangeLogStatement.ByTag) {
        sql +=
            " WHERE TAG='"
                + ((SelectFromDatabaseChangeLogStatement.ByTag) whereClause).getTagName()
                + "'";
      } else if (whereClause instanceof SelectFromDatabaseChangeLogStatement.ByNotNullCheckSum) {
        sql += " WHERE MD5SUM IS NOT NULL";
      } else {
        throw new UnexpectedLiquibaseException(
            "Unknown where clause type: " + whereClause.getClass().getName());
      }
    }

    if (statement.getOrderByColumns() != null && statement.getOrderByColumns().length > 0) {
      sql += " ORDER BY " + StringUtils.join(statement.getOrderByColumns(), ", ").toUpperCase();
    }

    return new Sql[] {new UnparsedSql(sql)};
  }
Ejemplo n.º 7
0
 @Override
 @Test
 public void escapeTableName_withSchema() {
   Database database = getDatabase();
   assertEquals(
       "catalogName.tableName",
       database.escapeTableName("catalogName", "schemaName", "tableName"));
 }
 public Sql[] generateSql(
     DropColumnStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
   if (database instanceof DB2Database) {
     return new Sql[] {
       new UnparsedSql(
           "ALTER TABLE "
               + database.escapeTableName(
                   statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
               + " DROP COLUMN "
               + database.escapeColumnName(
                   statement.getCatalogName(),
                   statement.getSchemaName(),
                   statement.getTableName(),
                   statement.getColumnName()))
     };
   } else if (database instanceof SybaseDatabase
       || database instanceof SybaseASADatabase
       || database instanceof FirebirdDatabase
       || database instanceof InformixDatabase) {
     return new Sql[] {
       new UnparsedSql(
           "ALTER TABLE "
               + database.escapeTableName(
                   statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
               + " DROP "
               + database.escapeColumnName(
                   statement.getCatalogName(),
                   statement.getSchemaName(),
                   statement.getTableName(),
                   statement.getColumnName()))
     };
   }
   return new Sql[] {
     new UnparsedSql(
         "ALTER TABLE "
             + database.escapeTableName(
                 statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
             + " DROP COLUMN "
             + database.escapeColumnName(
                 statement.getCatalogName(),
                 statement.getSchemaName(),
                 statement.getTableName(),
                 statement.getColumnName()))
   };
 }
 @Override
 public Sql[] generateSql(
     AddAutoIncrementStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
   return new Sql[] {
     new UnparsedSql(
         "ALTER TABLE "
             + database.escapeTableName(statement.getSchemaName(), statement.getTableName())
             + " ALTER COLUMN "
             + database.escapeColumnName(
                 statement.getSchemaName(), statement.getTableName(), statement.getColumnName())
             + " SET GENERATED ALWAYS AS IDENTITY",
         new Column()
             .setTable(new Table(statement.getTableName()).setSchema(statement.getSchemaName()))
             .setName(statement.getColumnName()))
   };
 }
 @Override
 public Sql[] generateSql(
     AddAutoIncrementStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
   return new Sql[] {
     new UnparsedSql(
         "ALTER TABLE "
             + database.escapeTableName(statement.getSchemaName(), statement.getTableName())
             + " ALTER COLUMN "
             + database.escapeColumnName(
                 statement.getSchemaName(), statement.getTableName(), statement.getColumnName())
             + " SET "
             + database.getAutoIncrementClause(
                 statement.getStartWith(), statement.getIncrementBy()),
         new Column()
             .setTable(new Table(statement.getTableName()).setSchema(statement.getSchemaName()))
             .setName(statement.getColumnName()))
   };
 }
 @Override
 public Sql[] generateSql(
     AddAutoIncrementStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
   return new Sql[] {
     new UnparsedSql(
         "ALTER TABLE "
             + database.escapeTableName(
                 statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
             + " MODIFY "
             + database.escapeColumnName(
                 statement.getCatalogName(),
                 statement.getSchemaName(),
                 statement.getTableName(),
                 statement.getColumnName())
             + " "
             + DataTypeFactory.getInstance()
                 .fromDescription(statement.getColumnDataType() + "{autoIncrement:true}")
                 .toDatabaseDataType(database),
         getAffectedColumn(statement))
   };
 }
Ejemplo n.º 12
0
 public void check(Database database, DatabaseChangeLog changeLog, ChangeSet changeSet)
     throws PreconditionFailedException, PreconditionErrorException {
   String currentSchemaName;
   try {
     currentSchemaName =
         getSchemaName() == null
             ? (database == null ? null : database.getDefaultSchemaName())
             : getSchemaName();
     if (!DatabaseSnapshotGeneratorFactory.getInstance()
         .getGenerator(database)
         .hasView(currentSchemaName, getViewName(), database)) {
       throw new PreconditionFailedException(
           "View "
               + database.escapeTableName(currentSchemaName, getViewName())
               + " does not exist",
           changeLog,
           this);
     }
   } catch (PreconditionFailedException e) {
     throw e;
   } catch (Exception e) {
     throw new PreconditionErrorException(e, changeLog, this);
   }
 }
Ejemplo n.º 13
0
  @Override
  protected DatabaseObject snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
      throws DatabaseException, InvalidExampleException {
    Database database = snapshot.getDatabase();
    Relation relation = ((Column) example).getRelation();
    if (((Column) example).getComputed() != null && ((Column) example).getComputed()) {
      return example;
    }
    Schema schema = relation.getSchema();

    List<CachedRow> columnMetadataRs = null;
    try {

      JdbcDatabaseSnapshot.CachingDatabaseMetaData databaseMetaData =
          ((JdbcDatabaseSnapshot) snapshot).getMetaData();

      columnMetadataRs =
          databaseMetaData.getColumns(
              ((AbstractJdbcDatabase) database).getJdbcCatalogName(schema),
              ((AbstractJdbcDatabase) database).getJdbcSchemaName(schema),
              relation.getName(),
              example.getName());

      if (columnMetadataRs.size() > 0) {
        CachedRow data = columnMetadataRs.get(0);
        Column column = readColumn(data, relation, database);

        if (column != null
            && database instanceof MSSQLDatabase
            && database.getDatabaseMajorVersion() >= 8) {
          String sql;
          if (database.getDatabaseMajorVersion() >= 9) {
            // SQL Server 2005 or later
            // https://technet.microsoft.com/en-us/library/ms177541.aspx
            sql =
                "SELECT CAST([ep].[value] AS [nvarchar](MAX)) AS [REMARKS] "
                    + "FROM [sys].[extended_properties] AS [ep] "
                    + "WHERE [ep].[class] = 1 "
                    + "AND [ep].[major_id] = OBJECT_ID(N'"
                    + database.escapeStringForDatabase(
                        database.escapeTableName(
                            schema.getCatalogName(), schema.getName(), relation.getName()))
                    + "') "
                    + "AND [ep].[minor_id] = COLUMNPROPERTY([ep].[major_id], N'"
                    + database.escapeStringForDatabase(column.getName())
                    + "', 'ColumnId') "
                    + "AND [ep].[name] = 'MS_Description'";
          } else {
            // SQL Server 2000
            // https://technet.microsoft.com/en-us/library/aa224810%28v=sql.80%29.aspx
            sql =
                "SELECT CAST([p].[value] AS [ntext]) AS [REMARKS] "
                    + "FROM [dbo].[sysproperties] AS [p] "
                    + "WHERE [p].[id] = OBJECT_ID(N'"
                    + database.escapeStringForDatabase(
                        database.escapeTableName(
                            schema.getCatalogName(), schema.getName(), relation.getName()))
                    + "') "
                    + "AND [p].[smallid] = COLUMNPROPERTY([p].[id], N'"
                    + database.escapeStringForDatabase(column.getName())
                    + "', 'ColumnId') "
                    + "AND [p].[type] = 4 "
                    + "AND [p].[name] = 'MS_Description'";
          }

          List<String> remarks =
              ExecutorService.getInstance()
                  .getExecutor(snapshot.getDatabase())
                  .queryForList(new RawSqlStatement(sql), String.class);
          if (remarks != null && remarks.size() > 0) {
            column.setRemarks(StringUtils.trimToNull(remarks.iterator().next()));
          }
        }

        return column;
      } else {
        return null;
      }
    } catch (Exception e) {
      throw new DatabaseException(e);
    }
  }
Ejemplo n.º 14
0
  protected Column readColumn(CachedRow columnMetadataResultSet, Relation table, Database database)
      throws SQLException, DatabaseException {
    String rawTableName = (String) columnMetadataResultSet.get("TABLE_NAME");
    String rawColumnName = (String) columnMetadataResultSet.get("COLUMN_NAME");
    String rawSchemaName =
        StringUtils.trimToNull((String) columnMetadataResultSet.get("TABLE_SCHEM"));
    String rawCatalogName =
        StringUtils.trimToNull((String) columnMetadataResultSet.get("TABLE_CAT"));
    String remarks = StringUtils.trimToNull((String) columnMetadataResultSet.get("REMARKS"));
    if (remarks != null) {
      remarks = remarks.replace("''", "'"); // come back escaped sometimes
    }

    Column column = new Column();
    column.setName(StringUtils.trimToNull(rawColumnName));
    column.setRelation(table);
    column.setRemarks(remarks);

    if (database instanceof OracleDatabase) {
      String nullable = columnMetadataResultSet.getString("NULLABLE");
      if (nullable.equals("Y")) {
        column.setNullable(true);
      } else {
        column.setNullable(false);
      }
    } else {
      int nullable = columnMetadataResultSet.getInt("NULLABLE");
      if (nullable == DatabaseMetaData.columnNoNulls) {
        column.setNullable(false);
      } else if (nullable == DatabaseMetaData.columnNullable) {
        column.setNullable(true);
      } else if (nullable == DatabaseMetaData.columnNullableUnknown) {
        LogFactory.getLogger()
            .info("Unknown nullable state for column " + column.toString() + ". Assuming nullable");
        column.setNullable(true);
      }
    }

    if (database.supportsAutoIncrement()) {
      if (table instanceof Table) {
        if (columnMetadataResultSet.containsColumn("IS_AUTOINCREMENT")) {
          String isAutoincrement = (String) columnMetadataResultSet.get("IS_AUTOINCREMENT");
          isAutoincrement = StringUtils.trimToNull(isAutoincrement);
          if (isAutoincrement == null) {
            column.setAutoIncrementInformation(null);
          } else if (isAutoincrement.equals("YES")) {
            column.setAutoIncrementInformation(new Column.AutoIncrementInformation());
          } else if (isAutoincrement.equals("NO")) {
            column.setAutoIncrementInformation(null);
          } else if (isAutoincrement.equals("")) {
            LogFactory.getLogger()
                .info(
                    "Unknown auto increment state for column "
                        + column.toString()
                        + ". Assuming not auto increment");
            column.setAutoIncrementInformation(null);
          } else {
            throw new UnexpectedLiquibaseException(
                "Unknown is_autoincrement value: '" + isAutoincrement + "'");
          }
        } else {
          // probably older version of java, need to select from the column to find out if it is
          // auto-increment
          String selectStatement;
          if (database.getDatabaseProductName().startsWith("DB2 UDB for AS/400")) {
            selectStatement =
                "select "
                    + database.escapeColumnName(
                        rawCatalogName, rawSchemaName, rawTableName, rawColumnName)
                    + " from "
                    + rawSchemaName
                    + "."
                    + rawTableName
                    + " where 0=1";
            LogFactory.getLogger().debug("rawCatalogName : <" + rawCatalogName + ">");
            LogFactory.getLogger().debug("rawSchemaName : <" + rawSchemaName + ">");
            LogFactory.getLogger().debug("rawTableName : <" + rawTableName + ">");
            LogFactory.getLogger().debug("raw selectStatement : <" + selectStatement + ">");

          } else {
            selectStatement =
                "select "
                    + database.escapeColumnName(
                        rawCatalogName, rawSchemaName, rawTableName, rawColumnName)
                    + " from "
                    + database.escapeTableName(rawCatalogName, rawSchemaName, rawTableName)
                    + " where 0=1";
          }
          LogFactory.getLogger()
              .debug(
                  "Checking "
                      + rawTableName
                      + "."
                      + rawCatalogName
                      + " for auto-increment with SQL: '"
                      + selectStatement
                      + "'");
          Connection underlyingConnection =
              ((JdbcConnection) database.getConnection()).getUnderlyingConnection();
          Statement statement = null;
          ResultSet columnSelectRS = null;

          try {
            statement = underlyingConnection.createStatement();
            columnSelectRS = statement.executeQuery(selectStatement);
            if (columnSelectRS.getMetaData().isAutoIncrement(1)) {
              column.setAutoIncrementInformation(new Column.AutoIncrementInformation());
            } else {
              column.setAutoIncrementInformation(null);
            }
          } finally {
            try {
              if (statement != null) {
                statement.close();
              }
            } catch (SQLException ignore) {
            }
            if (columnSelectRS != null) {
              columnSelectRS.close();
            }
          }
        }
      }
    }

    DataType type = readDataType(columnMetadataResultSet, column, database);
    column.setType(type);

    column.setDefaultValue(readDefaultValue(columnMetadataResultSet, column, database));

    return column;
  }
  @Override
  public Sql[] generateSql(
      CreateIndexStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {

    // Default filter of index creation:
    // creation of all indexes with associations are switched off.
    List<String> associatedWith = StringUtils.splitAndTrim(statement.getAssociatedWith(), ",");
    if (associatedWith != null
        && (associatedWith.contains(Index.MARK_PRIMARY_KEY)
            || associatedWith.contains(Index.MARK_UNIQUE_CONSTRAINT)
            || associatedWith.contains(Index.MARK_FOREIGN_KEY))) {
      return new Sql[0];
    }

    StringBuilder buffer = new StringBuilder();

    buffer.append("CREATE ");
    if (statement.isUnique() != null && statement.isUnique()) {
      buffer.append("UNIQUE ");
    }
    buffer.append("INDEX ");

    if (statement.getIndexName() != null) {
      String indexSchema = statement.getTableSchemaName();
      buffer
          .append(database.escapeIndexName(null, indexSchema, statement.getIndexName()))
          .append(" ");
    }
    buffer.append("ON ");
    buffer
        .append(
            database.escapeTableName(
                statement.getTableCatalogName(),
                statement.getTableSchemaName(),
                statement.getTableName()))
        .append("(");
    Iterator<String> iterator = Arrays.asList(statement.getColumns()).iterator();
    while (iterator.hasNext()) {
      String column = iterator.next();
      buffer.append(
          database.escapeColumnName(
              statement.getTableCatalogName(),
              statement.getTableSchemaName(),
              statement.getTableName(),
              column));
      if (iterator.hasNext()) {
        buffer.append(", ");
      }
    }
    buffer.append(")");

    if (StringUtils.trimToNull(statement.getTablespace()) != null
        && database.supportsTablespaces()) {
      if (database instanceof MSSQLDatabase || database instanceof SybaseASADatabase) {
        buffer.append(" ON ").append(statement.getTablespace());
      } else if (database instanceof DB2Database || database instanceof InformixDatabase) {
        buffer.append(" IN ").append(statement.getTablespace());
      } else {
        buffer.append(" TABLESPACE ").append(statement.getTablespace());
      }
    }

    return new Sql[] {new UnparsedSql(buffer.toString())};
  }
Ejemplo n.º 16
0
 /** override this method that could support cubrid syntax */
 @Override
 public Sql[] generateSql(
     RenameColumnStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
   String sql;
   if (database instanceof MSSQLDatabase) {
     sql =
         "exec sp_rename '"
             + database.escapeTableName(statement.getSchemaName(), statement.getTableName())
             + "."
             + database.escapeColumnName(
                 statement.getSchemaName(), statement.getTableName(), statement.getOldColumnName())
             + "', '"
             + statement.getNewColumnName()
             + "'";
   } else if (database instanceof MySQLDatabase) {
     sql =
         "ALTER TABLE "
             + database.escapeTableName(statement.getSchemaName(), statement.getTableName())
             + " CHANGE "
             + database.escapeColumnName(
                 statement.getSchemaName(), statement.getTableName(), statement.getOldColumnName())
             + " "
             + database.escapeColumnName(
                 statement.getSchemaName(), statement.getTableName(), statement.getNewColumnName())
             + " "
             + statement.getColumnDataType();
   } else if (database instanceof HsqlDatabase || database instanceof H2Database) {
     sql =
         "ALTER TABLE "
             + database.escapeTableName(statement.getSchemaName(), statement.getTableName())
             + " ALTER COLUMN "
             + database.escapeColumnName(
                 statement.getSchemaName(), statement.getTableName(), statement.getOldColumnName())
             + " RENAME TO "
             + database.escapeColumnName(
                 statement.getSchemaName(),
                 statement.getTableName(),
                 statement.getNewColumnName());
   } else if (database instanceof FirebirdDatabase) {
     sql =
         "ALTER TABLE "
             + database.escapeTableName(statement.getSchemaName(), statement.getTableName())
             + " ALTER COLUMN "
             + database.escapeColumnName(
                 statement.getSchemaName(), statement.getTableName(), statement.getOldColumnName())
             + " TO "
             + database.escapeColumnName(
                 statement.getSchemaName(),
                 statement.getTableName(),
                 statement.getNewColumnName());
   } else if ((database instanceof MaxDBDatabase)
       || (database instanceof DerbyDatabase)
       || (database instanceof InformixDatabase)) {
     sql =
         "RENAME COLUMN "
             + database.escapeTableName(statement.getSchemaName(), statement.getTableName())
             + "."
             + database.escapeColumnName(
                 statement.getSchemaName(), statement.getTableName(), statement.getOldColumnName())
             + " TO "
             + database.escapeColumnName(
                 statement.getSchemaName(),
                 statement.getTableName(),
                 statement.getNewColumnName());
   } else if (database instanceof SybaseASADatabase) {
     sql =
         "ALTER TABLE "
             + database.escapeTableName(statement.getSchemaName(), statement.getTableName())
             + " RENAME "
             + database.escapeColumnName(
                 statement.getSchemaName(), statement.getTableName(), statement.getOldColumnName())
             + " TO "
             + database.escapeColumnName(
                 statement.getSchemaName(),
                 statement.getTableName(),
                 statement.getNewColumnName());
   } else if (database instanceof CUBRIDDatabase) {
     sql =
         "ALTER TABLE "
             + database.escapeTableName(statement.getSchemaName(), statement.getTableName())
             + " RENAME COLUMN "
             + database.escapeColumnName(
                 statement.getSchemaName(), statement.getTableName(), statement.getOldColumnName())
             + " AS "
             + database.escapeColumnName(
                 statement.getSchemaName(),
                 statement.getTableName(),
                 statement.getNewColumnName());
   } else {
     sql =
         "ALTER TABLE "
             + database.escapeTableName(statement.getSchemaName(), statement.getTableName())
             + " RENAME COLUMN "
             + database.escapeColumnName(
                 statement.getSchemaName(), statement.getTableName(), statement.getOldColumnName())
             + " TO "
             + database.escapeColumnName(
                 statement.getSchemaName(),
                 statement.getTableName(),
                 statement.getNewColumnName());
   }
   return new Sql[] {new UnparsedSql(sql)};
 }
Ejemplo n.º 17
0
 @Override
 @Test
 public void escapeTableName_noSchema() {
   Database database = getDatabase();
   assertEquals("tableName", database.escapeTableName(null, null, "tableName"));
 }
Ejemplo n.º 18
0
 protected String generateSingleColumBaseSQL(AddColumnStatement statement, Database database) {
   return "ALTER TABLE "
       + database.escapeTableName(
           statement.getCatalogName(), statement.getSchemaName(), statement.getTableName());
 }
  @Override
  public Sql[] generateSql(
      CreateTempTableStatementVertica statement,
      Database database,
      SqlGeneratorChain sqlGeneratorChain) {
    StringBuilder sql = new StringBuilder();

    sql.append("CREATE ");
    if (statement.getIsGlobal() != null) sql.append(" GLOBAL ");
    else sql.append(" LOCAL ");
    sql.append(" TEMPORARY TABLE ");
    if (statement.getSchemaName() != null) sql.append(statement.getSchemaName()).append(".");
    else sql.append(database.getDefaultSchemaName()).append(".");
    if (statement.getTableName() != null) {
      sql.append(statement.getTableName()).append(" ");
    }

    boolean isSinglePrimaryKeyColumn =
        statement.getPrimaryKeyConstraint() != null
            && statement.getPrimaryKeyConstraint().getColumns().size() == 1;

    boolean isPrimaryKeyAutoIncrement = false;

    sql.append("( ");
    Iterator<String> columnIterator = statement.getColumns().iterator();
    List<String> primaryKeyColumns = new LinkedList<String>();
    while (columnIterator.hasNext()) {
      String column = columnIterator.next();
      DatabaseDataType columnType =
          statement.getColumnTypes().get(column).toDatabaseDataType(database);
      sql.append(
          database.escapeColumnName(
              statement.getCatalogName(),
              statement.getSchemaName(),
              statement.getTableName(),
              column));

      // This is the difference between vertica & other RDBMS - the encoding part.

      AutoIncrementConstraint autoIncrementConstraint = null;

      for (AutoIncrementConstraint currentAutoIncrementConstraint :
          statement.getAutoIncrementConstraints()) {
        if (column.equals(currentAutoIncrementConstraint.getColumnName())) {
          autoIncrementConstraint = currentAutoIncrementConstraint;
          break;
        }
      }

      boolean isAutoIncrementColumn = autoIncrementConstraint != null;
      boolean isPrimaryKeyColumn =
          statement.getPrimaryKeyConstraint() != null
              && statement.getPrimaryKeyConstraint().getColumns().contains(column);
      isPrimaryKeyAutoIncrement =
          isPrimaryKeyAutoIncrement || isPrimaryKeyColumn && isAutoIncrementColumn;

      if (isPrimaryKeyColumn) {
        primaryKeyColumns.add(column);
      }
      if (!isAutoIncrementColumn) {
        sql.append(" ").append(columnType);
      }

      // for the serial data type in postgres, there should be no default value
      if (!columnType.isAutoIncrement() && statement.getDefaultValue(column) != null) {
        Object defaultValue = statement.getDefaultValue(column);
        sql.append(" DEFAULT ");
        sql.append(statement.getColumnTypes().get(column).objectToSql(defaultValue, database));
      }

      // TODO: Change this - vertica supports both auto incremental & identity fields.
      if (isAutoIncrementColumn) {
        // TODO: check if database supports auto increment on non primary key column
        if (database.supportsAutoIncrement()) {
          String autoIncrementClause =
              database.getAutoIncrementClause(
                  autoIncrementConstraint.getStartWith(), autoIncrementConstraint.getIncrementBy());

          if (!"".equals(autoIncrementClause)) {
            sql.append(" ").append(autoIncrementClause);
          }

          if (database instanceof PostgresDatabase
              && autoIncrementConstraint.getStartWith() != null) {
            String sequenceName = statement.getTableName() + "_" + column + "_seq";
            //                        additionalSql.add(new UnparsedSql("alter sequence
            // "+database.escapeSequenceName(statement.getCatalogName(), statement.getSchemaName(),
            // sequenceName)+" start with "+autoIncrementConstraint.getStartWith(), new
            // Sequence().setName(sequenceName).setSchema(statement.getCatalogName(),
            // statement.getSchemaName())));
          }
        } else {
          LogFactory.getLogger()
              .warning(
                  database.getShortName()
                      + " does not support autoincrement columns as request for "
                      + (database.escapeTableName(
                          statement.getCatalogName(),
                          statement.getSchemaName(),
                          statement.getTableName())));
        }
      }

      if (isPrimaryKeyColumn) {

        String pkName =
            StringUtils.trimToNull(statement.getPrimaryKeyConstraint().getConstraintName());
        if (pkName != null) {
          sql.append(" CONSTRAINT ");
          sql.append(database.escapeConstraintName(pkName));
        }

        sql.append(" PRIMARY KEY ");
      }

      if (statement.getNotNullColumns().contains(column)) {
        sql.append(" NOT NULL");
      }

      if (statement.getColumnEncoding(column) != null) {
        sql.append(" ENCODING ").append(statement.getColumnEncoding(column));
      }

      if (statement.getColumnAccessrank(column) != null)
        sql.append(" ACCESSRANK  ").append(statement.getColumnAccessrank(column));

      if (columnIterator.hasNext()) {
        sql.append(", ");
      }
    }
    sql.append(" )");
    sql.append(" ON COMMIT ");
    if (statement.getIsPreserve()) sql.append(" PRESERVE ");
    else sql.append(" DELETE");
    sql.append("  ROWS ");

    if (statement.getOrderby() != null) sql.append(" ORDER BY ").append(statement.getOrderby());

    if (statement.getSegmentation() != null) {
      Segmentation seg = statement.getSegmentation();
      if (seg.getUnsegmented() == true) {
        sql.append(" UNSEGMENTED ");
      } else {
        sql.append(" SEGMENTED BY ");

        sql.append(seg.getExpression());
      }
      if (seg.getAllNodes()) {
        sql.append(" ALL NODES ");
      } else {
        sql.append(" NODES ").append(seg.getNodes());
        if (seg.getOffset() != null) sql.append(" OFFSET ").append(seg.getOffset().toString());
      }
    }

    if (statement.getKsafe() != null) sql.append(" KSAFE ").append(statement.getKsafe());

    if (statement.getPartitionby() != null)
      sql.append(" PARTITION BY ").append(statement.getPartitionby());

    System.out.println(sql.toString());
    return new Sql[] {new UnparsedSql(sql.toString())};
  }