public void setCacheMode(CacheMode cacheMode) { errorIfClosed(); checkTransactionSynchStatus(); if ( log.isTraceEnabled() ) { log.trace("setting cache mode to: " + cacheMode); } this.cacheMode= cacheMode; }
public void setFlushMode(FlushMode flushMode) { errorIfClosed(); checkTransactionSynchStatus(); if ( log.isTraceEnabled() ) { log.trace("setting flush mode to: " + flushMode); } this.flushMode = flushMode; }
public ActionQueue getActionQueue() { errorIfClosed(); checkTransactionSynchStatus(); return actionQueue; }
public Map getEnabledFilters() { errorIfClosed(); checkTransactionSynchStatus(); // First, validate all the enabled filters... //TODO: this implementation has bad performance Iterator itr = enabledFilters.values().iterator(); while ( itr.hasNext() ) { final Filter filter = (Filter) itr.next(); filter.validate(); } return enabledFilters; }
public Connection disconnect() throws HibernateException { errorIfClosed(); log.debug( "disconnecting session" ); return jdbcContext.getConnectionManager().manualDisconnect(); }
public Query getNamedQuery(String queryName) throws MappingException { errorIfClosed(); checkTransactionSynchStatus(); return super.getNamedQuery(queryName); }
public void reconnect(Connection conn) throws HibernateException { errorIfClosed(); log.debug( "reconnecting session" ); checkTransactionSynchStatus(); jdbcContext.getConnectionManager().manualReconnect( conn ); }
public void clear() { errorIfClosed(); checkTransactionSynchStatus(); persistenceContext.clear(); actionQueue.clear(); }
private void fireSaveOrUpdate(SaveOrUpdateEvent event) { errorIfClosed(); checkTransactionSynchStatus(); SaveOrUpdateEventListener[] saveOrUpdateEventListener = listeners.getSaveOrUpdateEventListeners(); for ( int i = 0; i < saveOrUpdateEventListener.length; i++ ) { saveOrUpdateEventListener[i].onSaveOrUpdate(event); } }
private void fireDelete(DeleteEvent event, Set transientEntities) { errorIfClosed(); checkTransactionSynchStatus(); DeleteEventListener[] deleteEventListener = listeners.getDeleteEventListeners(); for ( int i = 0; i < deleteEventListener.length; i++ ) { deleteEventListener[i].onDelete( event, transientEntities ); } }
private void fireLoad(LoadEvent event, LoadType loadType) { errorIfClosed(); checkTransactionSynchStatus(); LoadEventListener[] loadEventListener = listeners.getLoadEventListeners(); for ( int i = 0; i < loadEventListener.length; i++ ) { loadEventListener[i].onLoad(event, loadType); } }
private void fireEvict(EvictEvent evictEvent) { errorIfClosed(); checkTransactionSynchStatus(); EvictEventListener[] evictEventListener = listeners.getEvictEventListeners(); for ( int i = 0; i < evictEventListener.length; i++ ) { evictEventListener[i].onEvict( evictEvent ); } }
private void firePersist(Map copiedAlready, PersistEvent event) { errorIfClosed(); checkTransactionSynchStatus(); PersistEventListener[] persistEventListener = listeners.getPersistEventListeners(); for ( int i = 0; i < persistEventListener.length; i++ ) { persistEventListener[i].onPersist(event, copiedAlready); } }
private void fireRefresh(Map refreshedAlready, RefreshEvent refreshEvent) { errorIfClosed(); checkTransactionSynchStatus(); RefreshEventListener[] refreshEventListener = listeners.getRefreshEventListeners(); for ( int i = 0; i < refreshEventListener.length; i++ ) { refreshEventListener[i].onRefresh( refreshEvent, refreshedAlready ); } }
public Iterator iterateFilter(Object collection, String filter, QueryParameters queryParameters) throws HibernateException { errorIfClosed(); checkTransactionSynchStatus(); FilterQueryPlan plan = getFilterQueryPlan( collection, filter, queryParameters, true ); return plan.performIterate( queryParameters, this ); }
private Object fireSaveOrUpdateCopy(MergeEvent event) { errorIfClosed(); checkTransactionSynchStatus(); MergeEventListener[] saveOrUpdateCopyEventListener = listeners.getSaveOrUpdateCopyEventListeners(); for ( int i = 0; i < saveOrUpdateCopyEventListener.length; i++ ) { saveOrUpdateCopyEventListener[i].onMerge(event); } return event.getResult(); }
private Serializable fireSave(SaveOrUpdateEvent event) { errorIfClosed(); checkTransactionSynchStatus(); SaveOrUpdateEventListener[] saveEventListener = listeners.getSaveEventListeners(); for ( int i = 0; i < saveEventListener.length; i++ ) { saveEventListener[i].onSaveOrUpdate(event); } return event.getResultId(); }
private Object fireMerge(MergeEvent event) { errorIfClosed(); checkTransactionSynchStatus(); MergeEventListener[] mergeEventListener = listeners.getMergeEventListeners(); for ( int i = 0; i < mergeEventListener.length; i++ ) { mergeEventListener[i].onMerge(event); } return event.getResult(); }
public Query createFilter(Object collection, String queryString) { errorIfClosed(); checkTransactionSynchStatus(); CollectionFilterImpl filter = new CollectionFilterImpl( queryString, collection, this, getFilterQueryPlan( collection, queryString, null, false ).getParameterMetadata() ); filter.setComment( queryString ); return filter; }
public void flush() throws HibernateException { errorIfClosed(); checkTransactionSynchStatus(); if ( persistenceContext.getCascadeLevel() > 0 ) { throw new HibernateException("Flush during cascade is dangerous"); } FlushEventListener[] flushEventListener = listeners.getFlushEventListeners(); for ( int i = 0; i < flushEventListener.length; i++ ) { flushEventListener[i].onFlush( new FlushEvent(this) ); } }