Example usage for org.hibernate.mapping Property setOptional

List of usage examples for org.hibernate.mapping Property setOptional

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.mapping.*
  5. Property
  6. setOptional

Introduction

In this page you can find the example usage for org.hibernate.mapping Property setOptional.

Prototype

public void setOptional(boolean optional)

Source Link

Usage

From source file:org.codehaus.groovy.grails.orm.hibernate.cfg.AbstractGrailsDomainBinder.java

License:Apache License

/**
 * Binds a property to Hibernate runtime meta model. Deals with cascade strategy based on the Grails domain model
 *
 * @param grailsProperty The grails property instance
 * @param prop           The Hibernate property
 * @param mappings       The Hibernate mappings
 *///from   ww w . ja va  2 s .  c  o  m
protected void bindProperty(GrailsDomainClassProperty grailsProperty, Property prop, Mappings mappings) {
    // set the property name
    prop.setName(grailsProperty.getName());
    if (isBidirectionalManyToOneWithListMapping(grailsProperty, prop)) {
        prop.setInsertable(false);
        prop.setUpdateable(false);
    } else {
        prop.setInsertable(getInsertableness(grailsProperty));
        prop.setUpdateable(getUpdateableness(grailsProperty));
    }

    prop.setPropertyAccessorName(mappings.getDefaultAccess());
    prop.setOptional(grailsProperty.isOptional());

    setCascadeBehaviour(grailsProperty, prop);

    // lazy to true
    boolean isLazyable = grailsProperty.isOneToOne() || grailsProperty.isManyToOne()
            || grailsProperty.isEmbedded()
            || grailsProperty.isPersistent() && !grailsProperty.isAssociation() && !grailsProperty.isIdentity();

    if (isLazyable) {
        final boolean isLazy = getLaziness(grailsProperty);
        prop.setLazy(isLazy);

        if (isLazy && (grailsProperty.isManyToOne() || grailsProperty.isOneToOne())) {
            handleLazyProxy(grailsProperty.getDomainClass(), grailsProperty);
        }
    }
}

From source file:org.codehaus.groovy.grails.orm.hibernate.cfg.GrailsDomainBinder.java

License:Apache License

/**
 * Binds a property to Hibernate runtime meta model. Deals with cascade strategy based on the Grails domain model
 *
 * @param grailsProperty The grails property instance
 * @param prop           The Hibernate property
 * @param mappings       The Hibernate mappings
 *//*from w w w. j  av a  2 s. c o m*/
private static void bindProperty(GrailsDomainClassProperty grailsProperty, Property prop, Mappings mappings) {
    // set the property name
    prop.setName(grailsProperty.getName());
    if (isBidirectionalManyToOneWithListMapping(grailsProperty, prop)) {
        prop.setInsertable(false);
        prop.setUpdateable(false);
    } else {
        prop.setInsertable(getInsertableness(grailsProperty));
        prop.setUpdateable(getUpdateableness(grailsProperty));
    }

    prop.setPropertyAccessorName(mappings.getDefaultAccess());
    prop.setOptional(grailsProperty.isOptional());

    setCascadeBehaviour(grailsProperty, prop);

    // lazy to true
    boolean isLazyable = grailsProperty.isOneToOne() || grailsProperty.isManyToOne()
            || grailsProperty.isEmbedded()
            || grailsProperty.isPersistent() && !grailsProperty.isAssociation() && !grailsProperty.isIdentity();

    if (isLazyable) {
        final boolean isLazy = getLaziness(grailsProperty);
        prop.setLazy(isLazy);

        if (isLazy && (grailsProperty.isManyToOne() || grailsProperty.isOneToOne())) {
            HibernatePluginSupport.handleLazyProxy(grailsProperty.getDomainClass(), grailsProperty);
        }
    }
}

From source file:org.eclipse.emf.teneo.hibernate.HbDataStore.java

License:Open Source License

/**
 * Extra lazy mapping for lists needs a real property for the list index and
 * a real inverse for the other side as well.
 * /*from  w w  w.j  ava2s  .co  m*/
 * This method iterates over all associations and adds an inverse for the
 * list and set mappings.
 */
protected void addExtraLazyInverseProperties() {
    final Map<String, PersistentClass> persistentClasses = new HashMap<String, PersistentClass>();
    for (Iterator<?> pcs = getClassMappings(); pcs.hasNext();) {
        final PersistentClass pc = (PersistentClass) pcs.next();
        if (isClassOrSuperClassEAVMapped(pc)) {
            continue;
        }
        persistentClasses.put(pc.getEntityName(), pc);
    }
    for (Iterator<?> pcs = getClassMappings(); pcs.hasNext();) {
        final PersistentClass pc = (PersistentClass) pcs.next();

        // copy to prevent concurrent modification
        final Iterator<?> propIt = pc.getPropertyIterator();
        final List<Property> props = new ArrayList<Property>();
        while (propIt.hasNext()) {
            final Property prop = (Property) propIt.next();
            props.add(prop);
        }

        for (Property prop : props) {
            EClass eClass = null;
            if (pc.getMetaAttribute(HbMapperConstants.FEATUREMAP_META) == null) {
                if (pc.getEntityName() != null) {
                    eClass = getEntityNameStrategy().toEClass(pc.getEntityName());
                } else {
                    eClass = EModelResolver.instance().getEClass(pc.getMappedClass());
                }
            }

            final EStructuralFeature ef = eClass == null ? null
                    : StoreUtil.getEStructuralFeature(eClass, prop.getName());
            if (ef != null && ef instanceof EReference && prop.getValue() instanceof Collection) {
                final Collection collection = (Collection) prop.getValue();
                final EReference eReference = (EReference) ef;

                // only work for extra lazy
                if (!collection.isExtraLazy()) {
                    continue;
                }

                final Value elementValue = collection.getElement();
                final PersistentClass elementPC;
                if (elementValue instanceof OneToMany) {
                    final OneToMany oneToMany = (OneToMany) elementValue;
                    elementPC = oneToMany.getAssociatedClass();
                } else if (elementValue instanceof ManyToOne) {
                    final ManyToOne mto = (ManyToOne) elementValue;
                    elementPC = persistentClasses.get(mto.getReferencedEntityName());
                } else {
                    continue;
                }

                if (isClassOrSuperClassEAVMapped(elementPC)) {
                    continue;
                }

                collection.setInverse(true);

                // and add an eopposite
                if (eReference.getEOpposite() == null) {

                    final Table collectionTable = collection.getCollectionTable();

                    if (isClassOrSuperClassEAVMapped(elementPC)) {
                        continue;
                    }

                    final Property inverseRefProperty = new Property();
                    inverseRefProperty.setName(StoreUtil.getExtraLazyInversePropertyName(ef));
                    final Map<Object, Object> metas = new HashMap<Object, Object>();
                    final MetaAttribute metaAttribute = new MetaAttribute(
                            HbConstants.SYNTHETIC_PROPERTY_INDICATOR);
                    metaAttribute.addValue("true");
                    metas.put(HbConstants.SYNTHETIC_PROPERTY_INDICATOR, metaAttribute);
                    inverseRefProperty.setMetaAttributes(metas);
                    inverseRefProperty.setNodeName(inverseRefProperty.getName());
                    inverseRefProperty.setPropertyAccessorName(SyntheticPropertyHandler.class.getName());
                    inverseRefProperty.setLazy(false);

                    final ManyToOne mto = new ManyToOne(getMappings(), collectionTable);
                    mto.setReferencedEntityName(pc.getEntityName());
                    mto.setLazy(false);
                    mto.setFetchMode(FetchMode.SELECT);

                    inverseRefProperty.setValue(mto);
                    final Iterator<?> it = collection.getKey().getColumnIterator();
                    while (it.hasNext()) {
                        final Column originalColumn = (Column) it.next();
                        // final Column newColumn = new
                        // Column(originalColumn.getName());
                        mto.addColumn(originalColumn);
                    }
                    mto.createForeignKey();

                    // now determine if a join should be created
                    if (collectionTable.getName().equalsIgnoreCase(elementPC.getTable().getName())) {
                        elementPC.addProperty(inverseRefProperty);
                    } else {
                        // create a join
                        final Join join = new Join();
                        join.setPersistentClass(elementPC);
                        join.setTable(collectionTable);
                        join.addProperty(inverseRefProperty);

                        final ManyToOne keyValue = new ManyToOne(getMappings(), collectionTable);
                        join.setKey(keyValue);
                        @SuppressWarnings("unchecked")
                        final Iterator<Column> keyColumns = collection.getElement().getColumnIterator();
                        while (keyColumns.hasNext()) {
                            keyValue.addColumn(keyColumns.next());
                        }
                        keyValue.setReferencedEntityName(elementPC.getEntityName());
                        keyValue.setTable(collectionTable);
                        keyValue.createForeignKey();

                        elementPC.addJoin(join);
                    }
                }

                // add an opposite index
                if (collection.isIndexed() && !collection.isMap()) {

                    Table collectionTable = collection.getCollectionTable();

                    IndexedCollection indexedCollection = (IndexedCollection) collection;

                    final Column column = (Column) indexedCollection.getIndex().getColumnIterator().next();

                    final Property indexProperty = new Property();
                    indexProperty.setName(StoreUtil.getExtraLazyInverseIndexPropertyName(ef));
                    final Map<Object, Object> metas = new HashMap<Object, Object>();
                    final MetaAttribute metaAttribute = new MetaAttribute(
                            HbConstants.SYNTHETIC_PROPERTY_INDICATOR);
                    metaAttribute.addValue("true");
                    metas.put(HbConstants.SYNTHETIC_PROPERTY_INDICATOR, metaAttribute);
                    indexProperty.setMetaAttributes(metas);
                    indexProperty.setNodeName(indexProperty.getName());
                    indexProperty.setPropertyAccessorName(SyntheticPropertyHandler.class.getName());
                    // always make this nullable, nullability is controlled
                    // by the main property
                    indexProperty.setOptional(true);

                    Join join = null;
                    @SuppressWarnings("unchecked")
                    final Iterator<Join> it = (Iterator<Join>) elementPC.getJoinIterator();
                    while (it.hasNext()) {
                        final Join foundJoin = it.next();
                        if (foundJoin.getTable().getName().equalsIgnoreCase(collectionTable.getName())) {
                            join = foundJoin;
                            collectionTable = join.getTable();
                            break;
                        }
                    }

                    final SimpleValue sv = new SimpleValue(getMappings(),
                            indexedCollection.getIndex().getTable());
                    sv.setTypeName("integer");
                    // final Column svColumn = new Column(column.getName());
                    sv.addColumn(column); // checkColumnExists(collectionTable,
                    // svColumn));
                    indexProperty.setValue(sv);
                    if (join != null) {
                        join.addProperty(indexProperty);
                    } else {
                        elementPC.addProperty(indexProperty);
                    }
                }
            }
        }
    }

}

From source file:org.grails.orm.hibernate.cfg.AbstractGrailsDomainBinder.java

License:Apache License

/**
 * Binds a property to Hibernate runtime meta model. Deals with cascade strategy based on the Grails domain model
 *
 * @param grailsProperty The grails property instance
 * @param prop           The Hibernate property
 * @param mappings       The Hibernate mappings
 *///from w w w. ja v a 2  s  . co m
protected void bindProperty(PersistentProperty grailsProperty, Property prop, Mappings mappings) {
    // set the property name
    prop.setName(grailsProperty.getName());
    if (isBidirectionalManyToOneWithListMapping(grailsProperty, prop)) {
        prop.setInsertable(false);
        prop.setUpdateable(false);
    } else {
        prop.setInsertable(getInsertableness(grailsProperty));
        prop.setUpdateable(getUpdateableness(grailsProperty));
    }

    prop.setPropertyAccessorName(mappings.getDefaultAccess());
    prop.setOptional(grailsProperty.isNullable());

    setCascadeBehaviour(grailsProperty, prop);

    // lazy to true
    final boolean isToOne = grailsProperty instanceof ToOne;
    boolean isLazyable = isToOne || !(grailsProperty instanceof Association)
            && !grailsProperty.equals(grailsProperty.getOwner().getIdentity());

    if (isLazyable) {
        final boolean isLazy = getLaziness(grailsProperty);
        prop.setLazy(isLazy);

        if (isLazy && isToOne) {
            handleLazyProxy(grailsProperty.getOwner(), grailsProperty);
        }
    }
}

From source file:org.grails.orm.hibernate.cfg.GrailsDomainBinder.java

License:Apache License

/**
 * Binds a property to Hibernate runtime meta model. Deals with cascade strategy based on the Grails domain model
 *
 * @param grailsProperty The grails property instance
 * @param prop           The Hibernate property
 * @param mappings       The Hibernate mappings
 *///from  www  . j a v  a  2 s .  co  m
protected void bindProperty(PersistentProperty grailsProperty, Property prop,
        InFlightMetadataCollector mappings) {
    // set the property name
    prop.setName(grailsProperty.getName());
    if (isBidirectionalManyToOneWithListMapping(grailsProperty, prop)) {
        prop.setInsertable(false);
        prop.setUpdateable(false);
    } else {
        prop.setInsertable(getInsertableness(grailsProperty));
        prop.setUpdateable(getUpdateableness(grailsProperty));
    }

    AccessType accessType = AccessType
            .getAccessStrategy(grailsProperty.getMapping().getMappedForm().getAccessType());
    prop.setPropertyAccessorName(accessType.getType());
    prop.setOptional(grailsProperty.isNullable());

    setCascadeBehaviour(grailsProperty, prop);

    // lazy to true
    final boolean isToOne = grailsProperty instanceof ToOne;
    PersistentEntity propertyOwner = grailsProperty.getOwner();
    boolean isLazyable = isToOne
            || !(grailsProperty instanceof Association) && !grailsProperty.equals(propertyOwner.getIdentity());

    if (isLazyable) {
        final boolean isLazy = getLaziness(grailsProperty);
        prop.setLazy(isLazy);

        if (isLazy && isToOne
                && !(PersistentAttributeInterceptable.class.isAssignableFrom(propertyOwner.getJavaClass()))) {
            handleLazyProxy(propertyOwner, grailsProperty);
        }
    }
}