public boolean isUpdate() { return translators[0].isUpdateStatement(); } }
public Class getDynamicInstantiationResultType() { return translators[0].getDynamicInstantiationResultType(); }
public boolean isSelect() { return !translators[0].isManipulationStatement(); }
if ( collectionRole == null ) { translators[i] = queryTranslatorFactory .createQueryTranslator( hql, concreteQueryStrings[i], enabledFilters, factory, entityGraphQueryHint ); translators[i].compile( querySubstitutions, shallow ); .createFilterTranslator( hql, concreteQueryStrings[i], enabledFilters, factory ); ( (FilterTranslator) translators[i] ).compile( collectionRole, querySubstitutions, shallow ); combinedQuerySpaces.addAll( translators[i].getQuerySpaces() ); this.parameterMetadata = buildParameterMetadata( translators[0].getParameterTranslations(), hql ); if ( translators[0].isManipulationStatement() ) { returnMetadata = null; final Type[] types = ( length > 1 ) ? new Type[translators[0].getReturnTypes().length] : translators[0].getReturnTypes(); returnMetadata = new ReturnMetadata( translators[0].getReturnAliases(), types );
protected Exception compileBadHql(String hql, boolean scalar) { QueryTranslator newQueryTranslator; Map replacements = null; Exception newException = null; SessionFactoryImplementor factory = sessionFactory(); try { QueryTranslatorFactory ast = new ASTQueryTranslatorFactory(); newQueryTranslator = ast.createQueryTranslator( hql, hql, Collections.EMPTY_MAP, factory, null ); newQueryTranslator.compile( replacements, scalar ); } catch ( QueryException e ) { newException = e; } catch ( MappingException e ) { newException = e; } assertNotNull( "Expected exception from compilation of '" + hql + "'!", newException ); return newException; }
QueryTranslator oldQueryTranslator = classic.createQueryTranslator( hql, hql, Collections.EMPTY_MAP, sessionFactory(), null ); oldQueryTranslator.compile( Collections.EMPTY_MAP, true); assertEquals( "incorrect return type count", 1, oldQueryTranslator.getReturnTypes().length ); assertEquals( "incorrect return type", LongType.INSTANCE, oldQueryTranslator.getReturnTypes()[0] );
@Test @TestForIssue(jiraKey = "HHH-8579") public void testAliasWithLocale() { // Without the HHH-8579 fix, this will generate non-ascii query aliases. String hql = "from IAmAFoo"; QueryTranslatorFactory ast = new ASTQueryTranslatorFactory(); QueryTranslator queryTranslator = ast.createQueryTranslator( hql, hql, Collections.EMPTY_MAP, sessionFactory(), null ); queryTranslator.compile( Collections.EMPTY_MAP, false ); String sql = queryTranslator.getSQLString(); assertTrue( sql.matches( asciiRegex ) ); }
private QueryTranslatorImpl createNewQueryTranslator(String hql, Map replacements, boolean scalar, SessionFactoryImplementor factory) { QueryTranslatorFactory ast = new ASTQueryTranslatorFactory(); QueryTranslatorImpl newQueryTranslator = ( QueryTranslatorImpl ) ast.createQueryTranslator( hql, hql, Collections.EMPTY_MAP, factory, null ); newQueryTranslator.compile( replacements, scalar ); return newQueryTranslator; }
private ParameterMetadataImpl buildParameterMetadata(ParameterTranslations parameterTranslations, String hql) { final Map<Integer,OrdinalParameterDescriptor> ordinalParamDescriptors; if ( parameterTranslations.getPositionalParameterInformationMap().isEmpty() ) { ordinalParamDescriptors = Collections.emptyMap(); final Map<Integer,OrdinalParameterDescriptor> temp = new HashMap<>(); for ( Map.Entry<Integer, PositionalParameterInformation> entry : parameterTranslations.getPositionalParameterInformationMap().entrySet() ) { final int position = entry.getKey(); temp.put( position, position - 1, entry.getValue().getExpectedType(), entry.getValue().getSourceLocations() if ( parameterTranslations.getNamedParameterInformationMap().isEmpty() ) { namedParamDescriptorMap = Collections.emptyMap(); final Map<String, NamedParameterDescriptor> tmp = new HashMap<>(); for ( Map.Entry<String, NamedParameterInformation> namedEntry : parameterTranslations.getNamedParameterInformationMap().entrySet() ) { final String name = namedEntry.getKey(); tmp.put( new NamedParameterDescriptor( name, parameterTranslations.getNamedParameterInformation( name ).getExpectedType(), namedEntry.getValue().getSourceLocations()
/** * Coordinates the efforts to perform a scroll across all the included query translators. * * @param queryParameters The query parameters * @param session The session * * @return The query result iterator * * @throws HibernateException Indicates a problem performing the query */ public ScrollableResultsImplementor performScroll( QueryParameters queryParameters, SharedSessionContractImplementor session) throws HibernateException { if ( traceEnabled ) { LOG.tracev( "Iterate: {0}", getSourceQuery() ); queryParameters.traceParameters( session.getFactory() ); } if ( translators.length != 1 ) { throw new QueryException( "implicit polymorphism not supported for scroll() queries" ); } if ( queryParameters.getRowSelection().definesLimits() && translators[0].containsCollectionFetches() ) { throw new QueryException( "firstResult/maxResults not supported in conjunction with scroll() of a query containing collection fetches" ); } return translators[0].scroll( queryParameters, session ); }
private void checkQuerySpaces(QueryTranslator oldQueryTranslator, QueryTranslator newQueryTranslator) { // Check the query spaces for a regression. Set<Serializable> oldQuerySpaces = oldQueryTranslator.getQuerySpaces(); Set<Serializable> querySpaces = newQueryTranslator.getQuerySpaces(); assertEquals( "Query spaces is not the right size!", oldQuerySpaces.size(), querySpaces.size() ); for ( Object o : oldQuerySpaces ) { assertTrue( "New query space does not contain " + o + "!", querySpaces.contains( o ) ); } }
private void checkSql(QueryTranslator oldQueryTranslator, QueryTranslator newQueryTranslator, String hql, boolean scalar, String sql) { String oldsql = oldQueryTranslator.getSQLString(); String newsql = newQueryTranslator.getSQLString(); System.out.println( "HQL : " + ASTPrinter.escapeMultibyteChars(hql) ); System.out.println( "OLD SQL: " + ASTPrinter.escapeMultibyteChars(oldsql) ); System.out.println( "NEW SQL: " + ASTPrinter.escapeMultibyteChars(newsql) ); if ( sql == null ) { // Check the generated SQL. ASTPrinter.escapeMultibyteChars( assertSQLEquals( "SQL is not the same as the old SQL (scalar=" + scalar + ")", oldsql, newsql ); } else { assertSQLEquals( "SQL is not the same as the expected SQL (scalar=" + scalar + ")", sql, newsql ); } }
private void checkReturnedTypes(QueryTranslator oldQueryTranslator, QueryTranslator newQueryTranslator) { // Check the returned types for a regression. Type[] oldReturnTypes = oldQueryTranslator.getReturnTypes(); Type[] returnTypes = newQueryTranslator.getReturnTypes(); assertEquals( "Return types array is not the right length!", oldReturnTypes.length, returnTypes.length ); for ( int i = 0; i < returnTypes.length; i++ ) { assertNotNull( returnTypes[i] ); assertNotNull( oldReturnTypes[i] ); assertEquals( "Returned types did not match!", oldReturnTypes[i].getReturnedClass(), returnTypes[i].getReturnedClass() ); System.out.println("returnedType[" + i + "] = " + returnTypes[i] + " oldReturnTypes[" + i + "] = " + oldReturnTypes[i]); } }
/** * Returns the locations of all occurrences of the named parameter. */ @Override public int[] getNamedParameterLocs(String name) throws QueryException { ParameterInformation info = queryTranslator.getParameterTranslations().getNamedParameterInformation( name ); if ( info == null ) { try { info = queryTranslator.getParameterTranslations().getPositionalParameterInformation( Integer.parseInt( name ) ); } catch (Exception ignore) { } } if ( info == null ) { throw new QueryException( "Unrecognized parameter label : " + name ); } return info.getSourceLocations(); }
/** * This method should only be called for debugging purposes as it regenerates a new array every time. */ public String[] getSqlStrings() { List<String> sqlStrings = new ArrayList<>(); for ( int i = 0; i < translators.length; i++ ) { sqlStrings.addAll( translators[i].collectSqlStrings() ); } return ArrayHelper.toStringArray( sqlStrings ); }
/** * Coordinates the efforts to perform an execution across all the included query translators. * * @param queryParameters The query parameters * @param session The session * * @return The aggregated "affected row" count * * @throws HibernateException Indicates a problem performing the execution */ public int performExecuteUpdate(QueryParameters queryParameters, SharedSessionContractImplementor session) throws HibernateException { if ( traceEnabled ) { LOG.tracev( "Execute update: {0}", getSourceQuery() ); queryParameters.traceParameters( session.getFactory() ); } if ( translators.length != 1 ) { LOG.splitQueries( getSourceQuery(), translators.length ); } int result = 0; for ( QueryTranslator translator : translators ) { result += translator.executeUpdate( queryParameters, session ); } return result; }
default boolean isUpdateStatement() { return getQueryString().toLowerCase().trim().startsWith( "update" ); }
System.out.println("Compiling with classic QueryTranslator..."); QueryTranslatorFactory classic = new ClassicQueryTranslatorFactory(); oldQueryTranslator = classic.createQueryTranslator( hql, hql, Collections.EMPTY_MAP, factory, null ); oldQueryTranslator.compile( replacements, scalar );
private QueryTranslatorImpl compileQuery(String hql) { QueryTranslatorFactory ast = new ASTQueryTranslatorFactory(); QueryTranslatorImpl newQueryTranslator = (QueryTranslatorImpl) ast.createQueryTranslator( hql, hql, Collections.EMPTY_MAP, sessionFactory(), null ); newQueryTranslator.compile( Collections.emptyMap(), false ); return newQueryTranslator; } }
private void testMultiJoinAddition(String hql) { final HQLQueryPlan plan = sessionFactory().getQueryPlanCache().getHQLQueryPlan( hql, false, Collections.EMPTY_MAP ); assertEquals( 1, plan.getTranslators().length ); final QueryTranslator translator = plan.getTranslators()[0]; final String generatedSql = translator.getSQLString(); int sub1JoinColumnIndex = generatedSql.indexOf( ".base_sub_1" ); assertNotEquals( "Generated SQL doesn't contain a join for 'base' with 'PolymorphicSub1' via 'base_sub_1':\n" + generatedSql, -1, sub1JoinColumnIndex ); int sub2JoinColumnIndex = generatedSql.indexOf( ".base_sub_2" ); assertNotEquals( "Generated SQL doesn't contain a join for 'base' with 'PolymorphicSub2' via 'base_sub_2':\n" + generatedSql, -1, sub2JoinColumnIndex ); }