@Override public <N, V> MutationResult insert( final K key, final String cf, final HColumn<N, V> c ) { return target.insert( key, cf, c ); }
@Override public <SN, N, V> MutationResult insert( final K key, final String cf, final HSuperColumn<SN, N, V> superColumn ) { return target.insert( key, cf, superColumn ); }
public void setColumn( Keyspace ko, Object columnFamily, Object key, Object columnName, Object columnValue, int ttl ) throws Exception { if ( db_logger.isTraceEnabled() ) { db_logger.trace( "setColumn cf={} key={} name={} value={}", columnFamily, key, columnName, columnValue ); } ByteBuffer name_bytes = null; if ( columnName instanceof List ) { name_bytes = DynamicComposite.toByteBuffer( ( List<?> ) columnName ); } else { name_bytes = bytebuffer( columnName ); } ByteBuffer value_bytes = null; if ( columnValue instanceof List ) { value_bytes = DynamicComposite.toByteBuffer( ( List<?> ) columnValue ); } else { value_bytes = bytebuffer( columnValue ); } HColumn<ByteBuffer, ByteBuffer> col = createColumn( name_bytes, value_bytes, be, be ); if ( ttl != 0 ) { col.setTtl( ttl ); } Mutator<ByteBuffer> m = CountingMutator.createFlushingMutator( ko, be ); m.insert( bytebuffer( key ), columnFamily.toString(), col ); }
/** * Insert a new value keyed by key * * @param key Key for the value * @param value the String value to insert */ public void insert(final String key, final String columnName, final String value) { createMutator(keyspace, serializer).insert( key, columnFamilyName, createColumn(columnName, value, serializer, serializer)); }
/** * Insert a new value keyed by key * * @param key Key for the value * @param value the String value to insert */ public <K> void insert(final K key, final String value, Serializer<K> keySerializer) { createMutator(keyspace, keySerializer).insert( key, CF_NAME, createColumn(COLUMN_NAME, value, serializer, serializer)); }
/** * Write the data to column if the configured chunk size is reached or if the * stream should be closed * * @param close * @throws IOException */ private void writeData(boolean close) throws IOException { if (pos != 0 && (close || pos == chunk.length - 1)) { byte[] data; if (pos != chunk.length - 1) { data = new byte[(int) pos + 1]; // we need to adjust the array System.arraycopy(chunk, 0, data, 0, data.length); } else { data = chunk; } try { mutator.insert(key, cf, HFactory.createColumn(chunkPos, data, LongSerializer.get(), BytesArraySerializer.get())); } catch (HectorException e) { throw new IOException("Unable to write data", e); } chunkPos++; pos = 0; } }
@Test public void testSubDeleteHSuperColumn() { Mutator<String> m = createMutator(keyspace, se); List<HColumn<String, String>> columnList = new ArrayList<HColumn<String,String>>(); columnList.add(createColumn("col_1","val_1",se,se)); columnList.add(createColumn("col_2","val_2",se,se)); columnList.add(createColumn("col_3","val_3",se,se)); HSuperColumn<String, String, String> superColumn = createSuperColumn("super_name", columnList, se, se, se); m.insert("sk1", "Super1", superColumn); SuperColumnQuery<String, String, String, String> scq = HFactory.createSuperColumnQuery(keyspace, se, se, se, se); scq.setColumnFamily("Super1"); scq.setKey("sk1"); scq.setSuperName("super_name"); assertEquals(3,scq.execute().get().getColumns().size()); m.discardPendingMutations(); columnList.remove(1); columnList.remove(0); superColumn.setSubcolumns(columnList); m.addSubDelete("sk1", "Super1", superColumn); m.execute(); assertEquals(2,scq.execute().get().getColumns().size()); }
@Test public void testInsert() { Mutator<String> m = createMutator(keyspace, se); MutationResult mr = m.insert("k", "Standard1", createColumn("name", "value", se, se)); assertTrue("Execution time on single insert should be > 0",mr.getExecutionTimeMicro() > 0); assertTrue("Should have operated on a host", mr.getHostUsed() != null); assertColumnExists("Keyspace1", "Standard1", "k", "name"); }
@Test public void testSubDelete() { Mutator<String> m = createMutator(keyspace, se); List<HColumn<String, String>> columnList = new ArrayList<HColumn<String,String>>(); columnList.add(createColumn("col_1","val_1",se,se)); columnList.add(createColumn("col_2","val_2",se,se)); columnList.add(createColumn("col_3","val_3",se,se)); HSuperColumn<String, String, String> superColumn = createSuperColumn("super_name", columnList, se, se, se); m.insert("sk1", "Super1", superColumn); SuperColumnQuery<String, String, String, String> scq = HFactory.createSuperColumnQuery(keyspace, se, se, se, se); scq.setColumnFamily("Super1"); scq.setKey("sk1"); scq.setSuperName("super_name"); assertEquals(3,scq.execute().get().getColumns().size()); m.discardPendingMutations(); m.addSubDelete("sk1", "Super1", "super_name", "col_1", se, se); m.execute(); assertEquals(2,scq.execute().get().getColumns().size()); }
/** * Insert a new value keyed by key * * @param key Key for the value * @param value the String value to insert */ public <K> void insert(final K key, final String value, Serializer<K> keySerializer) { createMutator(keyspace, keySerializer).insert( key, CF_NAME, createColumn(COLUMN_NAME, value, serializer, serializer)); }
/** * Insert a new value keyed by key * * @param key Key for the value * @param value the String value to insert */ public void insert(final String key, final String columnName, final String value) { createMutator(keyspace, serializer).insert( key, columnFamilyName, createColumn(columnName, value, serializer, serializer)); }
@Test public void testExtraColumnShouldNotBeRead() { EntityManagerImpl em = new EntityManagerImpl(keyspace, "me.prettyprint.hom.beans"); MyTestBeanNoAnonymous bean1 = new MyTestBeanNoAnonymous(); bean1.setBaseId(UUID.randomUUID()); bean1.setLongProp1(1L); em.persist(bean1); // now add column that is not a property of bean Mutator<UUID> m = HFactory.createMutator(keyspace, UUIDSerializer.get()); HColumn<String, String> col = HFactory.createColumn("anonymousProperty", "blah", StringSerializer.get(), StringSerializer.get()); m.insert(bean1.getBaseId(), "NoAnonymousColumnFamily", col); MyTestBeanNoAnonymous bean2 = em.find(MyTestBeanNoAnonymous.class, bean1.getBaseId()); assertNotNull("Could not load bean from cassandra", bean2); assertEquals(bean1.getLongProp1(), bean2.getLongProp1()); }
@Override public void set(final K key, final V value) { createMutator( _keyspace, _serializer_k).insert( key, _cf_name, createColumn(COLUMN_NAME, value, BYTE_SERIALIZER, _serializer_v)); }
@Override public void set(final K key, final V value) { createMutator( _keyspace, _serializer_k).insert( key, _cf_name, createColumn(COLUMN_NAME, value, BYTE_SERIALIZER, _serializer_v)); }
/** * Insert a new value keyed by key * * @param key Key for the value * @param value the String value to insert */ public <K> void insert(final K key, final String value, Serializer<K> keySerializer) { createMutator(keyspace, keySerializer).insert( key, CF_NAME, createColumn(COLUMN_NAME, value, serializer, serializer)); }
/** * Insert a new value keyed by key * * @param key Key for the value * @param value the String value to insert */ public void insert(final String key, final String columnName, final String value) { createMutator(keyspace, serializer).insert( key, columnFamilyName, createColumn(columnName, value, serializer, serializer)); }
createColumn("name1", "value1", se, se), createColumn("name2", "value2", se, se)); m.insert("testSuperInsertGetRemove", cf, createSuperColumn("testSuperInsertGetRemove", columns, se, se, se));
@Test public void testInsertAndDeleteSuper() { Mutator<String> m = createMutator(keyspace, se); List<HColumn<String, String>> columnList = new ArrayList<HColumn<String,String>>(); columnList.add(createColumn("name","value",se,se)); HSuperColumn<String, String, String> superColumn = createSuperColumn("super_name", columnList, se, se, se); // Insert Super Column MutationResult r = m.insert("sk", "Super1", superColumn); assertTrue("Execute time should be > 0", r.getExecutionTimeMicro() > 0); assertTrue("Should have operated on a host", r.getHostUsed() != null); // Fetch and verify it exists. SuperColumnQuery<String, String, String, String> scq = HFactory.createSuperColumnQuery(keyspace, se, se, se, se); scq.setColumnFamily("Super1"); scq.setKey("sk"); scq.setSuperName("super_name"); assertEquals("super_name", scq.execute().get().getName()); // Remove the Super Column m.superDelete("sk", "Super1", "super_name", se); // Fetch and verify it exists. scq = HFactory.createSuperColumnQuery(keyspace, se, se, se, se); scq.setColumnFamily("Super1"); scq.setKey("sk"); scq.setSuperName("super_name"); assertNull("super_name", scq.execute().get()); }
@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()); }
MutationResult mr = m.insert( "testInsertGetRemove", cf,