private void renderNonScalarSelects(
SelectExpression[] selectExpressions, FromClause currentFromClause) throws SemanticException {
ASTAppender appender = new ASTAppender(getASTFactory(), this);
final int size = selectExpressions.length;
int nonscalarSize = 0;
for (int i = 0; i < size; i++) {
if (!selectExpressions[i].isScalar()) nonscalarSize++;
}
int j = 0;
for (int i = 0; i < size; i++) {
if (!selectExpressions[i].isScalar()) {
SelectExpression expr = selectExpressions[i];
FromElement fromElement = expr.getFromElement();
if (fromElement != null) {
renderNonScalarIdentifiers(fromElement, nonscalarSize, j, expr, appender);
j++;
}
}
}
if (!currentFromClause.isSubQuery()) {
// Generate the property select tokens.
int k = 0;
for (int i = 0; i < size; i++) {
if (!selectExpressions[i].isScalar()) {
FromElement fromElement = selectExpressions[i].getFromElement();
if (fromElement != null) {
renderNonScalarProperties(appender, fromElement, nonscalarSize, k);
k++;
}
}
}
}
}
private void renderScalarSelects(SelectExpression[] se, FromClause currentFromClause)
throws SemanticException {
if (!currentFromClause.isSubQuery()) {
for (int i = 0; i < se.length; i++) {
SelectExpression expr = se[i];
expr.setScalarColumn(i); // Create SQL_TOKEN nodes for the columns.
}
}
}
private boolean isReturnableEntity(SelectExpression selectExpression) throws SemanticException {
FromElement fromElement = selectExpression.getFromElement();
boolean isFetchOrValueCollection =
fromElement != null
&& (fromElement.isFetch() || fromElement.isCollectionOfValuesOrComponents());
if (isFetchOrValueCollection) {
return false;
} else {
return selectExpression.isReturnableEntity();
}
}
/**
* This method is no longer needed. Pass the Select object directly to the query.
*
* @return
*/
@Deprecated
@SuppressWarnings({"unchecked", "rawtypes"})
@Override
public Expression<T> createSelection() {
List<Expression<?>> properties = new ArrayList<>();
for (SelectExpression<?> expression : this.selectionMap.values()) {
properties.add(expression.createSelection());
}
Expression<?>[] array = properties.toArray(new Expression<?>[properties.size()]);
if (this.alias != null) {
return new QChildBean(this.resultType, array).as(this.alias);
} else {
return Projections.bean(this.resultType, array);
}
}
public AnsiSelectBuilder filter(final WhereClause whereClause) {
return from(
grammar,
selectExpression(
expression.setQuantifier(),
expression.selectList(),
expression.fromClause(),
some(combine(expression.whereClause(), whereClause)),
expression.orderByClause(),
expression.groupByClause(),
expression.offsetClause(),
expression.fetchClause()));
}
public AnsiSelectBuilder select(final SelectList selectList) {
return from(
grammar,
selectExpression(
expression.setQuantifier(),
selectList,
expression.fromClause(),
expression.whereClause(),
expression.orderByClause(),
expression.groupByClause(),
expression.offsetClause(),
expression.fetchClause()));
}
public AnsiSelectBuilder groupBy(final GroupByClause groupByClause) {
return from(
grammar,
selectExpression(
expression.setQuantifier(),
expression.selectList(),
expression.fromClause(),
expression.whereClause(),
expression.orderByClause(),
some(groupByClause),
expression.offsetClause(),
expression.fetchClause()));
}
private void renderNonScalarIdentifiers(
FromElement fromElement,
int nonscalarSize,
int j,
SelectExpression expr,
ASTAppender appender) {
String text = fromElement.renderIdentifierSelect(nonscalarSize, j);
if (!fromElement.getFromClause().isSubQuery()) {
if (!scalarSelect && !getWalker().isShallowQuery()) {
// TODO: is this a bit ugly?
expr.setText(text);
} else {
appender.append(SqlTokenTypes.SQL_TOKEN, text, false);
}
}
}
@Override
public AnsiSelectBuilder distinct() {
return from(
grammar,
selectExpression(
Option.<SetQuantifier>some(DISTINCT),
expression.selectList(),
expression.fromClause(),
expression.whereClause(),
expression.orderByClause(),
expression.groupByClause(),
expression.offsetClause(),
expression.fetchClause()));
}
@Override
public AnsiSelectBuilder fetch(int number) {
return from(
grammar,
selectExpression(
expression.setQuantifier(),
expression.selectList(),
expression.fromClause(),
expression.whereClause(),
expression.orderByClause(),
expression.groupByClause(),
expression.offsetClause(),
some(grammar.fetchClause(number))));
}
@Override
public AnsiSelectBuilder count() {
return from(
grammar,
selectExpression(
expression.setQuantifier(),
grammar.selectList(countStar()),
expression.fromClause(),
expression.whereClause(),
Option.<OrderByClause>none(),
expression.groupByClause(),
expression.offsetClause(),
expression.fetchClause()));
}
/**
* Prepares an explicitly defined select clause.
*
* @param fromClause The from clause linked to this select clause.
* @throws SemanticException indicates a semntic issue with the explicit select clause.
*/
public void initializeExplicitSelectClause(FromClause fromClause) throws SemanticException {
if (prepared) {
throw new IllegalStateException("SelectClause was already prepared!");
}
// explicit = true; // This is an explict Select.
// ArrayList sqlResultTypeList = new ArrayList();
ArrayList queryReturnTypeList = new ArrayList();
// First, collect all of the select expressions.
// NOTE: This must be done *before* invoking setScalarColumnText() because setScalarColumnText()
// changes the AST!!!
SelectExpression[] selectExpressions = collectSelectExpressions();
// we only support parameters in select in the case of INSERT...SELECT statements
if (getParameterPositions().size() > 0
&& getWalker().getStatementType() != HqlSqlTokenTypes.INSERT) {
throw new QueryException(
"Parameters are only supported in SELECT clauses when used as part of a INSERT INTO DML statement");
}
for (int i = 0; i < selectExpressions.length; i++) {
SelectExpression selectExpression = selectExpressions[i];
if (AggregatedSelectExpression.class.isInstance(selectExpression)) {
aggregatedSelectExpression = (AggregatedSelectExpression) selectExpression;
queryReturnTypeList.addAll(aggregatedSelectExpression.getAggregatedSelectionTypeList());
scalarSelect = true;
} else {
// we have no choice but to do this check here
// this is not very elegant but the "right way" would most likely involve a bigger rewrite
// so as to
// treat ParameterNodes in select clauses as SelectExpressions
boolean inSubquery =
selectExpression instanceof QueryNode
&& ((QueryNode) selectExpression).getFromClause().getParentFromClause() != null;
if (getWalker().getStatementType() == HqlSqlTokenTypes.INSERT && inSubquery) {
// we do not support parameters for subqueries in INSERT...SELECT
if (((QueryNode) selectExpression).getSelectClause().getParameterPositions().size() > 0) {
throw new QueryException(
"Use of parameters in subqueries of INSERT INTO DML statements is not supported.");
}
}
Type type = selectExpression.getDataType();
if (type == null) {
throw new IllegalStateException(
"No data type for node: "
+ selectExpression.getClass().getName()
+ " "
+ new ASTPrinter(SqlTokenTypes.class).showAsString((AST) selectExpression, ""));
}
// sqlResultTypeList.add( type );
// If the data type is not an association type, it could not have been in the FROM clause.
if (selectExpression.isScalar()) {
scalarSelect = true;
}
if (isReturnableEntity(selectExpression)) {
fromElementsForLoad.add(selectExpression.getFromElement());
}
// Always add the type to the return type list.
queryReturnTypeList.add(type);
}
}
// init the aliases, after initing the constructornode
initAliases(selectExpressions);
if (!getWalker().isShallowQuery()) {
// add the fetched entities
List fromElements = fromClause.getProjectionList();
ASTAppender appender =
new ASTAppender(getASTFactory(), this); // Get ready to start adding nodes.
int size = fromElements.size();
Iterator iterator = fromElements.iterator();
for (int k = 0; iterator.hasNext(); k++) {
FromElement fromElement = (FromElement) iterator.next();
if (fromElement.isFetch()) {
FromElement origin = null;
if (fromElement.getRealOrigin() == null) {
// work around that crazy issue where the tree contains
// "empty" FromElements (no text); afaict, this is caused
// by FromElementFactory.createCollectionJoin()
if (fromElement.getOrigin() == null) {
throw new QueryException(
"Unable to determine origin of join fetch ["
+ fromElement.getDisplayText()
+ "]");
} else {
origin = fromElement.getOrigin();
}
} else {
origin = fromElement.getRealOrigin();
}
if (!fromElementsForLoad.contains(origin)) {
throw new QueryException(
"query specified join fetching, but the owner "
+ "of the fetched association was not present in the select list "
+ "["
+ fromElement.getDisplayText()
+ "]");
}
Type type = fromElement.getSelectType();
addCollectionFromElement(fromElement);
if (type != null) {
boolean collectionOfElements = fromElement.isCollectionOfValuesOrComponents();
if (!collectionOfElements) {
// Add the type to the list of returned sqlResultTypes.
fromElement.setIncludeSubclasses(true);
fromElementsForLoad.add(fromElement);
// sqlResultTypeList.add( type );
// Generate the select expression.
String text = fromElement.renderIdentifierSelect(size, k);
SelectExpressionImpl generatedExpr =
(SelectExpressionImpl) appender.append(SqlTokenTypes.SELECT_EXPR, text, false);
if (generatedExpr != null) {
generatedExpr.setFromElement(fromElement);
}
}
}
}
}
// generate id select fragment and then property select fragment for
// each expression, just like generateSelectFragments().
renderNonScalarSelects(collectSelectExpressions(), fromClause);
}
if (scalarSelect || getWalker().isShallowQuery()) {
// If there are any scalars (non-entities) selected, render the select column aliases.
renderScalarSelects(selectExpressions, fromClause);
}
finishInitialization(/*sqlResultTypeList,*/ queryReturnTypeList);
}
@Override
public Sequence<Keyword<?>> fields() {
return SelectList.methods.fields(expression.selectList());
}
@Override
public Sequence<Object> parameters() {
return expression.parameters();
}
@Override
public String text() {
return expression.text();
}
