Refine search
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"); } }
@Override public List<String> getCaseSensitiveTableNames(String caseInsensitiveSchemaName) throws SchemaNotFoundException { KeyspaceMetadata keyspace = getKeyspaceByCaseInsensitiveName(caseInsensitiveSchemaName); ImmutableList.Builder<String> builder = ImmutableList.builder(); for (TableMetadata table : keyspace.getTables()) { builder.add(table.getName()); } for (MaterializedViewMetadata materializedView : keyspace.getMaterializedViews()) { builder.add(materializedView.getName()); } return builder.build(); }
@Override public List<String> getCaseSensitiveSchemaNames() { ImmutableList.Builder<String> builder = ImmutableList.builder(); List<KeyspaceMetadata> keyspaces = executeWithSession(session -> session.getCluster().getMetadata().getKeyspaces()); for (KeyspaceMetadata meta : keyspaces) { builder.add(meta.getName()); } return builder.build(); }
private static AbstractTableMetadata getTableMetadata(KeyspaceMetadata keyspace, String caseInsensitiveTableName) { List<AbstractTableMetadata> tables = Stream.concat( keyspace.getTables().stream(), keyspace.getMaterializedViews().stream()) .filter(table -> table.getName().equalsIgnoreCase(caseInsensitiveTableName)) .collect(toImmutableList()); if (tables.size() == 0) { throw new TableNotFoundException(new SchemaTableName(keyspace.getName(), caseInsensitiveTableName)); } else if (tables.size() == 1) { return tables.get(0); } String tableNames = tables.stream() .map(AbstractTableMetadata::getName) .sorted() .collect(joining(", ")); throw new PrestoException( NOT_SUPPORTED, format("More than one table has been found for the case insensitive table name: %s -> (%s)", caseInsensitiveTableName, tableNames)); }
@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 } }
@Test(groups = "short") public void should_store_type_definitions_in_their_keyspace() throws Exception { KeyspaceMetadata thisKeyspace = cluster().getMetadata().getKeyspace(this.keyspace); // Types that don't exist don't have definitions assertThat(thisKeyspace.getUserType("address1")).isNull(); assertThat(thisKeyspace.getUserType("phone1")).isNull(); // Types created by this test have definitions assertThat(thisKeyspace.getUserType(quote("\"User Address\""))).isNotNull(); assertThat(thisKeyspace.getUserType("phone")).isNotNull(); // If we create another keyspace, it doesn't have the definitions of this keyspace String otherKeyspaceName = this.keyspace + "_nonEx"; session() .execute( "CREATE KEYSPACE " + otherKeyspaceName + " " + "WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor': '1'}"); KeyspaceMetadata otherKeyspace = cluster().getMetadata().getKeyspace(otherKeyspaceName); assertThat(otherKeyspace.getUserType(quote("\"User Address\""))).isNull(); assertThat(otherKeyspace.getUserType("phone")).isNull(); }
.execute(SchemaBuilder.createKeyspace(keyspace).with().replication(replicationOptions)); Session session = cluster().connect(keyspace); session.execute(SchemaBuilder.createType("xtype").addColumn("d", DataType.text())); session.execute( SchemaBuilder.createType("ctype") .addColumn("\"Z\"", ks.getUserType("ztype").copy(true)) .addColumn("x", ks.getUserType("xtype").copy(true))); session.execute( SchemaBuilder.createType("atype").addColumn("c", ks.getUserType("ctype").copy(true))); SchemaBuilder.createTable("ztable") .addPartitionKey("zkey", DataType.text()) .addColumn("a", ks.getUserType("atype").copy(true)) .withOptions() .compactionOptions(SchemaBuilder.leveledStrategy().ssTableSizeInMB(95))); assertThat(ks.exportAsString().trim()).isEqualTo(getExpectedCqlString()); newCluster.init(); ks = newCluster.getMetadata().getKeyspace(keyspace); assertThat(ks.exportAsString().trim()).isEqualTo(getExpectedCqlString()); } finally { newCluster.close();
@Test(groups = "short") @CassandraVersion("2.1.0") public void should_parse_UDT_definitions_when_using_default_protocol_version() { Cluster.builder() .addContactPoints(getContactPoints().get(0)) .withPort(ccm().getBinaryPort()) .build()); Session session = cluster.connect(); session.execute( "create keyspace ks WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}"); session.execute("create type ks.foo (i int)"); cluster.close(); .withPort(ccm().getBinaryPort()) .build()); UserType fooType = cluster2.getMetadata().getKeyspace("ks").getUserType("foo");
@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") public void should_parse_virtual_metadata() { KeyspaceMetadata km = session().getCluster().getMetadata().getKeyspace("system_views"); assertThat(km.getTables().size() >= 2); assertThat(km.isVirtual()).isTrue(); assertThat(km.isDurableWrites()).isFalse(); assertThat(km.getName()).isEqualTo("system_views"); assertThat(km.getUserTypes().size()).isEqualTo(0); assertThat(km.getFunctions().size()).isEqualTo(0); assertThat(km.getMaterializedViews().size()).isEqualTo(0); assertThat(km.getAggregates().size()).isEqualTo(0); assertThat(km.asCQLQuery()) .isEqualTo( "/* VIRTUAL KEYSPACE system_views WITH REPLICATION = { 'class' : 'null' } " TableMetadata tm = km.getTable("clients"); assertThat(tm).isNotNull(); 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");
@Test(groups = "short") public void should_create_view_metadata() { 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();
/** * 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"); } }
private List<String> generateTableList() { List<String> tableList = new ArrayList<>(); for (TableMetadata tableMetadata : this.session.getCluster().getMetadata().getKeyspace(this.keyspace) .getTables()) { tableList.add(tableMetadata.getName()); } return tableList; }
@Override public void clearStorage() throws BackendException { if (this.storageConfig.get(DROP_ON_CLEAR)) { this.session.execute(dropKeyspace(this.keyspace)); } else if (this.exists()) { final Future<Seq<ResultSet>> result = Future.sequence( Iterator.ofAll(this.cluster.getMetadata().getKeyspace(this.keyspace).getTables()) .map(table -> Future.fromJavaFuture(this.session.executeAsync(truncate(this.keyspace, table.getName()))))); result.await(); } else { LOGGER.info("Keyspace {} does not exist in the cluster", this.keyspace); } }
protected UserType getUserType(String userType) { return getSession().getCluster().getMetadata().getKeyspace(KAA).getUserType(userType); }
@Override public void run() { Cluster cluster = null; try { // Send TASK_RUNNING sendStatus(driver, Protos.TaskState.TASK_RUNNING, "Started taking schema backup"); cluster = Cluster.builder().addContactPoint(daemon.getProbe().getEndpoint()).build(); final List<String> keyspaces = StorageUtil.filterSystemKeyspaces(daemon.getNonSystemKeySpaces()); if (keyspaces.size() > 0) { StringBuilder sb = new StringBuilder(); for (String keyspace : keyspaces) { LOGGER.info("Taking schema backup for keyspace: {}", keyspace); KeyspaceMetadata ksm = cluster.getMetadata().getKeyspace(keyspace); sb.append(ksm.exportAsString()).append(System.getProperty("line.separator")); } backupStorageDriver.uploadSchema(context, sb.toString()); } // Send TASK_FINISHED sendStatus(driver, Protos.TaskState.TASK_FINISHED, "Finished taking schema backup for keyspaces: " + keyspaces); } catch (Throwable t){ LOGGER.error("Schema backup failed. Reason: ", t); sendStatus(driver, Protos.TaskState.TASK_FAILED, t.getMessage()); } finally { if (cluster != null) cluster.close(); } }
@Override public Boolean call() throws Exception { return cluster().getMetadata().getKeyspace(keyspace).getTable("user") != null; } };
public List<String> getTableNames(String keySpace) { Metadata clusterMetadata = cluster.getMetadata(); KeyspaceMetadata keyspaceMetadata = clusterMetadata.getKeyspace(keySpace); if (keyspaceMetadata == null) { return ImmutableList.of(); } return keyspaceMetadata.getTables().stream() .map(TableMetadata::getName) .collect(toList()); }
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); }
private void assertExists(String fetchName, String realName) { KeyspaceMetadata km = cluster().getMetadata().getKeyspace(fetchName); assertNotNull(km); assertEquals(realName, km.getName()); }