Refine search
public boolean isSecondary() { if ( propertyHolder == null ) { throw new AssertionFailure( "Should not call getTable() on column w/o persistent class defined" ); } return StringHelper.isNotEmpty( explicitTableName ) && !propertyHolder.getTable().getName().equals( explicitTableName ); }
actuallyReplace && encloseInParensIfNecessary && !( getLastNonWhitespaceCharacter( beforePlaceholder ) == '(' ) && !( getLastNonWhitespaceCharacter( beforePlaceholder ) == ',' && getFirstNonWhitespaceCharacter( afterPlaceholder ) == ')' ); StringBuilder buf = new StringBuilder( beforePlaceholder ); replace( afterPlaceholder, placeholder,
private static String[] qualify(String alias, String[] columnNames, String[] formulaTemplates) { int span = columnNames.length; String[] result = new String[span]; for ( int i = 0; i < span; i++ ) { if ( columnNames[i] == null ) { result[i] = StringHelper.replace( formulaTemplates[i], Template.TEMPLATE, alias ); } else { result[i] = StringHelper.qualify( alias, columnNames[i] ); } } return result; }
public static String buildSafeClassName(String className, String defaultPackageName) { if ( className.indexOf( '.' ) < 0 && StringHelper.isNotEmpty( defaultPackageName ) ) { className = StringHelper.qualify( defaultPackageName, className ); } return className; }
private static List<String> parseKeywords(String extraKeywordsString) { if ( StringHelper.isEmpty( extraKeywordsString ) ) { return Collections.emptyList(); } return StringHelper.parseCommaSeparatedString( extraKeywordsString ); }
/** * 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()); } }
boolean unique, boolean applyNamingStrategy) { if ( StringHelper.isNotEmpty( formulaString ) ) { this.formula = new Formula(); this.formula.setFormula( formulaString ); this.mappingColumn = new Column(); redefineColumnName( columnName, propertyName, applyNamingStrategy ); this.mappingColumn.setLength( length ); if ( precision > 0 ) { //revelent precision this.mappingColumn.setPrecision( precision ); this.mappingColumn.setScale( scale );
InFlightMetadataCollector.EntityTableXref denormalizedSuperTableXref) { EntityTableNamingStrategyHelper namingStrategyHelper = new EntityTableNamingStrategyHelper( persistentClass.getClassName(), persistentClass.getEntityName(), name ); if ( StringHelper.isNotEmpty( tableName ) ) { logicalName = namingStrategyHelper.handleExplicitName( tableName, context ); catalog, logicalName, persistentClass.isAbstract(), uniqueConstraints, null, final RowId rowId = annotatedClass.getAnnotation( RowId.class ); if ( rowId != null ) { table.setRowId( rowId.value() ); LOG.debugf( "Bind entity %s on table %s", persistentClass.getEntityName(), table.getName() ); ( (TableOwner) persistentClass ).setTable( table );
@Test public void testJoinTableIndex(){ PersistentClass entity = metadata().getEntityBinding( Importer.class.getName() ); Property property = entity.getProperty( "cars" ); Bag set = (Bag)property.getValue(); Table collectionTable = set.getCollectionTable(); Iterator<Index> itr = collectionTable.getIndexIterator(); assertTrue( itr.hasNext() ); Index index = itr.next(); assertFalse( itr.hasNext() ); assertTrue( "index name is not generated", StringHelper.isNotEmpty( index.getName() ) ); assertEquals( 1, index.getColumnSpan() ); Iterator<Column> columnIterator = index.getColumnIterator(); Column column = columnIterator.next(); assertEquals( "importers_id", column.getName() ); assertSame( collectionTable, index.getTable() ); }
@Test public void testTableIndex() { PersistentClass entity = metadata().getEntityBinding( Car.class.getName() ); Iterator itr = entity.getTable().getUniqueKeyIterator(); assertTrue( itr.hasNext() ); UniqueKey uk = (UniqueKey) itr.next(); assertFalse( itr.hasNext() ); assertTrue( StringHelper.isNotEmpty( uk.getName() ) ); assertEquals( 2, uk.getColumnSpan() ); Column column = (Column) uk.getColumns().get( 0 ); assertEquals( "brand", column.getName() ); column = (Column) uk.getColumns().get( 1 ); assertEquals( "producer", column.getName() ); assertSame( entity.getTable(), uk.getTable() ); itr = entity.getTable().getIndexIterator(); assertTrue( itr.hasNext() ); Index index = (Index)itr.next(); assertFalse( itr.hasNext() ); assertEquals( "Car_idx", index.getName() ); assertEquals( 1, index.getColumnSpan() ); column = index.getColumnIterator().next(); assertEquals( "since", column.getName() ); assertSame( entity.getTable(), index.getTable() ); }
private String generateGeneratedValuesSelectString(final GenerationTiming generationTimingToMatch) { Select select = new Select( getFactory().getDialect() ); if ( getFactory().getSessionFactoryOptions().isCommentsEnabled() ) { select.setComment( "get generated state " + getEntityName() ); String[] aliasedIdColumns = StringHelper.qualify( getRootAlias(), getIdentifierColumnNames() );
private String generateEntityIdByNaturalIdSql(boolean[] valueNullness) { EntityPersister rootPersister = getFactory().getEntityPersister( getRootEntityName() ); if ( rootPersister != this ) { if ( rootPersister instanceof AbstractEntityPersister ) { Select select = new Select( getFactory().getDialect() ); if ( getFactory().getSessionFactoryOptions().isCommentsEnabled() ) { select.setComment( "get current natural-id->entity-id state " + getEntityName() ); final String tableAlias = generateTableAlias( rootAlias, propertyTableNumbers[naturalIdIdx] ); final String[] propertyColumnNames = getPropertyColumnNames( naturalIdIdx ); final String[] aliasedPropertyColumns = StringHelper.qualify( tableAlias, propertyColumnNames );
final Dialect dialect = session.getFactory().getServiceRegistry().getService( JdbcServices.class ).getJdbcEnvironment().getDialect(); final int inExprLimit = dialect.getInExpressionCountLimit(); session.getFactory().getSessionFactoryOptions().inClauseParameterPaddingEnabled() && bindValueCount > 2; final int loc = StringHelper.indexOfIdentifierWord( queryString, sourceToken ); StringHelper.getLastNonWhitespaceCharacter( beforePlaceholder ) == '(' && StringHelper.getFirstNonWhitespaceCharacter( afterPlaceholder ) == ')'; queryString = StringHelper.replace( beforePlaceholder, afterPlaceholder,
public static Object getConstantValue(String name, SessionFactoryImplementor factory) { boolean conventionalJavaConstants = factory.getSessionFactoryOptions().isConventionalJavaConstants(); Class clazz; try { if ( conventionalJavaConstants && !JAVA_CONSTANT_PATTERN.matcher( name ).find() ) { return null; } ClassLoaderService classLoaderService = factory.getServiceRegistry().getService( ClassLoaderService.class ); clazz = classLoaderService.classForName( StringHelper.qualifier( name ) ); } catch ( Throwable t ) { return null; } try { return clazz.getField( StringHelper.unqualify( name ) ).get( null ); } catch ( Throwable t ) { return null; } }
final Dialect dialect = session.getFactory().getDialect(); final int inExprLimit = dialect.getInExpressionCountLimit(); if (inExprLimit > 0 && vals.size() > inExprLimit) { StringHelper.getLastNonWhitespaceCharacter(beforePlaceholder) == '(' && StringHelper.getFirstNonWhitespaceCharacter(afterPlaceholder) == ')'; return StringHelper.replace( beforePlaceholder, afterPlaceholder,
String columnName, MetadataBuildingContext context) { if ( StringHelper.isEmpty( columnName ) ) { do { result = current; Table currentTable = current.getTable(); try { context.getMetadataCollector().getPhysicalColumnName( currentTable, columnName ); Iterator joins = current.getJoinIterator(); while ( !found && joins.hasNext() ) { result = joins.next(); current = current.getSuperclass();
@Test public void testSecondaryTableIndex(){ PersistentClass entity = metadata().getEntityBinding( Car.class.getName() ); Join join = (Join)entity.getJoinIterator().next(); Iterator<Index> itr = join.getTable().getIndexIterator(); assertTrue( itr.hasNext() ); Index index = itr.next(); assertFalse( itr.hasNext() ); assertTrue( "index name is not generated", StringHelper.isNotEmpty( index.getName() ) ); assertEquals( 2, index.getColumnSpan() ); Iterator<Column> columnIterator = index.getColumnIterator(); Column column = columnIterator.next(); assertEquals( "dealer_name", column.getName() ); column = columnIterator.next(); assertEquals( "rate", column.getName() ); assertSame( join.getTable(), index.getTable() ); }
public void validate(Mapping mapping) throws MappingException { Iterator iter = getPropertyIterator(); while ( iter.hasNext() ) { Property prop = (Property) iter.next(); if ( !prop.isValid( mapping ) ) { throw new MappingException( "property mapping has wrong number of columns: " + StringHelper.qualify( getEntityName(), prop.getName() ) + " type: " + prop.getType().getName() ); } } checkPropertyDuplication(); checkColumnDuplication(); }
for ( final FilterConfiguration filter : filters ) { filterAutoAliasFlags[filterCount] = false; filterNames[filterCount] = safeInterning( filter.getName() ); filterConditions[filterCount] = safeInterning( filter.getCondition() ); filterAliasTableMaps[filterCount] = filter.getAliasTableMap( factory ); if ( ( filterAliasTableMaps[filterCount].isEmpty() || isTableFromPersistentClass( filterAliasTableMaps[filterCount] ) ) && filter .useAutoAliasInjection() ) { filterConditions[filterCount] = safeInterning( Template.renderWhereStringTemplate( filter.getCondition(), FilterImpl.MARKER, factory.getDialect(), factory.getSqlFunctionRegistry() filterConditions[filterCount] = safeInterning( StringHelper.replace( filterConditions[filterCount], ":",