Refine search
Delete(TableMetadata table, List<Selector> columns) { this( Metadata.quoteIfNecessary(table.getKeyspace().getName()), Metadata.quoteIfNecessary(table.getName()), Arrays.asList(new Object[table.getPartitionKey().size()]), table.getPartitionKey(), columns); }
public TableMetadataAssert hasNumberOfColumns(int expected) { assertThat(actual.getColumns().size()).isEqualTo(expected); return this; }
@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); } } }
while (it.hasNext()) { TableMetadata oldTable = it.next(); String tableName = oldTable.getName(); && !newTables.containsKey(tableName)) { it.remove(); metadata.triggerOnTableRemoved(oldTable); TableMetadata oldTable = oldTables.put(newTable.getName(), newTable); if (oldTable == null) { metadata.triggerOnTableAdded(newTable); } else { for (MaterializedViewMetadata view : oldTable.getViews()) { view.setBaseTable(newTable); if (!oldTable.equals(newTable)) { metadata.triggerOnTableChanged(newTable, oldTable);
TableMetadata.build( keyspace, tableDef, cassandraVersion, cluster); tables.put(table.getName(), table); } catch (RuntimeException e) { "Error parsing schema for table %s.%s: " + "Cluster.getMetadata().getKeyspace(\"%s\").getTable(\"%s\") will be missing or incomplete", keyspace.getName(), cfName, keyspace.getName(), cfName), e);
private Iterator<Row> getNextRange() { if (logger.isDebugEnabled()) logger.debug(String.format("Processing new token range. %d more to go!", tokenRanges.length - currentRange)); TokenRangeHolder range = tokenRanges[currentRange]; Object startToken = validatorType.compose(validatorType.fromString(range.getStartToken())); Object endToken = validatorType.compose(validatorType.fromString(range.getEndToken())); logger.debug("Fetching rows with Query: " + cqlQuery + " in range start: [" + startToken + "] + and end: [" + endToken + "]"); ResultSet rs = session.execute(cqlQuery, startToken, endToken); for (ColumnMetadata meta : cluster.getMetadata().getKeyspace(keyspace).getTable(cfName).getPartitionKey()) partitionBoundColumns.put(meta.getName(), Boolean.TRUE); currentRange++; return rs.iterator(); }
@Test(groups = "short") public void should_escape_single_quote_table_comment() { // given String cql = String.format( "CREATE TABLE %s.single_quote (\n" + " c1 int PRIMARY KEY\n" + ") WITH comment = 'comment with single quote '' should work'", keyspace); // when session().execute(cql); TableMetadata table = cluster().getMetadata().getKeyspace(keyspace).getTable("single_quote"); // then assertThat(table.getOptions().getComment()) .isEqualTo("comment with single quote ' should work"); assertThat(table.asCQLQuery()).contains("comment = 'comment with single quote '' should work'"); }
@Test(groups = "short") public void should_parse_counter_table() { // given String cql = String.format( "CREATE TABLE %s.counters (\n" + " k text,\n" + " c counter,\n" + " PRIMARY KEY (k)\n" + ");", keyspace); // when session().execute(cql); TableMetadata table = cluster().getMetadata().getKeyspace(keyspace).getTable("counters"); // then assertThat(table).isNotNull().hasName("counters").hasNumberOfColumns(2).isNotCompactStorage(); assertThat(table.getColumns().get(0)).isNotNull().hasName("k").isPartitionKey().hasType(text()); assertThat(table.getColumns().get(1)) .isNotNull() .hasName("c") .isRegularColumn() .hasType(counter()); }
@Test(groups = "short") @CassandraVersion(value = "3.6", description = "Non-frozen UDTs were introduced in C* 3.6") public void should_indicate_user_type_is_not_frozen() { session().execute("CREATE TABLE not_frozen_table(k int primary key, v type_for_frozen_test)"); KeyspaceMetadata keyspaceMetadata = cluster().getMetadata().getKeyspace(this.keyspace); assertThat(keyspaceMetadata.getUserType("type_for_frozen_test")).isNotFrozen(); DataType userType = keyspaceMetadata.getTable("not_frozen_table").getColumn("v").getType(); assertThat(userType).isNotFrozen(); assertThat(userType.toString()).isEqualTo(keyspace + ".type_for_frozen_test"); ResultSet rs = session().execute("SELECT v FROM not_frozen_table WHERE k = 1"); assertThat(rs.getColumnDefinitions().getType(0)).isNotFrozen(); PreparedStatement pst = session().prepare("SELECT v FROM not_frozen_table WHERE k = ?"); assertThat(pst.getVariables().getType(0)).isNotFrozen(); } }
@Test(groups = "short") public void should_parse_virtual_metadata() { KeyspaceMetadata km = session().getCluster().getMetadata().getKeyspace("system_views"); assertThat(tm.getName()).isEqualTo("clients"); assertThat(tm.isVirtual()).isTrue(); 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(tm.getClusteringColumns().size()).isEqualTo(1); assertThat(tm.getClusteringOrder().size()).isEqualTo(1); assertThat(tm.getId()).isEqualTo(new UUID(0L, 0L)); assertThat(tm.getOptions()).isNull(); assertThat(tm.getKeyspace()).isEqualTo(km); assertThat(tm.asCQLQuery()) .isEqualTo( "/* VIRTUAL TABLE system_views.clients (address inet, port int, " + "PRIMARY KEY (address, port)) */"); ColumnMetadata cm = tm.getColumn("driver_name"); assertThat(cm).isNotNull(); assertThat(cm.getParent()).isEqualTo(tm);
/** * Validates that columns using collections of custom types are properly handled by the driver. * * @jira_ticket JAVA-1034 * @test_category metadata */ @Test(groups = "short") public void should_serialize_and_deserialize_collections_of_custom_types() { TestUtils.compactStorageSupportCheck(ccm()); TableMetadata table = cluster().getMetadata().getKeyspace(keyspace).getTable("test_collection"); assertThat(table.getColumn("c1")).hasType(DataType.list(CUSTOM_DYNAMIC_COMPOSITE)); assertThat(table.getColumn("c2")) .hasType(DataType.map(CUSTOM_DYNAMIC_COMPOSITE, CUSTOM_DYNAMIC_COMPOSITE)); session() .execute( "INSERT INTO test_collection(k, c1, c2) VALUES (0, [ 's@foo:i@32' ], { 's@foo:i@32': 's@bar:i@42' })"); Row r = session().execute("SELECT * FROM test_collection").one(); assertThat(r.getColumnDefinitions().getType("c1")) .isEqualTo(DataType.list(CUSTOM_DYNAMIC_COMPOSITE)); List<ByteBuffer> c1 = r.getList("c1", ByteBuffer.class); assertThat(c1.get(0)).isEqualTo(serializeForDynamicCompositeType("foo", 32)); assertThat(r.getColumnDefinitions().getType("c2")) .isEqualTo(DataType.map(CUSTOM_DYNAMIC_COMPOSITE, CUSTOM_DYNAMIC_COMPOSITE)); Map<ByteBuffer, ByteBuffer> c2 = r.getMap("c2", ByteBuffer.class, ByteBuffer.class); Map.Entry<ByteBuffer, ByteBuffer> entry = c2.entrySet().iterator().next(); assertThat(entry.getKey()).isEqualTo(serializeForDynamicCompositeType("foo", 32)); assertThat(entry.getValue()).isEqualTo(serializeForDynamicCompositeType("bar", 42)); }
CqlRecordWriter(Configuration conf) { this.conf = conf; this.queueSize = conf.getInt(CqlOutputFormat.QUEUE_SIZE, 32 * FBUtilities.getAvailableProcessors()); batchThreshold = conf.getLong(CqlOutputFormat.BATCH_THRESHOLD, 32); this.clients = new HashMap<>(); String keyspace = ConfigHelper.getOutputKeyspace(conf); try (Cluster cluster = CqlConfigHelper.getOutputCluster(ConfigHelper.getOutputInitialAddress(conf), conf)) { Metadata metadata = cluster.getMetadata(); ringCache = new NativeRingCache(conf, metadata); TableMetadata tableMetadata = metadata.getKeyspace(Metadata.quote(keyspace)).getTable(ConfigHelper.getOutputColumnFamily(conf)); clusterColumns = tableMetadata.getClusteringColumns(); partitionKeyColumns = tableMetadata.getPartitionKey(); String cqlQuery = CqlConfigHelper.getOutputCql(conf).trim(); if (cqlQuery.toLowerCase(Locale.ENGLISH).startsWith("insert")) throw new UnsupportedOperationException("INSERT with CqlRecordWriter is not supported, please use UPDATE/DELETE statement"); cql = appendKeyWhereClauses(cqlQuery); } catch (Exception e) { throw new RuntimeException(e); } }
Cluster cluster = session.getCluster(); KeyspaceMetadata keyspaceMetadata = cluster.getMetadata().getKeyspace(keyspace); TableMetadata tableMetadata = keyspaceMetadata.getTable(table); String column = field.getColumnName(); String fieldType = field.getDataType().name(); ColumnMetadata columnMetadata = tableMetadata.getColumn(column); } else if (!fieldType.equals(columnMetadata.getType().getName().name())) { if (tableMetadata.getClusteringColumns().contains(columnMetadata)) { continue; if (tableMetadata.getPrimaryKey().contains(columnMetadata)) { continue; for (ColumnMetadata colmeta: tableMetadata.getColumns()) { colmeta.getName(); boolean exists = false; for (EntityFieldMetaData field: entityMetadata.getFields()) { if (colmeta.getName().equalsIgnoreCase(field.getColumnName())) { exists = true; break;
keyspace, keyspace); session().execute(createTable); session().execute(createMV); TableMetadata table = cluster().getMetadata().getKeyspace(keyspace).getTable("\"T1\""); MaterializedViewMetadata mv = cluster().getMetadata().getKeyspace(keyspace).getMaterializedView("\"Mv1\""); assertThat(table).isNotNull().hasName("T1").hasMaterializedView(mv).hasNumberOfColumns(3); assertThat(table.getViews()).hasSize(1).containsOnly(mv); assertThat(table.getColumns().get(0)) .isNotNull() .hasName("theKey") .isPartitionKey() .hasType(cint()); assertThat(table.getColumns().get(1)) .isNotNull() .hasName("the;Clustering") .isClusteringColumn() .hasType(cint()); assertThat(table.getColumns().get(2)) .isNotNull() .hasName("the Value")
session().execute(createTable); session().execute(createMV); TableMetadata table = cluster().getMetadata().getKeyspace(keyspace).getTable("scores"); MaterializedViewMetadata mv = cluster().getMetadata().getKeyspace(keyspace).getMaterializedView("monthlyhigh"); assertThat(table.getColumns().get(0)).isNotNull().hasName("user").isPartitionKey(); assertThat(table.getColumns().get(1)).isNotNull().hasName("game").isClusteringColumn(); assertThat(table.getColumns().get(2)).isNotNull().hasName("year").isClusteringColumn(); assertThat(table.getColumns().get(3)).isNotNull().hasName("month").isClusteringColumn(); assertThat(table.getColumns().get(4)).isNotNull().hasName("day").isClusteringColumn(); assertThat(table.getColumns().get(5)).isNotNull().hasName("score").isRegularColumn(); .hasBaseTable(table) .hasNumberOfColumns(6) .isEqualTo(table.getView("monthlyhigh")); assertThat(mv.getColumns().get(0)).isNotNull().hasName("game").isPartitionKey(); assertThat(mv.getColumns().get(1)).isNotNull().hasName("year").isPartitionKey();
cluster().getMetadata().getKeyspace("system").getTable("local").getColumns(); assertThat(columnsToGrab.size()).isGreaterThan(1); final String column = columnsToGrab.get(i % columnsToGrab.size()).getName(); String query = String.format("select %s from system.local", column); ResultSetFuture future = session().executeAsync(query);
public void refreshTablenames() { Collection<TableMetadata> tableMetadatas = session.getCluster().getMetadata() .getKeyspace(STREAMING.STREAMING_KEYSPACE_NAME).getTables(); tablenames = new HashMap<>(); for (TableMetadata tableMetadata : tableMetadatas) { Set<String> columns = new HashSet<>(); for (ColumnMetadata columnMetadata : tableMetadata.getColumns()) { columns.add(columnMetadata.getName()); } tablenames.put(tableMetadata.getName(), columns.hashCode()); } }
public List<String> getColumnNames(String keySpace, String tableName) { checkState(tableExists(keySpace, tableName), "table %s.%s does not exist", keySpace, tableName); KeyspaceMetadata keyspaceMetadata = session.getCluster().getMetadata().getKeyspace(keySpace); TableMetadata tableMetadata = keyspaceMetadata.getTable(tableName); return tableMetadata.getColumns().stream().map(ColumnMetadata::getName).collect(toList()); }
/** * Because of the way databus tables were created historically using Astyanax and Cassandra 1.2 there may be * inconsistency in the names of the CQL columns in the subscription table. To be safe read the table metadata * to get the column names. */ private void getColumnNames() { TableMetadata table = _keyspace.getKeyspaceMetadata().getTable(CF_NAME); _rowkeyColumn = table.getPrimaryKey().get(0).getName(); _subscriptionNameColumn = table.getPrimaryKey().get(1).getName(); _subscriptionColumn = table.getColumns().get(2).getName(); } }
/** * Return true if column values for the given keyspace/table name are binary. * * @param keyspace Keyspace name. * @param storeName Store (ColumnFamily) name. * @return True if the given table's column values are binary. */ public boolean columnValueIsBinary(String keyspace, String storeName) { String cqlKeyspace = storeToCQLName(keyspace); String tableName = storeToCQLName(storeName); KeyspaceMetadata ksMetadata = m_cluster.getMetadata().getKeyspace(cqlKeyspace); TableMetadata tableMetadata = ksMetadata.getTable(tableName); ColumnMetadata colMetadata = tableMetadata.getColumn("value"); return colMetadata.getType().equals(DataType.blob()); } // columnValueIsBinary