this.factory = persister.getFactory(); final String[] tables = persister.getConstraintOrderedTableNameClosure(); Collections.addAll( temp, tables ); persister.getSubclassTableName( persister.getSubclassPropertyTableNumber( propertyPath ) ) );
private String[] decodeTreatAsRequests(Set<String> treatAsDeclarations) { final List<String> values = new ArrayList<String>(); for ( String subclass : treatAsDeclarations ) { final Queryable queryable = (Queryable) getFactory().getEntityPersister( subclass ); if ( !queryable.isAbstract() ) { values.add( queryable.getDiscriminatorSQLValue() ); } else if ( queryable.hasSubclasses() ) { // if the treat is an abstract class, add the concrete implementations to values if any Set<String> actualSubClasses = queryable.getEntityMetamodel().getSubclassEntityNames(); for ( String actualSubClass : actualSubClasses ) { if ( actualSubClass.equals( subclass ) ) { continue; } Queryable actualQueryable = (Queryable) getFactory().getEntityPersister( actualSubClass ); if ( !actualQueryable.hasSubclasses() ) { values.add( actualQueryable.getDiscriminatorSQLValue() ); } } } } return values.toArray( new String[values.size()] ); }
final Queryable productionEntityQueryable = getQueryable( entityName, sessionImplementor ); final Queryable rootProductionEntityQueryable = getQueryable( productionEntityQueryable.getRootEntityName(), sessionImplementor ); final Queryable auditedEntityQueryable = getQueryable( auditedEntityName, sessionImplementor ); final Queryable rootAuditedEntityQueryable = getQueryable( auditedEntityQueryable.getRootEntityName(), sessionImplementor ); updateTableName = auditedEntityQueryable.getSubclassTableName( 0 ); updateTableName = rootAuditedEntityQueryable.getTableName(); final String revEndColumnName = rootAuditedEntityQueryable.toColumns( audEntitiesCfg.getRevisionEndFieldName() )[0]; rootAuditedEntityQueryable.toColumns( audEntitiesCfg.getRevisionEndTimestampFieldName() )[0] ); update.addPrimaryKeyColumns( rootProductionEntityQueryable.getIdentifierColumnNames() ); rootAuditedEntityQueryable.toColumns( audEntitiesCfg.getRevisionNumberPath() )[0], "<> ?" );
private String[] fullDiscriminatorValues() { if ( fullDiscriminatorValues == null ) { // first access; build it final List<String> values = new ArrayList<String>(); for ( String subclass : getSubclassClosure() ) { final Queryable queryable = (Queryable) getFactory().getEntityPersister( subclass ); if ( !queryable.isAbstract() ) { values.add( queryable.getDiscriminatorSQLValue() ); } } fullDiscriminatorValues = values.toArray( new String[values.size()] ); } return fullDiscriminatorValues; }
final String checkQueryableEntityName = checkQueryable.getEntityName(); final boolean isMappedClass = clazz.getName().equals( checkQueryableEntityName ); if ( checkQueryable.isExplicitPolymorphism() ) { if ( isMappedClass ) { return new String[]{ clazz.getName() }; // NOTE EARLY EXIT final Class<?> mappedClass = checkQueryable.getMappedClass(); if ( mappedClass != null && clazz.isAssignableFrom( mappedClass ) ) { final boolean assignableSuperclass; if ( checkQueryable.isInherited() ) { Class<?> mappedSuperclass = entityPersister( checkQueryable.getMappedSuperclass() ).getMappedClass(); assignableSuperclass = clazz.isAssignableFrom( mappedSuperclass );
if ( persister.getIdentifierType() instanceof CompositeType ) { if ( componentIds == null ) { String[] propertyNames = ( (CompositeType) persister.getIdentifierType() ).getPropertyNames(); componentIds = new HashSet(); for ( int i = 0; i < propertyNames.length; i++ ) { else if ( name.equals( persister.getIdentifierPropertyName() ) ) { explicitIdInsertion = true; if ( persister.isVersioned() ) { if ( name.equals( persister.getPropertyNames()[persister.getVersionProperty()] ) ) { explicitVersionInsertion = true; String[] columnNames = persister.toColumns( name ); renderColumns( columnNames ); types.add( persister.toType( name ) );
String[][] columnNames = targetedPersister.getContraintOrderedTableKeyColumnClosure(); int subclassCount = delegate.getTargetedQueryable().getEntityMetamodel().getSubclassEntityNames().size(); Set<String> subclassTableNames = new HashSet<>(); for (int i = 0; i < subclassCount; i++) { subclassTableNames.add(delegate.getTargetedQueryable().getSubclassTableName(i));
final SelectValues selectClause = new SelectValues( dialect ).addColumns( tableAlias, getTargetedQueryable().getIdentifierColumnNames(), getTargetedQueryable().getIdentifierColumnNames() ); addAnyExtraIdSelectValues( selectClause ); select.setSelectClause( selectClause.render() ); String rootTableName = getTargetedQueryable().getTableName(); String fromJoinFragment = getTargetedQueryable().fromJoinFragment( tableAlias, true, false ); String whereJoinFragment = getTargetedQueryable().whereJoinFragment( tableAlias, true, false );
@Override protected IdsClauseBuilder newIdsClauseBuilder(List<Object[]> ids) { return new InlineIdsOrClauseBuilder( dialect(), getTargetedQueryable().getIdentifierType(), factory().getTypeResolver(), getTargetedQueryable().getIdentifierColumnNames(), ids ); }
public String getTableName() { return persister.getSubclassTableName( 0 ); }
final LinkedHashSet<String> spacesList = new LinkedHashSet<>(); for ( Queryable persister : affectedQueryables ) { spacesList.addAll( Arrays.asList( (String[]) persister.getQuerySpaces() ) ); if ( persister.canWriteToCache() ) { final EntityDataAccess entityDataAccess = persister.getCacheAccessStrategy(); if ( entityDataAccess != null ) { entityCleanups.add( new EntityCleanup( entityDataAccess, session ) ); if ( persister.hasNaturalIdentifier() && persister.hasNaturalIdCache() ) { naturalIdCleanups.add( new NaturalIdCleanup( persister.getNaturalIdCacheAccessStrategy(), session ) ); final Set<String> roles = factory.getMetamodel().getCollectionRolesByEntityParticipant( persister.getEntityName() ); if ( roles != null ) { for ( String role : roles ) {
final IdentifierGenerator generator = persister.getIdentifierGenerator(); if ( !BulkInsertionCapableIdentifierGenerator.class.isInstance( generator ) ) { throw new QueryException( final boolean includeVersionProperty = persister.isVersioned() && !insertStatement.getIntoClause().isExplicitVersionInsertion() && persister.isVersionPropertyInsertable(); if ( includeVersionProperty ) { VersionType versionType = persister.getVersionType(); AST versionValueNode = null; String sqlValue = insertStatement.getIntoClause().getQueryable().getDiscriminatorSQLValue(); AST discrimValue = getASTFactory().create( HqlSqlTokenTypes.SQL_TOKEN, sqlValue ); insertStatement.getSelectClause().addChild( discrimValue );
private String extractTableName() { // should be safe to only ever expect EntityPersister references here return fromElement.getQueryable().getTableName(); }
final Queryable q = SessionFactoryHelper.findQueryableUsingImports( sessionFactory, entityClass.getName() ); if ( q != null ) { final Type type = q.getDiscriminatorType(); String stringValue = q.getDiscriminatorSQLValue(); if ( stringValue != null && stringValue.length() > 2
Map enabledFilters, String alias) { String whereFragment = persister.filterFragment( alias, enabledFilters ).trim(); if ( "".equals( whereFragment ) ) { return; persister.generateFilterConditionAlias( alias ) + ".", "" );
protected String generateIdSubselect(Queryable persister) { return new StringBuilder() .append( "select " ) .append( String.join( ", ", (CharSequence[]) persister.getIdentifierColumnNames() ) ) .append( " from " ) .append( determineIdTableName( persister ) ) .toString(); }
protected void postProcessDelete(AST delete) throws SemanticException { QueryNode qn = ( QueryNode ) delete; FromClause fromClause = qn.getFromClause(); fromClause.resolve(); // For now, validate that the FROM clause did not reference any // form of subclass... FromElement fromElement = ( FromElement ) fromClause.getFromElements().get( 0 ); Queryable persister = fromElement.getQueryable(); // Make #@%$^#^&# sure no alias is applied to the table name fromElement.setText( persister.getTableName() ); // TODO : need a better way to do these checks if ( persister instanceof SingleTableEntityPersister ) { SingleTableEntityPersister step = ( SingleTableEntityPersister ) persister; new SyntheticAndFactory( getASTFactory() ) .addDiscriminatorWhereFragment( qn, step, fromElement.getTableAlias() ); } else { if ( persister.getMappedSuperclass() != null ) { // TODO : add support for spawning potential multiple sql deletes for these cases... // for now, just error as unsupported... throw new QueryException( "Delete statements against joined or union subclasses not yet supported!" ); } } }
for ( Type type : persister.getPropertyTypes() ) { if ( type.isCollectionType() ) { final CollectionType cType = (CollectionType) type; final AbstractCollectionPersister cPersister = (AbstractCollectionPersister) factory.getMetamodel().collectionPersister( cType.getRole() ); if ( cPersister.isManyToMany() ) { if ( persister.getIdentifierColumnNames().length > 1 && !dialect.supportsTuplesInSubqueries() ) { LOG.warn( + String.join( ", ", persister.getIdentifierColumnNames() ) + " from " + persister.getTableName() + idSubselectWhere + ")"; final String where = "(" + String.join( ", ", cPersister.getKeyColumnNames() ) + ") in " + idSubselect;
@Override public String getName() { return persister.getEntityName(); } @Override
@Override protected AST createIntoClause(String path, AST propertySpec) throws SemanticException { Queryable persister = (Queryable) getSessionFactoryHelper().requireClassPersister( path ); IntoClause intoClause = (IntoClause) getASTFactory().create( INTO, persister.getEntityName() ); intoClause.setFirstChild( propertySpec ); intoClause.initialize( persister ); addQuerySpaces( persister.getQuerySpaces() ); return intoClause; }