org.hibernate.mapping.UnionSubclass java code examples

Common ways to obtain UnionSubclass

private void myMethod () {
 UnionSubclass u =PersistentClass superclass;new UnionSubclass(superclass)
Smart code suggestions by Tabnine
}

private void bindUnionSubclassEntities(
    EntitySource entitySource,
    PersistentClass superEntityDescriptor) {
  for ( IdentifiableTypeSource subType : entitySource.getSubTypes() ) {
    final UnionSubclass subEntityDescriptor = new UnionSubclass( superEntityDescriptor, metadataBuildingContext );
    bindUnionSubclassEntity( (SubclassEntitySourceImpl) subType, subEntityDescriptor );
    superEntityDescriptor.addSubclass( subEntityDescriptor );
    entitySource.getLocalMetadataBuildingContext().getMetadataCollector().addEntityBinding( subEntityDescriptor );
  }
}

private void bindUnionSubclassEntity(
    SubclassEntitySourceImpl entitySource,
    UnionSubclass entityDescriptor) {
  MappingDocument mappingDocument = entitySource.sourceMappingDocument();
  bindBasicEntityValues(
      mappingDocument,
      entitySource,
      entityDescriptor
  );
  final Table primaryTable = bindEntityTableSpecification(
      mappingDocument,
      entitySource.getPrimaryTable(),
      entityDescriptor.getSuperclass().getTable(),
      entitySource,
      entityDescriptor
  );
  entityDescriptor.setTable( primaryTable );
  if ( log.isDebugEnabled() ) {
    log.debugf( "Mapping union-subclass: %s -> %s", entityDescriptor.getEntityName(), primaryTable.getName() );
  }
  // todo : tooling hints
  bindAllEntityAttributes(
      entitySource.sourceMappingDocument(),
      entitySource,
      entityDescriptor
  );
  bindUnionSubclassEntities( entitySource, entityDescriptor );
}

protected Iterator getNonDuplicatedPropertyIterator() {
  return getPropertyClosureIterator();
}

public static void bindUnionSubclass(Element node, UnionSubclass unionSubclass,
    Mappings mappings, java.util.Map inheritedMetas) throws MappingException {
  bindClass( node, unionSubclass, mappings, inheritedMetas );
  inheritedMetas = getMetas( node, inheritedMetas, true ); // get meta's from <subclass>
  if ( unionSubclass.getEntityPersisterClass() == null ) {
    unionSubclass.getRootClass().setEntityPersisterClass(
      UnionSubclassEntityPersister.class );
  }
  Attribute schemaNode = node.attribute( "schema" );
  String schema = schemaNode == null ? mappings.getSchemaName() : schemaNode.getValue();
  Attribute catalogNode = node.attribute( "catalog" );
  String catalog = catalogNode == null ? mappings.getCatalogName() : catalogNode.getValue();
  Table mytable = mappings.addDenormalizedTable( 
      schema, 
      catalog, 
      getClassTableName(unionSubclass, node, mappings ), 
      unionSubclass.isAbstract(), 
      getSubselect( node ), 
      unionSubclass.getSuperclass().getTable() );
  unionSubclass.setTable( mytable );
  log.info( "Mapping union-subclass: "
    + unionSubclass.getEntityName()
    + " -> "
    + unionSubclass.getTable().getName() );
  createClassProperties( node, unionSubclass, mappings, inheritedMetas );
}

public static void bindUnionSubclass(Element node, UnionSubclass unionSubclass,
    Mappings mappings, java.util.Map inheritedMetas) throws MappingException {
  bindClass( node, unionSubclass, mappings, inheritedMetas );
  inheritedMetas = getMetas( node, inheritedMetas, true ); // get meta's from <subclass>
  Attribute schemaNode = node.attribute( "schema" );
  String schema = schemaNode == null ?
      mappings.getSchemaName() : schemaNode.getValue();
  Attribute catalogNode = node.attribute( "catalog" );
  String catalog = catalogNode == null ?
      mappings.getCatalogName() : catalogNode.getValue();
  Table denormalizedSuperTable = unionSubclass.getSuperclass().getTable();
  Table mytable = mappings.addDenormalizedTable(
      schema,
      catalog,
      getClassTableName(unionSubclass, node, schema, catalog, denormalizedSuperTable, mappings ),
      unionSubclass.isAbstract() != null && unionSubclass.isAbstract().booleanValue(),
      getSubselect( node ),
      denormalizedSuperTable
    );
  unionSubclass.setTable( mytable );
  if ( LOG.isDebugEnabled() ) {
    LOG.debugf( "Mapping union-subclass: %s -> %s", unionSubclass.getEntityName(), unionSubclass.getTable().getName() );
  }
  createClassProperties( node, unionSubclass, mappings, inheritedMetas );
}

public void validate(Mapping mapping) throws MappingException {
  super.validate(mapping);
  if ( key!=null && !key.isValid(mapping) ) {
    throw new MappingException(
      "subclass key mapping has wrong number of columns: " +
      getEntityName() +
      " type: " +
      key.getType().getName()
    );
  }
}

public void setTable(Table table) {
  this.table = table;
  getSuperclass().addSubclassTable(table);
}

public Table getIdentityTable() {
  return getTable();
}

@Test
public void testProperCallbacks() {
  PersistentClassVisitorValidator vv = new PersistentClassVisitorValidator();
  new RootClass( metadataBuildingContext ).accept( vv );
  new Subclass( new RootClass( metadataBuildingContext ), metadataBuildingContext ).accept( vv );
  new JoinedSubclass( new RootClass( metadataBuildingContext ), metadataBuildingContext ).accept( vv );
  new SingleTableSubclass( new RootClass( metadataBuildingContext ), metadataBuildingContext ).accept( vv );
  new UnionSubclass( new RootClass( metadataBuildingContext ), metadataBuildingContext ).accept( vv );
}

private void bindUnionSubclassEntity(
    SubclassEntitySourceImpl entitySource,
    UnionSubclass entityDescriptor) {
  MappingDocument mappingDocument = entitySource.sourceMappingDocument();
  bindBasicEntityValues(
      mappingDocument,
      entitySource,
      entityDescriptor
  );
  final MappedTable primaryTable = bindEntityTableSpecification(
      mappingDocument,
      entitySource.getPrimaryTable(),
      entityDescriptor.getSuperManagedTypeMapping().getMappedTable(),
      entitySource,
      entityDescriptor
  );
  entityDescriptor.setMappedTable( primaryTable );
  if ( log.isDebugEnabled() ) {
    log.debugf( "Mapping union-subclass: %s -> %s", entityDescriptor.getEntityName(), primaryTable.getName() );
  }
  // todo : tooling hints
  bindAllEntityAttributes(
      entitySource.sourceMappingDocument(),
      entitySource,
      entityDescriptor
  );
  bindUnionSubclassEntities( entitySource, entityDescriptor );
}

public void bindUnionSubclass(HibernatePersistentEntity subClass, UnionSubclass unionSubclass,
                   Mappings mappings, String sessionFactoryBeanName) throws MappingException {
  Mapping subMapping = getMapping(subClass.getJavaClass());
  if ( unionSubclass.getEntityPersisterClass() == null ) {
    unionSubclass.getRootClass().setEntityPersisterClass(
        UnionSubclassEntityPersister.class );
  }
  String schema = subMapping != null && subMapping.getTable().getSchema() != null ?
      subMapping.getTable().getSchema() : null;
  String catalog = subMapping != null && subMapping.getTable().getCatalog() != null ?
      subMapping.getTable().getCatalog() : null;
  Table denormalizedSuperTable = unionSubclass.getSuperclass().getTable();
  Table mytable = mappings.addDenormalizedTable(
      schema,
      catalog,
      getTableName(subClass, sessionFactoryBeanName),
      unionSubclass.isAbstract() != null && unionSubclass.isAbstract(),
      null,
      denormalizedSuperTable
  );
  unionSubclass.setTable( mytable );
  unionSubclass.setClassName(subClass.getName());
  LOG.info(
      "Mapping union-subclass: " + unionSubclass.getEntityName() +
          " -> " + unionSubclass.getTable().getName()
  );
  createClassProperties(subClass, unionSubclass, mappings, sessionFactoryBeanName);
}
/**

public static void bindUnionSubclass(Element node, UnionSubclass unionSubclass,
    Mappings mappings, java.util.Map inheritedMetas) throws MappingException {
  bindClass( node, unionSubclass, mappings, inheritedMetas );
  inheritedMetas = getMetas( node, inheritedMetas, true ); // get meta's from <subclass>
  Attribute schemaNode = node.attribute( "schema" );
  String schema = schemaNode == null ?
      mappings.getSchemaName() : schemaNode.getValue();
  Attribute catalogNode = node.attribute( "catalog" );
  String catalog = catalogNode == null ?
      mappings.getCatalogName() : catalogNode.getValue();
  Table denormalizedSuperTable = unionSubclass.getSuperclass().getTable();
  Table mytable = mappings.addDenormalizedTable(
      schema,
      catalog,
      getClassTableName(unionSubclass, node, schema, catalog, denormalizedSuperTable, mappings ),
      unionSubclass.isAbstract() != null && unionSubclass.isAbstract().booleanValue(),
      getSubselect( node ),
      denormalizedSuperTable
    );
  unionSubclass.setTable( mytable );
  if ( LOG.isDebugEnabled() ) {
    LOG.debugf( "Mapping union-subclass: %s -> %s", unionSubclass.getEntityName(), unionSubclass.getTable().getName() );
  }
  createClassProperties( node, unionSubclass, mappings, inheritedMetas );
}

public void validate(Mapping mapping) throws MappingException {
  super.validate(mapping);
  if ( key!=null && !key.isValid(mapping) ) {
    throw new MappingException(
      "subclass key mapping has wrong number of columns: " +
      getEntityName() +
      " type: " +
      key.getType().getName()
    );
  }
}

@Override
public void setMappedTable(MappedTable table) {
  this.table = table;
  getSuperclass().addSubclassTable(table);
}

public Table getIdentityTable() {
  return getTable();
}

public static void bindUnionSubclass(Element node, UnionSubclass unionSubclass,
    Mappings mappings, java.util.Map inheritedMetas) throws MappingException {
  bindClass( node, unionSubclass, mappings, inheritedMetas );
  inheritedMetas = getMetas( node, inheritedMetas, true ); // get meta's from <subclass>
  if ( unionSubclass.getEntityPersisterClass() == null ) {
    unionSubclass.getRootClass().setEntityPersisterClass(
      UnionSubclassEntityPersister.class );
  }
  Attribute schemaNode = node.attribute( "schema" );
  String schema = schemaNode == null ?
      mappings.getSchemaName() : schemaNode.getValue();
  Attribute catalogNode = node.attribute( "catalog" );
  String catalog = catalogNode == null ?
      mappings.getCatalogName() : catalogNode.getValue();
  Table denormalizedSuperTable = unionSubclass.getSuperclass().getTable();
  Table mytable = mappings.addDenormalizedTable(
      schema,
      catalog,
      getClassTableName(unionSubclass, node, schema, catalog, denormalizedSuperTable, mappings ),
      unionSubclass.isAbstract() != null && unionSubclass.isAbstract().booleanValue(),
      getSubselect( node ),
      denormalizedSuperTable
    );
  unionSubclass.setTable( mytable );
  log.info(
      "Mapping union-subclass: " + unionSubclass.getEntityName() +
      " -> " + unionSubclass.getTable().getName()
    );
  createClassProperties( node, unionSubclass, mappings, inheritedMetas );
}

private static PersistentClass makePersistentClass(
    InheritanceState inheritanceState,
    PersistentClass superEntity,
    MetadataBuildingContext metadataBuildingContext) {
  //we now know what kind of persistent entity it is
  if ( !inheritanceState.hasParents() ) {
    return new RootClass( metadataBuildingContext );
  }
  else if ( InheritanceType.SINGLE_TABLE.equals( inheritanceState.getType() ) ) {
    return new SingleTableSubclass( superEntity, metadataBuildingContext );
  }
  else if ( InheritanceType.JOINED.equals( inheritanceState.getType() ) ) {
    return new JoinedSubclass( superEntity, metadataBuildingContext );
  }
  else if ( InheritanceType.TABLE_PER_CLASS.equals( inheritanceState.getType() ) ) {
    return new UnionSubclass( superEntity, metadataBuildingContext );
  }
  else {
    throw new AssertionFailure( "Unknown inheritance type: " + inheritanceState.getType() );
  }
}

public void validate(Mapping mapping) throws MappingException {
  super.validate(mapping);
  if ( key!=null && !key.isValid(mapping) ) {
    throw new MappingException(
      "subclass key mapping has wrong number of columns: " +
      getEntityName() +
      " type: " +
      key.getType().getName()
    );
  }
}

public void setTable(Table table) {
  this.table = table;
  getSuperclass().addSubclassTable(table);
}

public Table getIdentityTable() {
  return getTable();
}

Javadoc

A subclass in a table-per-concrete-class mapping

Most used methods

Popular in Java

Creating JSON documents from java classes using gson
orElseThrow (Optional)
Return the contained value, if present, otherwise throw an exception to be created by the provided s
getSystemService (Context)
startActivity (Activity)
Color (java.awt)
The Color class is used to encapsulate colors in the default sRGB color space or colors in arbitrary
ServerSocket (java.net)
This class represents a server-side socket that waits for incoming client connections. A ServerSocke
LinkedHashMap (java.util)
LinkedHashMap is an implementation of Map that guarantees iteration order. All optional operations a
TimerTask (java.util)
The TimerTask class represents a task to run at a specified time. The task may be run once or repeat
Cipher (javax.crypto)
This class provides access to implementations of cryptographic ciphers for encryption and decryption
LoggerFactory (org.slf4j)
The LoggerFactory is a utility class producing Loggers for various logging APIs, most notably for lo
14 Best Plugins for Eclipse

How to useUnionSubclass in org.hibernate.mapping

Best Java code snippets using org.hibernate.mapping.UnionSubclass (Showing top 20 results out of 315)

How to use
UnionSubclass
in
org.hibernate.mapping