Esempio n. 1
0
  public void validateColumns(Dialect dialect, Mapping mapping, TableMetadata tableInfo) {
    Iterator iter = getColumnIterator();
    while (iter.hasNext()) {
      Column col = (Column) iter.next();

      ColumnMetadata columnInfo = tableInfo.getColumnMetadata(col.getName());

      if (columnInfo == null) {
        throw new HibernateException(
            "Missing column: "
                + col.getName()
                + " in "
                + Table.qualify(
                    tableInfo.getCatalog(), tableInfo.getSchema(), tableInfo.getName()));
      } else {
        final boolean typesMatch =
            col.getSqlType(dialect, mapping)
                    .toLowerCase(Locale.ROOT)
                    .startsWith(columnInfo.getTypeName().toLowerCase(Locale.ROOT))
                || columnInfo.getTypeCode() == col.getSqlTypeCode(mapping);
        if (!typesMatch) {
          throw new HibernateException(
              "Wrong column type in "
                  + Table.qualify(
                      tableInfo.getCatalog(), tableInfo.getSchema(), tableInfo.getName())
                  + " for column "
                  + col.getName()
                  + ". Found: "
                  + columnInfo.getTypeName().toLowerCase(Locale.ROOT)
                  + ", expected: "
                  + col.getSqlType(dialect, mapping));
        }
      }
    }
  }
  private void buildColumnAnnotation(
      Selectable selectable, StringBuffer annotations, boolean insertable, boolean updatable) {
    if (selectable.isFormula()) {
      annotations
          .append("@")
          .append(importType("org.hibernate.annotations.Formula"))
          .append("(value=\"")
          .append(selectable.getText())
          .append("\")");
    } else {
      Column column = (Column) selectable;
      annotations
          .append("@" + importType("javax.persistence.Column") + "(name=\"")
          .append(column.getName())
          .append("\"");

      appendCommonColumnInfo(annotations, column, insertable, updatable);

      if (column.getPrecision() != Column.DEFAULT_PRECISION) { // the default is actually 0 in spec
        annotations.append(", precision=").append(column.getPrecision());
      }
      if (column.getScale() != Column.DEFAULT_SCALE) { // default is actually 0 in spec
        annotations.append(", scale=").append(column.getScale());
      } else if (column.getLength() != 255) {
        annotations.append(", length=").append(column.getLength());
      }

      // TODO support secondary table
      annotations.append(")");
    }
  }
  public void testForeignKeyColumnBinding() {
    GroovyClassLoader cl = new GroovyClassLoader();
    GrailsDomainClass oneClass =
        new DefaultGrailsDomainClass(
            cl.parseClass(
                "class TestOneSide {\n"
                    + "    Long id \n"
                    + "    Long version \n"
                    + "    String name \n"
                    + "    String description \n"
                    + "}"));
    GrailsDomainClass domainClass =
        new DefaultGrailsDomainClass(
            cl.parseClass(
                "class TestManySide {\n"
                    + "    Long id \n"
                    + "    Long version \n"
                    + "    String name \n"
                    + "    TestOneSide testOneSide \n"
                    + "\n"
                    + "    static mapping = {\n"
                    + "        columns {\n"
                    + "            testOneSide column:'EXPECTED_COLUMN_NAME'"
                    + "        }\n"
                    + "    }\n"
                    + "}"));

    DefaultGrailsDomainConfiguration config =
        getDomainConfig(cl, new Class[] {oneClass.getClazz(), domainClass.getClazz()});

    PersistentClass persistentClass = config.getClassMapping("TestManySide");

    Column column = (Column) persistentClass.getProperty("testOneSide").getColumnIterator().next();
    assertEquals("EXPECTED_COLUMN_NAME", column.getName());
  }
Esempio n. 4
0
  private void bindColumnsToVersioning(Table table, RootClass rc, Set processed, Mapping mapping) {
    TableIdentifier identifier = TableIdentifier.create(table);

    String optimisticLockColumnName = revengStrategy.getOptimisticLockColumnName(identifier);

    if (optimisticLockColumnName != null) {
      Column column = table.getColumn(new Column(optimisticLockColumnName));
      if (column == null) {
        log.warn(
            "Column " + column + " wanted for <version>/<timestamp> not found in " + identifier);
      } else {
        bindVersionProperty(table, identifier, column, rc, processed, mapping);
      }
    } else {
      log.debug("Scanning " + identifier + " for <version>/<timestamp> columns.");
      Iterator columnIterator = table.getColumnIterator();
      while (columnIterator.hasNext()) {
        Column column = (Column) columnIterator.next();
        boolean useIt = revengStrategy.useColumnForOptimisticLock(identifier, column.getName());
        if (useIt && !processed.contains(column)) {
          bindVersionProperty(table, identifier, column, rc, processed, mapping);
          return;
        }
      }
      log.debug(
          "No columns reported while scanning for <version>/<timestamp> columns in " + identifier);
    }
  }
Esempio n. 5
0
  @SuppressWarnings("unchecked")
  public List<T> findByText2(String searchText, String sortColumn, boolean ascending) {
    List<Column> cols = HibernateUtil.getColumns(persistentClass.getName(), excludeDefault);
    String query = "select * from " + schemaName + "." + tableName + " where ";
    Iterator<Column> it = cols.iterator();
    while (it.hasNext()) {
      Column col = it.next();
      String colName = col.getName();
      String propName = HibernateUtil.convertToHibernatePropertyName(colName);
      String type = HibernateUtil.getPropertyType(persistentClass, propName);
      String condition = null;
      if (type != null) {
        if (type.equals("integer") || type.equals("smallint")) {
          try {
            Integer.valueOf(searchText);
            condition = colName + "=" + searchText;
          } catch (NumberFormatException ex) {
          }
        } else if (type.equals("timestamp")) {
          try {
            Integer.valueOf(searchText);
            condition =
                "( YEAR("
                    + colName
                    + ") = "
                    + searchText
                    + "  OR "
                    + "  MONTH("
                    + colName
                    + ") = "
                    + searchText
                    + "  OR "
                    + "  DAY("
                    + colName
                    + ") = "
                    + searchText
                    + ")";
          } catch (NumberFormatException ex) {
          }
        } else if (type.equals("string") || type.equals("timestamp") || type.equals("date"))
          condition = colName + " ilike '%" + searchText + "%'";

        if (condition != null)
          if (query.trim().endsWith("where")) query = query + condition;
          else query = query + " OR " + condition;
      }
      System.out.println("\n TYPE ZA KOLONU: " + colName + " JE: " + type + "\n");
    }
    if (sortColumn != null && !sortColumn.equals("")) {
      if (ascending) query = query + " order by " + sortColumn + " asc";
      else query = query + " order by " + sortColumn + " desc";
    }
    System.out.println("\n\n\n FINAL QUERY = " + query + " \n\n\n");
    return getSession().createSQLQuery(query).list();
  }
  /**
   * Tests that single- and multi-column user type mappings work correctly. Also Checks that the
   * "sqlType" property is honoured.
   */
  public void testUserTypeMappings() {
    DefaultGrailsDomainConfiguration config = getDomainConfig(MULTI_COLUMN_USER_TYPE_DEFINITION);
    PersistentClass persistentClass = config.getClassMapping("Item");

    // First check the "name" property and its associated column.
    Property nameProperty = persistentClass.getProperty("name");
    assertEquals(1, nameProperty.getColumnSpan());
    assertEquals("name", nameProperty.getName());

    Column column = (Column) nameProperty.getColumnIterator().next();
    assertEquals("s_name", column.getName());
    assertEquals("text", column.getSqlType());

    // Next the "other" property.
    Property otherProperty = persistentClass.getProperty("other");
    assertEquals(1, otherProperty.getColumnSpan());
    assertEquals("other", otherProperty.getName());

    column = (Column) otherProperty.getColumnIterator().next();
    assertEquals("other", column.getName());
    assertEquals("wrapper-characters", column.getSqlType());
    assertEquals(MyUserType.class.getName(), column.getValue().getType().getName());
    assertTrue(column.getValue() instanceof SimpleValue);
    SimpleValue v = (SimpleValue) column.getValue();
    assertEquals("myParam1", v.getTypeParameters().get("param1"));
    assertEquals("myParam2", v.getTypeParameters().get("param2"));

    // And now for the "price" property, which should have two
    // columns.
    Property priceProperty = persistentClass.getProperty("price");
    assertEquals(2, priceProperty.getColumnSpan());
    assertEquals("price", priceProperty.getName());

    Iterator<?> colIter = priceProperty.getColumnIterator();
    column = (Column) colIter.next();
    assertEquals("value", column.getName());
    assertNull("SQL type should have been 'null' for 'value' column.", column.getSqlType());

    column = (Column) colIter.next();
    assertEquals("currency_code", column.getName());
    assertEquals("text", column.getSqlType());
  }
  public void testDefaultNamingStrategy() {

    GroovyClassLoader cl = new GroovyClassLoader();
    GrailsDomainClass oneClass =
        new DefaultGrailsDomainClass(
            cl.parseClass(
                "class TestOneSide {\n"
                    + "    Long id \n"
                    + "    Long version \n"
                    + "    String fooName \n"
                    + "    String barDescriPtion \n"
                    + "}"));
    GrailsDomainClass domainClass =
        new DefaultGrailsDomainClass(
            cl.parseClass(
                "class TestManySide {\n"
                    + "    Long id \n"
                    + "    Long version \n"
                    + "    TestOneSide testOneSide \n"
                    + "\n"
                    + "    static mapping = {\n"
                    + "        columns {\n"
                    + "            testOneSide column:'EXPECTED_COLUMN_NAME'"
                    + "        }\n"
                    + "    }\n"
                    + "}"));

    DefaultGrailsDomainConfiguration config =
        getDomainConfig(cl, new Class[] {oneClass.getClazz(), domainClass.getClazz()});

    PersistentClass persistentClass = config.getClassMapping("TestOneSide");
    assertEquals("test_one_side", persistentClass.getTable().getName());

    Column column = (Column) persistentClass.getProperty("id").getColumnIterator().next();
    assertEquals("id", column.getName());

    column = (Column) persistentClass.getProperty("version").getColumnIterator().next();
    assertEquals("version", column.getName());

    column = (Column) persistentClass.getProperty("fooName").getColumnIterator().next();
    assertEquals("foo_name", column.getName());

    column = (Column) persistentClass.getProperty("barDescriPtion").getColumnIterator().next();
    assertEquals("bar_descri_ption", column.getName());

    persistentClass = config.getClassMapping("TestManySide");
    assertEquals("test_many_side", persistentClass.getTable().getName());

    column = (Column) persistentClass.getProperty("id").getColumnIterator().next();
    assertEquals("id", column.getName());

    column = (Column) persistentClass.getProperty("version").getColumnIterator().next();
    assertEquals("version", column.getName());

    column = (Column) persistentClass.getProperty("testOneSide").getColumnIterator().next();
    assertEquals("EXPECTED_COLUMN_NAME", column.getName());
  }
Esempio n. 8
0
  private void bindVersionProperty(
      Table table,
      TableIdentifier identifier,
      Column column,
      RootClass rc,
      Set processed,
      Mapping mapping) {

    processed.add(column);
    String propertyName = revengStrategy.columnToPropertyName(identifier, column.getName());
    Property property =
        bindBasicProperty(makeUnique(rc, propertyName), table, column, processed, mapping);
    rc.addProperty(property);
    rc.setVersion(property);
    rc.setOptimisticLockMode(Versioning.OPTIMISTIC_LOCK_VERSION);
    log.debug(
        "Column "
            + column.getName()
            + " will be used for <version>/<timestamp> columns in "
            + identifier);
  }
  @SuppressWarnings({"unchecked"})
  @Test
  public void testJoinColumnName() {
    Iterator<Column> columns =
        getCfg().getClassMapping(MIDDLE_VERSIONS_ENTITY_NAME).getTable().getColumnIterator();

    boolean id1Found = false;
    boolean id2Found = false;

    while (columns.hasNext()) {
      Column column = columns.next();
      if ("ID_1".equals(column.getName())) {
        id1Found = true;
      }

      if ("ID_2".equals(column.getName())) {
        id2Found = true;
      }
    }

    assert id1Found && id2Found;
  }
Esempio n. 10
0
  private Property bindMeta(Property property, TableIdentifier identifier) {
    Iterator columnIterator = property.getValue().getColumnIterator();
    while (columnIterator.hasNext()) {
      Column col = (Column) columnIterator.next();

      Map map = revengStrategy.columnToMetaAttributes(identifier, col.getName());
      if (map != null) { // TODO: merge from each column ?
        property.setMetaAttributes(map);
      }
    }

    return property;
  }
Esempio n. 11
0
  @SuppressWarnings("unchecked")
  public List<T> findByText(String searchText, String sortProp, boolean ascending) {
    List<Column> cols = HibernateUtil.getColumns(persistentClass.getName(), excludeDefault);
    Iterator<Column> it = cols.iterator();
    Criteria crit = getSession().createCriteria(persistentClass);
    Disjunction disjunction = Restrictions.disjunction();
    while (it.hasNext()) {
      Column col = it.next();
      String colName = col.getName();
      String propName = HibernateUtil.convertToHibernatePropertyName(colName);
      String type = HibernateUtil.getPropertyType(persistentClass, propName);
      if (type != null) {
        if (type.equals("integer") || type.equals("smallint")) {
          try {
            Integer.valueOf(searchText);
            Criterion criterium = Restrictions.eq(propName, Integer.valueOf(searchText));
            disjunction.add(criterium);
          } catch (NumberFormatException ex) {
          }
        } else if (type.equals("string")) {
          Criterion criterium = Restrictions.ilike(propName, searchText, MatchMode.ANYWHERE);
          disjunction.add(criterium);
        }
        /*else
            	if(type.equals("timestamp")){
            		Disjunction dis = Restrictions.disjunction();
           			SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
           			try {
        	dis.add(Restrictions.eq(propName, format.parse(searchText)));
        } catch (ParseException e) {
        }
        try{
            			Integer.valueOf(searchText);
            			dis.add(Restrictions.sqlRestriction(
            					"YEAR(DATE("+colName+"))="+searchText+ " OR " +
               		"MONTH(DATE("+colName+"))="+searchText+ " OR " +
               		"DAY(DATE("+colName+"))="+searchText));
            		} catch(NumberFormatException ex) {
            		}
            		disjunction.add(dis);
            	}*/
      }
    }
    crit.add(disjunction);
    if (sortProp != null && !sortProp.equals("")) {
      if (ascending) crit.addOrder(Order.asc(sortProp));
      else crit.addOrder(Order.desc(sortProp));
    }

    return crit.list();
  }
  public void visit(Configuration cfg, Table table, Column col, IssueCollector pc) {
    if (currentDbTable == null) {
      return;
    }

    Column dbColumn = currentDbTable.getColumn(new Column(col.getName()));

    if (dbColumn == null) {
      pc.reportIssue(
          new Issue(
              "SCHEMA_COLUMN_MISSING",
              Issue.HIGH_PRIORITY,
              table(table) + " is missing column: " + col.getName()));
    } else {
      // TODO: this needs to be able to know if a type is truly compatible or not. Right now it
      // requires an exact match.
      // String sqlType = col.getSqlType( dialect, mapping );
      int dbTypeCode = dbColumn.getSqlTypeCode().intValue();
      int modelTypeCode = col.getSqlTypeCode(mapping);
      // TODO: sqltype name string
      if (!(dbTypeCode == modelTypeCode)) {
        pc.reportIssue(
            new Issue(
                "SCHEMA_COLUMN_TYPE_MISMATCH",
                Issue.NORMAL_PRIORITY,
                table(table)
                    + " has a wrong column type for "
                    + col.getName()
                    + ", expected: "
                    + JDBCToHibernateTypeHelper.getJDBCTypeName(modelTypeCode)
                    + " but was "
                    + JDBCToHibernateTypeHelper.getJDBCTypeName(dbTypeCode)
                    + " in db"));
      }
    }
  }
Esempio n. 13
0
 public static boolean isColumnPresent(String tableName, String columnName, Configuration cfg) {
   final Iterator<Table> tables = (Iterator<Table>) cfg.getTableMappings();
   while (tables.hasNext()) {
     Table table = tables.next();
     if (tableName.equals(table.getName())) {
       Iterator<Column> columns = (Iterator<Column>) table.getColumnIterator();
       while (columns.hasNext()) {
         Column column = columns.next();
         if (columnName.equals(column.getName())) {
           return true;
         }
       }
     }
   }
   return false;
 }
Esempio n. 14
0
  /**
   * @param table
   * @param rc
   * @param primaryKey
   */
  private void bindColumnsToProperties(
      Table table, RootClass rc, Set processedColumns, Mapping mapping) {

    for (Iterator iterator = table.getColumnIterator(); iterator.hasNext(); ) {
      Column column = (Column) iterator.next();
      if (!processedColumns.contains(column)) {
        checkColumn(column);

        String propertyName =
            revengStrategy.columnToPropertyName(TableIdentifier.create(table), column.getName());

        Property property =
            bindBasicProperty(
                makeUnique(rc, propertyName), table, column, processedColumns, mapping);

        rc.addProperty(property);
      }
    }
  }
  /** Test for GRAILS-4200 */
  public void testEmbeddedComponentMapping() {
    DefaultGrailsDomainConfiguration config =
        getDomainConfig(
            "class Widget {\n"
                + "    Long id \n"
                + "    Long version \n"
                + "    EmbeddedWidget ew \n"
                + "    static embedded = ['ew']\n"
                + "}\n"
                + "    class EmbeddedWidget {\n"
                + "       String ew\n"
                + "       static mapping = {\n"
                + "           ew column: 'widget_name'\n"
                + "       }\n"
                + "    }");

    Table tableMapping = getTableMapping("widget", config);
    Column embeddedComponentMappedColumn = tableMapping.getColumn(new Column("widget_name"));
    assertNotNull(embeddedComponentMappedColumn);
    assertEquals("widget_name", embeddedComponentMappedColumn.getName());
  }
  public void testCustomNamingStrategy() throws Exception {

    // somewhat artificial in that it doesn't test that setting the property
    // in DataSource.groovy works, but that's handled in DataSourceConfigurationTests
    GrailsDomainBinder.configureNamingStrategy(CustomNamingStrategy.class);

    GroovyClassLoader cl = new GroovyClassLoader();
    GrailsDomainClass oneClass =
        new DefaultGrailsDomainClass(
            cl.parseClass(
                "class TestOneSide {\n"
                    + "    Long id \n"
                    + "    Long version \n"
                    + "    String fooName \n"
                    + "    String barDescriPtion \n"
                    + "}"));
    GrailsDomainClass domainClass =
        new DefaultGrailsDomainClass(
            cl.parseClass(
                "class TestManySide {\n"
                    + "    Long id \n"
                    + "    Long version \n"
                    + "    TestOneSide testOneSide \n"
                    + "\n"
                    + "    static mapping = {\n"
                    + "        columns {\n"
                    + "            testOneSide column:'EXPECTED_COLUMN_NAME'"
                    + "        }\n"
                    + "    }\n"
                    + "}"));

    DefaultGrailsDomainConfiguration config =
        getDomainConfig(cl, new Class[] {oneClass.getClazz(), domainClass.getClazz()});

    PersistentClass persistentClass = config.getClassMapping("TestOneSide");
    assertEquals("table_TestOneSide", persistentClass.getTable().getName());

    Column column = (Column) persistentClass.getProperty("id").getColumnIterator().next();
    assertEquals("col_id", column.getName());

    column = (Column) persistentClass.getProperty("version").getColumnIterator().next();
    assertEquals("col_version", column.getName());

    column = (Column) persistentClass.getProperty("fooName").getColumnIterator().next();
    assertEquals("col_fooName", column.getName());

    column = (Column) persistentClass.getProperty("barDescriPtion").getColumnIterator().next();
    assertEquals("col_barDescriPtion", column.getName());

    persistentClass = config.getClassMapping("TestManySide");
    assertEquals("table_TestManySide", persistentClass.getTable().getName());

    column = (Column) persistentClass.getProperty("id").getColumnIterator().next();
    assertEquals("col_id", column.getName());

    column = (Column) persistentClass.getProperty("version").getColumnIterator().next();
    assertEquals("col_version", column.getName());

    column = (Column) persistentClass.getProperty("testOneSide").getColumnIterator().next();
    assertEquals("EXPECTED_COLUMN_NAME", column.getName());
  }
Esempio n. 17
0
  /**
   * @param column
   * @param generatedIdentifier
   * @return
   */
  private String guessAndAlignType(
      Table table, Column column, Mapping mapping, boolean generatedIdentifier) {
    // TODO: this method mutates the column if the types does not match...not good.
    // maybe we should copy the column instead before calling this method.
    Integer sqlTypeCode = column.getSqlTypeCode();
    String location =
        "Table: "
            + Table.qualify(table.getCatalog(), table.getSchema(), table.getQuotedName())
            + " column: "
            + column.getQuotedName();
    if (sqlTypeCode == null) {
      throw new JDBCBinderException("sqltype is null for " + location);
    }

    String preferredHibernateType =
        revengStrategy.columnToHibernateTypeName(
            TableIdentifier.create(table),
            column.getName(),
            sqlTypeCode.intValue(),
            column.getLength(),
            column.getPrecision(),
            column.getScale(),
            column.isNullable(),
            generatedIdentifier);

    Type wantedType = TypeFactory.heuristicType(preferredHibernateType);

    if (wantedType != null) {
      int[] wantedSqlTypes = wantedType.sqlTypes(mapping);

      if (wantedSqlTypes.length > 1) {
        throw new JDBCBinderException(
            "The type "
                + preferredHibernateType
                + " found on "
                + location
                + " spans multiple columns. Only single column types allowed.");
      }

      int wantedSqlType = wantedSqlTypes[0];
      if (wantedSqlType != sqlTypeCode.intValue()) {
        log.debug(
            "Sql type mismatch for "
                + location
                + " between DB and wanted hibernate type. Sql type set to "
                + typeCodeName(sqlTypeCode.intValue())
                + " instead of "
                + typeCodeName(wantedSqlType));
        column.setSqlTypeCode(new Integer(wantedSqlType));
      }
    } else {
      log.debug(
          "No Hibernate type found for "
              + preferredHibernateType
              + ". Most likely cause is a missing UserType class.");
    }

    if (preferredHibernateType == null) {
      throw new JDBCBinderException(
          "Could not find javatype for " + typeCodeName(sqlTypeCode.intValue()));
    }

    return preferredHibernateType;
  }
Esempio n. 18
0
  /**
   * Basically create an [classname]Id.class and add properties for it.
   *
   * @param rc
   * @param compositeKeyColumns
   * @param processed
   * @return
   */
  private SimpleValue handleCompositeKey(
      RootClass rc, Set processedColumns, List keyColumns, Mapping mapping) {
    Component pkc = new Component(rc);
    pkc.setMetaAttributes(Collections.EMPTY_MAP);
    pkc.setEmbedded(false);

    String compositeIdName =
        revengStrategy.tableToCompositeIdName(TableIdentifier.create(rc.getTable()));
    if (compositeIdName == null) {
      compositeIdName = revengStrategy.classNameToCompositeIdName(rc.getClassName());
    }
    pkc.setComponentClassName(compositeIdName);
    Table table = rc.getTable();
    List list = null;
    if (cfg.preferBasicCompositeIds()) {
      list = new ArrayList(keyColumns);
    } else {
      list = findForeignKeys(table.getForeignKeyIterator(), keyColumns);
    }
    for (Iterator iter = list.iterator(); iter.hasNext(); ) {
      Object element = iter.next();
      Property property;
      if (element instanceof Column) {
        Column column = (Column) element;
        if (processedColumns.contains(column)) {
          throw new JDBCBinderException(
              "Binding column twice for primary key should not happen: " + column);
        } else {
          checkColumn(column);

          String propertyName =
              revengStrategy.columnToPropertyName(TableIdentifier.create(table), column.getName());
          property =
              bindBasicProperty(
                  makeUnique(pkc, propertyName), table, column, processedColumns, mapping);

          processedColumns.add(column);
        }
      } else if (element instanceof ForeignKeyForColumns) {
        ForeignKeyForColumns fkfc = (ForeignKeyForColumns) element;
        ForeignKey foreignKey = fkfc.key;
        String propertyName =
            revengStrategy.foreignKeyToEntityName(
                foreignKey.getName(),
                TableIdentifier.create(foreignKey.getTable()),
                foreignKey.getColumns(),
                TableIdentifier.create(foreignKey.getReferencedTable()),
                foreignKey.getReferencedColumns(),
                true);
        property =
            bindManyToOne(makeUnique(pkc, propertyName), true, table, foreignKey, processedColumns);
        processedColumns.addAll(fkfc.columns);
      } else {
        throw new JDBCBinderException("unknown thing");
      }

      markAsUseInEquals(property);
      pkc.addProperty(property);
    }

    return pkc;
  }
  @SuppressWarnings({"unchecked"})
  public void doSecondPass(Map persistentClasses) throws MappingException {
    PersistentClass referencedPersistentClass =
        (PersistentClass) persistentClasses.get(referencedEntityName);
    // TODO better error names
    if (referencedPersistentClass == null) {
      throw new AnnotationException("Unknown entity name: " + referencedEntityName);
    }
    if (!(referencedPersistentClass.getIdentifier() instanceof Component)) {
      throw new AssertionFailure(
          "Unexpected identifier type on the referenced entity when mapping a @MapsId: "
              + referencedEntityName);
    }
    Component referencedComponent = (Component) referencedPersistentClass.getIdentifier();
    Iterator<Property> properties = referencedComponent.getPropertyIterator();

    // prepare column name structure
    boolean isExplicitReference = true;
    Map<String, Ejb3JoinColumn> columnByReferencedName =
        new HashMap<String, Ejb3JoinColumn>(joinColumns.length);
    for (Ejb3JoinColumn joinColumn : joinColumns) {
      final String referencedColumnName = joinColumn.getReferencedColumn();
      if (referencedColumnName == null
          || BinderHelper.isEmptyAnnotationValue(referencedColumnName)) {
        break;
      }
      // JPA 2 requires referencedColumnNames to be case insensitive
      columnByReferencedName.put(referencedColumnName.toLowerCase(), joinColumn);
    }
    // try default column orientation
    int index = 0;
    if (columnByReferencedName.isEmpty()) {
      isExplicitReference = false;
      for (Ejb3JoinColumn joinColumn : joinColumns) {
        columnByReferencedName.put("" + index, joinColumn);
        index++;
      }
      index = 0;
    }

    while (properties.hasNext()) {
      Property referencedProperty = properties.next();
      if (referencedProperty.isComposite()) {
        throw new AssertionFailure(
            "Unexpected nested component on the referenced entity when mapping a @MapsId: "
                + referencedEntityName);
      } else {
        Property property = new Property();
        property.setName(referencedProperty.getName());
        property.setNodeName(referencedProperty.getNodeName());
        // FIXME set optional?
        // property.setOptional( property.isOptional() );
        property.setPersistentClass(component.getOwner());
        property.setPropertyAccessorName(referencedProperty.getPropertyAccessorName());
        SimpleValue value = new SimpleValue(mappings, component.getTable());
        property.setValue(value);
        final SimpleValue referencedValue = (SimpleValue) referencedProperty.getValue();
        value.setTypeName(referencedValue.getTypeName());
        value.setTypeParameters(referencedValue.getTypeParameters());
        final Iterator<Column> columns = referencedValue.getColumnIterator();

        if (joinColumns[0].isNameDeferred()) {
          joinColumns[0].copyReferencedStructureAndCreateDefaultJoinColumns(
              referencedPersistentClass, columns, value);
        } else {
          // FIXME take care of Formula
          while (columns.hasNext()) {
            Column column = columns.next();
            final Ejb3JoinColumn joinColumn;
            String logicalColumnName = null;
            if (isExplicitReference) {
              final String columnName = column.getName();
              logicalColumnName =
                  mappings.getLogicalColumnName(columnName, referencedPersistentClass.getTable());
              // JPA 2 requires referencedColumnNames to be case insensitive
              joinColumn = columnByReferencedName.get(logicalColumnName.toLowerCase());
            } else {
              joinColumn = columnByReferencedName.get("" + index);
              index++;
            }
            if (joinColumn == null && !joinColumns[0].isNameDeferred()) {
              throw new AnnotationException(
                  isExplicitReference
                      ? "Unable to find column reference in the @MapsId mapping: "
                          + logicalColumnName
                      : "Implicit column reference in the @MapsId mapping fails, try to use explicit referenceColumnNames: "
                          + referencedEntityName);
            }
            final String columnName =
                joinColumn == null || joinColumn.isNameDeferred()
                    ? "tata_" + column.getName()
                    : joinColumn.getName();
            value.addColumn(new Column(columnName));
            column.setValue(value);
          }
        }
        component.addProperty(property);
      }
    }
  }
Esempio n. 20
0
  public Iterator sqlAlterStrings(
      Dialect dialect,
      Mapping p,
      TableMetadata tableInfo,
      String defaultCatalog,
      String defaultSchema)
      throws HibernateException {

    StringBuffer root =
        new StringBuffer("alter table ")
            .append(getQualifiedName(dialect, defaultCatalog, defaultSchema))
            .append(' ')
            .append(dialect.getAddColumnString());

    Iterator iter = getColumnIterator();
    List results = new ArrayList();
    while (iter.hasNext()) {
      Column column = (Column) iter.next();

      ColumnMetadata columnInfo = tableInfo.getColumnMetadata(column.getName());

      if (columnInfo == null) {
        // the column doesnt exist at all.
        StringBuffer alter =
            new StringBuffer(root.toString())
                .append(' ')
                .append(column.getQuotedName(dialect))
                .append(' ')
                .append(column.getSqlType(dialect, p));

        String defaultValue = column.getDefaultValue();
        if (defaultValue != null) {
          alter.append(" default ").append(defaultValue);

          if (column.isNullable()) {
            alter.append(dialect.getNullColumnString());
          } else {
            alter.append(" not null");
          }
        }

        boolean useUniqueConstraint =
            column.isUnique()
                && dialect.supportsUnique()
                && (!column.isNullable() || dialect.supportsNotNullUnique());
        if (useUniqueConstraint) {
          alter.append(" unique");
        }

        if (column.hasCheckConstraint() && dialect.supportsColumnCheck()) {
          alter.append(" check(").append(column.getCheckConstraint()).append(")");
        }

        String columnComment = column.getComment();
        if (columnComment != null) alter.append(dialect.getColumnComment(columnComment));

        results.add(alter.toString());
      }
    }

    return results.iterator();
  }
Esempio n. 21
0
  public Iterator sqlAlterStrings(
      Dialect dialect,
      Mapping p,
      TableInformation tableInfo,
      String defaultCatalog,
      String defaultSchema)
      throws HibernateException {

    StringBuilder root =
        new StringBuilder("alter table ")
            .append(getQualifiedName(dialect, defaultCatalog, defaultSchema))
            .append(' ')
            .append(dialect.getAddColumnString());

    Iterator iter = getColumnIterator();
    List results = new ArrayList();

    while (iter.hasNext()) {
      final Column column = (Column) iter.next();
      final ColumnInformation columnInfo =
          tableInfo.getColumn(Identifier.toIdentifier(column.getName(), column.isQuoted()));

      if (columnInfo == null) {
        // the column doesnt exist at all.
        StringBuilder alter =
            new StringBuilder(root.toString())
                .append(' ')
                .append(column.getQuotedName(dialect))
                .append(' ')
                .append(column.getSqlType(dialect, p));

        String defaultValue = column.getDefaultValue();
        if (defaultValue != null) {
          alter.append(" default ").append(defaultValue);
        }

        if (column.isNullable()) {
          alter.append(dialect.getNullColumnString());
        } else {
          alter.append(" not null");
        }

        if (column.isUnique()) {
          String keyName = Constraint.generateName("UK_", this, column);
          UniqueKey uk = getOrCreateUniqueKey(keyName);
          uk.addColumn(column);
          alter.append(dialect.getUniqueDelegate().getColumnDefinitionUniquenessFragment(column));
        }

        if (column.hasCheckConstraint() && dialect.supportsColumnCheck()) {
          alter.append(" check(").append(column.getCheckConstraint()).append(")");
        }

        String columnComment = column.getComment();
        if (columnComment != null) {
          alter.append(dialect.getColumnComment(columnComment));
        }

        alter.append(dialect.getAddColumnSuffixString());

        results.add(alter.toString());
      }
    }

    if (results.isEmpty()) {
      Logger.getLogger(SchemaUpdate.class)
          .debugf("No alter strings for table : %s", getQuotedName());
    }

    return results.iterator();
  }
Esempio n. 22
0
  private PrimaryKeyInfo bindPrimaryKeyToProperties(
      Table table, RootClass rc, Set processed, Mapping mapping, DatabaseCollector collector) {
    SimpleValue id = null;
    String idPropertyname = null;

    PrimaryKeyInfo pki = new PrimaryKeyInfo();

    List keyColumns = null;
    if (table.getPrimaryKey() != null) {
      keyColumns = table.getPrimaryKey().getColumns();
    } else {
      log.debug("No primary key found for " + table + ", using all properties as the identifier.");
      keyColumns = new ArrayList();
      Iterator iter = table.getColumnIterator();
      while (iter.hasNext()) {
        Column col = (Column) iter.next();
        keyColumns.add(col);
      }
    }

    final TableIdentifier tableIdentifier = TableIdentifier.create(table);

    String tableIdentifierStrategyName = "assigned";

    boolean naturalId;

    if (keyColumns.size() > 1) {
      log.debug(
          "id strategy for " + rc.getEntityName() + " since it has a multiple column primary key");
      naturalId = true;

      id = handleCompositeKey(rc, processed, keyColumns, mapping);
      idPropertyname = revengStrategy.tableToIdentifierPropertyName(tableIdentifier);
      if (idPropertyname == null) {
        idPropertyname = "id";
      }
    } else {
      pki.suggestedStrategy = revengStrategy.getTableIdentifierStrategyName(tableIdentifier);
      String suggestedStrategy = pki.suggestedStrategy;
      if (suggestedStrategy == null) {
        suggestedStrategy =
            collector.getSuggestedIdentifierStrategy(
                tableIdentifier.getCatalog(),
                tableIdentifier.getSchema(),
                tableIdentifier.getName());
        if (suggestedStrategy == null) {
          suggestedStrategy = "assigned";
        }
        tableIdentifierStrategyName = suggestedStrategy;
      } else {
        tableIdentifierStrategyName = suggestedStrategy;
      }

      naturalId = "assigned".equals(tableIdentifierStrategyName);
      Column pkc = (Column) keyColumns.get(0);
      checkColumn(pkc);

      id = bindColumnToSimpleValue(table, pkc, mapping, !naturalId);

      idPropertyname = revengStrategy.tableToIdentifierPropertyName(tableIdentifier);
      if (idPropertyname == null) {
        idPropertyname = revengStrategy.columnToPropertyName(tableIdentifier, pkc.getName());
      }

      processed.add(pkc);
    }
    id.setIdentifierGeneratorStrategy(tableIdentifierStrategyName);
    pki.suggestedProperties = revengStrategy.getTableIdentifierProperties(tableIdentifier);
    id.setIdentifierGeneratorProperties(pki.suggestedProperties);
    if (naturalId) {
      id.setNullValue("undefined");
    }

    Property property =
        makeProperty(
            tableIdentifier, makeUnique(rc, idPropertyname), id, true, true, false, null, null);
    rc.setIdentifierProperty(property);
    rc.setIdentifier(id);

    return pki;
  }