Example usage for org.hibernate.engine.query.spi HQLQueryPlan getSqlStrings

Introduction

In this page you can find the example usage for org.hibernate.engine.query.spi HQLQueryPlan getSqlStrings.

Prototype

public String[] getSqlStrings() 

Source Link

Document

This method should only be called for debugging purposes as it regenerates a new array every time.

Usage

From source file:com.blazebit.persistence.integration.hibernate.base.HibernateExtendedQuerySupport.java

License:Apache License

@Override
public String getSql(EntityManager em, Query query) {
    SessionImplementor session = em.unwrap(SessionImplementor.class);
    HQLQueryPlan queryPlan = getOriginalQueryPlan(session, query);

    if (queryPlan.getTranslators().length > 1) {
        throw new IllegalArgumentException("No support for multiple translators yet!");
    }/*from   www  . ja  v  a 2 s  .  co  m*/
    QueryTranslator queryTranslator = queryPlan.getTranslators()[0];

    String[] sqls;
    if (queryTranslator.isManipulationStatement()) {
        StatementExecutor executor = getStatementExecutor(queryTranslator);
        if (!(executor instanceof BasicExecutor)) {
            throw new IllegalArgumentException(
                    "Using polymorphic deletes/updates with CTEs is not yet supported");
        }
        sqls = executor.getSqlStatements();
    } else {
        sqls = queryPlan.getSqlStrings();
    }
    // TODO: have to handle multiple sql strings which happens when having e.g. a polymorphic UPDATE/DELETE
    for (int i = 0; i < sqls.length; i++) {
        if (sqls[i] != null) {
            return sqls[i];
        }
    }

    return null;
}

---

From source file:com.blazebit.persistence.integration.hibernate.base.HibernateExtendedQuerySupport.java

License:Apache License

@Override
public int executeUpdate(com.blazebit.persistence.spi.ServiceProvider serviceProvider,
        List<Query> participatingQueries, Query baseQuery, Query query, String finalSql) {
    DbmsDialect dbmsDialect = serviceProvider.getService(DbmsDialect.class);
    EntityManager em = serviceProvider.getService(EntityManager.class);
    SessionImplementor session = em.unwrap(SessionImplementor.class);
    SessionFactoryImplementor sfi = session.getFactory();

    if (session.isClosed()) {
        throw new PersistenceException("Entity manager is closed!");
    }//  w w  w  .j  av  a2 s .  c o m

    Integer firstResult = null;
    Integer maxResults = null;

    if (query.getFirstResult() > 0) {
        firstResult = query.getFirstResult();
    }
    if (query.getMaxResults() != Integer.MAX_VALUE) {
        maxResults = query.getMaxResults();
    }

    // Create combined query parameters
    List<String> queryStrings = new ArrayList<>(participatingQueries.size());
    Set<String> querySpaces = new HashSet<>();
    QueryParamEntry queryParametersEntry = createQueryParameters(em, participatingQueries, queryStrings,
            querySpaces);
    QueryParameters queryParameters = queryParametersEntry.queryParameters;

    QueryPlanCacheKey cacheKey = createCacheKey(queryStrings, firstResult, maxResults);
    CacheEntry<HQLQueryPlan> queryPlanEntry = getQueryPlan(sfi, query, cacheKey);
    HQLQueryPlan queryPlan = queryPlanEntry.getValue();

    if (!queryPlanEntry.isFromCache()) {
        prepareQueryPlan(queryPlan, queryParametersEntry.specifications, finalSql, session, baseQuery, true,
                dbmsDialect);
        queryPlan = putQueryPlanIfAbsent(sfi, cacheKey, queryPlan);
    }

    autoFlush(querySpaces, session);

    if (queryPlan.getReturnMetadata() == null) {
        return hibernateAccess.performExecuteUpdate(queryPlan, session, queryParameters);
    }

    boolean caseInsensitive = !Boolean.valueOf(serviceProvider.getService(ConfigurationSource.class)
            .getProperty("com.blazebit.persistence.returning_clause_case_sensitive"));
    String exampleQuerySql = queryPlan.getSqlStrings()[0];
    String[][] returningColumns = getReturningColumns(caseInsensitive, exampleQuerySql);
    int[] returningColumnTypes = dbmsDialect.needsReturningSqlTypes() ? getReturningColumnTypes(queryPlan, sfi)
            : null;

    try {
        @SuppressWarnings("unchecked")
        List<Object> results = hibernateAccess.performList(queryPlan,
                wrapSession(session, dbmsDialect, returningColumns, returningColumnTypes, null),
                queryParameters);

        if (results.size() != 1) {
            throw new IllegalArgumentException("Expected size 1 but was: " + results.size());
        }

        Number count = (Number) results.get(0);
        return count.intValue();
    } catch (QueryExecutionRequestException he) {
        LOG.severe("Could not execute the following SQL query: " + finalSql);
        throw new IllegalStateException(he);
    } catch (TypeMismatchException e) {
        LOG.severe("Could not execute the following SQL query: " + finalSql);
        throw new IllegalArgumentException(e);
    } catch (HibernateException he) {
        LOG.severe("Could not execute the following SQL query: " + finalSql);
        hibernateAccess.throwPersistenceException(em, he);
        return 0;
    }
}

---

From source file:com.blazebit.persistence.integration.hibernate.base.HibernateExtendedQuerySupport.java

License:Apache License

@Override
@SuppressWarnings("unchecked")
public ReturningResult<Object[]> executeReturning(com.blazebit.persistence.spi.ServiceProvider serviceProvider,
        List<Query> participatingQueries, Query modificationBaseQuery, Query exampleQuery, String sqlOverride) {
    DbmsDialect dbmsDialect = serviceProvider.getService(DbmsDialect.class);
    EntityManager em = serviceProvider.getService(EntityManager.class);
    SessionImplementor session = em.unwrap(SessionImplementor.class);
    SessionFactoryImplementor sfi = session.getFactory();

    if (session.isClosed()) {
        throw new PersistenceException("Entity manager is closed!");
    }/*from   w w  w .jav  a  2s  . co  m*/

    // Create combined query parameters
    List<String> queryStrings = new ArrayList<>(participatingQueries.size());
    Set<String> querySpaces = new HashSet<>();
    QueryParamEntry queryParametersEntry = createQueryParameters(em, participatingQueries, queryStrings,
            querySpaces);
    QueryParameters queryParameters = queryParametersEntry.queryParameters;

    // Create plan for example query
    QueryPlanCacheKey cacheKey = createCacheKey(queryStrings);
    CacheEntry<HQLQueryPlan> queryPlanEntry = getQueryPlan(sfi, exampleQuery, cacheKey);
    HQLQueryPlan queryPlan = queryPlanEntry.getValue();
    String exampleQuerySql = queryPlan.getSqlStrings()[0];

    StringBuilder sqlSb = new StringBuilder(sqlOverride.length() + 100);
    sqlSb.append(sqlOverride);

    boolean caseInsensitive = !Boolean.valueOf(serviceProvider.getService(ConfigurationSource.class)
            .getProperty("com.blazebit.persistence.returning_clause_case_sensitive"));
    String[][] returningColumns = getReturningColumns(caseInsensitive, exampleQuerySql);
    int[] returningColumnTypes = dbmsDialect.needsReturningSqlTypes() ? getReturningColumnTypes(queryPlan, sfi)
            : null;
    String finalSql = sqlSb.toString();

    try {
        HibernateReturningResult<Object[]> returningResult = new HibernateReturningResult<Object[]>();
        if (!queryPlanEntry.isFromCache()) {
            prepareQueryPlan(queryPlan, queryParametersEntry.specifications, finalSql, session,
                    modificationBaseQuery, true, dbmsDialect);
            queryPlan = putQueryPlanIfAbsent(sfi, cacheKey, queryPlan);
        }

        if (queryPlan.getTranslators().length > 1) {
            throw new IllegalArgumentException("No support for multiple translators yet!");
        }

        QueryTranslator queryTranslator = queryPlan.getTranslators()[0];

        // If the DBMS doesn't support inclusion of cascading deletes in a with clause, we have to execute them manually
        StatementExecutor executor = getExecutor(queryTranslator, session, modificationBaseQuery);
        List<String> originalDeletes = Collections.emptyList();

        if (executor != null && executor instanceof DeleteExecutor) {
            originalDeletes = getField(executor, "deletes");
        }

        // Extract query loader for native listing
        QueryLoader queryLoader = getField(queryTranslator, "queryLoader");

        // Do the native list operation with custom session and combined parameters

        /*
         * NATIVE LIST START
         */
        hibernateAccess.checkTransactionSynchStatus(session);
        queryParameters.validateParameters();
        autoFlush(querySpaces, session);

        List<Object[]> results = Collections.EMPTY_LIST;
        boolean success = false;

        try {
            for (String delete : originalDeletes) {
                hibernateAccess.doExecute(executor, delete, queryParameters, session,
                        queryParametersEntry.specifications);
            }

            results = hibernateAccess.list(queryLoader,
                    wrapSession(session, dbmsDialect, returningColumns, returningColumnTypes, returningResult),
                    queryParameters);
            success = true;
        } catch (QueryExecutionRequestException he) {
            LOG.severe("Could not execute the following SQL query: " + finalSql);
            throw new IllegalStateException(he);
        } catch (TypeMismatchException e) {
            LOG.severe("Could not execute the following SQL query: " + finalSql);
            throw new IllegalArgumentException(e);
        } catch (HibernateException he) {
            LOG.severe("Could not execute the following SQL query: " + finalSql);
            throw hibernateAccess.convert(em, he);
        } finally {
            hibernateAccess.afterTransaction(session, success);
        }
        /*
         * NATIVE LIST END
         */

        returningResult.setResultList(results);
        return returningResult;
    } catch (Exception e1) {
        throw new RuntimeException(e1);
    }
}

---