@Override public int executeUpdate() { Query baseQuery = participatingQueries.get(0); baseQuery.setFirstResult(firstResult); baseQuery.setMaxResults(maxResults); ReturningResult<Object[]> result = extendedQuerySupport.executeReturning(serviceProvider, participatingQueries, modificationBaseQuery, delegate, sql); return result.getUpdateCount(); }
@Override public int executeUpdate() { return extendedQuerySupport.executeUpdate(serviceProvider, participatingQueries, baseQuery, delegate, sql); }
private boolean applyCascadingDelete(Query baseQuery, List<Query> participatingQueries, StringBuilder sb, String cteBaseName, boolean firstCte) { List<String> cascadingDeleteSqls = extendedQuerySupport.getCascadingDeleteSql(em, baseQuery); StringBuilder cascadingDeleteSqlSb = new StringBuilder(); int cteBaseNameCount = 0; for (String cascadingDeleteSql : cascadingDeleteSqls) { if (firstCte) { firstCte = false; } else { sb.append(",\n"); } // Since we kind of need the parameters from the base query, it will participate for each cascade participatingQueries.add(baseQuery); sb.append(cteBaseName); sb.append('_').append(cteBaseNameCount++); sb.append(" AS (\n"); cascadingDeleteSqlSb.setLength(0); cascadingDeleteSqlSb.append(cascadingDeleteSql); dbmsDialect.appendExtendedSql(cascadingDeleteSqlSb, DbmsStatementType.DELETE, false, true, null, null, null, null, null); sb.append(cascadingDeleteSqlSb); sb.append("\n)"); } return firstCte; }
String sql = extendedQuerySupport.getSql(em, baseQuery); String ownerAlias = extendedQuerySupport.getSqlAlias(em, baseQuery, entityAlias); String targetAlias = extendedQuerySupport.getSqlAlias(em, baseQuery, CollectionUpdateModificationQuerySpecification.COLLECTION_BASE_QUERY_ALIAS); JoinTable joinTable = mainQuery.jpaProvider.getJoinTable(entityType, collectionName); int joinTableIndex = SqlUtils.indexOfTableName(sql, joinTable.getTableName());
@Override public String getSql() { return extendedQuerySupport.getSql(em, query); }
@SuppressWarnings("unchecked") public X orderBy(String expression, boolean ascending, boolean nullFirst) { prepareAndCheck(); AbstractCommonQueryBuilder<?, ?, ?, ?, ?> leftMostQuery = getLeftMost(setOperationManager.getStartQueryBuilder()); int position; AliasInfo aliasInfo = leftMostQuery.aliasManager.getAliasInfo(expression); if (aliasInfo == null) { position = cbf.getExtendedQuerySupport().getSqlSelectAttributePosition(em, leftMostQuery.getTypedQueryForFinalOperationBuilder(), expression); } else { // find out the position by JPQL alias position = cbf.getExtendedQuerySupport().getSqlSelectAliasPosition(em, leftMostQuery.getTypedQueryForFinalOperationBuilder(), expression); } orderByElements.add(new DefaultOrderByElement(expression, position, ascending, isNullable(this, expression), nullFirst)); return (X) this; }
protected List<String> getKeyRestrictedLeftJoinAliases(Query baseQuery, Set<JoinNode> keyRestrictedLeftJoins, Set<ClauseType> clauseExclusions) { List<String> keyRestrictedLeftJoinAliases = new ArrayList<String>(); if (!keyRestrictedLeftJoins.isEmpty()) { for (JoinNode node : keyRestrictedLeftJoins) { if (!clauseExclusions.isEmpty() && clauseExclusions.containsAll(node.getClauseDependencies()) && !node.isCardinalityMandatory()) { continue; } // The alias of the target entity table String sqlAlias = cbf.getExtendedQuerySupport().getSqlAlias(em, baseQuery, node.getAliasInfo().getAlias()); keyRestrictedLeftJoinAliases.add(sqlAlias); } } return keyRestrictedLeftJoinAliases; }
@Override public List<T> getResultList() { delegate.setFirstResult(firstResult); delegate.setMaxResults(maxResults); return extendedQuerySupport.getResultList(serviceProvider, participatingQueries, delegate, sql); }
@Override public T getSingleResult() { delegate.setFirstResult(firstResult); delegate.setMaxResults(maxResults); return (T) extendedQuerySupport.getSingleResult(serviceProvider, participatingQueries, delegate, sql); } }
public void assertSupportsAdvancedSql(String message) { if (cbf.getExtendedQuerySupport() == null || !cbf.getExtendedQuerySupport().supportsAdvancedSql()) { throw new IllegalStateException(message + " There is no extended query support for the JPA provider yet!"); } } }
Query valuesExampleQuery = getValuesExampleQuery(clazz, valueCount, identifiableReference, valueClazzAttributeName, rootAlias, castedParameter, attributes, valuesSb, strategy, dummyTable, node); String exampleQuerySql = mainQuery.cbf.getExtendedQuerySupport().getSql(mainQuery.em, valuesExampleQuery); String exampleQuerySqlAlias = mainQuery.cbf.getExtendedQuerySupport().getSqlAlias(mainQuery.em, valuesExampleQuery, "e"); String exampleQueryCollectionSqlAlias = null; if (!node.isValueClazzAttributeSingular()) { exampleQueryCollectionSqlAlias = mainQuery.cbf.getExtendedQuerySupport().getSqlAlias(mainQuery.em, valuesExampleQuery, node.getValueClazzAlias("e_")); String syntheticPredicate = exampleQuerySql.substring(SqlUtils.indexOfWhere(exampleQuerySql) + " where ".length()); if (baseQuery != null) { valuesTableSqlAlias = cbf.getExtendedQuerySupport().getSqlAlias(em, baseQuery, node.getAlias()); syntheticPredicate = syntheticPredicate.replace(exampleQuerySqlAlias, valuesTableSqlAlias); if (exampleQueryCollectionSqlAlias != null) { pluralTableAlias = cbf.getExtendedQuerySupport().getSqlAlias(em, baseQuery, node.getValueClazzAlias(node.getAlias() + "_")); syntheticPredicate = syntheticPredicate.replace(exampleQueryCollectionSqlAlias, pluralTableAlias); String baseQuerySql = cbf.getExtendedQuerySupport().getSql(em, baseQuery); int[] indexRange = SqlUtils.indexOfFullJoin(baseQuerySql, pluralTableAlias); String baseTableAlias = " " + valuesTableSqlAlias + " ";
@Override protected void initialize() { List<Query> participatingQueries = new ArrayList<Query>(); for (Map.Entry<String, Collection<?>> entry : listParameters.entrySet()) { baseQuery.setParameter(entry.getKey(), entry.getValue()); } String sqlQuery = extendedQuerySupport.getSql(em, baseQuery); StringBuilder sqlSb = applySqlTransformations(sqlQuery); // Need to inline LIMIT and OFFSET dbmsDialect.appendExtendedSql(sqlSb, statementType, false, true, null, limit, offset, null, null); participatingQueries.add(baseQuery); this.sql = sqlSb.toString(); this.participatingQueries = participatingQueries; this.dirty = false; }
String sqlAlias = extendedQuerySupport.getSqlAlias(em, baseQuery, tableNameRemappingEntry.getKey()); String newCteName = tableNameRemappingEntry.getValue();
String insertExampleSql = extendedQuerySupport.getSql(em, insertExampleQuery); String ownerAlias = extendedQuerySupport.getSqlAlias(em, insertExampleQuery, entityAlias); String targetAlias = extendedQuerySupport.getSqlAlias(em, insertExampleQuery, COLLECTION_BASE_QUERY_ALIAS); JoinTable joinTable = mainQuery.jpaProvider.getJoinTable(entityType, collectionName); int joinTableIndex = SqlUtils.indexOfTableName(insertExampleSql, joinTable.getTableName());
@Override protected void initialize() { List<Query> participatingQueries = new ArrayList<Query>(); for (Map.Entry<String, Collection<?>> entry : listParameters.entrySet()) { baseQuery.setParameter(entry.getKey(), entry.getValue()); } StringBuilder sqlSb = new StringBuilder(extendedQuerySupport.getSql(em, baseQuery)); StringBuilder withClause = applyCtes(sqlSb, baseQuery, participatingQueries); // NOTE: CTEs will only be added, if this is a subquery Map<String, String> addedCtes = applyExtendedSql(sqlSb, false, false, withClause, returningColumns, null); participatingQueries.add(baseQuery); this.sql = sqlSb.toString(); this.participatingQueries = participatingQueries; this.addedCtes = addedCtes; this.dirty = false; } }
@Override public ReturningResult<T> getSingleResult() { Query baseQuery = participatingQueries.get(0); baseQuery.setFirstResult(firstResult); baseQuery.setMaxResults(maxResults); ReturningResult<Object[]> result = extendedQuerySupport.executeReturning(serviceProvider, participatingQueries, modificationBaseQuery, delegate, sql); List<Object[]> resultList = result.getResultList(); final int updateCount = result.getUpdateCount(); if (requiresWrapping) { // NOTE: Hibernate will return the object directly for single attribute case instead of an object array int size = resultList.size(); List<Object[]> newResultList = new ArrayList<>(size); for (int i = 0; i < size; i++) { newResultList.add(new Object[]{ resultList.get(i) }); } resultList = newResultList; } return new DefaultReturningResult<T>(resultList, updateCount, dbmsDialect, objectBuilder); } }
String sql = extendedQuerySupport.getSql(em, baseQuery); String ownerAlias = extendedQuerySupport.getSqlAlias(em, baseQuery, entityAlias); String targetAlias = extendedQuerySupport.getSqlAlias(em, baseQuery, CollectionDeleteModificationQuerySpecification.COLLECTION_BASE_QUERY_ALIAS); JoinTable joinTable = mainQuery.jpaProvider.getJoinTable(entityType, collectionName); if (joinTable == null) {
protected void initialize() { List<Query> participatingQueries = new ArrayList<>(); for (Map.Entry<String, Collection<?>> entry : listParameters.entrySet()) { baseQuery.setParameter(entry.getKey(), entry.getValue()); } String sqlQuery = extendedQuerySupport.getSql(em, baseQuery); StringBuilder sqlSb = applySqlTransformations(sqlQuery); StringBuilder withClause = applyCtes(sqlSb, baseQuery, participatingQueries); Map<String, String> addedCtes = applyExtendedSql(sqlSb, false, false, withClause, null, null); participatingQueries.add(baseQuery); this.sql = sqlSb.toString(); this.participatingQueries = participatingQueries; this.addedCtes = addedCtes; this.dirty = false; }
private String getSql(Query query) { if (query instanceof CustomSQLQuery) { return ((CustomSQLQuery) query).getSql(); } else if (query instanceof CustomSQLTypedQuery<?>) { return ((CustomSQLTypedQuery<?>) query).getSql(); } return extendedQuerySupport.getSql(em, query); }
@Override protected void initialize() { List<Query> participatingQueries = new ArrayList<Query>(); for (Map.Entry<String, Collection<?>> entry : listParameters.entrySet()) { baseQuery.setParameter(entry.getKey(), entry.getValue()); } String sqlQuery = extendedQuerySupport.getSql(em, baseQuery); StringBuilder sqlSb = applySqlTransformations(sqlQuery); StringBuilder withClause = applyCtes(sqlSb, baseQuery, participatingQueries); // NOTE: CTEs will only be added, if this is a subquery Map<String, String> addedCtes = applyExtendedSql(sqlSb, false, isEmbedded, withClause, returningColumns, includedModificationStates); participatingQueries.add(baseQuery); // Some dbms like DB2 will need to wrap modification queries in select queries when using CTEs boolean hasCtes = withClause != null && withClause.length() != 0 || addedCtes != null && !addedCtes.isEmpty(); if (hasCtes && returningAttributeBindingMap.isEmpty() && !dbmsDialect.usesExecuteUpdateWhenWithClauseInModificationQuery()) { query = exampleQuery; } else { query = baseQuery; } this.sql = sqlSb.toString(); this.participatingQueries = participatingQueries; this.addedCtes = addedCtes; this.dirty = false; }