protected void set(PreparedStatement st, Object value, int index, SessionImplementor session) throws SQLException { if ( value == null ) { st.setNull( index, sqlTypes( null )[0] ); } else { byte[] toSet = unWrap( value ); final boolean useInputStream = session.getFactory().getDialect().useInputStreamToInsertBlob(); if ( useInputStream ) { st.setBinaryStream( index, new ByteArrayInputStream( toSet ), toSet.length ); } else { st.setBlob( index, Hibernate.getLobCreator( session ).createBlob( toSet ) ); } } }
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException { ois.defaultReadObject(); persister = session.getFactory().getEntityPersister( entityName ); }
public String toString() { return "CollectionKey" + MessageHelper.collectionInfoString( factory.getCollectionPersister(role), key, factory ); } }
private EntityPersister getEntityPersister(final Class entityClass) { ClassMetadata classMetadata = factoryImplementor.getClassMetadata(entityClass); String name = classMetadata.getEntityName(); if(name == null) { throw new RuntimeException("No entity persister found for class " + entityClass); } return factoryImplementor.getEntityPersister(name); } }
public Connection openConnection() throws HibernateException { log.debug("opening JDBC connection"); try { return factory.getConnectionProvider().getConnection(); } catch (SQLException sqle) { throw JDBCExceptionHelper.convert( factory.getSQLExceptionConverter(), sqle, "Cannot open connection" ); } }
ClassMetadata classMetadata = sessionFactory.getClassMetadata(entity.getClass()); if (classMetadata == null) { for (Iterator iter = sessionFactory.getAllClassMetadata().values().iterator(); iter.hasNext();) { ClassMetadata temp = (ClassMetadata) iter.next(); if (entity.getClass().equals(temp.getMappedClass(EntityMode.POJO))) { EntityPersister persister = sessionFactory.getEntityPersister(entityName); if (type instanceof CollectionType) { CollectionType collectionType = (CollectionType) type; propertyType = persister.getFactory().getCollectionPersister(collectionType.getRole()).getElementType().getReturnedClass(); collection = true; } else {
protected CollectionCacheEntry(Object owner, String field) { ClassMetadata ownerClassMetadata = factoryImplementor.getClassMetadata(owner.getClass()); Type t = ownerClassMetadata.getPropertyType(field); Assert.assertTrue(t instanceof CollectionType); CollectionType type = (CollectionType)t; role = type.getRole(); collectionPersister = factoryImplementor.getCollectionPersister(role); if(collectionPersister.hasCache()) { cacheRegion = collectionPersister.getCacheAccessStrategy().getRegion(); cacheAccess = cacheRegion.buildAccessStrategy(AccessType.READ_ONLY); } else { cacheRegion = null; cacheAccess = null; } persistentCollection = (PersistentCollection) factoryImplementor.getEntityPersister(ownerClassMetadata.getEntityName()).getPropertyValue(owner, field, entityMode); keyOfOwner = persistentCollection.getKey(); }
final Map<String, ClassMetadata> classesMetadata = sessionFactory.getAllClassMetadata(); for (final String className : classesMetadata.keySet()) { try { classesBySimpleName.put(actualClass.getSimpleName(), actualClass.asSubclass(IObject.class)); final Set<String> subclassNames = sessionFactory.getEntityPersister(className).getEntityMetamodel().getSubclassEntityNames(); for (final String subclassName : subclassNames) { if (!subclassName.equals(className)) { if (property.type instanceof CollectionType) { final CollectionType ct = (CollectionType) property.type; isAssociatedEntity = sessionFactory.getCollectionPersister(ct.getRole()).getElementType().isEntityType(); } else { isAssociatedEntity = property.type instanceof AssociationType;
private TransactionManager getTransactionManager() { SessionFactoryImplementor sessionFactory = (SessionFactoryImplementor) getSessionFactory(); return sessionFactory.getTransactionManager(); }
protected String generateLockString() { SessionFactoryImplementor factory = lockable.getFactory(); Update update = new Update( factory.getDialect() ); update.setTableName( lockable.getRootTableName() ); update.setPrimaryKeyColumnNames( lockable.getRootTableIdentifierColumnNames() ); update.setVersionColumnName( lockable.getVersionColumnName() ); update.addColumn( lockable.getVersionColumnName() ); if ( factory.getSettings().isCommentsEnabled() ) { update.setComment( lockMode + " lock " + lockable.getEntityName() ); } return update.toStatementString(); }
/** Create an action that will evict collection and entity regions based on queryspaces (table names). * TODO: cache the autodetected information and pass it in instead. **/ public BulkOperationCleanupAction(SessionImplementor session, Set querySpaces) { this.session = session; Set tmpSpaces = new HashSet(querySpaces); SessionFactoryImplementor factory = session.getFactory(); Iterator iterator = factory.getAllClassMetadata().entrySet().iterator(); while ( iterator.hasNext() ) { Map.Entry entry = (Map.Entry) iterator.next(); String entityName = (String) entry.getKey(); EntityPersister persister = factory.getEntityPersister( entityName ); Serializable[] entitySpaces = persister.getQuerySpaces(); if (affectedEntity( querySpaces, entitySpaces )) { if ( persister.hasCache() ) { affectedEntityNames.add( persister.getEntityName() ); } Set roles = session.getFactory().getCollectionRolesByEntityParticipant( persister.getEntityName() ); if ( roles != null ) { affectedCollectionRoles.addAll( roles ); } for ( int y = 0; y < entitySpaces.length; y++ ) { tmpSpaces.add( entitySpaces[y] ); } } } this.spaces = (Serializable[]) tmpSpaces.toArray( new Serializable[tmpSpaces.size()] ); }
private void setStatementFetchSize(PreparedStatement statement) throws SQLException { Integer statementFetchSize = factory.getSettings().getJdbcFetchSize(); if ( statementFetchSize!=null ) { statement.setFetchSize( statementFetchSize.intValue() ); } }
public static DataSource getDataSource(SessionFactory sessionFactory) { if (sessionFactory instanceof SessionFactoryImplementor) { ConnectionProvider cp = ((SessionFactoryImplementor) sessionFactory).getConnectionProvider(); if (cp instanceof DataSourceConnectionProvider) { return ((DataSourceConnectionProvider) cp) .getDataSource(); } } return null; }
public CacheEntry<List> assertEquals(final List other) { Assert.assertTrue(this.result.size() == other.size()); for(int i = 0; i < this.result.size(); i++) { ClassMetadata classMetadata = factoryImplementor.getClassMetadata(this.result.get(i).getClass()); ClassMetadata classMetadata1 = factoryImplementor.getClassMetadata(this.result.get(i).getClass()); Assert.assertEquals(classMetadata.getEntityName(), classMetadata1.getEntityName()); Assert.assertEquals(classMetadata.getIdentifier(this.result.get(i), entityMode), classMetadata.getIdentifier(other.get(i), entityMode)); } return this; }
public void execute(Executable executable) { final boolean lockQueryCache = session.getFactory().getSettings().isQueryCacheEnabled(); if ( executable.hasAfterTransactionCompletion() || lockQueryCache ) { executions.add( executable ); } if (lockQueryCache) { session.getFactory() .getUpdateTimestampsCache() .preinvalidate( executable.getPropertySpaces() ); } executable.execute(); }
/** * Get the names of all entities */ public String[] getEntityNames() { if ( sessionFactory == null ) { return ArrayHelper.toStringArray( entityStatistics.asMap().keySet() ); } else { return ArrayHelper.toStringArray( sessionFactory.getAllClassMetadata().keySet() ); } }
public Map getAllSecondLevelCacheRegions() { return getCurrentSessionFactoryImplementor().getAllSecondLevelCacheRegions(); }
public Connection openConnection() throws HibernateException { log.debug("opening JDBC connection"); try { return factory.getConnectionProvider().getConnection(); } catch (SQLException sqle) { throw JDBCExceptionHelper.convert( factory.getSQLExceptionConverter(), sqle, "Cannot open connection" ); } }
public TransactionManager getTransactionManager() { return getCurrentSessionFactoryImplementor().getTransactionManager(); }
private String getSchemaPrefix() throws SQLException { String schemaPrefix = ""; final String defaultSchema = ((SessionFactoryImplementor) session.getSessionFactory()).getSettings() .getDefaultSchemaName(); if (defaultSchema != null && !defaultSchema.trim().isEmpty()) { schemaPrefix = defaultSchema + "."; } return schemaPrefix; }