private <T> T getValuesCQL( final MapScope scope, final Collection<String> keys, final ResultsBuilderCQL<T> builder ) { final List<ByteBuffer> serializedKeys = new ArrayList<>(); keys.forEach(key -> serializedKeys.add(getMapEntryPartitionKey(scope,key))); Clause in = QueryBuilder.in("key", serializedKeys ); Statement statement = QueryBuilder.select().all().from(MAP_ENTRIES_TABLE) .where(in); ResultSet resultSet = session.execute(statement); return builder.buildResultsCQL( resultSet ); }
/** * @return cql query statement to retrieve a task from the "workflows" table */ public String getSelectTaskStatement() { return QueryBuilder.select(PAYLOAD_KEY) .from(keyspace, TABLE_WORKFLOWS) .where(eq(WORKFLOW_ID_KEY, bindMarker())) .and(eq(SHARD_ID_KEY, bindMarker())) .and(eq(ENTITY_KEY, ENTITY_TYPE_TASK)) .and(eq(TASK_ID_KEY, bindMarker())) .getQueryString(); }
@Override public void writeMessageData( final UUID messageId, final DatabaseQueueMessageBody messageBody ) { Preconditions.checkArgument(QakkaUtils.isTimeUuid(messageId), "MessageId is not a type 1 UUID"); logger.trace("writeMessageData {}", messageId); Statement insert = QueryBuilder.insertInto(TABLE_MESSAGE_DATA) .value( COLUMN_MESSAGE_ID, messageId) .value( COLUMN_MESSAGE_DATA, messageBody.getBlob()) .value( COLUMN_CONTENT_TYPE, messageBody.getContentType()) .using( QueryBuilder.ttl( maxTtl ) ); cassandraClient.getApplicationSession().execute(insert); }
/** * @return cql query statement to insert a new task into the "workflows" table */ public String getInsertTaskStatement() { return QueryBuilder.insertInto(keyspace, TABLE_WORKFLOWS) .value(WORKFLOW_ID_KEY, bindMarker()) .value(SHARD_ID_KEY, bindMarker()) .value(TASK_ID_KEY, bindMarker()) .value(ENTITY_KEY, ENTITY_TYPE_TASK) .value(PAYLOAD_KEY, bindMarker()) .getQueryString(); }
private static String insertSQL(final String table, final int timeout) { Insert insertInto = insertInto(table) .value(ID, raw("?")) .value(CREATED_AT, raw("?")) .value(ACCESSED_AT, raw("?")) .value(SAVED_AT, raw("?")) .value(ATTRIBUTES, raw("?")); if (timeout > 0) { insertInto.using(ttl(timeout)); } return insertInto.getQueryString(); }
Factory(Session session, TimestampCodec timestampCodec, Set<Integer> buckets) { this.session = session; this.timestampCodec = timestampCodec; this.preparedStatement = session.prepare( QueryBuilder.select("ts", "trace_id") .from(Tables.SERVICE_NAME_INDEX) .where(QueryBuilder.eq("service_name", QueryBuilder.bindMarker("service_name"))) .and(QueryBuilder.in("bucket", buckets)) .and(QueryBuilder.gte("ts", QueryBuilder.bindMarker("start_ts"))) .and(QueryBuilder.lte("ts", QueryBuilder.bindMarker("end_ts"))) .limit(QueryBuilder.bindMarker("limit_")) .orderBy(QueryBuilder.desc("ts"))); }
@Override public void recordTransferLog( String queueName, String source, String dest, UUID messageId) { Statement insert = QueryBuilder.insertInto(TABLE_TRANSFER_LOG) .value(COLUMN_QUEUE_NAME, queueName ) .value(COLUMN_SOURCE_REGION, source ) .value(COLUMN_DEST_REGION, dest ) .value(COLUMN_MESSAGE_ID, messageId ) .value(COLUMN_TRANSFER_TIME, System.currentTimeMillis() ); cassandraClient.getApplicationSession().execute(insert); // logger.debug("Recorded transfer log for queue {} dest {} messageId {}", // queueName, dest, messageId); }
private PreparedStatement prepareBetweenUidStatement(Session session) { return session.prepare(select(UID) .from(TABLE_NAME) .where(eq(MAILBOX_ID, bindMarker(MAILBOX_ID))) .and(gte(UID, bindMarker(UID_FROM))) .and(lte(UID, bindMarker(UID_TO)))); }
protected ResultSet events0(String analyseId, String jvmId, Range range, String[] fields) { return connector.session().execute(QueryBuilder.select(fields).from(TABLE_NAME) .where(eq("analyse_id", UUID.fromString(analyseId))) .and(eq("jvm_id", jvmId)) .and(gte("written_at", QueryBuilder.fcall("minTimeuuid", range.from().getMillis()))) .and(lte("written_at", QueryBuilder.fcall("maxTimeuuid", range.to().getMillis()))).setFetchSize(fetchSize)); }
private void advance(){ Clause queueNameClause = QueryBuilder.eq( ShardSerializationImpl.COLUMN_QUEUE_NAME, queueName); Clause regionClause = QueryBuilder.eq( ShardSerializationImpl.COLUMN_REGION, region); Clause activeClause = QueryBuilder.eq( ShardSerializationImpl.COLUMN_ACTIVE, 1); Clause shardIdClause; if (nextStart == 0L && lastShardId.isPresent()) { shardIdClause = QueryBuilder.gt( ShardSerializationImpl.COLUMN_SHARD_ID, lastShardId.get() ); } else if (nextStart == 0L && !lastShardId.isPresent()) { shardIdClause = QueryBuilder.gte( ShardSerializationImpl.COLUMN_SHARD_ID, 0L ); } else { shardIdClause = QueryBuilder.gt( ShardSerializationImpl.COLUMN_SHARD_ID, nextStart ); } Statement query = QueryBuilder.select().all().from(ShardSerializationImpl.getTableName(shardType)) .where(queueNameClause) .and(regionClause) .and(activeClause) .and(shardIdClause) .limit(PAGE_SIZE); List<Row> rows = cassandraClient.getQueueMessageSession().execute(query).all(); currentIterator = getIteratorFromRows(rows); }
@Override public CassandraEndpointUser findByExternalIdAndTenantId(String externalId, String tenantId) { LOG.debug("Try to find endpoint user by external id {} and tenant id {}", externalId, tenantId); Where where = select().from(getColumnFamilyName()) .where(eq(EP_USER_EXTERNAL_ID_PROPERTY, externalId)) .and(eq(EP_USER_TENANT_ID_PROPERTY, tenantId)); LOG.trace("Try to find endpoint user by cql select {}", where); CassandraEndpointUser endpointUser = findOneByStatement(where); LOG.trace("Found {} endpoint user", endpointUser); return endpointUser; }
Insert insertStmt = QueryBuilder.insertInto(table); insertStmt.value(YCSB_KEY, QueryBuilder.bindMarker()); insertStmt.value(field, QueryBuilder.bindMarker()); stmt = session.prepare(insertStmt); stmt.setConsistencyLevel(writeConsistencyLevel); if (trace) { session.execute(boundStmt);
select = select().all().from("foo").where(eq("k", 4)).and(gt("c", "a")).and(lte("c", "z")); assertEquals(select.toString(), query); select().all().from("foo").where().and(eq("k", 4)).and(gt("c", "a")).and(lte("c", "z")); assertEquals(select.toString(), query); "SELECT a,b,\"C\" FROM foo WHERE a IN ('127.0.0.1','127.0.0.3') AND \"C\"='foo' ORDER BY a ASC,b DESC LIMIT 42;"; select = select("a", "b", quote("C")) .from("foo") .where(in("a", InetAddress.getByName("127.0.0.1"), InetAddress.getByName("127.0.0.3"))) .and(eq(quote("C"), "foo")) .orderBy(asc("a"), desc("b")) select = select().writeTime("a").ttl("a").from("foo").allowFiltering(); assertEquals(select.toString(), query); select() .limit(bindMarker("limit")); assertEquals(select.toString(), query); "SELECT DISTINCT longName AS a,ttl(longName) AS ttla FROM foo WHERE k IN () LIMIT :limit;"; select = select() .where(in("k")) .limit(bindMarker("limit")); assertEquals(select.toString(), query);
query = select().from(table).where(eq("k", 42)); batch_query += "APPLY BATCH;"; batch = batch() .add(insertInto(table).values(new String[] {"k", "a"}, new Object[] {42, 1})) .add(update(table).using(ttl(400))); assertEquals(batch.getRoutingKey(protocolVersion, codecRegistry), bb); assertEquals(batch.toString(), batch_query); batch_query += String.format("SELECT * FROM %s.test_int WHERE k=42;", keyspace); batch_query += "APPLY BATCH;"; batch = batch(query); assertEquals(batch.getRoutingKey(protocolVersion, codecRegistry), bb); assertEquals(batch.toString(), batch_query); batch_query += "SELECT * FROM foo WHERE k=42;"; batch_query += "APPLY BATCH;"; batch = batch().add(select().from("foo").where(eq("k", 42))); assertEquals(batch.getRoutingKey(protocolVersion, codecRegistry), null); assertEquals(batch.toString(), batch_query); batch_query += "INSERT INTO foo.bar (a) VALUES (123);"; batch_query += "APPLY BATCH;"; batch = batch().using(timestamp(42)).add(insertInto("foo", "bar").value("a", 123)); assertEquals(batch.getRoutingKey(protocolVersion, codecRegistry), null); assertEquals(batch.toString(), batch_query);
public void updateShardPointer(final Shard shard){ Assignment assignment = QueryBuilder.set(COLUMN_POINTER, shard.getPointer()); Clause queueNameClause = QueryBuilder.eq(COLUMN_QUEUE_NAME, shard.getQueueName()); Clause regionClause = QueryBuilder.eq(COLUMN_REGION, shard.getRegion()); Clause activeClause = QueryBuilder.eq(COLUMN_ACTIVE, 1); Clause shardIdClause = QueryBuilder.eq(COLUMN_SHARD_ID, shard.getShardId()); Statement update = QueryBuilder.update(getTableName(shard.getType())) .with(assignment) .where(queueNameClause) .and(regionClause) .and(activeClause) .and(shardIdClause); cassandraClient.getQueueMessageSession().execute(update); }
void incrementCounterInStorage( String queueName, Shard.Type type, long shardId, long increment ) { Statement update = QueryBuilder.update( TABLE_COUNTERS ) .where( QueryBuilder.eq( COLUMN_QUEUE_NAME, queueName ) ) .and( QueryBuilder.eq( COLUMN_SHARD_TYPE, type.toString() ) ) .and( QueryBuilder.eq( COLUMN_SHARD_ID, shardId ) ) .with( QueryBuilder.incr( COLUMN_COUNTER_VALUE, increment ) ); cassandraClient.getQueueMessageSession().execute( update ); }
@Override public void deleteMessageData( final UUID messageId ) { logger.trace("deleteMessageData {}", messageId); Clause messageIdClause = QueryBuilder.eq(COLUMN_MESSAGE_ID, messageId); Statement delete = QueryBuilder.delete().from(TABLE_MESSAGE_DATA).where(messageIdClause); cassandraClient.getApplicationSession().execute(delete); }
select() .all() .from("foo") .where(eq("k", 4)) .and(eq(Arrays.asList("c1", "c2"), Arrays.<Object>asList("a", 2))); assertEquals(select.toString(), query); select() .all() .from("foo") .where(eq("k", 4)) .and(gt(Arrays.asList("c1", "c2"), Arrays.<Object>asList("a", 2))); assertEquals(select.toString(), query); select() .all() .from("foo") .where(eq("k", 4)) .and(gte(Arrays.asList("c1", "c2"), Arrays.<Object>asList("a", 2))) .and(lt(Arrays.asList("c1", "c2"), Arrays.<Object>asList("b", 0))); assertEquals(select.toString(), query); select() .where(eq("k", 4)) .and(lte(Arrays.asList("c1", "c2"), Arrays.<Object>asList("a", 2))); assertEquals(select.toString(), query); ImmutableList.<List<?>>of(
update("foo", "bar") .using(timestamp(42)) .with(set("a", 12)) .and(set("b", Arrays.asList(3, 2, 1))) .and(incr("c", 3)) .where(eq("k", 2)); assertEquals(update.toString(), query); update = update("foo").where().and(eq("k", 2)).with(set("b", null)); assertEquals(update.toString(), query); "UPDATE foo SET a[2]='foo',b=[3,2,1]+b,c=c-{'a'} WHERE k=2 AND l='foo' AND m<4 AND n>=1;"; update = update("foo") .with(setIdx("a", 2, "foo")) .and(prependAll("b", Arrays.asList(3, 2, 1))) .and(remove("c", "a")) .where(eq("k", 2)) .and(eq("l", "foo")) .and(lt("m", 4)) .and(gte("n", 1)); assertEquals(update.toString(), query); update("foo") .with() .and(prepend("b", 3)) .and(append("c", "a")) .and(appendAll("d", Arrays.asList(1, 2, 3))) .and(discard("e", 1));
private void decrementCounterInStorage( String queueName, DatabaseQueueMessage.Type type, long decrement ) { Statement update = QueryBuilder.update( TABLE_MESSAGE_COUNTERS ) .where( QueryBuilder.eq( COLUMN_QUEUE_NAME, queueName ) ) .and( QueryBuilder.eq( COLUMN_MESSAGE_TYPE, type.toString() ) ) .with( QueryBuilder.decr( COLUMN_COUNTER_VALUE, decrement ) ); cassandraClient.getQueueMessageSession().execute( update ); }