@Override public void insertInBatch(final List<? extends PersistentObject> entities) throws SPersistenceException { if (!entities.isEmpty()) { final Session session = getSession(true); for (final PersistentObject entity : entities) { final Class<? extends PersistentObject> entityClass = entity.getClass(); checkClassMapping(entityClass); setId(entity); session.save(entity); } } }
@Override public <T extends PersistentObject> T selectById(final SelectByIdDescriptor<T> selectDescriptor) throws SBonitaReadException { try { final Session session = getSession(true); final T object = this.selectById(session, selectDescriptor); if (selectDescriptor.isReadOnly()) { disconnectEntityFromSession(session, object); } return object; } catch (final SPersistenceException e) { throw new SBonitaReadException(e, selectDescriptor); } }
@Override public void flushStatements() throws SPersistenceException { super.flushStatements(false); }
@Override public <T> T selectOne(final SelectOneDescriptor<T> selectDescriptor) throws SBonitaReadException { try { return selectOne(getSession(true), selectDescriptor); } catch (final SPersistenceException e) { throw new SBonitaReadException(e, selectDescriptor); } }
try { final Class<? extends PersistentObject> entityClass = selectDescriptor.getEntityType(); checkClassMapping(entityClass); final Session session = getSession(true); if (selectDescriptor.hasAFilter()) { final QueryOptions queryOptions = selectDescriptor.getQueryOptions(); final boolean enableWordSearch = isWordSearchEnabled(selectDescriptor.getEntityType()); queryBuilder.appendFilters(queryOptions.getFilters(), queryOptions.getMultipleFilter(), enableWordSearch); query = queryBuilder.buildQuery(session); setQueryCache(query, selectDescriptor.getQueryName()); try { queryBuilder.setTenantId(query, getTenantId()); } catch (STenantIdNotSetException e) { throw new SBonitaReadException(e); setParameters(query, selectDescriptor.getInputParameters()); query.setFirstResult(selectDescriptor.getStartIndex()); query.setMaxResults(selectDescriptor.getPageSize()); checkOrderByClause(query); disconnectIfReadOnly(list, query, session); return list;
@Override public void deleteAll(final Class<? extends PersistentObject> entityClass) throws SPersistenceException { final Class<? extends PersistentObject> mappedClass = getMappedClass(entityClass); final Query query = getSession(true).getNamedQuery("deleteAll" + mappedClass.getSimpleName()); try { query.executeUpdate(); } catch (final AssertionFailure | LockAcquisitionException | StaleStateException e) { throw new SRetryableException(e); } catch (final HibernateException he) { throw new SPersistenceException(he); } }
@SuppressWarnings("unchecked") private <T> T selectOne(final Session session, final SelectOneDescriptor<T> selectDescriptor) throws SBonitaReadException { try { checkClassMapping(selectDescriptor.getEntityType()); } catch (final SPersistenceException e) { throw new SBonitaReadException(e); } final Query query = session.getNamedQuery(selectDescriptor.getQueryName()); setQueryCache(query, selectDescriptor.getQueryName()); final Map<String, Object> parameters = selectDescriptor.getInputParameters(); if (parameters != null) { setParameters(query, parameters); } query.setMaxResults(1); try { return disconnectIfReadOnly((T) query.uniqueResult(), query, session); } catch (final AssertionFailure | LockAcquisitionException | StaleStateException e) { throw new SRetryableException(e); } catch (final HibernateException he) { throw new SBonitaReadException(he); } }
@Override public void update(final UpdateDescriptor updateDescriptor) throws SPersistenceException { // FIXME: deal with disconnected objects: final Class<? extends PersistentObject> entityClass = updateDescriptor.getEntity().getClass(); checkClassMapping(entityClass); final PersistentObject entity = updateDescriptor.getEntity(); final Session session = getSession(false); if (!session.contains(entity)) { throw new SPersistenceException("The object cannot be updated because it's disconnected " + entity); } for (final Map.Entry<String, Object> field : updateDescriptor.getFields().entrySet()) { setField(entity, field.getKey(), field.getValue()); } }
@Override public int update(final String updateQueryName, final Map<String, Object> inputParameters) throws SPersistenceException { final Query query = getSession(true).getNamedQuery(updateQueryName); try { if (inputParameters != null) { setParameters(query, inputParameters); } return query.executeUpdate(); } catch (final HibernateException he) { throw new SPersistenceException(he); } }
void flushStatements(final boolean useTenant) throws SPersistenceException { final Session session = getSession(useTenant); session.flush(); }
private static <T> T disconnectIfReadOnly(T object, Query query, Session session) { if (query.isReadOnly()) { disconnectEntityFromSession(session, object); } return object; }
protected AbstractHibernatePersistenceService(final SessionFactory sessionFactory, final List<Class<? extends PersistentObject>> classMapping, final Map<String, String> classAliasMappings, final boolean enableWordSearch, final Set<String> wordSearchExclusionMappings, final TechnicalLoggerService logger) throws ClassNotFoundException { super("TEST", '#', enableWordSearch, wordSearchExclusionMappings, logger); this.sessionFactory = sessionFactory; this.classAliasMappings = classAliasMappings; this.classMapping = classMapping; orderByCheckingMode = getOrderByCheckingMode(); statistics = sessionFactory.getStatistics(); cacheQueries = Collections.emptyMap(); interfaceToClassMapping = Collections.emptyMap(); mappingExclusions = Collections.emptyList(); orderByBuilder = new DefaultOrderByBuilder(); }
@Override public void insert(final PersistentObject entity) throws SPersistenceException { setTenant(entity); super.insert(entity); }
@SuppressWarnings("unchecked") <T extends PersistentObject> T selectById(final Session session, final SelectByIdDescriptor<T> selectDescriptor) throws SBonitaReadException { Class<? extends PersistentObject> mappedClass; try { mappedClass = getMappedClass(selectDescriptor.getEntityType()); } catch (final SPersistenceException e) { throw new SBonitaReadException(e); } try { return (T) session.get(mappedClass, selectDescriptor.getId()); } catch (final AssertionFailure | LockAcquisitionException | StaleStateException e) { throw new SRetryableException(e); } catch (final HibernateException he) { throw new SBonitaReadException(he); } }
try { final Class<? extends PersistentObject> entityClass = selectDescriptor.getEntityType(); checkClassMapping(entityClass); final Session session = getSession(true); if (selectDescriptor.hasAFilter()) { final QueryOptions queryOptions = selectDescriptor.getQueryOptions(); final boolean enableWordSearch = isWordSearchEnabled(selectDescriptor.getEntityType()); queryBuilder.appendFilters(queryOptions.getFilters(), queryOptions.getMultipleFilter(), enableWordSearch); query = queryBuilder.buildQuery(session); setQueryCache(query, selectDescriptor.getQueryName()); try { queryBuilder.setTenantId(query, getTenantId()); } catch (STenantIdNotSetException e) { throw new SBonitaReadException(e); setParameters(query, selectDescriptor.getInputParameters()); query.setFirstResult(selectDescriptor.getStartIndex()); query.setMaxResults(selectDescriptor.getPageSize()); checkOrderByClause(query); disconnectIfReadOnly(list, query, session); return list;
@Override public void deleteAll(final Class<? extends PersistentObject> entityClass) throws SPersistenceException { final Class<? extends PersistentObject> mappedClass = getMappedClass(entityClass); final Query query = getSession(true).getNamedQuery("deleteAll" + mappedClass.getSimpleName()); try { query.executeUpdate(); } catch (final AssertionFailure | LockAcquisitionException | StaleStateException e) { throw new SRetryableException(e); } catch (final HibernateException he) { throw new SPersistenceException(he); } }
@SuppressWarnings("unchecked") private <T> T selectOne(final Session session, final SelectOneDescriptor<T> selectDescriptor) throws SBonitaReadException { try { checkClassMapping(selectDescriptor.getEntityType()); } catch (final SPersistenceException e) { throw new SBonitaReadException(e); } final Query query = session.getNamedQuery(selectDescriptor.getQueryName()); setQueryCache(query, selectDescriptor.getQueryName()); final Map<String, Object> parameters = selectDescriptor.getInputParameters(); if (parameters != null) { setParameters(query, parameters); } query.setMaxResults(1); try { return disconnectIfReadOnly((T) query.uniqueResult(), query, session); } catch (final AssertionFailure | LockAcquisitionException | StaleStateException e) { throw new SRetryableException(e); } catch (final HibernateException he) { throw new SBonitaReadException(he); } }
@Override public void update(final UpdateDescriptor updateDescriptor) throws SPersistenceException { // FIXME: deal with disconnected objects: final Class<? extends PersistentObject> entityClass = updateDescriptor.getEntity().getClass(); checkClassMapping(entityClass); final PersistentObject entity = updateDescriptor.getEntity(); final Session session = getSession(false); if (!session.contains(entity)) { throw new SPersistenceException("The object cannot be updated because it's disconnected " + entity); } for (final Map.Entry<String, Object> field : updateDescriptor.getFields().entrySet()) { setField(entity, field.getKey(), field.getValue()); } }
@Override public <T> T selectOne(final SelectOneDescriptor<T> selectDescriptor) throws SBonitaReadException { try { return selectOne(getSession(true), selectDescriptor); } catch (final SPersistenceException e) { throw new SBonitaReadException(e, selectDescriptor); } }
@Override public int update(final String updateQueryName, final Map<String, Object> inputParameters) throws SPersistenceException { final Query query = getSession(true).getNamedQuery(updateQueryName); try { if (inputParameters != null) { setParameters(query, inputParameters); } return query.executeUpdate(); } catch (final HibernateException he) { throw new SPersistenceException(he); } }