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

Introduction

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

Prototype

public QueryTranslator[] getTranslators() 

Source Link

Document

Access to the underlying translators associated with this query

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!");
    }// ww  w.  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 List<String> getCascadingDeleteSql(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 w  w w. j  av  a2 s.com
    // TODO: check if this is actually a delete statement
    QueryTranslator queryTranslator = queryPlan.getTranslators()[0];
    StatementExecutor executor = getStatementExecutor(queryTranslator);
    if (executor == null || !(executor instanceof DeleteExecutor)) {
        return Collections.EMPTY_LIST;
    }

    List<String> deletes = getField(executor, "deletes");
    if (deletes == null) {
        return Collections.EMPTY_LIST;
    }
    return deletes;
}

---

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

License:Apache License

@Override
public String getSqlAlias(EntityManager em, Query query, String alias) {
    SessionImplementor session = em.unwrap(SessionImplementor.class);
    HQLQueryPlan plan = getOriginalQueryPlan(session, query);
    if (plan.getTranslators().length > 1) {
        throw new IllegalArgumentException("No support for multiple translators yet!");
    }//w  w  w . j av a  2s. co m
    QueryTranslator translator = plan.getTranslators()[0];

    QueryNode queryNode = getField(translator, "sqlAst");
    FromElement fromElement = queryNode.getFromClause().getFromElement(alias);

    if (fromElement == null) {
        throw new IllegalArgumentException("The alias " + alias + " could not be found in the query: " + query);
    }

    return fromElement.getTableAlias();
}

---

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

License:Apache License

@Override
public int getSqlSelectAliasPosition(EntityManager em, Query query, String alias) {
    SessionImplementor session = em.unwrap(SessionImplementor.class);
    HQLQueryPlan plan = getOriginalQueryPlan(session, query);
    if (plan.getTranslators().length > 1) {
        throw new IllegalArgumentException("No support for multiple translators yet!");
    }// w  ww  .ja va2  s .com
    QueryTranslator translator = plan.getTranslators()[0];

    try {
        QueryNode queryNode = getField(translator, "sqlAst");

        String[] aliases = queryNode.getSelectClause().getQueryReturnAliases();

        for (int i = 0; i < aliases.length; i++) {
            if (alias.equals(aliases[i])) {
                // the ordinal is 1 based
                return i + 1;
            }
        }

        return -1;
    } catch (Exception e1) {
        throw new RuntimeException(e1);
    }
}

---

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

License:Apache License

@Override
public int getSqlSelectAttributePosition(EntityManager em, Query query, String expression) {
    if (expression.contains(".")) {
        // TODO: implement
        throw new UnsupportedOperationException("Embeddables are not yet supported!");
    }//  w  w w . ja va 2 s . co m

    SessionImplementor session = em.unwrap(SessionImplementor.class);
    HQLQueryPlan plan = getOriginalQueryPlan(session, query);
    if (plan.getTranslators().length > 1) {
        throw new IllegalArgumentException("No support for multiple translators yet!");
    }
    QueryTranslator translator = plan.getTranslators()[0];

    try {
        QueryNode queryNode = getField(translator, "sqlAst");
        SelectClause selectClause = queryNode.getSelectClause();
        Type[] queryReturnTypes = selectClause.getQueryReturnTypes();

        boolean found = false;
        // The ordinal is 1 based
        int position = 1;
        for (int i = 0; i < queryReturnTypes.length; i++) {
            Type t = queryReturnTypes[i];
            if (t instanceof ManyToOneType) {
                ManyToOneType manyToOneType = (ManyToOneType) t;
                AbstractEntityPersister persister = (AbstractEntityPersister) session.getFactory()
                        .getEntityPersister(manyToOneType.getAssociatedEntityName());

                int propertyIndex = persister.getPropertyIndex(expression);
                found = true;
                for (int j = 0; j < propertyIndex; j++) {
                    position += persister.getPropertyColumnNames(j).length;
                }
                // Increment to the actual property position
                position++;
            } else {
                position++;
            }
        }

        if (found) {
            return position;
        }

        AST selectItem = selectClause.getFirstChild();

        while (selectItem != null && (selectItem.getType() == SqlTokenTypes.DISTINCT
                || selectItem.getType() == SqlTokenTypes.ALL)) {
            selectItem = selectItem.getNextSibling();
        }

        position = 1;
        for (AST n = selectItem; n != null; n = n.getNextSibling()) {
            if (n instanceof DotNode) {
                DotNode dot = (DotNode) n;
                if (expression.equals(dot.getPropertyPath())) {
                    // Check if the property is an embeddable
                    if (dot.getText().contains(",")) {
                        throw new IllegalStateException("Can't order by the embeddable: " + expression);
                    }
                    found = true;
                    break;
                }
            }
            position++;
        }

        if (found) {
            return position;
        }

        return -1;
    } catch (Exception e1) {
        throw new RuntimeException(e1);
    }
}

---

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. j a va 2 s .  c  om

    // 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);
    }
}

---

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

License:Apache License

private List<QueryParamEntry> getQueryParamEntries(EntityManager em, List<Query> queries,
        Set<String> querySpaces) {
    SessionImplementor session = em.unwrap(SessionImplementor.class);
    SessionFactoryImplementor sfi = session.getFactory();
    List<QueryParamEntry> result = new ArrayList<QueryParamEntry>(queries.size());
    Deque<Query> queryQueue = new LinkedList<Query>(queries);

    while (queryQueue.size() > 0) {
        Query q = queryQueue.remove();
        if (q instanceof CteQueryWrapper) {
            List<Query> participatingQueries = ((CteQueryWrapper) q).getParticipatingQueries();
            for (int i = participatingQueries.size() - 1; i > -1; i--) {
                queryQueue.addFirst(participatingQueries.get(i));
            }//w ww.  j ava2 s . c  om
            continue;
        }

        org.hibernate.Query hibernateQuery = q.unwrap(org.hibernate.Query.class);

        Map<String, TypedValue> namedParams = new HashMap<String, TypedValue>(
                hibernateAccess.getNamedParams(hibernateQuery));
        String queryString = hibernateAccess.expandParameterLists(session, hibernateQuery, namedParams);

        HQLQueryPlan queryPlan = sfi.getQueryPlanCache().getHQLQueryPlan(queryString, false,
                Collections.EMPTY_MAP);

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

        querySpaces.addAll(queryPlan.getQuerySpaces());

        QueryTranslator queryTranslator = queryPlan.getTranslators()[0];
        QueryParameters queryParameters;
        List<ParameterSpecification> specifications;

        try {
            queryParameters = hibernateAccess.getQueryParameters(hibernateQuery, namedParams);
            specifications = getField(queryTranslator, "collectedParameterSpecifications");

            // This only happens for modification queries
            if (specifications == null) {
                StatementExecutor executor = getStatementExecutor(queryTranslator);
                if (!(executor instanceof BasicExecutor)) {
                    throw new IllegalArgumentException(
                            "Using polymorphic deletes/updates with CTEs is not yet supported");
                }
                specifications = getField(executor, "parameterSpecifications");
            }
        } catch (Exception e1) {
            throw new RuntimeException(e1);
        }

        result.add(new QueryParamEntry(queryString, queryParameters, specifications));
    }

    return result;
}

---

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

License:Apache License

private void prepareQueryPlan(HQLQueryPlan queryPlan, List<ParameterSpecification> queryParameterSpecifications,
        String finalSql, SessionImplementor session, Query modificationBaseQuery, boolean isModification,
        DbmsDialect dbmsDialect) {/*from  w w  w  .jav a  2  s . c  o m*/
    try {
        if (queryPlan.getTranslators().length > 1) {
            throw new IllegalArgumentException("No support for multiple translators yet!");
        }

        QueryTranslator queryTranslator = queryPlan.getTranslators()[0];
        // Override the sql in the query plan
        setField(queryTranslator, "sql", finalSql);

        QueryLoader queryLoader = getField(queryTranslator, "queryLoader");
        // INSERT statement does not have a query loader
        if (queryLoader != null) {
            setField(queryLoader, "factory",
                    hibernateAccess.wrapSessionFactory(queryLoader.getFactory(), dbmsDialect));
        }

        // Modification queries keep the sql in the executor
        StatementExecutor executor = null;

        Field statementExectuor = null;
        boolean madeAccessible = false;

        try {
            statementExectuor = ReflectionUtils.getField(queryTranslator.getClass(), "statementExecutor");
            madeAccessible = !statementExectuor.isAccessible();

            if (madeAccessible) {
                statementExectuor.setAccessible(true);
            }

            executor = (StatementExecutor) statementExectuor.get(queryTranslator);

            if (executor == null && isModification) {
                // We have to set an executor
                org.hibernate.Query lastHibernateQuery = modificationBaseQuery
                        .unwrap(org.hibernate.Query.class);

                Map<String, TypedValue> namedParams = new HashMap<String, TypedValue>(
                        hibernateAccess.getNamedParams(lastHibernateQuery));
                String queryString = hibernateAccess.expandParameterLists(session, lastHibernateQuery,
                        namedParams);

                // Extract the executor from the last query which is the actual main query
                HQLQueryPlan lastQueryPlan = session.getFactory().getQueryPlanCache()
                        .getHQLQueryPlan(queryString, false, Collections.EMPTY_MAP);
                if (lastQueryPlan.getTranslators().length > 1) {
                    throw new IllegalArgumentException("No support for multiple translators yet!");
                }
                QueryTranslator lastQueryTranslator = lastQueryPlan.getTranslators()[0];
                executor = (StatementExecutor) statementExectuor.get(lastQueryTranslator);
                // Now we use this executor for our example query
                statementExectuor.set(queryTranslator, executor);
            }
        } finally {
            if (madeAccessible) {
                statementExectuor.setAccessible(false);
            }
        }

        if (executor != null) {
            setField(executor, "sql", finalSql);
            setField(executor, BasicExecutor.class, "parameterSpecifications", queryParameterSpecifications);

            if (executor instanceof DeleteExecutor) {
                int withIndex;
                if (dbmsDialect.supportsModificationQueryInWithClause()) {
                    setField(executor, "deletes", new ArrayList<String>());
                } else if ((withIndex = finalSql.indexOf("with ")) != -1) {
                    int end = getCTEEnd(finalSql, withIndex);

                    List<String> originalDeletes = getField(executor, "deletes");
                    int maxLength = 0;

                    for (String s : originalDeletes) {
                        maxLength = Math.max(maxLength, s.length());
                    }

                    List<String> deletes = new ArrayList<String>(originalDeletes.size());
                    StringBuilder newSb = new StringBuilder(end + maxLength);
                    // Prefix properly with cte
                    StringBuilder withClauseSb = new StringBuilder(end - withIndex);
                    withClauseSb.append(finalSql, withIndex, end);

                    for (String s : originalDeletes) {
                        // TODO: The strings should also receive the simple CTE name instead of the complex one
                        newSb.append(s);
                        dbmsDialect.appendExtendedSql(newSb, DbmsStatementType.DELETE, false, false,
                                withClauseSb, null, null, null, null);
                        deletes.add(newSb.toString());
                        newSb.setLength(0);
                    }

                    setField(executor, "deletes", deletes);
                }
            }
        }

        // Prepare queryTranslator for aggregated parameters
        ParameterTranslations translations = hibernateAccess
                .createParameterTranslations(queryParameterSpecifications);
        setField(queryTranslator, "paramTranslations", translations);
        setField(queryTranslator, "collectedParameterSpecifications", queryParameterSpecifications);
    } catch (Exception e1) {
        throw new RuntimeException(e1);
    }
}

---

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

License:Apache License

private StatementExecutor getExecutor(QueryTranslator queryTranslator, SessionImplementor session,
        Query lastQuery) {//  www. j  a v  a2s.c  o  m
    // Modification queries keep the sql in the executor
    StatementExecutor executor = null;

    Field statementExectuor = null;
    boolean madeAccessible = false;

    try {
        statementExectuor = ReflectionUtils.getField(queryTranslator.getClass(), "statementExecutor");
        madeAccessible = !statementExectuor.isAccessible();

        if (madeAccessible) {
            statementExectuor.setAccessible(true);
        }

        executor = (StatementExecutor) statementExectuor.get(queryTranslator);

        if (executor == null) {
            // We have to set an executor
            org.hibernate.Query lastHibernateQuery = lastQuery.unwrap(org.hibernate.Query.class);

            Map<String, TypedValue> namedParams = new HashMap<String, TypedValue>(
                    hibernateAccess.getNamedParams(lastHibernateQuery));
            String queryString = hibernateAccess.expandParameterLists(session, lastHibernateQuery, namedParams);

            // Extract the executor from the last query which is the actual main query
            HQLQueryPlan lastQueryPlan = session.getFactory().getQueryPlanCache().getHQLQueryPlan(queryString,
                    false, Collections.EMPTY_MAP);
            if (lastQueryPlan.getTranslators().length > 1) {
                throw new IllegalArgumentException("No support for multiple translators yet!");
            }
            QueryTranslator lastQueryTranslator = lastQueryPlan.getTranslators()[0];
            executor = (StatementExecutor) statementExectuor.get(lastQueryTranslator);
        }
    } catch (Exception e1) {
        throw new RuntimeException(e1);
    } finally {
        if (madeAccessible) {
            statementExectuor.setAccessible(false);
        }
    }

    return executor;
}

---

From source file:org.jboss.tools.hibernate4_0.QueryHelper.java

License:Open Source License

static String generateSQL(ExecutionContext executionContext, final SessionFactory sessionFactory,
        final String query) {

    if (StringHelper.isEmpty(query))
        return ""; //$NON-NLS-1$

    String result = (String) executionContext.execute(new ExecutionContext.Command() {
        public Object execute() {
            try {
                SessionFactoryImpl sfimpl = (SessionFactoryImpl) sessionFactory; // hack - to get to the actual queries..
                StringBuffer str = new StringBuffer(256);
                HQLQueryPlan plan = new HQLQueryPlan(query, false, Collections.EMPTY_MAP, sfimpl);

                QueryTranslator[] translators = plan.getTranslators();
                for (int i = 0; i < translators.length; i++) {
                    QueryTranslator translator = translators[i];
                    if (translator.isManipulationStatement()) {
                        str.append(HibernateConsoleMessages.DynamicSQLPreviewView_manipulation_of + i + ":"); //$NON-NLS-1$
                        Iterator<?> iterator = translator.getQuerySpaces().iterator();
                        while (iterator.hasNext()) {
                            Object qspace = iterator.next();
                            str.append(qspace);
                            if (iterator.hasNext()) {
                                str.append(", "); //$NON-NLS-1$
                            }/*from   www  .j  av a  2 s .  com*/
                        }

                    } else {
                        Type[] returnTypes = translator.getReturnTypes();
                        str.append(i + ": "); //$NON-NLS-1$
                        for (int j = 0; j < returnTypes.length; j++) {
                            Type returnType = returnTypes[j];
                            str.append(returnType.getName());
                            if (j < returnTypes.length - 1) {
                                str.append(", "); //$NON-NLS-1$
                            }
                        }
                    }
                    str.append("\n-----------------\n"); //$NON-NLS-1$
                    Iterator<?> sqls = translator.collectSqlStrings().iterator();
                    while (sqls.hasNext()) {
                        String sql = (String) sqls.next();
                        str.append(QLFormatHelper.formatForScreen(sql));
                        str.append("\n\n"); //$NON-NLS-1$
                    }
                }
                return str.toString();
            } catch (Throwable t) {
                StringBuffer msgs = new StringBuffer();

                Throwable cause = t;
                while (cause != null) {
                    msgs.append(t);
                    if (cause.getCause() == cause) {
                        cause = null;
                    } else {
                        cause = cause.getCause();
                        if (cause != null)
                            msgs.append(HibernateConsoleMessages.DynamicSQLPreviewView_caused_by);
                    }
                }
                return msgs.toString();
            }

        }
    });

    return result;
}

---