コード例 #1
0
ファイル: TableInspector.java プロジェクト: gitblit/iciql
  /**
   * Reads the DatabaseMetaData for the details of this table including primary keys and indexes.
   *
   * @param metaData the database meta data
   */
  void read(DatabaseMetaData metaData) throws SQLException {
    ResultSet rs = null;

    // primary keys
    try {
      rs = metaData.getPrimaryKeys(null, schema, table);
      while (rs.next()) {
        String c = rs.getString("COLUMN_NAME");
        primaryKeys.add(c);
      }
      closeSilently(rs);

      // indexes
      rs = metaData.getIndexInfo(null, schema, table, false, true);
      indexes = Utils.newHashMap();
      while (rs.next()) {
        IndexInspector info = new IndexInspector(rs);
        if (info.type.equals(IndexType.UNIQUE)) {
          String name = info.name.toLowerCase();
          if (name.startsWith("primary")
              || name.startsWith("sys_idx_sys_pk")
              || name.startsWith("sql")
              || name.endsWith("_pkey")) {
            // skip primary key indexes
            continue;
          }
        }
        if (indexes.containsKey(info.name)) {
          indexes.get(info.name).addColumn(rs);
        } else {
          indexes.put(info.name, info);
        }
      }
      closeSilently(rs);

      // columns
      rs = metaData.getColumns(null, schema, table, null);
      columns = Utils.newHashMap();
      while (rs.next()) {
        ColumnInspector col = new ColumnInspector();
        col.name = rs.getString("COLUMN_NAME");
        col.type = rs.getString("TYPE_NAME");
        col.clazz = ModelUtils.getClassForSqlType(col.type, dateTimeClass);
        col.size = rs.getInt("COLUMN_SIZE");
        col.nullable = rs.getInt("NULLABLE") == DatabaseMetaData.columnNullable;
        try {
          Object autoIncrement = rs.getObject("IS_AUTOINCREMENT");
          if (autoIncrement instanceof Boolean) {
            col.isAutoIncrement = (Boolean) autoIncrement;
          } else if (autoIncrement instanceof String) {
            String val = autoIncrement.toString().toLowerCase();
            col.isAutoIncrement = val.equals("true") | val.equals("yes");
          } else if (autoIncrement instanceof Number) {
            Number n = (Number) autoIncrement;
            col.isAutoIncrement = n.intValue() > 0;
          }
        } catch (SQLException s) {
          //					throw s;
        }
        if (primaryKeys.size() == 1) {
          if (col.name.equalsIgnoreCase(primaryKeys.get(0))) {
            col.isPrimaryKey = true;
          }
        }
        if (!col.isAutoIncrement) {
          col.defaultValue = rs.getString("COLUMN_DEF");
        }
        columns.put(col.name.toLowerCase(), col);
      }
    } finally {
      closeSilently(rs);
    }
  }
コード例 #2
0
ファイル: TableInspector.java プロジェクト: gitblit/iciql
  /**
   * Validates a column against the model's field definition. Checks for existence, supported type,
   * type mapping, default value, defined lengths, primary key, autoincrement.
   */
  private void validate(
      List<ValidationRemark> remarks, FieldDefinition fieldDef, boolean throwError) {
    // unknown field
    if (!columns.containsKey(fieldDef.columnName.toLowerCase())) {
      // unknown column mapping
      remarks.add(error(table, fieldDef, "Does not exist in database!").throwError(throwError));
      return;
    }
    ColumnInspector col = columns.get(fieldDef.columnName.toLowerCase());
    Class<?> fieldClass = fieldDef.field.getType();
    Class<?> jdbcClass = ModelUtils.getClassForSqlType(col.type, dateTimeClass);

    // supported type check
    // iciql maps to VARCHAR for unsupported types.
    if (fieldDef.dataType.equals("VARCHAR") && (fieldClass != String.class)) {
      remarks.add(
          error(
                  table,
                  fieldDef,
                  "iciql does not currently implement support for " + fieldClass.getName())
              .throwError(throwError));
    }
    // number types
    if (!fieldClass.equals(jdbcClass)) {
      if (Number.class.isAssignableFrom(fieldClass)) {
        remarks.add(
            warn(
                table,
                col,
                format(
                    "Precision mismatch: ModelObject={0}, ColumnObject={1}",
                    fieldClass.getSimpleName(), jdbcClass.getSimpleName())));
      } else {
        if (!Date.class.isAssignableFrom(jdbcClass)) {
          remarks.add(
              warn(
                  table,
                  col,
                  format(
                      "Object Mismatch: ModelObject={0}, ColumnObject={1}",
                      fieldClass.getSimpleName(), jdbcClass.getSimpleName())));
        }
      }
    }

    // string types
    if (fieldClass == String.class) {
      if ((fieldDef.length != col.size) && (col.size < Integer.MAX_VALUE)) {
        remarks.add(
            warn(
                table,
                col,
                format(
                    "{0}.length={1}, ColumnMaxLength={2}",
                    IQColumn.class.getSimpleName(), fieldDef.length, col.size)));
      }
      if (fieldDef.length > 0 && !fieldDef.trim) {
        remarks.add(
            consider(
                table,
                col,
                format(
                    "{0}.trim=true will prevent IciqlExceptions on"
                        + " INSERT or UPDATE, but will clip data!",
                    IQColumn.class.getSimpleName())));
      }
    }

    // numeric autoIncrement
    if (fieldDef.isAutoIncrement != col.isAutoIncrement) {
      remarks.add(
          warn(
              table,
              col,
              format(
                  "{0}.autoIncrement={1}" + " while Column autoIncrement={2}",
                  IQColumn.class.getSimpleName(), fieldDef.isAutoIncrement, col.isAutoIncrement)));
    }
    // default value
    if (!col.isAutoIncrement && !col.isPrimaryKey) {
      String defaultValue = null;
      if (fieldDef.defaultValue != null && fieldDef.defaultValue instanceof String) {
        defaultValue = fieldDef.defaultValue.toString();
      }
      // check Model.defaultValue format
      if (!ModelUtils.isProperlyFormattedDefaultValue(defaultValue)) {
        remarks.add(
            error(
                    table,
                    col,
                    format(
                        "{0}.defaultValue=\"{1}\"" + " is improperly formatted!",
                        IQColumn.class.getSimpleName(), defaultValue))
                .throwError(throwError));
        // next field
        return;
      }
      // compare Model.defaultValue to Column.defaultValue
      if (isNullOrEmpty(defaultValue) && !isNullOrEmpty(col.defaultValue)) {
        // Model.defaultValue is NULL, Column.defaultValue is NOT NULL
        remarks.add(
            warn(
                table,
                col,
                format(
                    "{0}.defaultValue=\"\"" + " while column default=\"{1}\"",
                    IQColumn.class.getSimpleName(), col.defaultValue)));
      } else if (!isNullOrEmpty(defaultValue) && isNullOrEmpty(col.defaultValue)) {
        // Column.defaultValue is NULL, Model.defaultValue is NOT NULL
        remarks.add(
            warn(
                table,
                col,
                format(
                    "{0}.defaultValue=\"{1}\"" + " while column default=\"\"",
                    IQColumn.class.getSimpleName(), defaultValue)));
      } else if (!isNullOrEmpty(defaultValue) && !isNullOrEmpty(col.defaultValue)) {
        if (!defaultValue.equals(col.defaultValue)) {
          // Model.defaultValue != Column.defaultValue
          remarks.add(
              warn(
                  table,
                  col,
                  format(
                      "{0}.defaultValue=\"{1}\"" + " while column default=\"{2}\"",
                      IQColumn.class.getSimpleName(), defaultValue, col.defaultValue)));
        }
      }

      // sanity check Model.defaultValue literal value
      if (!ModelUtils.isValidDefaultValue(fieldDef.field.getType(), defaultValue)) {
        remarks.add(
            error(
                table,
                col,
                format(
                    "{0}.defaultValue=\"{1}\" is invalid!",
                    IQColumn.class.getSimpleName(), defaultValue)));
      }
    }
  }