private void checkSizeEstimatesTableExist() { KeyspaceMetadata keyspaceMetadata = executeWithSession(session -> session.getCluster().getMetadata().getKeyspace(SYSTEM)); checkState(keyspaceMetadata != null, "system keyspace metadata must not be null"); TableMetadata table = keyspaceMetadata.getTable(SIZE_ESTIMATES); if (table == null) { throw new PrestoException(NOT_SUPPORTED, "Cassandra versions prior to 2.1.5 are not supported"); } }
private void createTable(TableDefinition tableDefinition, boolean forceCheckSchema) throws Exception { boolean exists; if(!forceCheckSchema){ exists = dataStaxCluster.getClusterSession().getCluster() .getMetadata() .getKeyspace(CQLUtils.quote( tableDefinition.getKeyspace() ) ) .getTable( tableDefinition.getTableName() ) != null; }else{ exists = dataStaxCluster.getClusterSession() .execute("select * from system.schema_columnfamilies where keyspace_name='"+tableDefinition.getKeyspace() +"' and columnfamily_name='"+CQLUtils.unquote(tableDefinition.getTableName())+"'").one() != null; } if( exists ){ logger.info("Not creating table {}, it already exists.", tableDefinition.getTableName()); return; } String CQL = tableDefinition.getTableCQL(cassandraFig, TableDefinition.ACTION.CREATE); if (logger.isDebugEnabled()) { logger.debug(CQL); } if ( tableDefinition.getKeyspace().equals( cassandraFig.getApplicationKeyspace() )) { dataStaxCluster.getApplicationSession().execute( CQL ); } else { dataStaxCluster.getApplicationLocalSession().execute( CQL ); } logger.info("Created table: {} in keyspace {}", tableDefinition.getTableName(), tableDefinition.getKeyspace()); }
@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); } } }
@Test(groups = "short") public void remainingDeleteTests() throws Exception { Statement query; TableMetadata table = cluster().getMetadata().getKeyspace(keyspace).getTable(TABLE_TEXT); assertNotNull(table); String expected = String.format("DELETE k FROM %s.test_text;", keyspace); query = delete("k").from(table); assertEquals(query.toString(), expected); try { session().execute(query); fail(); } catch (SyntaxError e) { // Missing WHERE clause } }
@Override public Boolean call() throws Exception { return cluster().getMetadata().getKeyspace(keyspace).getTable("user") != null; } };
private TableMetadata getTable(String name) { return cluster().getMetadata().getKeyspace(keyspace).getTable(name); }
private static int[] computePkIndices(Metadata clusterMetadata, ColumnDefinitions boundColumns) { List<ColumnMetadata> partitionKeyColumns = null; int[] pkIndexes = null; KeyspaceMetadata km = clusterMetadata.getKeyspace(Metadata.quote(boundColumns.getKeyspace(0))); if (km != null) { TableMetadata tm = km.getTable(Metadata.quote(boundColumns.getTable(0))); if (tm != null) { partitionKeyColumns = tm.getPartitionKey(); pkIndexes = new int[partitionKeyColumns.size()]; for (int i = 0; i < pkIndexes.length; ++i) pkIndexes[i] = -1; } } // Note: we rely on the fact CQL queries cannot span multiple tables. If that change, we'll have // to get smarter. for (int i = 0; i < boundColumns.size(); i++) maybeGetIndex(boundColumns.getName(i), i, partitionKeyColumns, pkIndexes); return allSet(pkIndexes) ? pkIndexes : null; }
@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", dataProvider = "existingKeyspaceName") public void should_notify_of_table_creation(String keyspace) throws InterruptedException { execute(CREATE_TABLE, keyspace); for (SchemaChangeListener listener : listeners) { ArgumentCaptor<TableMetadata> added = ArgumentCaptor.forClass(TableMetadata.class); verify(listener, timeout(NOTIF_TIMEOUT_MS).times(1)).onTableAdded(added.capture()); assertThat(added.getValue()).isInKeyspace(handleId(keyspace)).hasName("table1"); } for (Metadata m : metadatas()) assertThat(m.getKeyspace(keyspace).getTable("table1")).isNotNull(); }
@Test(groups = "short", dataProvider = "existingKeyspaceName") public void should_notify_of_table_drop(String keyspace) throws InterruptedException { execute(CREATE_TABLE, keyspace); for (SchemaChangeListener listener : listeners) { ArgumentCaptor<TableMetadata> added = ArgumentCaptor.forClass(TableMetadata.class); verify(listener, timeout(NOTIF_TIMEOUT_MS).times(1)).onTableAdded(added.capture()); assertThat(added.getValue()).hasName("table1").isInKeyspace(handleId(keyspace)); } execute(DROP_TABLE, keyspace); for (SchemaChangeListener listener : listeners) { ArgumentCaptor<TableMetadata> removed = ArgumentCaptor.forClass(TableMetadata.class); verify(listener, timeout(NOTIF_TIMEOUT_MS).times(1)).onTableRemoved(removed.capture()); assertThat(removed.getValue()).hasName("table1"); } for (Metadata m : metadatas()) assertThat(m.getKeyspace(keyspace).getTable("table1")).isNull(); }
@Test(groups = "short") public void textRoutingKeyTest() throws Exception { BuiltStatement query; TableMetadata table = cluster().getMetadata().getKeyspace(keyspace).getTable(TABLE_TEXT); assertNotNull(table); ProtocolVersion protocolVersion = cluster().getConfiguration().getProtocolOptions().getProtocolVersion(); CodecRegistry codecRegistry = CodecRegistry.DEFAULT_INSTANCE; String txt = "If she weighs the same as a duck... she's made of wood."; query = insertInto(table).values(new String[] {"k", "a", "b"}, new Object[] {txt, 1, 2}); assertEquals( query.getRoutingKey(protocolVersion, codecRegistry), ByteBuffer.wrap(txt.getBytes())); session().execute(query); query = select().from(table).where(eq("k", txt)); assertEquals( query.getRoutingKey(protocolVersion, codecRegistry), ByteBuffer.wrap(txt.getBytes())); Row row = session().execute(query).one(); assertEquals(row.getString("k"), txt); assertEquals(row.getInt("a"), 1); assertEquals(row.getInt("b"), 2); }
@Test(groups = "short") public void should_not_mix_indexes_from_different_tables() { String[] statements = { "CREATE TABLE test_ab (a int PRIMARY KEY, b int);", "CREATE INDEX test_b on test_ab (b);", "CREATE TABLE test_cd (c int PRIMARY KEY, d int);", "CREATE INDEX test_d on test_cd (d);", }; for (String statement : statements) session().execute(statement); TableMetadata table_ab = cluster().getMetadata().getKeyspace(keyspace).getTable("test_ab"); TableMetadata table_cd = cluster().getMetadata().getKeyspace(keyspace).getTable("test_cd"); assertThat(table_ab.getIndexes().size()).isEqualTo(1); assertThat(table_ab.getIndexes()).extracting("name").containsOnly("test_b"); assertThat(table_cd.getIndexes().size()).isEqualTo(1); assertThat(table_cd.getIndexes()).extracting("name").containsOnly("test_d"); }
@Test(groups = "short") public void intRoutingKeyTest() throws Exception { BuiltStatement query; TableMetadata table = cluster().getMetadata().getKeyspace(keyspace).getTable(TABLE_INT); assertNotNull(table); ProtocolVersion protocolVersion = cluster().getConfiguration().getProtocolOptions().getProtocolVersion(); CodecRegistry codecRegistry = CodecRegistry.DEFAULT_INSTANCE; query = insertInto(table).values(new String[] {"k", "a", "b"}, new Object[] {42, 1, 2}); ByteBuffer bb = ByteBuffer.allocate(4); bb.putInt(0, 42); assertEquals(query.getRoutingKey(protocolVersion, codecRegistry), bb); session().execute(query); query = select().from(table).where(eq("k", 42)); assertEquals(query.getRoutingKey(protocolVersion, codecRegistry), bb); Row row = session().execute(query).one(); assertEquals(row.getInt("k"), 42); assertEquals(row.getInt("a"), 1); assertEquals(row.getInt("b"), 2); }
/** * Validates that columns using the duration type are properly represented in {@link * TableMetadata}. * * @jira_ticket JAVA-1347 * @test_category metadata */ @Test(groups = "short") public void should_parse_column_metadata() { // column metadata TableMetadata table = cluster().getMetadata().getKeyspace(keyspace).getTable("test_duration"); assertThat(table.getColumn("c1")).hasType(DataType.duration()); assertThat(table.asCQLQuery()).contains("c1 duration"); } }
@Test(groups = "short") public void routingKeyColumnCaseSensitivityForQuotedIdentifiersTest() throws Exception { BuiltStatement query; TableMetadata table = cluster().getMetadata().getKeyspace(keyspace).getTable(TABLE_CASE_QUOTED); assertNotNull(table); ProtocolVersion protocolVersion = cluster().getConfiguration().getProtocolOptions().getProtocolVersion(); CodecRegistry codecRegistry = CodecRegistry.DEFAULT_INSTANCE; query = insertInto(table) .values( new String[] {"\"theKey\"", "a", "b", "\"tHEkEY\""}, new Object[] {42, 1, 2, 3}); ByteBuffer bb = ByteBuffer.allocate(4); bb.putInt(0, 42); assertEquals(query.getRoutingKey(protocolVersion, codecRegistry), bb); query = insertInto(table) .values(new String[] {"theKey", "a", "b", "\"tHEkEY\""}, new Object[] {42, 1, 2, 3}); assertNull(query.getRoutingKey(protocolVersion, codecRegistry)); query = insertInto(table) .values(new String[] {"theKey", "a", "b", "theKey"}, new Object[] {42, 1, 2, 3}); assertNull(query.getRoutingKey(protocolVersion, codecRegistry)); }
/** * 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)); }
@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_indicate_user_type_is_frozen() { session() .execute("CREATE TABLE frozen_table(k int primary key, v frozen<type_for_frozen_test>)"); KeyspaceMetadata keyspaceMetadata = cluster().getMetadata().getKeyspace(this.keyspace); assertThat(keyspaceMetadata.getUserType("type_for_frozen_test")).isNotFrozen(); DataType userType = keyspaceMetadata.getTable("frozen_table").getColumn("v").getType(); assertThat(userType).isFrozen(); assertThat(userType.toString()).isEqualTo("frozen<" + keyspace + ".type_for_frozen_test>"); // The frozen flag is not set for result set definitions (the protocol does not provide // that information and it's not really useful in that situation). We always return false. ResultSet rs = session().execute("SELECT v FROM frozen_table WHERE k = 1"); assertThat(rs.getColumnDefinitions().getType(0)).isNotFrozen(); // Same thing for prepared statements PreparedStatement pst = session().prepare("SELECT v FROM frozen_table WHERE k = ?"); assertThat(pst.getVariables().getType(0)).isNotFrozen(); }
@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") public void should_parse_dense_table() { TestUtils.compactStorageSupportCheck(ccm()); // given String cql = String.format( "CREATE TABLE %s.dense (\n" + " k int,\n" + " c int,\n" + " PRIMARY KEY (k, c)\n" + " ) WITH COMPACT STORAGE;", keyspace); // when session().execute(cql); TableMetadata table = cluster().getMetadata().getKeyspace(keyspace).getTable("dense"); // then assertThat(table).isNotNull().hasName("dense").hasNumberOfColumns(2).isCompactStorage(); assertThat(table.getColumns().get(0)).isNotNull().hasName("k").isPartitionKey().hasType(cint()); assertThat(table.getColumns().get(1)) .isNotNull() .hasName("c") .isClusteringColumn() .hasType(cint()); }