private static void checkColumnNames(List<ColumnMetadata> columns) { Map<String, ColumnMetadata> lowercaseNameToColumnMap = new HashMap<>(); for (ColumnMetadata column : columns) { String lowercaseName = column.getName().toLowerCase(ENGLISH); if (lowercaseNameToColumnMap.containsKey(lowercaseName)) { throw new PrestoException( NOT_SUPPORTED, format("More than one column has been found for the case insensitive column name: %s -> (%s, %s)", lowercaseName, lowercaseNameToColumnMap.get(lowercaseName).getName(), column.getName())); } lowercaseNameToColumnMap.put(lowercaseName, column); } }
checkColumnNames(columns); for (ColumnMetadata columnMetadata : columns) { columnNames.add(columnMetadata.getName()); primaryKeySet.add(columnMeta.getName()); boolean hidden = hiddenColumns.contains(columnMeta.getName()); CassandraColumnHandle columnHandle = buildColumnHandle(tableMeta, columnMeta, true, false, columnNames.indexOf(columnMeta.getName()), hidden); columnHandles.add(columnHandle); primaryKeySet.add(columnMeta.getName()); boolean hidden = hiddenColumns.contains(columnMeta.getName()); CassandraColumnHandle columnHandle = buildColumnHandle(tableMeta, columnMeta, false, true, columnNames.indexOf(columnMeta.getName()), hidden); columnHandles.add(columnHandle); if (!primaryKeySet.contains(columnMeta.getName())) { boolean hidden = hiddenColumns.contains(columnMeta.getName()); CassandraColumnHandle columnHandle = buildColumnHandle(tableMeta, columnMeta, false, false, columnNames.indexOf(columnMeta.getName()), hidden); columnHandles.add(columnHandle);
private CassandraColumnHandle buildColumnHandle(AbstractTableMetadata tableMetadata, ColumnMetadata columnMeta, boolean partitionKey, boolean clusteringKey, int ordinalPosition, boolean hidden) { CassandraType cassandraType = CassandraType.getCassandraType(columnMeta.getType().getName()); List<CassandraType> typeArguments = null; if (cassandraType != null && cassandraType.getTypeArgumentSize() > 0) { List<DataType> typeArgs = columnMeta.getType().getTypeArguments(); switch (cassandraType.getTypeArgumentSize()) { case 1: typeArguments = ImmutableList.of(CassandraType.getCassandraType(typeArgs.get(0).getName())); break; case 2: typeArguments = ImmutableList.of(CassandraType.getCassandraType(typeArgs.get(0).getName()), CassandraType.getCassandraType(typeArgs.get(1).getName())); break; default: throw new IllegalArgumentException("Invalid type arguments: " + typeArgs); } } boolean indexed = false; SchemaTableName schemaTableName = new SchemaTableName(tableMetadata.getKeyspace().getName(), tableMetadata.getName()); if (!isMaterializedView(schemaTableName)) { TableMetadata table = (TableMetadata) tableMetadata; for (IndexMetadata idx : table.getIndexes()) { if (idx.getTarget().equals(columnMeta.getName())) { indexed = true; break; } } } return new CassandraColumnHandle(connectorId, columnMeta.getName(), ordinalPosition, cassandraType, typeArguments, partitionKey, clusteringKey, indexed, hidden); }
void add(ColumnMetadata column) { columns.put(column.getName(), column); }
private static void maybeGetIndex( String name, int j, List<ColumnMetadata> pkColumns, int[] pkIndexes) { if (pkColumns == null) return; for (int i = 0; i < pkColumns.size(); ++i) { if (name.equals(pkColumns.get(i).getName())) { // We may have the same column prepared multiple times, but only pick the first value pkIndexes[i] = j; return; } } }
private StringBuilder appendClusteringOrder(StringBuilder sb) { sb.append("CLUSTERING ORDER BY ("); for (int i = 0; i < clusteringColumns.size(); i++) { if (i > 0) sb.append(", "); sb.append(Metadata.quoteIfNecessary(clusteringColumns.get(i).getName())) .append(' ') .append(clusteringOrder.get(i)); } return sb.append(')'); }
void maybeAddRoutingKey(String name, Object value) { if (routingKeyValues == null || name == null || value == null || Utils.containsSpecialValue(value)) return; for (int i = 0; i < partitionKey.size(); i++) { if (Utils.handleId(name).equals(partitionKey.get(i).getName())) { routingKeyValues.set(i, value); return; } } }
private static String targetFromLegacyOptions( ColumnMetadata column, Map<String, String> options) { String columnName = Metadata.quoteIfNecessary(column.getName()); if (options.containsKey(INDEX_KEYS_OPTION_NAME)) return String.format("keys(%s)", columnName); if (options.containsKey(INDEX_ENTRIES_OPTION_NAME)) return String.format("entries(%s)", columnName); if (column.getType() instanceof DataType.CollectionType && column.getType().isFrozen()) return String.format("full(%s)", columnName); // Note: the keyword 'values' is not accepted as a valid index target function until 3.0 return columnName; }
public ColumnMetadataAssert hasName(String name) { assertThat(actual.getName()).isEqualTo(name); return this; }
while (it.hasNext()) { ColumnMetadata column = it.next(); sb.append(Metadata.quoteIfNecessary(column.getName())); if (it.hasNext()) sb.append(", "); sb.append(Metadata.quoteIfNecessary(partitionKey.get(0).getName())); } else { sb.append('('); if (first) first = false; else sb.append(", "); sb.append(Metadata.quoteIfNecessary(cm.getName())); sb.append(", ").append(Metadata.quoteIfNecessary(cm.getName())); sb.append(')');
@Override public void deleteByColumn(String schemaName, String tableName, String columnName, Object columnValue) { Session session = factory.getConnection(); String rowKeyName = null; CQLTranslator translator = new CQLTranslator(); try { List<ColumnMetadata> primaryKeys = session.getCluster().getMetadata().getKeyspace("\"" + schemaName + "\"") .getTable("\"" + tableName + "\"").getPrimaryKey(); rowKeyName = primaryKeys.get(0).getName(); } finally { // factory.releaseConnection(session); } List rowKeys = getColumnsById(schemaName, tableName, columnName, rowKeyName, columnValue, columnValue.getClass()); for (Object rowKey : rowKeys) { if (rowKey != null) { String deleteQuery = CQLTranslator.DELETE_QUERY; deleteQuery = StringUtils.replace(deleteQuery, CQLTranslator.COLUMN_FAMILY, translator.ensureCase(new StringBuilder(), tableName, false).toString()); StringBuilder deleteQueryBuilder = new StringBuilder(deleteQuery); deleteQueryBuilder.append(CQLTranslator.ADD_WHERE_CLAUSE); deleteQueryBuilder = translator.ensureCase(deleteQueryBuilder, rowKeyName, false); deleteQueryBuilder.append(CQLTranslator.EQ_CLAUSE); translator.appendValue(deleteQueryBuilder, rowKey.getClass(), rowKey, false, false); this.execute(deleteQueryBuilder.toString(), null); } } }
for (ColumnMetadata c : partitionKey) columns.put(c.getName(), c); for (ColumnMetadata c : clusteringColumns) columns.put(c.getName(), c); for (ColumnMetadata c : otherColumns) columns.put(c.getName(), c); return tm; for (ColumnMetadata c : partitionKey) columns.put(c.getName(), c); for (ColumnMetadata c : clusteringColumns) columns.put(c.getName(), c); for (ColumnMetadata c : otherColumns) columns.put(c.getName(), c);
final String column = columnsToGrab.get(i % columnsToGrab.size()).getName(); String query = String.format("select %s from system.local", column); ResultSetFuture future = session().executeAsync(query);
assertThat(tm.getColumns().size()).isEqualTo(12); assertThat(tm.getPartitionKey().size()).isEqualTo(1); assertThat(tm.getPartitionKey().get(0).getName()).isEqualTo("address"); assertThat(tm.getClusteringColumns().size()).isEqualTo(1); assertThat(tm.getClusteringColumns().get(0).getName()).isEqualTo("port"); assertThat(tm.getIndexes().size()).isEqualTo(0); assertThat(tm.getViews().size()).isEqualTo(0); assertThat(cm.getParent()).isEqualTo(tm); assertThat(cm.getType()).isEqualTo(DataType.text()); assertThat(cm.getName()).isEqualTo("driver_name");
/** * add where clauses for partition keys and cluster columns */ private String appendKeyWhereClauses(String cqlQuery) { String keyWhereClause = ""; for (ColumnMetadata partitionKey : partitionKeyColumns) keyWhereClause += String.format("%s = ?", keyWhereClause.isEmpty() ? quote(partitionKey.getName()) : (" AND " + quote(partitionKey.getName()))); for (ColumnMetadata clusterColumn : clusterColumns) keyWhereClause += " AND " + quote(clusterColumn.getName()) + " = ?"; return cqlQuery + " WHERE " + keyWhereClause; }
public RowIterator() { AbstractType type = partitioner.getTokenValidator(); ResultSet rs = session.execute(cqlQuery, type.compose(type.fromString(split.getStartToken())), type.compose(type.fromString(split.getEndToken())) ); for (ColumnMetadata meta : cluster.getMetadata().getKeyspace(quote(keyspace)).getTable(quote(cfName)).getPartitionKey()) partitionBoundColumns.put(meta.getName(), Boolean.TRUE); rows = rs.iterator(); }
private static String deleteQuery(TableMetadata tableMetadata) { Delete delete = QueryBuilder.delete().from(tableMetadata); Delete.Where where = delete.where(); List<ColumnMetadata> columns = tableMetadata.getPrimaryKey(); for(ColumnMetadata column : columns) { where.and(QueryBuilder.eq(column.getName(), QueryBuilder.bindMarker())); } return delete.toString(); }