public QuerySelect copy() { QuerySelect copy = new QuerySelect(dialect); copy.joins = this.joins.copy(); copy.select.append(this.select.toString()); copy.where.append(this.where.toString()); copy.groupBy.append(this.groupBy.toString()); copy.orderBy.append(this.orderBy.toString()); copy.having.append(this.having.toString()); copy.comment = this.comment; copy.distinct = this.distinct; return copy; }
private void renderPropertiesSelect(QuerySelect sql) { int size = returnedTypes.size(); for (int k = 0; k < size; k++) { String suffix = size == 1 ? "" : Integer.toString(k) + '_'; String name = (String) returnedTypes.get(k); sql.addSelectFragmentString(persisters[k].propertySelectFragment(name, suffix, false)); } }
private void renderSQL() throws QueryException, MappingException { final int rtsize; if (returnedTypes.size() == 0 && scalarTypes.size() == 0) { // ie no select clause in HQL returnedTypes = fromTypes; rtsize = returnedTypes.size(); } else { rtsize = returnedTypes.size(); Iterator iter = entitiesToFetch.iterator(); while (iter.hasNext()) { returnedTypes.add(iter.next()); } } int size = returnedTypes.size(); persisters = new Queryable[size]; names = new String[size]; owners = new int[size]; ownerAssociationTypes = new EntityType[size]; suffixes = new String[size]; includeInSelect = new boolean[size]; for (int i = 0; i < size; i++) { String name = (String) returnedTypes.get(i); // if ( !isName(name) ) throw new QueryException("unknown type: " + name); persisters[i] = getEntityPersisterForName(name); // TODO: cannot use generateSuffixes() - it handles the initial suffix differently. suffixes[i] = (size == 1) ? "" : Integer.toString(i) + '_'; names[i] = name; includeInSelect[i] = !entitiesToFetch.contains(name); if (includeInSelect[i]) selectLength++; if (name.equals(collectionOwnerName)) collectionOwnerColumn = i; String oneToOneOwner = (String) oneToOneOwnerNames.get(name); owners[i] = (oneToOneOwner == null) ? -1 : returnedTypes.indexOf(oneToOneOwner); ownerAssociationTypes[i] = (EntityType) uniqueKeyOwnerReferences.get(name); } if (ArrayHelper.isAllNegative(owners)) owners = null; String scalarSelect = renderScalarSelect(); // Must be done here because of side-effect! yuck... int scalarSize = scalarTypes.size(); hasScalars = scalarTypes.size() != rtsize; returnTypes = new Type[scalarSize]; for (int i = 0; i < scalarSize; i++) { returnTypes[i] = (Type) scalarTypes.get(i); } QuerySelect sql = new QuerySelect(getFactory().getDialect()); sql.setDistinct(distinct); if (!shallowQuery) { renderIdentifierSelect(sql); renderPropertiesSelect(sql); } if (collectionPersister != null) { sql.addSelectFragmentString(collectionPersister.selectFragment(fetchName, "__")); } if (hasScalars || shallowQuery) sql.addSelectFragmentString(scalarSelect); // TODO: for some dialects it would be appropriate to add the renderOrderByPropertiesSelect() to // other select strings mergeJoins(sql.getJoinFragment()); sql.setWhereTokens(whereTokens.iterator()); sql.setGroupByTokens(groupByTokens.iterator()); sql.setHavingTokens(havingTokens.iterator()); sql.setOrderByTokens(orderByTokens.iterator()); if (collectionPersister != null && collectionPersister.hasOrdering()) { sql.addOrderBy(collectionPersister.getSQLOrderByString(fetchName)); } scalarColumnNames = NameGenerator.generateColumnNames(returnTypes, getFactory()); // initialize the Set of queried identifier spaces (ie. tables) Iterator iter = collections.values().iterator(); while (iter.hasNext()) { CollectionPersister p = getCollectionPersister((String) iter.next()); addQuerySpaces(p.getCollectionSpaces()); } iter = typeMap.keySet().iterator(); while (iter.hasNext()) { Queryable p = getEntityPersisterForName((String) iter.next()); addQuerySpaces(p.getQuerySpaces()); } sqlString = sql.toQueryString(); if (holderClass != null) holderConstructor = ReflectHelper.getConstructor(holderClass, returnTypes); if (hasScalars) { actualReturnTypes = returnTypes; } else { actualReturnTypes = new Type[selectLength]; int j = 0; for (int i = 0; i < persisters.length; i++) { if (includeInSelect[i]) { actualReturnTypes[j++] = getFactory() .getTypeResolver() .getTypeFactory() .manyToOne(persisters[i].getEntityName(), shallowQuery); } } } }