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"); } }
protected UserType getUserType(String userType) { return getSession().getCluster().getMetadata().getKeyspace(KAA).getUserType(userType); }
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()); }
/** * Execute CQL that will create the keyspace if it doesn't exist and alter it if it does. * @throws Exception * @param forceCheck */ @Override public synchronized void createApplicationKeyspace(boolean forceCheck) throws Exception { boolean exists; if(!forceCheck) { // this gets info from client's metadata exists = getClusterSession().getCluster().getMetadata() .getKeyspace(CQLUtils.quote(cassandraConfig.getApplicationKeyspace())) != null; }else{ exists = getClusterSession() .execute("select * from system.schema_keyspaces where keyspace_name = '"+cassandraConfig.getApplicationKeyspace()+"'") .one() != null; } if(exists){ logger.info("Not creating keyspace {}, it already exists.", cassandraConfig.getApplicationKeyspace()); return; } final String createApplicationKeyspace = String.format( "CREATE KEYSPACE IF NOT EXISTS %s WITH replication = %s", CQLUtils.quote( cassandraConfig.getApplicationKeyspace()), CQLUtils.getFormattedReplication( cassandraConfig.getStrategy(), cassandraConfig.getStrategyOptions()) ); getClusterSession().execute(createApplicationKeyspace); waitForSchemaAgreement(); logger.info("Created keyspace: {}", cassandraConfig.getApplicationKeyspace()); }
if(!forceCheck) { exists = getClusterSession().getCluster().getMetadata() .getKeyspace(CQLUtils.quote(cassandraConfig.getApplicationLocalKeyspace())) != null; }else{ exists = getClusterSession()
@SuppressWarnings("unchecked") private UDTValue convertValue(Object value, CassandraEntityMapper<?> mapper, CassandraClient cassandraClient) { String keyspace = cassandraClient.getSession().getLoggedKeyspace(); UserType userType = cassandraClient.getSession() .getCluster() .getMetadata() .getKeyspace(keyspace) .getUserType(mapper.getName()); UDTValue udtValue = userType.newValue(); for (String name : mapper.getNonKeyColumnNames()) { Object fieldValue = mapper.getColumnValueForName(name, value, cassandraClient); if (fieldValue != null) { udtValue.set(name, fieldValue, (Class<Object>) fieldValue.getClass()); } else { udtValue.setToNull(name); } } return udtValue; } }
protected boolean existsKeyspace() { return this.cluster().getMetadata().getKeyspace(this.keyspace) != null; }
private void assertNotExists(String name) { assertNull(cluster().getMetadata().getKeyspace(name)); } }
private void assertExists(String fetchName, String realName) { KeyspaceMetadata km = cluster().getMetadata().getKeyspace(fetchName); assertNotNull(km); assertEquals(realName, km.getName()); }
@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); } } }
@Override public Boolean call() throws Exception { return cluster().getMetadata().getKeyspace(keyspace).getTable("user") != null; } };
private MaterializedViewMetadata getMaterializedView(String name) { return cluster().getMetadata().getKeyspace(keyspace).getMaterializedView(name); } }
private TableMetadata getTable(String name) { return cluster().getMetadata().getKeyspace(keyspace).getTable(name); }
@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_parse_user_defined_type_when_definition_in_old_user_types() { Metadata metadata = cluster().getMetadata(); KeyspaceMetadata keyspaceMetadata = metadata.getKeyspace(this.keyspace); assertThat(parse("\"A\"", cluster(), keyspace, null, keyspaceMetadata.userTypes, false, false)) .isUserType(keyspace, "A"); }
/** * Ensures that if a table is configured with change data capture enabled that {@link * TableOptionsMetadata#isCDC()} returns true for that table. * * @test_category metadata * @jira_ticket JAVA-1287 * @jira_ticket CASSANDRA-12041 */ @Test(groups = "short") public void should_parse_cdc_from_table_options() { // given // create a simple table with cdc as true. String cql = String.format( "CREATE TABLE %s.cdc_table (\n" + " k text,\n" + " c int,\n" + " v timeuuid,\n" + " PRIMARY KEY (k, c)\n" + ") WITH cdc=true;", keyspace); session().execute(cql); // when retrieving the table's metadata. TableMetadata table = cluster().getMetadata().getKeyspace(keyspace).getTable("cdc_table"); // then the table's options should have cdc as true. assertThat(table.getOptions().isCDC()).isEqualTo(true); assertThat(table.asCQLQuery(true)).contains("cdc = true"); } }
@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_user_defined_type_when_definition_in_current_user_types() { Metadata metadata = cluster().getMetadata(); KeyspaceMetadata keyspaceMetadata = metadata.getKeyspace(this.keyspace); assertThat( parse( "frozen<\"A\">", cluster(), keyspace, keyspaceMetadata.userTypes, null, false, false)) .isUserType(keyspace, "A"); }
@Test(groups = "short") public void insertUdtTest() throws Exception { UserType udtType = cluster().getMetadata().getKeyspace(keyspace).getUserType("udt"); UDTValue udtValue = udtType.newValue().setInt("i", 2).setInet("a", InetAddress.getByName("localhost")); Statement insert = insertInto("udtTest").value("k", 1).value("t", udtValue); assertEquals(insert.toString(), "INSERT INTO udtTest (k,t) VALUES (1,{i:2,a:'127.0.0.1'});"); session().execute(insert); List<Row> rows = session().execute(select().from("udtTest").where(eq("k", 1))).all(); assertEquals(rows.size(), 1); Row r1 = rows.get(0); assertEquals("127.0.0.1", r1.getUDTValue("t").getInet("a").getHostAddress()); }
@Test(groups = "short") public void should_handle_UDT_with_many_fields() throws Exception { int MAX_TEST_LENGTH = 1024; // create the seed udt StringBuilder sb = new StringBuilder(); for (int i = 0; i < MAX_TEST_LENGTH; ++i) { sb.append(String.format("v_%s int", i)); if (i + 1 < MAX_TEST_LENGTH) sb.append(","); } session().execute(String.format("CREATE TYPE lengthy_udt (%s)", sb.toString())); // create a table with multiple sizes of udts session().execute("CREATE TABLE lengthy_udt_table (k int PRIMARY KEY, v frozen<lengthy_udt>)"); // hold onto the UserType for future use UserType udtDef = cluster().getMetadata().getKeyspace(keyspace).getUserType("lengthy_udt"); // verify inserts and reads for (int i : Arrays.asList(0, 1, 2, 3, MAX_TEST_LENGTH)) { // create udt UDTValue createdUDT = udtDef.newValue(); for (int j = 0; j < i; ++j) { createdUDT.setInt(j, j); } // write udt session().execute("INSERT INTO lengthy_udt_table (k, v) VALUES (0, ?)", createdUDT); // verify udt was written and read correctly UDTValue r = session().execute("SELECT v FROM lengthy_udt_table WHERE k=0").one().getUDTValue("v"); assertThat(r.toString()).isEqualTo(createdUDT.toString()); } }