コード例 #1
0
ファイル: Column.java プロジェクト: fangguanya/hibernate-orm
 /** Shallow copy, the value is not copied */
 protected Object clone() {
   Column copy = new Column();
   copy.setLength(length);
   copy.setScale(scale);
   copy.setValue(value);
   copy.setTypeIndex(typeIndex);
   copy.setName(getQuotedName());
   copy.setNullable(nullable);
   copy.setPrecision(precision);
   copy.setUnique(unique);
   copy.setSqlType(sqlType);
   copy.setSqlTypeCode(sqlTypeCode);
   copy.uniqueInteger = uniqueInteger; // usually useless
   copy.setCheckConstraint(checkConstraint);
   copy.setComment(comment);
   copy.setDefaultValue(defaultValue);
   copy.setCustomRead(customRead);
   copy.setCustomWrite(customWrite);
   return copy;
 }
コード例 #2
0
  /**
   * Builds the <code>Join</code> instance for the mapped by side of a <i>OneToOne</i> association
   * using a join tables.
   *
   * <p>Note:<br>
   *
   * <ul>
   *   <li>From the mappedBy side we should not create the PK nor the FK, this is handled from the
   *       other side.
   *   <li>This method is a dirty dupe of EntityBinder.bindSecondaryTable</i>.
   */
  private Join buildJoinFromMappedBySide(
      PersistentClass persistentClass, Property otherSideProperty, Join originalJoin) {
    Join join = new Join();
    join.setPersistentClass(persistentClass);

    // no check constraints available on joins
    join.setTable(originalJoin.getTable());
    join.setInverse(true);
    SimpleValue key =
        new DependantValue(mappings, join.getTable(), persistentClass.getIdentifier());
    // TODO support @ForeignKey
    join.setKey(key);
    join.setSequentialSelect(false);
    // TODO support for inverse and optional
    join.setOptional(true); // perhaps not quite per-spec, but a Good Thing anyway
    key.setCascadeDeleteEnabled(false);
    Iterator mappedByColumns = otherSideProperty.getValue().getColumnIterator();
    while (mappedByColumns.hasNext()) {
      Column column = (Column) mappedByColumns.next();
      Column copy = new Column();
      copy.setLength(column.getLength());
      copy.setScale(column.getScale());
      copy.setValue(key);
      copy.setName(column.getQuotedName());
      copy.setNullable(column.isNullable());
      copy.setPrecision(column.getPrecision());
      copy.setUnique(column.isUnique());
      copy.setSqlType(column.getSqlType());
      copy.setCheckConstraint(column.getCheckConstraint());
      copy.setComment(column.getComment());
      copy.setDefaultValue(column.getDefaultValue());
      key.addColumn(copy);
    }
    persistentClass.addJoin(join);
    return join;
  }
コード例 #3
0
  public static void processBasicColumns(
      MetaDataDialect metaDataDialect,
      ReverseEngineeringStrategy revengStrategy,
      String defaultSchema,
      String defaultCatalog,
      Table table,
      ProgressListener progress) {

    String qualify =
        TableNameQualifier.qualify(table.getCatalog(), table.getSchema(), table.getName());
    Iterator<?> columnIterator = null;

    try {
      Map<?, ?> columnRs = null;
      log.debug("Finding columns for " + qualify);
      progress.startSubTask("Finding columns for " + qualify);
      columnIterator =
          metaDataDialect.getColumns(
              getCatalogForDBLookup(table.getCatalog(), defaultCatalog),
              getSchemaForDBLookup(table.getSchema(), defaultSchema),
              table.getName(),
              null);
      // dumpHeader(columnRs);
      while (columnIterator.hasNext()) {
        // dumpRow(columnRs);
        columnRs = (Map<?, ?>) columnIterator.next();
        String tableName = (String) columnRs.get("TABLE_NAME");
        int sqlType = ((Integer) columnRs.get("DATA_TYPE")).intValue();
        // String sqlTypeName = (String) columnRs.get("TYPE_NAME");
        String columnName = (String) columnRs.get("COLUMN_NAME");
        String comment = (String) columnRs.get("REMARKS");

        TableIdentifier ti =
            RevEngUtils.createTableIdentifier(table, defaultCatalog, defaultSchema);
        if (revengStrategy.excludeColumn(ti, columnName)) {
          log.debug("Column " + ti + "." + columnName + " excluded by strategy");
          continue;
        }
        if (!tableName.equals(table.getName())) {
          log.debug(
              "Table name "
                  + tableName
                  + " does not match requested "
                  + table.getName()
                  + ". Ignoring column "
                  + columnName
                  + " since it either is invalid or a duplicate");
          continue;
        }

        // String columnDefaultValue = columnRs.getString("COLUMN_DEF"); TODO: only read if have a
        // way to avoid issues with clobs/lobs and similar
        int dbNullability = ((Integer) columnRs.get("NULLABLE")).intValue();
        boolean isNullable = true;
        switch (dbNullability) {
          case DatabaseMetaData.columnNullable:
          case DatabaseMetaData.columnNullableUnknown:
            isNullable = true;
            break;
          case DatabaseMetaData.columnNoNulls:
            isNullable = false;
            break;
          default:
            isNullable = true;
        }

        int size = ((Integer) columnRs.get("COLUMN_SIZE")).intValue();
        int decimalDigits = ((Integer) columnRs.get("DECIMAL_DIGITS")).intValue();

        Column column = new Column();
        column.setName(quote(columnName, metaDataDialect));
        Column existing = table.getColumn(column);
        if (existing != null) {
          // TODO: should we just pick it up and fill it up with whatever we get from the db instead
          // ?
          throw new JDBCBinderException(column + " already exists in " + qualify);
        }

        // TODO: column.setSqlType(sqlTypeName); //this does not work 'cos the
        // precision/scale/length are not retured in TYPE_NAME
        // column.setSqlType(sqlTypeName);
        column.setComment(comment);
        column.setSqlTypeCode(new Integer(sqlType));
        if (intBounds(size)) {
          if (JDBCToHibernateTypeHelper.typeHasLength(sqlType)) {
            column.setLength(size);
          }
          if (JDBCToHibernateTypeHelper.typeHasScaleAndPrecision(sqlType)) {
            column.setPrecision(size);
          }
        }
        if (intBounds(decimalDigits)) {
          if (JDBCToHibernateTypeHelper.typeHasScaleAndPrecision(sqlType)) {
            column.setScale(decimalDigits);
          }
        }

        column.setNullable(isNullable);

        // columnDefaultValue is useless for Hibernate
        // isIndexed  (available via Indexes)
        // unique - detected when getting indexes
        // isPk - detected when finding primary keys

        table.addColumn(column);
      }
    } finally {

      if (columnIterator != null) {
        try {
          metaDataDialect.close(columnIterator);
        } catch (JDBCException se) {
          log.warn("Exception while closing iterator for column meta data", se);
        }
      }
    }
  }
コード例 #4
0
  // TODO refactor this code, there is a lot of duplication in this method
  public void doSecondPass(Map persistentClasses) throws MappingException {
    org.hibernate.mapping.OneToOne value =
        new org.hibernate.mapping.OneToOne(
            mappings, propertyHolder.getTable(), propertyHolder.getPersistentClass());
    final String propertyName = inferredData.getPropertyName();
    value.setPropertyName(propertyName);
    String referencedEntityName =
        ToOneBinder.getReferenceEntityName(inferredData, targetEntity, mappings);
    value.setReferencedEntityName(referencedEntityName);
    AnnotationBinder.defineFetchingStrategy(value, inferredData.getProperty());
    // value.setFetchMode( fetchMode );
    value.setCascadeDeleteEnabled(cascadeOnDelete);
    // value.setLazy( fetchMode != FetchMode.JOIN );

    if (!optional) value.setConstrained(true);
    value.setForeignKeyType(
        value.isConstrained()
            ? ForeignKeyDirection.FOREIGN_KEY_FROM_PARENT
            : ForeignKeyDirection.FOREIGN_KEY_TO_PARENT);
    PropertyBinder binder = new PropertyBinder();
    binder.setName(propertyName);
    binder.setValue(value);
    binder.setCascade(cascadeStrategy);
    binder.setAccessType(inferredData.getDefaultAccess());
    Property prop = binder.makeProperty();
    if (BinderHelper.isEmptyAnnotationValue(mappedBy)) {
      /*
       * we need to check if the columns are in the right order
       * if not, then we need to create a many to one and formula
       * but actually, since entities linked by a one to one need
       * to share the same composite id class, this cannot happen in hibernate
       */
      boolean rightOrder = true;

      if (rightOrder) {
        String path = StringHelper.qualify(propertyHolder.getPath(), propertyName);
        (new ToOneFkSecondPass(
                value,
                joinColumns,
                !optional, // cannot have nullabe and unique on certain DBs
                propertyHolder.getEntityOwnerClassName(),
                path,
                mappings))
            .doSecondPass(persistentClasses);
        // no column associated since its a one to one
        propertyHolder.addProperty(prop, inferredData.getDeclaringClass());
      } else {
        // this is a many to one with Formula

      }
    } else {
      PersistentClass otherSide =
          (PersistentClass) persistentClasses.get(value.getReferencedEntityName());
      Property otherSideProperty;
      try {
        if (otherSide == null) {
          throw new MappingException("Unable to find entity: " + value.getReferencedEntityName());
        }
        otherSideProperty = BinderHelper.findPropertyByName(otherSide, mappedBy);
      } catch (MappingException e) {
        throw new AnnotationException(
            "Unknown mappedBy in: "
                + StringHelper.qualify(ownerEntity, ownerProperty)
                + ", referenced property unknown: "
                + StringHelper.qualify(value.getReferencedEntityName(), mappedBy));
      }
      if (otherSideProperty == null) {
        throw new AnnotationException(
            "Unknown mappedBy in: "
                + StringHelper.qualify(ownerEntity, ownerProperty)
                + ", referenced property unknown: "
                + StringHelper.qualify(value.getReferencedEntityName(), mappedBy));
      }
      if (otherSideProperty.getValue() instanceof OneToOne) {
        propertyHolder.addProperty(prop, inferredData.getDeclaringClass());
      } else if (otherSideProperty.getValue() instanceof ManyToOne) {
        Iterator it = otherSide.getJoinIterator();
        Join otherSideJoin = null;
        while (it.hasNext()) {
          Join otherSideJoinValue = (Join) it.next();
          if (otherSideJoinValue.containsProperty(otherSideProperty)) {
            otherSideJoin = otherSideJoinValue;
            break;
          }
        }
        if (otherSideJoin != null) {
          // @OneToOne @JoinTable
          Join mappedByJoin =
              buildJoinFromMappedBySide(
                  (PersistentClass) persistentClasses.get(ownerEntity),
                  otherSideProperty,
                  otherSideJoin);
          ManyToOne manyToOne = new ManyToOne(mappings, mappedByJoin.getTable());
          // FIXME use ignore not found here
          manyToOne.setIgnoreNotFound(ignoreNotFound);
          manyToOne.setCascadeDeleteEnabled(value.isCascadeDeleteEnabled());
          manyToOne.setEmbedded(value.isEmbedded());
          manyToOne.setFetchMode(value.getFetchMode());
          manyToOne.setLazy(value.isLazy());
          manyToOne.setReferencedEntityName(value.getReferencedEntityName());
          manyToOne.setUnwrapProxy(value.isUnwrapProxy());
          prop.setValue(manyToOne);
          Iterator otherSideJoinKeyColumns = otherSideJoin.getKey().getColumnIterator();
          while (otherSideJoinKeyColumns.hasNext()) {
            Column column = (Column) otherSideJoinKeyColumns.next();
            Column copy = new Column();
            copy.setLength(column.getLength());
            copy.setScale(column.getScale());
            copy.setValue(manyToOne);
            copy.setName(column.getQuotedName());
            copy.setNullable(column.isNullable());
            copy.setPrecision(column.getPrecision());
            copy.setUnique(column.isUnique());
            copy.setSqlType(column.getSqlType());
            copy.setCheckConstraint(column.getCheckConstraint());
            copy.setComment(column.getComment());
            copy.setDefaultValue(column.getDefaultValue());
            manyToOne.addColumn(copy);
          }
          mappedByJoin.addProperty(prop);
        } else {
          propertyHolder.addProperty(prop, inferredData.getDeclaringClass());
        }

        value.setReferencedPropertyName(mappedBy);

        String propertyRef = value.getReferencedPropertyName();
        if (propertyRef != null) {
          mappings.addUniquePropertyReference(value.getReferencedEntityName(), propertyRef);
        }
      } else {
        throw new AnnotationException(
            "Referenced property not a (One|Many)ToOne: "
                + StringHelper.qualify(otherSide.getEntityName(), mappedBy)
                + " in mappedBy of "
                + StringHelper.qualify(ownerEntity, ownerProperty));
      }
    }
    ForeignKey fk = inferredData.getProperty().getAnnotation(ForeignKey.class);
    String fkName = fk != null ? fk.name() : "";
    if (!BinderHelper.isEmptyAnnotationValue(fkName)) value.setForeignKeyName(fkName);
  }