private void removeByKeyHashFromEpByEndpointGroupId(byte[] endpointKeyHash) { CassandraEndpointProfile storedProfile = findByKeyHash(endpointKeyHash); List<CassandraEndpointGroupState> cfGroupState = new ArrayList<>(); List<String> endpointGroupIds = new ArrayList<>(); List<Statement> statementList = new ArrayList<>(); if (storedProfile.getGroupStates() != null) { cfGroupState.addAll(storedProfile.getGroupStates()); } if (cfGroupState != null) { for (CassandraEndpointGroupState cf : cfGroupState) { endpointGroupIds.add(cf.getEndpointGroupId()); } } if (endpointGroupIds != null) { for (String id : endpointGroupIds) { statementList.add(delete() .from(EP_BY_ENDPOINT_GROUP_ID_COLUMN_FAMILY_NAME) .where(eq(EP_BY_ENDPOINT_GROUP_ID_ENDPOINT_GROUP_ID_PROPERTY, id)) .and(eq( EP_BY_ENDPOINT_GROUP_ID_ENDPOINT_KEY_HASH_PROPERTY, getByteBuffer(endpointKeyHash)))); } } Statement[] st = new Statement[statementList.size()]; statementList.toArray(st); executeBatch(st); }
private void removeValueCQL(CacheScope scope, K key) { Preconditions.checkNotNull( scope, "scope is required"); Preconditions.checkNotNull( key, "key is required" ); // determine bucketed row-key based application UUID final String rowKeyString = scope.getApplication().getUuid().toString(); final int bucket = BUCKET_LOCATOR.getCurrentBucket(rowKeyString); // determine column name based on K key to string final String columnName = key.toString(); final Clause inKey = QueryBuilder.eq("key", getPartitionKey(scope, rowKeyString, bucket) ); final Clause inColumn = QueryBuilder.eq("column1", DataType.text().serialize(columnName, ProtocolVersion.NEWEST_SUPPORTED) ); final Statement statement = QueryBuilder.delete().from(SCOPED_CACHE_TABLE) .where(inKey) .and(inColumn); session.execute(statement); }
@Override public void removeTransferLog( String queueName, String source, String dest, UUID messageId ) throws QakkaException { Statement query = QueryBuilder.select().all().from(TABLE_TRANSFER_LOG) .where( QueryBuilder.eq( COLUMN_QUEUE_NAME, queueName )) .and( QueryBuilder.eq( COLUMN_DEST_REGION, dest )) .and( QueryBuilder.eq( COLUMN_MESSAGE_ID, messageId )); ResultSet rs = cassandraClient.getApplicationSession().execute( query ); if ( rs.getAvailableWithoutFetching() == 0 ) { StringBuilder sb = new StringBuilder(); sb.append( "Transfer log entry not found for queueName=" ).append( queueName ); sb.append( " dest=" ).append( dest ); sb.append( " messageId=" ).append( messageId ); throw new QakkaException( sb.toString() ); } Statement deleteQuery = QueryBuilder.delete().from(TABLE_TRANSFER_LOG) .where( QueryBuilder.eq( COLUMN_QUEUE_NAME, queueName )) .and( QueryBuilder.eq( COLUMN_DEST_REGION, dest )) .and( QueryBuilder.eq( COLUMN_MESSAGE_ID, messageId )); cassandraClient.getApplicationSession().execute( deleteQuery ); }
private Statement createDeleteMessageStatement( final String queueName, final String region, final Long shardIdOrNull, final DatabaseQueueMessage.Type type, final UUID queueMessageId ) { final long shardId; if ( shardIdOrNull == null ) { Shard.Type shardType = DatabaseQueueMessage.Type.DEFAULT.equals( type ) ? Shard.Type.DEFAULT : Shard.Type.INFLIGHT; Shard shard = shardStrategy.selectShard( queueName, region, shardType, queueMessageId ); shardId = shard.getShardId(); } else { shardId = shardIdOrNull; } Clause queueNameClause = QueryBuilder.eq( COLUMN_QUEUE_NAME, queueName ); Clause regionClause = QueryBuilder.eq( COLUMN_REGION, region ); Clause shardIdClause = QueryBuilder.eq( COLUMN_SHARD_ID, shardId ); Clause queueMessageIdClause = QueryBuilder.eq( COLUMN_QUEUE_MESSAGE_ID, queueMessageId); Statement delete = QueryBuilder.delete().from(getTableName( type )) .where(queueNameClause) .and(regionClause) .and(shardIdClause) .and(queueMessageIdClause); return delete; }
@Override public void revokeToken(final UUID tokenUUID, final ByteBuffer principalKeyBuffer){ Preconditions.checkNotNull(tokenUUID, "token UUID is required"); logger.trace("revokeToken, token UUID: {}", tokenUUID); final BatchStatement batchStatement = new BatchStatement(); batchStatement.add( QueryBuilder.delete() .from(TOKENS_TABLE) .where(QueryBuilder .eq("key", DataType.uuid().serialize(tokenUUID, ProtocolVersion.NEWEST_SUPPORTED)))); if(principalKeyBuffer != null){ batchStatement.add( QueryBuilder.delete() .from(PRINCIPAL_TOKENS_TABLE) .where(QueryBuilder .eq("key", principalKeyBuffer)) .and(QueryBuilder .eq("column1", DataType.uuid().serialize(tokenUUID, ProtocolVersion.NEWEST_SUPPORTED)))); } session.execute(batchStatement); }
@Override public void delete( final MapScope scope, final String key ) { Statement deleteMapEntry; Clause equalsEntryKey = QueryBuilder.eq("key", getMapEntryPartitionKey(scope, key)); deleteMapEntry = QueryBuilder.delete().from(MAP_ENTRIES_TABLE) .where(equalsEntryKey); session.execute(deleteMapEntry); // not sure which bucket the value is in, execute a delete against them all final int[] buckets = BUCKET_LOCATOR.getAllBuckets( scope.getName() ); List<ByteBuffer> mapKeys = new ArrayList<>(); for( int bucket : buckets){ mapKeys.add( getMapKeyPartitionKey(scope, bucket)); } Statement deleteMapKey; Clause inKey = QueryBuilder.in("key", mapKeys); Clause column1Equals = QueryBuilder.eq("column1", DataType.text().serialize(key, ProtocolVersion.NEWEST_SUPPORTED)); deleteMapKey = QueryBuilder.delete().from(MAP_KEYS_TABLE) .where(inKey).and(column1Equals); session.execute(deleteMapKey); }
@Override public void removeByKeyHash(byte[] endpointKeyHash) { LOG.debug("Remove endpoint profile by key hash [{}]", Utils.encodeHexString(endpointKeyHash)); CassandraEndpointProfile storedProfile = findByKeyHash(endpointKeyHash); removeByKeyHashFromEpByEndpointGroupId(endpointKeyHash); String appId = storedProfile.getApplicationId(); if (!appId.isEmpty()) { Statement deleteEp = delete() .from(EP_BY_APP_ID_COLUMN_FAMILY_NAME) .where(eq(EP_BY_APP_ID_APPLICATION_ID_PROPERTY, appId)) .and(eq(EP_BY_APP_ID_ENDPOINT_KEY_HASH_PROPERTY, getByteBuffer(endpointKeyHash))); executeBatch(deleteEp); } getMapper().delete(getByteBuffer(endpointKeyHash)); }
@Override public void deleteAllShards(String queueName, String region) { BatchStatement batch = new BatchStatement(); Shard.Type[] shardTypes = new Shard.Type[]{Shard.Type.DEFAULT, Shard.Type.INFLIGHT}; for (Shard.Type shardType : shardTypes) { Statement delete = QueryBuilder.delete().from( getTableName( shardType ) ) .where( QueryBuilder.eq(COLUMN_QUEUE_NAME, queueName) ) .and( QueryBuilder.eq(COLUMN_REGION, region) ); logger.trace("Removing shards for queue {} region {} shardType {} query {}", queueName, region, shardType, batch.toString()); batch.add( delete ); } cassandraClient.getQueueMessageSession().execute( batch ); }
private Statement createDeleteAllMessagesStatement( Shard shard ) { Clause queueNameClause = QueryBuilder.eq( COLUMN_QUEUE_NAME, shard.getQueueName() ); Clause regionClause = QueryBuilder.eq( COLUMN_REGION, shard.getRegion() ); Clause shardIdClause = QueryBuilder.eq( COLUMN_SHARD_ID, shard.getShardId() ); DatabaseQueueMessage.Type dbqmType = Shard.Type.DEFAULT.equals( shard.getType() ) ? DatabaseQueueMessage.Type.DEFAULT : DatabaseQueueMessage.Type.INFLIGHT; Statement deleteAll = QueryBuilder.delete().from( getTableName( dbqmType )) .where(queueNameClause) .and(regionClause) .and(shardIdClause); return deleteAll; }
@Override public void remove(String applicationId, String credentialsId) { LOG.debug("Deleting credential by applicationID[{}] and credentialsID[{}]", applicationId, credentialsId); Delete.Where query = delete().from(getColumnFamilyName()) .where(eq(CREDENTIALS_ID_PROPERTY, credentialsId)) .and(eq(CREDENTIALS_APPLICATION_ID_PROPERTY, applicationId)); execute(query); } }
@Override public void removeByUserIdAndAppTokenAndSchemaVersion(String userId, String appToken, Integer schemaVersion) { execute(delete().from(getColumnFamilyName()) .where(eq(EP_USER_CONF_USER_ID_PROPERTY, userId)) .and(eq(EP_USER_CONF_APP_TOKEN_PROPERTY, appToken)) .and(eq(EP_USER_CONF_VERSION_PROPERTY, schemaVersion))); LOG.debug("Removed user specific configuration by user id {}, " + "application token {} and schema version {}", userId, appToken, schemaVersion); }
public void deleteShard(final Shard shard){ 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 delete = QueryBuilder.delete().from(getTableName(shard.getType())) .where(queueNameClause) .and(regionClause) .and(activeClause) .and(shardIdClause); cassandraClient.getQueueMessageSession().execute(delete); }
@Override public void removeById(String id) { LOG.debug("Remove endpoint notifications by id {}", id); CassandraEndpointNotification key = new CassandraEndpointNotification(id); Statement delete = delete().from(getColumnFamilyName()) .where(eq(ET_NF_ENDPOINT_KEY_HASH_PROPERTY, key.getEndpointKeyHash())) .and(eq(ET_NF_LAST_MOD_TIME_PROPERTY, key.getLastModifyTime())); execute(delete); LOG.debug("[{}] Execute query {}:", id, delete); }
@Override public void removeByEndpointKeyHashAndConfigurationVersion(byte[] endpointKeyHash, Integer confSchemaVersion) { LOG.debug("Remove endpoint specific configuration by endpointKeyHash {} and confSchemaVersion {}", endpointKeyHash, confSchemaVersion); Delete.Where deleteQuery = delete().from(getColumnFamilyName()) .where(eq(EPS_CONFIGURATION_KEY_HASH_PROPERTY, getByteBuffer(endpointKeyHash))) .and(eq(EP_CONFIGURATION_VERSION_PROPERTY, confSchemaVersion)); LOG.trace("Remove endpoint specific configuration by endpointKeyHash and confSchemaVersion query {}", deleteQuery); execute(deleteQuery); }
/** * @return cql query statement to delete a task from the "workflows" table */ public String getDeleteTaskStatement() { return QueryBuilder.delete() .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 removeByExternalIdAndTenantId(String externalId, String tenantId) { LOG.debug("Try to remove endpoint user by external id {} and tenant id {}", externalId, tenantId); execute(delete().from(getColumnFamilyName()) .where(eq(EP_USER_EXTERNAL_ID_PROPERTY, externalId)) .and(eq(EP_USER_TENANT_ID_PROPERTY, tenantId))); }
@Override public void removeNotificationsByTopicId(String topicId) { LOG.debug("Remove notifications by topic id {}", topicId); Delete.Where query = delete().from(getColumnFamilyName()) .where(eq(NF_TOPIC_ID_PROPERTY, topicId)) .and(QueryBuilder.in( NF_NOTIFICATION_TYPE_PROPERTY, getStringTypes(NotificationTypeDto.values()))); execute(query); LOG.trace("Execute query {}", query); }
@Override public void removeById(String id) { LOG.debug("Remove notification by id {}", id); CassandraNotification nf = new CassandraNotification(id); Delete.Where deleteQuery = delete().from(getColumnFamilyName()) .where(eq(NF_TOPIC_ID_PROPERTY, nf.getTopicId())) .and(eq(NF_NOTIFICATION_TYPE_PROPERTY, nf.getType().name())) .and(eq(NF_VERSION_PROPERTY, nf.getNfVersion())) .and(eq(NF_SEQ_NUM_PROPERTY, nf.getSeqNum())); LOG.trace("Remove notification by id {}", deleteQuery); execute(deleteQuery); }
/** * @return cql query statement to delete a workflow from the "workflows" table */ public String getDeleteWorkflowStatement() { return QueryBuilder.delete() .from(keyspace, TABLE_WORKFLOWS) .where(eq(WORKFLOW_ID_KEY, bindMarker())) .and(eq(SHARD_ID_KEY, bindMarker())) .getQueryString(); }