/** * Filters the FilterItems such that only the FilterItems are returned, which contain SelectItems that are contained * in selectItemList * * @param filters * @param selectItemList * @return */ private static Set<FilterItem> applicableFilters(Collection<FilterItem> filters, Collection<SelectItem> selectItemList) { Set<SelectItem> items = new HashSet<SelectItem>(selectItemList); return filters.stream().filter(fi -> { Collection<SelectItem> fiSelectItems = new ArrayList<>(); fiSelectItems.add(fi.getSelectItem()); Object operand = fi.getOperand(); if (operand instanceof SelectItem) { fiSelectItems.add((SelectItem) operand); } return items.containsAll(fiSelectItems); }).collect(Collectors.toSet()); }
/** * Filters the FilterItems such that only the FilterItems are returned, which contain SelectItems that are contained * in selectItemList * * @param filters * @param selectItemList * @return */ private static Set<FilterItem> applicableFilters(Collection<FilterItem> filters, Collection<SelectItem> selectItemList) { Set<SelectItem> items = new HashSet<SelectItem>(selectItemList); return filters.stream().filter(fi -> { Collection<SelectItem> fiSelectItems = new ArrayList<>(); fiSelectItems.add(fi.getSelectItem()); Object operand = fi.getOperand(); if (operand instanceof SelectItem) { fiSelectItems.add((SelectItem) operand); } return items.containsAll(fiSelectItems); }).collect(Collectors.toSet()); }
private static void addEvaluatedSelectItems(List<SelectItem> result, FilterItem item) { final FilterItem[] orItems = item.getChildItems(); if (orItems != null) { for (FilterItem filterItem : orItems) { addEvaluatedSelectItems(result, filterItem); } } final SelectItem selectItem = item.getSelectItem(); if (selectItem != null && !result.contains(selectItem)) { result.add(selectItem); } final Object operand = item.getOperand(); if (operand != null && operand instanceof SelectItem && !result.contains(operand)) { result.add((SelectItem) operand); } }
private static void addEvaluatedSelectItems(List<SelectItem> result, FilterItem item) { final FilterItem[] orItems = item.getChildItems(); if (orItems != null) { for (FilterItem filterItem : orItems) { addEvaluatedSelectItems(result, filterItem); } } final SelectItem selectItem = item.getSelectItem(); if (selectItem != null && !result.contains(selectItem)) { result.add(selectItem); } final Object operand = item.getOperand(); if (operand != null && operand instanceof SelectItem && !result.contains(operand)) { result.add((SelectItem) operand); } }
/** * Rewrites a (non-compound) {@link FilterItem} when it's operand has already been rewritten into a SQL literal. * * @param item * @param operandLiteral * @return */ protected String rewriteFilterItemWithOperandLiteral(FilterItem item, String operandLiteral) { final OperatorType operator = item.getOperator(); final SelectItem selectItem = item.getSelectItem(); final StringBuilder sb = new StringBuilder(); sb.append(selectItem.getSameQueryAlias(false)); FilterItem.appendOperator(sb, item.getOperand(), operator); sb.append(operandLiteral); return sb.toString(); }
private static String buildWhereClauseItem(final FilterItem whereItem, final String queryObjectHandle) { final StringBuilder whereClauseItemBuilder = new StringBuilder(); whereClauseItemBuilder.append(queryObjectHandle); whereClauseItemBuilder.append("."); whereClauseItemBuilder.append(whereItem.getSelectItem().getColumn().getName()); whereClauseItemBuilder.append(whereItem.getOperator().toSql()); final Object operand = whereItem.getOperand(); if (operand instanceof String) { whereClauseItemBuilder.append("\""); } whereClauseItemBuilder.append(operand); if (operand instanceof String) { whereClauseItemBuilder.append("\""); } return whereClauseItemBuilder.toString(); } }
/** * Rewrites a (non-compound) {@link FilterItem} when it's operand has already been rewritten into a SQL literal. * * @param item * @param operandLiteral * @return */ protected String rewriteFilterItemWithOperandLiteral(FilterItem item, String operandLiteral) { final OperatorType operator = item.getOperator(); final SelectItem selectItem = item.getSelectItem(); final StringBuilder sb = new StringBuilder(); sb.append(selectItem.getSameQueryAlias(false)); FilterItem.appendOperator(sb, item.getOperand(), operator); sb.append(operandLiteral); return sb.toString(); }
public static DataSet getFiltered(DataSet dataSet, Collection<FilterItem> filterItems) { if (filterItems == null || filterItems.isEmpty()) { return dataSet; } final List<SelectItem> selectItemsOnOutput = dataSet.getSelectItems(); final Iterable<SelectItem> selectItems = filterItems.stream().map(f -> f.getSelectItem()).filter(s -> s != null)::iterator; final List<SelectItem> scalarFunctionSelectItems = getUnmaterializedScalarFunctionSelectItems(selectItems, dataSet); final boolean calculateScalarFunctions = !scalarFunctionSelectItems.isEmpty(); if (calculateScalarFunctions) { // scalar functions are needed in evaluation of the filters dataSet = new ScalarFunctionDataSet(scalarFunctionSelectItems, dataSet); } final FilteredDataSet filteredDataSet = new FilteredDataSet(dataSet, filterItems); if (calculateScalarFunctions) { return getSelection(selectItemsOnOutput, filteredDataSet); } else { return filteredDataSet; } }
public static DataSet getFiltered(DataSet dataSet, Collection<FilterItem> filterItems) { if (filterItems == null || filterItems.isEmpty()) { return dataSet; } final List<SelectItem> selectItemsOnOutput = dataSet.getSelectItems(); final Iterable<SelectItem> selectItems = filterItems.stream().map(f -> f.getSelectItem()).filter(s -> s != null)::iterator; final List<SelectItem> scalarFunctionSelectItems = getUnmaterializedScalarFunctionSelectItems(selectItems, dataSet); final boolean calculateScalarFunctions = !scalarFunctionSelectItems.isEmpty(); if (calculateScalarFunctions) { // scalar functions are needed in evaluation of the filters dataSet = new ScalarFunctionDataSet(scalarFunctionSelectItems, dataSet); } final FilteredDataSet filteredDataSet = new FilteredDataSet(dataSet, filterItems); if (calculateScalarFunctions) { return getSelection(selectItemsOnOutput, filteredDataSet); } else { return filteredDataSet; } }
/** * @throws MetaModelException when value is null */ @Override public synchronized void execute() { final List<FilterItem> whereItems = getWhereItems(); if (whereItems == null || whereItems.size() == 0) { throw new IllegalArgumentException("HBase currently only supports deleting items by their row key."); } final FilterItem filterItem = whereItems.get(0); if (!HBaseDataContext.FIELD_ID.equals(filterItem.getSelectItem().getColumn().getName())) { throw new IllegalArgumentException("HBase currently only supports deleting items by their row key."); } getRowKeys(filterItem).forEach(rowKey -> _dataContext.getHBaseClient().deleteRow(getTable().getName(), rowKey)); }
/** * @throws MetaModelException when value is null */ @Override public synchronized void execute() { final List<FilterItem> whereItems = getWhereItems(); if (whereItems == null || whereItems.size() == 0) { throw new IllegalArgumentException("HBase currently only supports deleting items by their row key."); } final FilterItem filterItem = whereItems.get(0); if (!HBaseDataContext.FIELD_ID.equals(filterItem.getSelectItem().getColumn().getName())) { throw new IllegalArgumentException("HBase currently only supports deleting items by their row key."); } getRowKeys(filterItem).forEach(rowKey -> _dataContext.getHBaseClient().deleteRow(getTable().getName(), rowKey)); }
@Override public String rewriteFilterItem(FilterItem item) { if (!item.isCompoundFilter()) { final SelectItem selectItem = item.getSelectItem(); final Column column = selectItem.getColumn(); if (column != null) { if (column.getType() == ColumnType.TIMESTAMP) { // HSQLDB does not treat (TIMESTAMP 'yyyy-MM-dd hh:mm:ss') // tokens correctly String result = super.rewriteFilterItem(item); int indexOfTimestamp = result.lastIndexOf("TIMESTAMP"); if (indexOfTimestamp != -1) { result = result.substring(0, indexOfTimestamp) + result.substring(indexOfTimestamp + "TIMESTAMP".length()); } return result; } } } return super.rewriteFilterItem(item); }
@Override public String rewriteFilterItem(FilterItem item) { if (!item.isCompoundFilter()) { final SelectItem selectItem = item.getSelectItem(); final Column column = selectItem.getColumn(); if (column != null) { if (column.getType() == ColumnType.TIMESTAMP) { // HSQLDB does not treat (TIMESTAMP 'yyyy-MM-dd hh:mm:ss') // tokens correctly String result = super.rewriteFilterItem(item); int indexOfTimestamp = result.lastIndexOf("TIMESTAMP"); if (indexOfTimestamp != -1) { result = result.substring(0, indexOfTimestamp) + result.substring(indexOfTimestamp + "TIMESTAMP".length()); } return result; } } } return super.rewriteFilterItem(item); }
private DataSet materializeMainSchemaTableInternal(Table table, List<SelectItem> selectItems, List<FilterItem> whereItems, int firstRow, int maxRows, boolean queryPostProcessed) { final List<FilterItem> postProcessWhereItems = new ArrayList<>(); final MongoCursor<Document> cursor = getDocumentMongoCursor(table, whereItems, firstRow, maxRows, whereItem -> { postProcessWhereItems.add(whereItem); }); final DataSet dataSet; if (postProcessWhereItems.isEmpty()) { dataSet = new MongoDbDataSet(cursor, selectItems, queryPostProcessed); } else { final List<SelectItem> selectItemsToQuery = new ArrayList<>(selectItems); postProcessWhereItems.forEach(whereItem -> { final Column column = whereItem.getSelectItem().getColumn(); if (column != null) { // TODO: Minor optimization possible here to avoid having multiple select items for the same column. // We could check if the column is already being queried. selectItemsToQuery.add(new SelectItem(column)); } }); final DataSet innerDataSet1 = new MongoDbDataSet(cursor, selectItemsToQuery, queryPostProcessed); final DataSet innerDataSet2 = MetaModelHelper.getFiltered(innerDataSet1, postProcessWhereItems); dataSet = MetaModelHelper.getSelection(selectItems, innerDataSet2); } return dataSet; }
@Override public String rewriteFilterItem(final FilterItem item) { if (item.getOperand() instanceof String && item.getOperand().equals("")) { // In Oracle empty strings are treated as null. Typical SQL constructs with an empty string do not work. return super.rewriteFilterItem(new FilterItem(item.getSelectItem(), item.getOperator(), null)); } else { return super.rewriteFilterItem(item); } } }
@Override public String rewriteFilterItem(final FilterItem item) { if (item.getOperand() instanceof String && item.getOperand().equals("")) { // In Oracle empty strings are treated as null. Typical SQL constructs with an empty string do not work. return super.rewriteFilterItem(new FilterItem(item.getSelectItem(), item.getOperator(), null)); } else { return super.rewriteFilterItem(item); } } }
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; } }
private FilterItem copyFilterItem(FilterItem item, Object[] values, AtomicInteger parameterIndex) { if (item.isCompoundFilter()) { final FilterItem[] childItems = item.getChildItems(); final FilterItem[] newChildItems = new FilterItem[childItems.length]; for (int i = 0; i < childItems.length; i++) { final FilterItem childItem = childItems[i]; final FilterItem newChildItem = copyFilterItem(childItem, values, parameterIndex); newChildItems[i] = newChildItem; } final FilterItem newFilter = new FilterItem(item.getLogicalOperator(), newChildItems); return newFilter; } else { if (item.getOperand() instanceof QueryParameter) { final Object newOperand = values[parameterIndex.getAndIncrement()]; final FilterItem newFilter = new FilterItem(item.getSelectItem(), item.getOperator(), newOperand); return newFilter; } else { return item; } } }
private FilterItem copyFilterItem(FilterItem item, Object[] values, AtomicInteger parameterIndex) { if (item.isCompoundFilter()) { final FilterItem[] childItems = item.getChildItems(); final FilterItem[] newChildItems = new FilterItem[childItems.length]; for (int i = 0; i < childItems.length; i++) { final FilterItem childItem = childItems[i]; final FilterItem newChildItem = copyFilterItem(childItem, values, parameterIndex); newChildItems[i] = newChildItem; } final FilterItem newFilter = new FilterItem(item.getLogicalOperator(), newChildItems); return newFilter; } else { if (item.getOperand() instanceof QueryParameter) { final Object newOperand = values[parameterIndex.getAndIncrement()]; final FilterItem newFilter = new FilterItem(item.getSelectItem(), item.getOperator(), newOperand); return newFilter; } else { return item; } } }
@Override public void execute() throws MetaModelException { String sql = createSqlStatement(); logger.debug("Delete statement created: {}", sql); final boolean reuseStatement = !_inlineValues; final PreparedStatement st = _updateCallback.getPreparedStatement(sql, reuseStatement, false); try { if (reuseStatement) { int valueCounter = 1; final List<FilterItem> whereItems = getWhereItems(); for (FilterItem whereItem : whereItems) { if (JdbcUtils.isPreparedParameterCandidate(whereItem)) { Object operand = whereItem.getOperand(); _queryRewriter.setStatementParameter(st, valueCounter, whereItem.getSelectItem().getColumn(), operand); valueCounter++; } } } _updateCallback.executeDelete(st, reuseStatement); } catch (SQLException e) { throw JdbcUtils.wrapException(e, "execute delete statement: " + sql, JdbcActionType.UPDATE); } finally { if (_inlineValues) { FileHelper.safeClose(st); } } }