Refine search
@Test(groups = "short") public void should_execute_prepared_statements() throws Exception { // Simple calls to all versions of the execute/executeAsync methods for prepared statements // Note: the goal is only to exercice the Session methods, PreparedStatementTest have better // prepared statement tests. String key = "execute_prepared_test"; ResultSet rs = session() .execute( String.format( Locale.US, "INSERT INTO %s (k, t, i, f) VALUES ('%s', '%s', %d, %f)", TABLE2, key, "foo", 42, 24.03f)); assertThat(rs.isExhausted()).isTrue(); PreparedStatement p = session().prepare(String.format(TestUtils.SELECT_ALL_FORMAT + " WHERE k = ?", TABLE2)); BoundStatement bs = p.bind(key); // executePrepared checkExecuteResultSet(session().execute(bs), key); checkExecuteResultSet(session().execute(bs.setConsistencyLevel(ConsistencyLevel.ONE)), key); // executePreparedAsync checkExecuteResultSet(session().executeAsync(bs).getUninterruptibly(), key); checkExecuteResultSet( session().executeAsync(bs.setConsistencyLevel(ConsistencyLevel.ONE)).getUninterruptibly(), key); }
@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", expectedExceptions = InvalidQueryException.class) public void should_fail_when_prepared_on_another_cluster() throws Exception { Cluster otherCluster = Cluster.builder() .addContactPoints(getContactPoints()) .withPort(ccm().getBinaryPort()) .build(); try { PreparedStatement pst = otherCluster.connect().prepare("select * from system.peers where inet = ?"); BoundStatement bs = pst.bind().setInet(0, InetAddress.getByName("localhost")); // We expect that the error gets detected without a roundtrip to the server, so use // executeAsync session().executeAsync(bs); } finally { otherCluster.close(); } }
scanStmt.append(QueryBuilder.bindMarker()); stmt = session.prepare(scanStmt.toString()); stmt.setConsistencyLevel(readConsistencyLevel); if (trace) { logger.debug("startKey = {}, recordcount = {}", startkey, recordcount); ResultSet rs = session.execute(stmt.bind(startkey, Integer.valueOf(recordcount)));
private void insertRecords() { int records = 30000; PreparedStatement insertStmt = session().prepare("insert into record (name, phone, value) values (?, ?, ?)"); for (int i = 0; i < records; i++) { if (i % 1000 == 0) logger.debug("Inserting record {}.", i); session().execute(insertStmt.bind("0", Integer.toString(i), "test")); } logger.debug("Inserts complete."); }
/** * Validates that a prepared statement with no variables is correctly prepared and executed. * * @jira_ticket JAVA-1132 */ @Test(groups = "short") public void should_execute_prepared_statement_with_no_variables() throws Exception { PreparedStatement ps = session().prepare("select * from system.local"); session().execute(ps.bind()); }
/** * Validates that a prepared statement with variables is correctly prepared and executed. * * @jira_ticket JAVA-1132 */ @Test(groups = "short") public void should_execute_prepared_statement_with_variables() throws Exception { PreparedStatement ps = session().prepare("select * from system.local where key=?"); session().execute(ps.bind("local")); } }
@Test(groups = "short") public void should_set_routing_key_on_case_insensitive_keyspace_and_table() { session().execute(String.format("CREATE TABLE %s.foo (i int PRIMARY KEY)", keyspace)); PreparedStatement ps = session().prepare(String.format("INSERT INTO %s.foo (i) VALUES (?)", keyspace)); BoundStatement bs = ps.bind(1); assertThat(bs.getRoutingKey(ProtocolVersion.NEWEST_SUPPORTED, CodecRegistry.DEFAULT_INSTANCE)) .isNotNull(); }
@Test(groups = "short", expectedExceptions = NoHostAvailableException.class) public void should_not_reprepare_invalid_statements() { // given session().execute("ALTER TABLE prepared_statement_invalidation_test ADD d int"); PreparedStatement ps = session() .prepare("SELECT a, b, c, d FROM prepared_statement_invalidation_test WHERE a = ?"); session().execute("ALTER TABLE prepared_statement_invalidation_test DROP d"); // when session().execute(ps.bind()); }
@Test(groups = "short") public void should_use_collection_codecs_with_prepared_statements_1() { session() .execute( session() .prepare(insertQuery) .bind(n_int, l_int, l_bigint, s_float, s_double, m_varint, m_decimal)); PreparedStatement ps = session().prepare(selectQuery); ResultSet rows = session().execute(ps.bind(n_int)); Row row = rows.one(); assertRow(row); }
@Test(groups = "short") public void should_use_defaut_codecs_with_prepared_statements_1() { session() .execute( session() .prepare(insertQuery) .bind(n_int, n_bigint, n_float, n_double, n_varint, n_decimal)); PreparedStatement ps = session().prepare(selectQuery); ResultSet rows = session().execute(ps.bind(n_int, n_bigint)); Row row = rows.one(); assertRow(row); }
@Test(groups = "short") public void should_set_routing_key_on_case_sensitive_keyspace_and_table() { session() .execute( "CREATE KEYSPACE \"Test\" WITH replication = { " + " 'class': 'SimpleStrategy'," + " 'replication_factor': '1'" + "}"); session().execute("CREATE TABLE \"Test\".\"Foo\" (i int PRIMARY KEY)"); PreparedStatement ps = session().prepare("INSERT INTO \"Test\".\"Foo\" (i) VALUES (?)"); BoundStatement bs = ps.bind(1); assertThat(bs.getRoutingKey(ProtocolVersion.NEWEST_SUPPORTED, CodecRegistry.DEFAULT_INSTANCE)) .isNotNull(); }
@Test(groups = "short") public void should_execute_wrapped_bound_statement() { PreparedStatement preparedStatement = session().prepare(new SimpleStatement(INSERT_QUERY)); session().execute(new CustomStatement(preparedStatement.bind("key_bound", 1))); preparedStatement = session().prepare(new SimpleStatement(SELECT_QUERY)); ResultSet rs = session().execute(new CustomStatement(preparedStatement.bind("key_bound"))); assertThat(rs.one().getInt("v")).isEqualTo(1); }