public Keyspace getKeyspace( String keyspace, UUID prefix ) { Keyspace ko = null; if ( ( prefix != null ) ) { ko = createVirtualKeyspace( keyspace, prefix, ue, cluster, consistencyLevelPolicy, ON_FAIL_TRY_ALL_AVAILABLE, accessMap ); } else { ko = HFactory.createKeyspace( keyspace, cluster, consistencyLevelPolicy, ON_FAIL_TRY_ALL_AVAILABLE, accessMap ); } return ko; }
/** * Create a mutator that will flush when the maximum size is reached * @param keyspace * @param keySerializer * @param <K> * @return */ public static <K> CountingMutator<K> createFlushingMutator( Keyspace keyspace, Serializer<K> keySerializer ) { Mutator<K> target = HFactory.createMutator( keyspace, keySerializer ); return new CountingMutator<K>( target, MAX_SIZE ); } }
SliceQuery<ByteBuffer, UUID, UUID> q = createSliceQuery( ko, be, ue, ue ); q.setColumnFamily( CONSUMER_QUEUE_TIMEOUTS.getColumnFamily() ); q.setKey( key ); q.setColumnNames( transactionId ); HColumn<UUID, UUID> col = q.execute().get().getColumnByName( transactionId ); UUID origTrans = col.getName(); UUID messageId = col.getValue(); mutator.addInsertion( key, CONSUMER_QUEUE_TIMEOUTS.getColumnFamily(), createColumn( expirationId, messageId, cass.createTimestamp(), ue, ue ) ); mutator.execute();
public Mutator<ByteBuffer> batchIncrementQueueCounter( Mutator<ByteBuffer> m, UUID queueId, String name, long value, long timestamp, UUID applicationId ) { if ( logger.isTraceEnabled() ) { logger.trace( "BIQC: Incrementing property {} of queue {} by value {}", name, queueId, value ); } m.addInsertion( bytebuffer( key( queueId, DICTIONARY_COUNTERS ).toString() ), QueuesCF.QUEUE_DICTIONARIES.toString(), createColumn( name, ByteBuffer.allocate( 0 ), timestamp, se, be ) ); if ( "o".equals( counterType ) || "p".equals( counterType ) ) { HCounterColumn<String> c = createCounterColumn( name, value ); ByteBuffer keybytes = bytebuffer( queueId ); m.addCounter( keybytes, QueuesCF.COUNTERS.toString(), c ); } if ( "n".equals( counterType ) || "p".equals( counterType ) ) { PrefixedSerializer ps = new PrefixedSerializer( applicationId, ue, ue ); batcher.add( new Count( QueuesCF.COUNTERS.toString(), ps.toByteBuffer( queueId ), name, value ) ); } return m; }
public boolean hasOutstandingTransactions( UUID queueId, UUID consumerId ) { SliceQuery<ByteBuffer, UUID, UUID> q = createSliceQuery( ko, be, ue, ue ); q.setColumnFamily( CONSUMER_QUEUE_TIMEOUTS.getColumnFamily() ); q.setKey( getQueueClientTransactionKey( queueId, consumerId ) ); q.setRange( null, null, false, 1 ); return q.execute().get().getColumns().size() > 0; }
entries = createSliceQuery( cass.getApplicationKeyspace( applicationId ), ue, be, be ) .setColumnFamily( PROPERTY_INDEX_ENTRIES.getColumnFamily() ).setKey( queueId ) .setRange( DynamicComposite.toByteBuffer( entryName ), setGreaterThanEqualityFlag( new DynamicComposite( entryName ) ).serialize(), false, INDEX_ENTRY_LIST_COUNT ).execute().get().getColumns(); DynamicComposite composite = DynamicComposite.fromByteBuffer( entry.getName().duplicate() ); prev_value = composite.get( 2 ); prev_timestamp = ( UUID ) composite.get( 3 ); batch.addDeletion( bytebuffer( queueId ), PROPERTY_INDEX_ENTRIES.getColumnFamily(), entry.getName().duplicate(), be, timestamp ); batch.addInsertion( bytebuffer( queueId ), PROPERTY_INDEX_ENTRIES.getColumnFamily(), createColumn( DynamicComposite .toByteBuffer( entryName, indexValueCode( entryValue ), toIndexableValue( entryValue ),
@Before public void setUp() { cluster = getOrCreateCluster("Test Cluster", "127.0.0.1:9170"); keyspace = createKeyspace("Keyspace1", cluster); Mutator<String> m = createMutator(keyspace, ss); for (int i = 0; i < columns; i++) { m.addInsertion(SOURCE_KEY, CF, createColumn(UUID.randomUUID(), String.valueOf(i), us, ss)); } m.execute(); }
/** * Get the bounds for the queue * * @return The bounds for the queue */ public QueueBounds getQueueBounds( UUID queueId ) { try { ColumnSlice<String, UUID> result = HFactory.createSliceQuery( ko, ue, se, ue ).setKey( queueId ) .setColumnNames( QUEUE_NEWEST, QUEUE_OLDEST ) .setColumnFamily( QUEUE_PROPERTIES.getColumnFamily() ).execute() .get(); if ( result != null && result.getColumnByName( QUEUE_OLDEST ) != null && result.getColumnByName( QUEUE_NEWEST ) != null ) { return new QueueBounds( result.getColumnByName( QUEUE_OLDEST ).getValue(), result.getColumnByName( QUEUE_NEWEST ).getValue() ); } } catch ( Exception e ) { logger.error( "Error getting oldest queue message ID", e ); } return null; }
SliceQuery<ByteBuffer, UUID, UUID> q = createSliceQuery( ko, be, ue, ue ); q.setColumnFamily( CONSUMER_QUEUE_TIMEOUTS.getColumnFamily() ); q.setKey( getQueueClientTransactionKey( queueId, consumerId ) ); q.setRange( params.startId, startTimeUUID, false, params.limit + 1 ); column.getName(), column.getValue(), queueId, consumerId ); logger.trace( "Max timeuuid : '{}', Current timeuuid : '{}', comparison '{}'", startTimeUUID, column.getName(), UUIDUtils.compare( startTimeUUID, column.getName() ) );
@Test public void testRowDeletion() { String cf = "Standard1"; long initialTime = keyspace.createClock(); Mutator<String> m = createMutator(keyspace, se); for (int i = 0; i < 5; i++) { m.addInsertion("key" + i, cf, createColumn("name", "value" + i, se, se)); } m.execute(); // Try to delete the row with key "k0" with a clock previous to the insertion. // Cassandra will discard this operation. m.addDeletion("key0", cf, null, se, (initialTime - 100)); m.execute(); // Check that the delete was harmless QueryResult<HColumn<String, String>> columnResult = createColumnQuery(keyspace, se, se, se).setColumnFamily(cf).setKey("key0"). setName("name").execute(); assertEquals("value0", columnResult.get().getValue()); for (int i = 0; i < 5; i++) { m.addDeletion("key" + i, cf, null, se); } m.execute(); // Check that the delete took place now columnResult = createColumnQuery(keyspace, se, se, se). setColumnFamily(cf).setKey("key0").setName("name").execute(); assertNull(columnResult.get()); }
@Before public void setupLocal() { //setupClient(); Cluster cluster = getOrCreateCluster("MyCluster", "127.0.0.1:9170"); keyspace = createKeyspace("Keyspace1", cluster); Mutator<String> mutator = HFactory.createMutator(keyspace, StringSerializer.get()); mutator.addInsertion("zznate", "Standard1", HFactory.createStringColumn("email", "nate@datastax.com")); mutator.addInsertion("zznate", "Standard1", HFactory.createColumn("int", 1, StringSerializer.get(), IntegerSerializer.get())); mutator.addInsertion("zznate", "Standard1", HFactory.createColumn("long", 1L, StringSerializer.get(), LongSerializer.get())); timeUUID = TimeUUIDUtils.getTimeUUID(System.currentTimeMillis()); mutator.addInsertion("zznate", "Standard1", HFactory.createColumn("uuid", timeUUID, StringSerializer.get(), UUIDSerializer.get())); mutator.execute(); }
@Test public void testTruncateColumnFamily() throws Exception { ColumnFamilyDefinition cfDef = HFactory.createColumnFamilyDefinition("Keyspace1", "TruncateableCf"); cassandraCluster.addColumnFamily(cfDef); Keyspace workingKeyspace = HFactory.createKeyspace("Keyspace1", cassandraCluster); Mutator<String> mutator = HFactory.createMutator(workingKeyspace, StringSerializer.get()); mutator.insert("mykey", "TruncateableCf", HFactory.createStringColumn("mycolname", "myval")); ColumnQuery<String,String,String> q = HFactory.createColumnQuery(workingKeyspace, StringSerializer.get(), StringSerializer.get(), StringSerializer.get()); q.setKey("mykey").setName("mycolname").setColumnFamily("TruncateableCf"); assertEquals("myval",q.execute().get().getValue()); cassandraCluster.truncate("Keyspace1", "TruncateableCf"); assertNull(q.execute().get()); }
SliceQuery<ByteBuffer, N, V> q = createSliceQuery( ko, be, nameSerializer, valueSerializer ); q.setColumnFamily( columnFamily.toString() ); q.setKey( bytebuffer( key ) ); q.setColumnNames( ( N[] ) nameSerializer.fromBytesSet( se.toBytesSet( new ArrayList<String>( columnNames ) ) ) .toArray() ); QueryResult<ColumnSlice<N, V>> r = q.execute(); ColumnSlice<N, V> slice = r.get(); List<HColumn<N, V>> results = slice.getColumns();
String cf = "Standard1"; Mutator<String> m = createMutator(ko, se); MutationResult mr = m.insert( "testInsertGetRemove", cf, createColumn("testInsertGetRemove", "testInsertGetRemove_value_", se, se)); ColumnQuery<String, String, String> q = createColumnQuery(ko, se, se, se); q.setName("testInsertGetRemove").setColumnFamily(cf); QueryResult<HColumn<String, String>> r = q.setKey("testInsertGetRemove") assertNotNull(r); m = createMutator(ko, se); m.delete("testInsertGetRemove", cf, "testInsertGetRemove", se); ColumnQuery<String, String, String> q2 = createColumnQuery(ko, se, se, se); q2.setName("testInsertGetRemove").setColumnFamily(cf); QueryResult<HColumn<String, String>> r2 = q2.setKey("testInsertGetRemove") .execute(); assertNotNull(r2); assertNull("Value should have been deleted", r2.get());
private void writeLock(HLock lock, String seenLockIds) { Mutator<String> mutator = createMutator(keyspace, StringSerializer.get()); mutator.addInsertion(lock.getPath(), lockManagerConfigurator.getLockManagerCF(), createColumnForLock(lock.getLockId(), seenLockIds)); mutator.execute(); }
public <N, V> ColumnSlice<N, V> getColumns( Keyspace ko, Object columnFamily, Object key, N[] columns, Serializer<N> nameSerializer, Serializer<V> valueSerializer ) throws Exception { if ( db_logger.isTraceEnabled() ) { db_logger.trace( "getColumn cf={} key={} column={}", columnFamily, key, columns ); } /* * ByteBuffer column_bytes = null; if (column instanceof List) { * column_bytes = Composite.serializeToByteBuffer((List<?>) column); } else * { column_bytes = bytebuffer(column); } */ SliceQuery<ByteBuffer, N, V> q = HFactory.createSliceQuery( ko, be, nameSerializer, valueSerializer ); QueryResult<ColumnSlice<N, V>> r = q.setKey( bytebuffer( key ) ).setColumnNames( columns ).setColumnFamily( columnFamily.toString() ) .execute(); ColumnSlice<N, V> result = r.get(); if ( db_logger.isTraceEnabled() ) { if ( result == null ) { db_logger.trace( "getColumn returned null" ); } } return result; }
@Test public void testModificationIterator() { LinkedList<String> KEYS= new LinkedList<String>(); for (int j = 0; j < 100; j++) { KEYS.add(KEY+j); } Mutator mutator = HFactory.createMutator(keyspace, se); MultigetSliceIterator<String, UUID, String> it= new MultigetSliceIterator<String, UUID, String>(false,keyspace, se,us,se, CF, KEYS, null,null,1,10,1000);// Retrieve all columns from row -> 1000 Map<UUID, String> results = new HashMap<UUID, String>(); while (it.hasNext()) { Row<String,UUID, String> r = it.next(); for (HColumn<UUID, String> c : r.getColumnSlice().getColumns()) { results.put(c.getName(), c.getValue()); mutator.addDeletion(r.getKey(), CF, c.getName(), us); mutator.execute(); } } assertEquals(100*1000, results.size()); } @Test
/** * Get the position in the queue for the given appId, consumer and queu * * @param queueId The queueId * @param consumerId The consumerId */ public UUID getConsumerQueuePosition( UUID queueId, UUID consumerId ) { HColumn<UUID, UUID> result = HFactory.createColumnQuery( ko, ue, ue, ue ).setKey( consumerId ).setName( queueId ) .setColumnFamily( CONSUMERS.getColumnFamily() ).execute().get(); if ( result != null ) { return result.getValue(); } return null; }
RangeSlicesQuery<String, String, String> q = createRangeSlicesQuery(ko, se, se, se); q.setColumnFamily(cf); OrderedRows<String, String, String> rows = r.get(); assertNotNull(rows); .getColumnByName("testRangeSlicesQueryColumn1").getValue()); assertEquals("value12", slice .getColumnByName("testRangeSlicesQueryColumn2").getValue()); assertNull(slice.getColumnByName("testRangeSlicesQueryColumn3")); List<HColumn<String, String>> columns = slice.getColumns(); r = q.execute(); assertNotNull(r); rows = r.get(); assertEquals(3, rows.getCount()); for (Row<String, String, String> row2 : rows) { assertEquals(2, slice.getColumns().size()); for (HColumn<String, String> column : slice.getColumns()) { if (!column.getName().equals("testRangeSlicesQueryColumn1") && !column.getName().equals("testRangeSlicesQueryColumn2")) { fail("A columns with unexpected column name returned: "
private void deleteLock(HLock lock) { // cancel the heartbeat task if it exists Future<Void> heartbeat = ((HLockImpl) lock).getHeartbeat(); if (heartbeat != null) { heartbeat.cancel(false); } Mutator<String> mutator = createMutator(keyspace, StringSerializer.get()); mutator.addDeletion(lock.getPath(), lockManagerConfigurator.getLockManagerCF(), lock.getLockId(), StringSerializer.get(), keyspace.createClock()); mutator.execute(); }