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());
  }
Example #2
0
 public String sqlTemporaryTableCreateString(Dialect dialect, Mapping mapping)
     throws HibernateException {
   StringBuffer buffer =
       new StringBuffer(dialect.getCreateTemporaryTableString())
           .append(' ')
           .append(name)
           .append(" (");
   Iterator itr = getColumnIterator();
   while (itr.hasNext()) {
     final Column column = (Column) itr.next();
     buffer.append(column.getQuotedName(dialect)).append(' ');
     buffer.append(column.getSqlType(dialect, mapping));
     if (column.isNullable()) {
       buffer.append(dialect.getNullColumnString());
     } else {
       buffer.append(" not null");
     }
     if (itr.hasNext()) {
       buffer.append(", ");
     }
   }
   buffer.append(") ");
   buffer.append(dialect.getCreateTemporaryTablePostfix());
   return buffer.toString();
 }
Example #3
0
 public Iterator sqlCommentStrings(Dialect dialect, String defaultCatalog, String defaultSchema) {
   List comments = new ArrayList();
   if (dialect.supportsCommentOn()) {
     String tableName = getQualifiedName(dialect, defaultCatalog, defaultSchema);
     if (comment != null) {
       comments.add("comment on table " + tableName + " is '" + comment + "'");
     }
     Iterator iter = getColumnIterator();
     while (iter.hasNext()) {
       Column column = (Column) iter.next();
       String columnComment = column.getComment();
       if (columnComment != null) {
         comments.add(
             "comment on column "
                 + tableName
                 + '.'
                 + column.getQuotedName(dialect)
                 + " is '"
                 + columnComment
                 + "'");
       }
     }
   }
   return comments.iterator();
 }
Example #4
0
 public Iterator sqlCommentStrings(Dialect dialect, String defaultCatalog, String defaultSchema) {
   List comments = new ArrayList();
   if (dialect.supportsCommentOn()) {
     String tableName = getQualifiedName(dialect, defaultCatalog, defaultSchema);
     if (comment != null) {
       StringBuffer buf =
           new StringBuffer()
               .append("comment on table ")
               .append(tableName)
               .append(" is '")
               .append(comment)
               .append("'");
       comments.add(buf.toString());
     }
     Iterator iter = getColumnIterator();
     while (iter.hasNext()) {
       Column column = (Column) iter.next();
       String columnComment = column.getComment();
       if (columnComment != null) {
         StringBuffer buf =
             new StringBuffer()
                 .append("comment on column ")
                 .append(tableName)
                 .append('.')
                 .append(column.getQuotedName(dialect))
                 .append(" is '")
                 .append(columnComment)
                 .append("'");
         comments.add(buf.toString());
       }
     }
   }
   return comments.iterator();
 }
Example #5
0
 public void addColumn(Column column) {
   if (!columns.contains(column)) {
     columns.add(column);
   }
   column.setValue(this);
   column.setTypeIndex(columns.size() - 1);
 }
Example #6
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);
    }
  }
 private void assertColumnPrecisionAndScale(
     ConstrainedProperty constrainedProperty, int expectedPrecision, int expectedScale) {
   Column column = new Column();
   GrailsDomainBinder.bindNumericColumnConstraints(column, constrainedProperty);
   assertEquals(expectedPrecision, column.getPrecision());
   assertEquals(expectedScale, column.getScale());
 }
Example #8
0
  /**
   * Return the column which is identified by column provided as argument.
   *
   * @param column column with atleast a name.
   * @return the underlying column or null if not inside this table. Note: the instance *can* be
   *     different than the input parameter, but the name will be the same.
   */
  public Column getColumn(Column column) {
    if (column == null) return null;

    Column myColumn = (Column) columns.get(column.getCanonicalName());

    return column.equals(myColumn) ? myColumn : null;
  }
Example #9
0
 public void addColumn(Column column) {
   Column old = (Column) getColumn(column);
   if (old == null) {
     columns.put(column.getCanonicalName(), column);
     column.uniqueInteger = columns.size();
   } else {
     column.uniqueInteger = old.uniqueInteger;
   }
 }
Example #10
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();
  }
Example #11
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;
  }
Example #12
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();
  }
  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(")");
    }
  }
  /**
   * Called to apply column definitions from the referenced FK column to this column.
   *
   * @param column the referenced column.
   */
  public void overrideFromReferencedColumnIfNecessary(org.hibernate.mapping.Column column) {
    if (getMappingColumn() != null) {
      // columnDefinition can also be specified using @JoinColumn, hence we have to check
      // whether it is set or not
      if (StringHelper.isEmpty(sqlType)) {
        sqlType = column.getSqlType();
        getMappingColumn().setSqlType(sqlType);
      }

      // these properties can only be applied on the referenced column - we can just take them over
      getMappingColumn().setLength(column.getLength());
      getMappingColumn().setPrecision(column.getPrecision());
      getMappingColumn().setScale(column.getScale());
    }
  }
 /** used for mappedBy cases */
 public void linkValueUsingAColumnCopy(Column column, SimpleValue value) {
   initMappingColumn(
       // column.getName(),
       column.getQuotedName(),
       null,
       column.getLength(),
       column.getPrecision(),
       column.getScale(),
       getMappingColumn().isNullable(),
       column.getSqlType(),
       getMappingColumn().isUnique(),
       false // We do copy no strategy here
       );
   linkWithValue(value);
 }
 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;
 }
  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());
  }
Example #18
0
  private List columnMatches(Column[] myPkColumns, int offset, ForeignKey key) {

    if (key.getColumnSpan() > (myPkColumns.length - offset)) {
      return null; // not enough columns in the key
    }

    List columns = new ArrayList();
    for (int j = 0; j < key.getColumnSpan(); j++) {
      Column column = myPkColumns[j + offset];
      if (!column.equals(key.getColumn(j))) {
        return null;
      } else {
        columns.add(column);
      }
    }
    return columns.isEmpty() ? null : columns;
  }
Example #19
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));
        }
      }
    }
  }
 public void testScaleProperty() {
   DefaultGrailsDomainConfiguration config =
       getDomainConfig(
           "class Widget {\n"
               + "    Long id \n"
               + "    Long version \n"
               + "    Float width \n"
               + "    Float height \n"
               + "    static mapping = {\n"
               + "        width scale: 7\n"
               + "    }\n"
               + "}");
   Table tableMapping = getTableMapping("widget", config);
   Column heightColumn = tableMapping.getColumn(new Column("height"));
   Column widthColumn = tableMapping.getColumn(new Column("width"));
   assertEquals(7, widthColumn.getScale());
   assertEquals(Column.DEFAULT_SCALE, heightColumn.getScale());
 }
 public void testPrecisionProperty() {
   DefaultGrailsDomainConfiguration config =
       getDomainConfig(
           "class Widget {\n"
               + "    Long id \n"
               + "    Long version \n"
               + "    Float width \n"
               + "    Float height \n"
               + "    static mapping = {\n"
               + "        width precision: 3\n"
               + "    }\n"
               + "}");
   Table tableMapping = getTableMapping("widget", config);
   Column heightColumn = tableMapping.getColumn(new Column("height"));
   Column widthColumn = tableMapping.getColumn(new Column("width"));
   assertEquals(3, widthColumn.getPrecision());
   assertEquals(Column.DEFAULT_PRECISION, heightColumn.getPrecision());
 }
 public void testUniqueProperty() {
   DefaultGrailsDomainConfiguration config =
       getDomainConfig(
           "class Widget {\n"
               + "    Long id \n"
               + "    Long version \n"
               + "    String name \n"
               + "    String description \n"
               + "    static mapping = {\n"
               + "        name unique: true\n"
               + "    }\n"
               + "}");
   Table tableMapping = getTableMapping("widget", config);
   Column nameColumn = tableMapping.getColumn(new Column("name"));
   Column descriptionColumn = tableMapping.getColumn(new Column("description"));
   assertEquals(true, nameColumn.isUnique());
   assertEquals(false, descriptionColumn.isUnique());
 }
 public void testLengthProperty() {
   DefaultGrailsDomainConfiguration config =
       getDomainConfig(
           "class Widget {\n"
               + "    Long id \n"
               + "    Long version \n"
               + "    String name \n"
               + "    String description \n"
               + "    static mapping = {\n"
               + "        name column: 's_name', sqlType: 'text', length: 42\n"
               + "        description column: 's_description', sqlType: 'text'\n"
               + "    }\n"
               + "}");
   Table tableMapping = getTableMapping("widget", config);
   Column nameColumn = tableMapping.getColumn(new Column("s_name"));
   Column descriptionColumn = tableMapping.getColumn(new Column("s_description"));
   assertEquals(42, nameColumn.getLength());
   assertEquals(Column.DEFAULT_LENGTH, descriptionColumn.getLength());
 }
Example #24
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());
  }
Example #26
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;
  }
  protected void appendCommonColumnInfo(
      StringBuffer annotations, Column column, boolean insertable, boolean updatable) {
    if (column.isUnique()) {
      annotations.append(", unique=").append(column.isUnique());
    }
    if (!column.isNullable()) {
      annotations.append(", nullable=").append(column.isNullable());
    }

    if (!insertable) {
      annotations.append(", insertable=").append(insertable);
    }

    if (!updatable) {
      annotations.append(", updatable=").append(updatable);
    }

    String sqlType = column.getSqlType();
    if (StringHelper.isNotEmpty(sqlType)) {
      annotations.append(", columnDefinition=\"").append(sqlType).append("\"");
    }
  }
Example #29
0
  public void /*test*/ AddNewProperty() {
    System.out.println("******************* testAddNewProperty ********************");
    PersistentClass userMapping = HibernateUtil.getClassMapping(User.class);

    Column column = new Column();
    column.setName("MOTTO");
    column.setNullable(false);
    column.setUnique(true);
    column.setSqlType("VARCHAR");
    userMapping.getTable().addColumn(column);

    SimpleValue value = new SimpleValue();
    value.setTable(userMapping.getTable());
    value.addColumn(column);
    value.setTypeName("string");

    Property prop = new Property();
    prop.setValue(value);
    prop.setName("motto");
    prop.setPropertyAccessorName("field");
    prop.setNodeName(prop.getName());
    userMapping.addProperty(prop);

    HibernateUtil.rebuildSessionFactory();

    ClassMetadata metadata = HibernateUtil.getClassMetadata(User.class);
    String[] propNames = metadata.getPropertyNames();
    boolean mottoFound = false;
    for (int i = 0; i < propNames.length; i++) {
      String propName = propNames[i];
      if (propName.equalsIgnoreCase("motto")) {
        mottoFound = true;
        break;
      }
    }

    assertTrue(mottoFound);
  }
  /**
   * calculated the max length of an attribute of type String
   *
   * @param c Cluster that holds the attribute
   * @param attributeName name of the attribute
   * @return max allowed length of the attribute
   */
  public int getLenthOfStringAttribute(ICluster c, String attributeName) {

    Assert.notNull(c, "c may not be null");
    Assert.notNull(attributeName, "attributeName may not be null");

    PersistentClass pc = cfg.getClassMapping(c.getDaoClass().getName());

    if (pc == null)
      throw new ConfigurationException(
          "Persistent Dao Class from Cluster "
              + c.getClass().getName()
              + " is not Hibernate configured");

    Property p = pc.getProperty(attributeName);

    if (p == null)
      throw new ConfigurationException(
          "Property " + attributeName + " in cluster " + c.getClass().getName() + " not found");

    Iterator<Column> i = (Iterator<Column>) p.getValue().getColumnIterator();
    Column column = i.next();
    return column.getLength();
  }