public SelectItem getSelectItem(Column column) { if (column != null) { for (SelectItem item : getItems()) { if (column.equals(item.getColumn())) { return item; } } } return null; }
@Override public FilterBuilder<RowDeletionBuilder> where(Column column) { final SelectItem selectItem = new SelectItem(column); return new AbstractFilterBuilder<RowDeletionBuilder>(selectItem) { @Override protected RowDeletionBuilder applyFilter(FilterItem filter) { return where(filter); } }; }
@Override public List<InputColumn<?>> getInputColumns() { final List<InputColumn<?>> result = new ArrayList<>(); final List<SelectItem> selectItems = _row.getSelectItems(); for (final SelectItem selectItem : selectItems) { if (selectItem.getColumn() != null && selectItem.getAggregateFunction() == null) { result.add(new MetaModelInputColumn(selectItem.getColumn())); } } return result; } }
public static boolean isCountAllItem(SelectItem item) { if (item != null && item.getAggregateFunction() != null && item.getAggregateFunction().toString().equals("COUNT") && item.getExpression() == "*") { return true; } return false; }
private static void validateSoqlSupportedSelectItem(SelectItem selectItem) throws UnsupportedOperationException { if (selectItem.hasFunction()) { throw new UnsupportedOperationException("Function select items not supported: " + selectItem); } if (selectItem.getSubQuerySelectItem() != null) { throw new UnsupportedOperationException("Subquery select items not supported: " + selectItem); } }
public Query select(Column... columns) { for (Column column : columns) { SelectItem selectItem = new SelectItem(column); selectItem.setQuery(this); _selectClause.addItem(selectItem); } return this; }
Column column = item.getColumn(); if (column != null) { Object value = row.getValue(new SelectItem(column)); objects.add(value); } else if (SelectItem.isCountAllItem(item)) { Object functionResult = item.getAggregateFunction().evaluate(objects.toArray()); resultRow[i] = functionResult; } else { if (item.getAggregateFunction() != null) { logger.error("No function input found for SelectItem: {}", item);
final Column column = selectItem.getColumn(); final Object operand = whereItem.getOperand(); if (column == null || operand == null || !column.isPrimaryKey() || selectItem.hasFunction()) { throw new IllegalStateException( "HBase currently only supports deleting items by their row key. Violated by where item: "
if (selectItem.hasFunction() || selectItem.getColumn() == null) { allSelectItemsAreColumns = false; break; final FilterItem whereItem = whereItems.get(0); final SelectItem selectItem = whereItem.getSelectItem(); if (!whereItem.isCompoundFilter() && selectItem != null && selectItem.getColumn() != null) { final Column column = selectItem.getColumn(); if (column.isPrimaryKey() && OperatorType.EQUALS_TO.equals(whereItem.getOperator())) { logger.debug( if (selectItem.getAlias() != null) { thereIsAtLeastOneAlias = true; break;
private boolean isOptimizable(FilterItem whereItem) { if (whereItem.isCompoundFilter()) { return false; } if (whereItem.getExpression() != null) { return false; } final SelectItem selectItem = whereItem.getSelectItem(); if (selectItem.getExpression() != null || selectItem.getAggregateFunction() != null || selectItem .getScalarFunction() != null) { return false; } final Column column = selectItem.getColumn(); if (column == null) { return false; } switch (column.getName()) { case COLUMN_OFFSET: return OPTIMIZED_OFFSET_OPERATORS.contains(whereItem.getOperator()); case COLUMN_PARTITION: return OPTIMIZED_PARTITION_OPERATORS.contains(whereItem.getOperator()); default: return false; } }
for (int i = 0; i < values.length; i++) { final SelectItem selectItem = header.getSelectItem(i); final Column column = selectItem.getColumn(); assert selectItem.getAggregateFunction() == null; assert selectItem.getScalarFunction() == null;
if (SelectItem.isCountAllItem(selectItem)) { final boolean functionApproximationAllowed = selectItem.isFunctionApproximationAllowed(); if (isMainSchemaTable(table)) { logger.debug("Query is a COUNT query with {} where items. Trying executeCountQuery(...)", final FilterItem whereItem = whereItems.get(0); final SelectItem selectItem = whereItem.getSelectItem(); if (!whereItem.isCompoundFilter() && selectItem != null && !selectItem.hasFunction() && selectItem.getColumn() != null) { final Column column = selectItem.getColumn(); if (column.isPrimaryKey() && OperatorType.EQUALS_TO.equals(whereItem.getOperator())) { logger.debug(
@Override public List<InputColumn<?>> getInputColumns() { List<InputColumn<?>> result = new ArrayList<InputColumn<?>>(); SelectItem[] selectItems = _row.getSelectItems(); for (SelectItem selectItem : selectItems) { if (selectItem.getColumn() != null && selectItem.getFunction() == null) { result.add(new MetaModelInputColumn(selectItem.getColumn())); } } return result; } }
final AggregateFunction aggregateFunction = selectItem.getAggregateFunction(); if (aggregateFunction != null && !_queryRewriter.isAggregateFunctionSupported(aggregateFunction)) { throw new MetaModelException("Aggregate function '" + aggregateFunction.getFunctionName() for (Iterator<SelectItem> it = scalarFunctionSelectItems.iterator(); it.hasNext();) { final SelectItem selectItem = (SelectItem) it.next(); if (_queryRewriter.isScalarFunctionSupported(selectItem.getScalarFunction())) { it.remove();
public static DataSet getSelection(final List<SelectItem> selectItems, final DataSet dataSet) { final List<SelectItem> dataSetSelectItems = dataSet.getSelectItems(); // check if the selection is already the same if (selectItems.equals(dataSetSelectItems)) { // return the DataSet unmodified return dataSet; } final List<SelectItem> scalarFunctionSelectItemsToEvaluate = new ArrayList<>(); for (SelectItem selectItem : selectItems) { if (selectItem.getScalarFunction() != null) { if (!dataSetSelectItems.contains(selectItem) && dataSetSelectItems.contains(selectItem.replaceFunction(null))) { scalarFunctionSelectItemsToEvaluate.add(selectItem); } } } if (scalarFunctionSelectItemsToEvaluate.isEmpty()) { return new SubSelectionDataSet(selectItems, dataSet); } final ScalarFunctionDataSet scalaFunctionDataSet = new ScalarFunctionDataSet(scalarFunctionSelectItemsToEvaluate, dataSet); return new SubSelectionDataSet(selectItems, scalaFunctionDataSet); }
public static List<SelectItem> getAggregateFunctionSelectItems(Iterable<SelectItem> selectItems) { return CollectionUtils.filter(selectItems, arg -> { return arg.getAggregateFunction() != null; }); }
@Override public Object getValue(int index) throws IndexOutOfBoundsException { final List<SelectItem> scalarFunctionSelectItems = _scalarFunctionDataSet .getScalarFunctionSelectItemsToEvaluate(); final int scalarFunctionCount = scalarFunctionSelectItems.size(); if (index >= scalarFunctionCount) { return _row.getValue(index - scalarFunctionCount); } final SelectItem selectItem = scalarFunctionSelectItems.get(index); final SelectItem selectItemWithoutFunction = selectItem.replaceFunction(null); return selectItem.getScalarFunction().evaluate(_row, selectItem.getFunctionParameters(), selectItemWithoutFunction); }
/** * @return an alias that can be used in WHERE, GROUP BY and ORDER BY clauses in the same query */ public String getSameQueryAlias(boolean includeSchemaInColumnPath) { if (_column != null) { final StringBuilder sb = new StringBuilder(); final String columnPrefix = getToStringColumnPrefix(includeSchemaInColumnPath); sb.append(columnPrefix); sb.append(_column.getQuotedName()); appendFunctionSql(sb); return sb.toString(); } final String alias = getAlias(); if (alias == null) { final String result = toStringNoAlias(includeSchemaInColumnPath).toString(); logger.debug("Could not resolve a reasonable same-query alias for SelectItem: {}", result); return result; } return alias; }
@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; }
/** * Gets select items with scalar functions that haven't already been materialized in a data set. * * @param selectItems * @param dataSetWithMaterializedSelectItems a {@link DataSet} containing the already materialized select items * @return */ public static List<SelectItem> getUnmaterializedScalarFunctionSelectItems(Iterable<SelectItem> selectItems, DataSet dataSetWithMaterializedSelectItems) { return CollectionUtils.filter(selectItems, arg -> { return arg.getScalarFunction() != null && (dataSetWithMaterializedSelectItems == null || dataSetWithMaterializedSelectItems.indexOf(arg) == -1); }); }