private FromItem getItemByReference(final FromItem item, final String reference) { if (reference.equals(item.toStringNoAlias(false))) { return item; if (reference.equals(item.toStringNoAlias(true))) { return item; final String alias = item.getAlias(); if (reference.equals(alias)) { return item; final Table table = item.getTable(); if (alias == null && table != null && reference.equals(table.getName())) { return item; final JoinType join = item.getJoin(); if (join != null) { final FromItem leftResult = getItemByReference(item.getLeftSide(), reference); if (leftResult != null) { return leftResult; final FromItem rightResult = getItemByReference(item.getRightSide(), reference); if (rightResult != null) { return rightResult;
public static List<FromItem> getTableFromItems(FromItem item) { List<FromItem> result = new ArrayList<FromItem>(); if (item.getTable() != null) { result.add(item); } else if (item.getSubQuery() != null) { FromItem[] sqItems = getTableFromItems(item.getSubQuery()); for (int i = 0; i < sqItems.length; i++) { result.add(sqItems[i]); } } else if (item.getJoin() != null) { FromItem leftSide = item.getLeftSide(); result.addAll(getTableFromItems(leftSide)); FromItem rightSide = item.getRightSide(); result.addAll(getTableFromItems(rightSide)); } else { throw new IllegalStateException("FromItem was neither of Table type, SubQuery type or Join type: " + item); } return result; }
protected DataSet materializeFromItem(final FromItem fromItem, final List<SelectItem> selectItems) { DataSet dataSet; JoinType joinType = fromItem.getJoin(); if (fromItem.getTable() != null) { final FromItem selectedFromItem = selectItem.getFromItem(); if (selectedFromItem != null) { if (selectedFromItem.equals(fromItem)) { selectItemsToMaterialize.add(selectItem.replaceFunction(null)); if (fromItem.getLeftSide() == null || fromItem.getRightSide() == null) { throw new IllegalArgumentException("Joined FromItem requires both left and right side: " + fromItem); final List<SelectItem> leftOn = Arrays.asList(fromItem.getLeftOn()); fromItemDataSets[0] = materializeFromItem(fromItem.getLeftSide(), CollectionUtils.concat(true, selectItems, leftOn)); final List<SelectItem> rightOn = Arrays.asList(fromItem.getRightOn()); fromItemDataSets[1] = materializeFromItem(fromItem.getRightSide(), CollectionUtils.concat(true, selectItems, rightOn)); throw new IllegalArgumentException("FromItem type not supported: " + fromItem); } else if (fromItem.getSubQuery() != null) { dataSet = executeQuery(fromItem.getSubQuery()); } else { throw new IllegalArgumentException("FromItem type not supported: " + fromItem);
public static Table resolveTable(FromItem fromItem) { final Table table = fromItem.getTable(); return resolveUnderlyingTable(table); }
private Column findColumnInAliasedTable(Column column, FromItem fromItem, String aliasPart, String columnPart) { if (column != null) { // ensure that if the column has already been found, return it return column; } Table table = fromItem.getTable(); if (table != null) { String alias = fromItem.getAlias(); if (alias != null && alias.equals(aliasPart)) { column = table.getColumnByName(columnPart); } } else { FromItem leftSide = fromItem.getLeftSide(); column = findColumnInAliasedTable(column, leftSide, aliasPart, columnPart); FromItem rightSide = fromItem.getRightSide(); column = findColumnInAliasedTable(column, rightSide, aliasPart, columnPart); if (column != null) { Query subQuery = fromItem.getSubQuery(); if (subQuery != null) { List<FromItem> items = subQuery.getFromClause().getItems(); for (FromItem subQueryFromItem : items) { column = findColumnInAliasedTable(column, subQueryFromItem, aliasPart, columnPart); } } } } return column; }
private void replaceParametersInFromClause(Object[] values, AtomicInteger parameterIndex, Query originalQuery, Query newQuery) { final List<FromItem> fromItems = originalQuery.getFromClause().getItems(); int i = 0; for (FromItem fromItem : fromItems) { final Query subQuery = fromItem.getSubQuery(); if (subQuery != null) { final Query newSubQuery = newQuery.getFromClause().getItem(i).getSubQuery(); replaceParametersInQuery(values, parameterIndex, subQuery, newSubQuery); newQuery.getFromClause().removeItem(i); newQuery.getFromClause().addItem(i, new FromItem(newSubQuery).setAlias(fromItem.getAlias())); } i++; } }
public JoinFromBuilderImpl(Query query, FromItem leftItem, Table rightTable, JoinType joinType, DataContext dataContext) { super(query, dataContext); this.joinType = joinType; this.leftItem = leftItem; this.rightItem = new FromItem(rightTable); }
if ("*".equals(columnName)) { throw new MultipleSelectItemsParsedException(fromItem); } else if (fromItem.getTable() != null) { Column column = fromItem.getTable().getColumnByName(columnName); int offset = -1; while (function == null && column == null) { column = fromItem.getTable().getColumnByName(part1); if (column != null) { final String part2 = columnName.substring(offset + 1); return selectItem; } else if (fromItem.getSubQuery() != null) { final Query subQuery = fromItem.getSubQuery(); final SelectItem subQuerySelectItem = new SelectItemParser(subQuery, _allowExpressionBasedSelectItems).findSelectItem(columnName);
private void appendJoinOnItem(StringBuilder sb, String sideAlias, SelectItem onItem) { final FromItem fromItem = onItem.getFromItem(); if (fromItem != null && fromItem.getSubQuery() != null && fromItem.getAlias() != null) { // there's a corner case scenario where an ON item references a // subquery being joined. In that case the getSuperQueryAlias() // method will include the subquery alias. final String superQueryAlias = onItem.getSuperQueryAlias(); sb.append(superQueryAlias); return; } if(_join != null && _leftSide.getJoin() != null) { sb.append(onItem.toSql()); return; } if (sideAlias != null) { sb.append(sideAlias); sb.append('.'); } final String superQueryAlias = onItem.getSuperQueryAlias(); sb.append(superQueryAlias); }
/** * Creates a SelectItem that references another select item in a subquery * * @param subQuerySelectItem * @param subQueryFromItem the FromItem that holds the sub-query */ public SelectItem(SelectItem subQuerySelectItem, FromItem subQueryFromItem) { this(null, subQueryFromItem, null, null, null, subQuerySelectItem, null, false); if (subQueryFromItem.getSubQuery() == null) { throw new IllegalArgumentException("Only sub-query based FromItems allowed."); } if (subQuerySelectItem.getQuery() != null && !subQuerySelectItem.getQuery().equals(subQueryFromItem.getSubQuery())) { throw new IllegalArgumentException("The SelectItem must exist in the sub-query"); } }
@Override protected FromItem clone() { FromItem f = new FromItem(); f._alias = _alias; f._join = _join; f._table = _table; f._expression = _expression; if (_subQuery != null) { f._subQuery = _subQuery.clone(); } if (_leftOn != null && _leftSide != null && _rightOn != null && _rightSide != null) { f._leftSide = _leftSide.clone(); f._leftOn = _leftOn.clone(); f._rightSide = _rightSide.clone(); f._rightOn = _rightOn.clone(); } return f; }
@Override protected Query beforeRewrite(Query query) { query = query.clone(); JdbcDataContext dataContext = getDataContext(); if (dataContext != null) { String identifierQuoteString = dataContext.getIdentifierQuoteString(); if (identifierQuoteString != null) { List<SelectItem> selectItems = query.getSelectClause().getItems(); for (SelectItem item : selectItems) { String alias = item.getAlias(); if (needsQuoting(alias, identifierQuoteString)) { item.setAlias(identifierQuoteString + alias + identifierQuoteString); } } List<FromItem> fromItems = query.getFromClause().getItems(); for (FromItem item : fromItems) { String alias = item.getAlias(); if (needsQuoting(alias, identifierQuoteString)) { item.setAlias(identifierQuoteString + alias + identifierQuoteString); } } } } return query; }
sb.append(')'); } else if (_join != null) { String leftSideAlias = _leftSide.getSameQueryAlias(); String rightSideAlias = _rightSide.getSameQueryAlias(); sb.append(_leftSide.toSql()); sb.append(' '); sb.append(_join); sb.append(" JOIN "); sb.append(_rightSide.toSql()); for (int i = 0; i < _leftOn.length; i++) { if (i == 0) { appendJoinOnItem(sb, leftSideAlias, primary); appendJoinOnItem(sb, rightSideAlias, foreign);
@Override public String toString() { return toSql(); } }
/** * Gets the alias of a table, if it is registered (and visible, ie. not part * of a sub-query) in the FromItem * * @param table * the table to get the alias for * @return the alias or null if none is found */ public String getAlias(Table table) { String result = null; if (table != null) { // Search recursively through left and right side, unless they // are sub-query FromItems if (table.equals(_table)) { result = _alias; } else if (_join != null) { result = _rightSide.getAlias(table); if (result == null) { result = _leftSide.getAlias(table); } } } return result; }
@Override public TableFromBuilder as(String alias) { if (alias == null) { throw new IllegalArgumentException("alias cannot be null"); } fromItem.setAlias(alias); return this; }