コード例 #1
0
  @Override
  public void addComment(SQLColumn c) {
    if (c.getRemarks() == null || c.getRemarks().trim().length() == 0) return;

    print("\n-- Comment for column [");
    print(c.getName());
    print("]: ");
    print(c.getRemarks().replaceAll(REGEX_CRLF, "\n-- "));
    endStatement(StatementType.COMMENT, c);
  }
コード例 #2
0
  /**
   * Overridden to generate add table statement to have domain/type level
   * check constraints be added on the table level. The reason why it is being
   * generated on the table level is because SQL Server does not allow
   * multiple named check constraints on a single column. Only one named or
   * unnamed check constraint per column is allowed.
   *
   * Since check constraints from multiple objects are being combined into the
   * table level, we must ensure that there are no name conflicts by
   * prepending tags to identify which SQLObject type and physical name the
   * check constraint is actually supposed to be applied on. e.g.
   * col_<column-name>_<constraint-name> or table_<table-name>_<constraint-name>.
   * This is especially important since actual table level check constraints
   * will be added in the future.
   */
  @Override
  public void addTable(SQLTable t) throws SQLException, SQLObjectException {
    Map<String, SQLObject> colNameMap =
        new HashMap<String, SQLObject>(); // for detecting duplicate column names
    // generate a new physical name if necessary
    createPhysicalName(topLevelNames, t); // also adds generated physical name to the map
    print("\nCREATE TABLE ");
    print(toQualifiedName(t));
    println(" (");
    boolean firstCol = true;

    List<SQLColumn> columns = t.getColumns();

    for (SQLColumn c : columns) {
      if (!firstCol) println(",");
      print("                ");

      print(columnDefinition(c, colNameMap));

      firstCol = false;
    }

    SQLIndex pk = t.getPrimaryKeyIndex();
    if (pk.getChildCount() > 0) {
      print(",\n");
      print("                ");
      writePKConstraintClause(pk);
    }

    for (SQLColumn c : columns) {
      UserDefinedSQLType type = c.getUserDefinedSQLType();
      List<SQLCheckConstraint> checkConstraints;
      SQLTypeConstraint constraintType = type.getConstraintType(getPlatformName());
      if (constraintType == null) {
        constraintType = type.getDefaultPhysicalProperties().getConstraintType();
        checkConstraints = type.getDefaultPhysicalProperties().getCheckConstraints();
      } else {
        checkConstraints = type.getCheckConstraints(getPlatformName());
      }

      if (constraintType == SQLTypeConstraint.CHECK) {
        print(",\n");
        print(columnCheckConstraint(c, checkConstraints));
      }
    }

    print("\n)");
    endStatement(StatementType.CREATE, t);
    addComment(t, true);
  }
コード例 #3
0
  /**
   * Overridden because check constraints can only be added to the table level. Each constraint
   * clause is delimited by a comma.
   */
  @Override
  protected String columnCheckConstraint(SQLColumn c, List<SQLCheckConstraint> checkConstraints) {
    if (!supportsCheckConstraint()
        || c == null
        || checkConstraints == null
        || checkConstraints.isEmpty()) {
      return "";
    }

    SPVariableResolver resolver = c.getVariableResolver();
    SPVariableHelper helper = new SPVariableHelper(c);
    SPResolverRegistry.register(c, resolver);

    StringBuilder sb = new StringBuilder();
    for (SQLCheckConstraint constraint : checkConstraints) {
      if (sb.length() > 0) {
        sb.append(",\n");
      }
      sb.append("                ");
      sb.append(
          String.format(
              "CONSTRAINT %s CHECK (%s)",
              constraint.getName(), helper.substitute(constraint.getConstraint())));
    }

    SPResolverRegistry.deregister(c, resolver);

    return sb.toString();
  }
コード例 #4
0
 @Override
 public void addColumn(SQLColumn c) {
   print("\nALTER TABLE ");
   print(toQualifiedName(c.getParent()));
   print(" ADD ");
   print(columnDefinition(c, new HashMap<String, SQLObject>()));
   endStatement(StatementType.CREATE, c);
 }
コード例 #5
0
 /** Adds support for the SQL Server <code>identity</code> feature. */
 @Override
 public String columnType(SQLColumn c) {
   String type = super.columnType(c);
   if (c.isAutoIncrement()) {
     type += " IDENTITY";
   }
   return type;
 }
コード例 #6
0
 @Override
 public void renameColumn(SQLColumn oldCol, SQLColumn newCol) {
   Map<String, SQLObject> empty = new HashMap<String, SQLObject>(0);
   print("sp_rename @objname='");
   print(toQualifiedName(oldCol.getParent()));
   print(".");
   print(createPhysicalName(empty, oldCol));
   print("', @newname='");
   print(createPhysicalName(empty, newCol));
   print("', @objtype='COLUMN'");
   endStatement(StatementType.ALTER, newCol);
 }
コード例 #7
0
  /**
   * SQL Server does not allow multiple named check constraints on the column level. Only one named
   * or unnamed check constraint is allowed. Instead, we must add them on the table level.
   *
   * @see #addTable(SQLTable)
   */
  @Override
  protected String columnDefinition(SQLColumn c, Map<String, SQLObject> colNameMap) {
    StringBuffer def = new StringBuffer();

    // Column name
    def.append(createPhysicalName(colNameMap, c));

    def.append(" ");
    def.append(columnType(c));

    UserDefinedSQLType type = c.getUserDefinedSQLType();
    String defaultValue = type.getDefaultValue(getPlatformName());
    if (defaultValue != null && !defaultValue.equals("")) {
      def.append(" ");
      def.append("DEFAULT ");
      def.append(defaultValue);
    }

    def.append(columnNullability(c));

    List<SQLEnumeration> enumerations;
    SQLTypeConstraint constraintType = type.getConstraintType(getPlatformName());
    if (constraintType == null) {
      constraintType = type.getDefaultPhysicalProperties().getConstraintType();
      enumerations =
          type.getDefaultPhysicalProperties().getChildrenWithoutPopulating(SQLEnumeration.class);
    } else {
      enumerations = type.getEnumerations(getPlatformName());
    }

    // Add enumeration.
    if (constraintType == SQLTypeConstraint.ENUM) {
      String columnEnumeration = columnEnumeration(c, enumerations);
      if (columnEnumeration != null && columnEnumeration.length() > 0) {
        def.append(" " + columnEnumeration);
      }
    }

    logger.debug("column definition " + def.toString());
    return def.toString();
  }