@Override public int addColumnForOrdering(ColumnDefinition c) { int index = super.addColumnForOrdering(c); selectors.add(new SimpleSelector(c.name.toString(), index, c.type)); return selectors.size() - 1; } }
/** * Returns the index of the specified column within the resultset * @param c the column * @return the index of the specified column within the resultset or -1 */ public int getResultSetIndex(ColumnDefinition c) { return getColumnIndex(c); }
private void initStaticColumnsInfo() { if (!cfm.hasStaticColumns()) return; // If it's a wildcard, we do select static but not only them if (selection.isWildcard()) { selectsStaticColumns = true; return; } // Otherwise, check the selected columns selectsStaticColumns = !Iterables.isEmpty(Iterables.filter(selection.getColumns(), isStaticFilter)); selectsOnlyStaticColumns = true; for (ColumnDefinition def : selection.getColumns()) { if (def.kind != ColumnDefinition.Kind.PARTITION_KEY && def.kind != ColumnDefinition.Kind.STATIC) { selectsOnlyStaticColumns = false; break; } } }
columnMapping.addMapping(alias == null ? def : makeAliasSpec(cfm, def.type, alias), def); return new SimpleSelector(def.name.toString(), addAndGetIndex(def, defs), def.type); columnMapping.addMapping(makeWritetimeOrTTLSpec(cfm, tot, alias), def); return new WritetimeOrTTLSelector(def.name.toString(), addAndGetIndex(def, defs), tot.isWritetime); Selector selected = makeSelector(cfm, withField.selected, null, defs, tmpMapping); AbstractType<?> type = selected.getType(); if (!(type instanceof UserType)) columnMapping.addMapping(makeFieldSelectSpec(cfm, withField, ut.fieldType(i), alias), tmpMapping.getMappings().values()); return new FieldSelector(ut, i, selected); args.add(makeSelector(cfm, arg, null, defs, tmpMapping)); throw new InvalidRequestException(String.format("Unknown function '%s'", withFun.functionName)); ColumnSpecification spec = makeFunctionSpec(cfm, withFun, returnType, alias); Function fun = Functions.get(cfm.ksName, withFun.functionName, args, spec); if (columnMapping != null)
private static ResultSet buildCasFailureResultSet(ByteBuffer key, ColumnFamily cf, Iterable<ColumnDefinition> columnsWithConditions, boolean isBatch, QueryOptions options) throws InvalidRequestException { CFMetaData cfm = cf.metadata(); Selection selection; if (columnsWithConditions == null) { selection = Selection.wildcard(cfm, false, null); } else { // We can have multiple conditions on the same columns (for collections) so use a set // to avoid duplicate, but preserve the order just to it follows the order of IF in the query in general Set<ColumnDefinition> defs = new LinkedHashSet<>(); // Adding the partition key for batches to disambiguate if the conditions span multipe rows (we don't add them outside // of batches for compatibility sakes). if (isBatch) { defs.addAll(cfm.partitionKeyColumns()); defs.addAll(cfm.clusteringColumns()); } for (ColumnDefinition def : columnsWithConditions) defs.add(def); selection = Selection.forColumns(new ArrayList<>(defs)); } long now = System.currentTimeMillis(); Selection.ResultSetBuilder builder = selection.resultSetBuilder(now); SelectStatement.forSelection(cfm, selection).processColumnFamily(key, cf, options, now, builder); return builder.build(); }
private void processOrderingClause(SelectStatement stmt, CFMetaData cfm) throws InvalidRequestException { verifyOrderingIsAllowed(stmt); // If we order post-query (see orderResults), the sorted column needs to be in the ResultSet for sorting, even if we don't // ultimately ship them to the client (CASSANDRA-4911). if (stmt.keyIsInRelation) { stmt.orderingIndexes = new HashMap<>(); for (ColumnIdentifier.Raw rawColumn : stmt.parameters.orderings.keySet()) { ColumnIdentifier column = rawColumn.prepare(cfm); final ColumnDefinition def = cfm.getColumnDefinition(column); if (def == null) handleUnrecognizedOrderingColumn(column); int index = stmt.selection.getResultSetIndex(def); if (index < 0) index = stmt.selection.addColumnForOrdering(def); stmt.orderingIndexes.put(def.name, index); } } stmt.isReversed = isReversed(stmt, cfm); }
? Selection.wildcard(cfm, parameters.isCount, parameters.countAlias) : Selection.fromSelectors(cfm, selectClause);
private void validateDistinctSelection() throws InvalidRequestException { Collection<ColumnDefinition> requestedColumns = selection.getColumns(); for (ColumnDefinition def : requestedColumns) if (def.kind != ColumnDefinition.Kind.PARTITION_KEY && def.kind != ColumnDefinition.Kind.STATIC) throw new InvalidRequestException(String.format("SELECT DISTINCT queries must only request partition key columns and/or static columns (not %s)", def.name)); // If it's a key range, we require that all partition key columns are selected so we don't have to bother with post-query grouping. if (!isKeyRange) return; for (ColumnDefinition def : cfm.partitionKeyColumns()) if (!requestedColumns.contains(def)) throw new InvalidRequestException(String.format("SELECT DISTINCT queries must request all the partition key columns (missing %s)", def.name)); }
public void newRow() throws InvalidRequestException { if (current != null) resultSet.addRow(handleRow(this)); current = new ArrayList<ByteBuffer>(columns.size()); }
private ResultSetBuilder(long now) { this.resultSet = new ResultSet(getResultMetadata().copy(), new ArrayList<List<ByteBuffer>>()); this.timestamps = collectTimestamps ? new long[columns.size()] : null; this.ttls = collectTTLs ? new int[columns.size()] : null; this.now = now; }
/** Returns true if a non-frozen collection is selected, false otherwise. */ private boolean selectACollection() { if (!cfm.comparator.hasCollections()) return false; for (ColumnDefinition def : selection.getColumns()) { if (def.type.isCollection() && def.type.isMultiCell()) return true; } return false; }
public ResultSet build() throws InvalidRequestException { if (current != null) { resultSet.addRow(handleRow(this)); current = null; } return resultSet; } }
public ResultSet.Metadata getResultMetadata() { return parameters.isCount ? ResultSet.makeCountMetadata(keyspace(), columnFamily(), parameters.countAlias) : selection.getResultMetadata(); }
for (ColumnDefinition def : selection.getColumns()) if (def.kind == ColumnDefinition.Kind.REGULAR || def.kind == ColumnDefinition.Kind.STATIC) columns.add(cfm.comparator.create(prefix, def));
for (ColumnDefinition def : selection.getColumns()) for (ColumnDefinition def : selection.getColumns())