@Override public void setConf(final Configuration config) { super.setConf(config); // Copy some Titan configuration keys to the Hadoop Configuration keys used by Cassandra's ColumnFamilyInputFormat ConfigHelper.setInputInitialAddress(config, titanConf.get(GraphDatabaseConfiguration.STORAGE_HOSTS)[0]); if (titanConf.has(GraphDatabaseConfiguration.STORAGE_PORT)) ConfigHelper.setInputRpcPort(config, String.valueOf(titanConf.get(GraphDatabaseConfiguration.STORAGE_PORT))); if (titanConf.has(GraphDatabaseConfiguration.AUTH_USERNAME)) ConfigHelper.setInputKeyspaceUserName(config, titanConf.get(GraphDatabaseConfiguration.AUTH_USERNAME)); if (titanConf.has(GraphDatabaseConfiguration.AUTH_PASSWORD)) ConfigHelper.setInputKeyspacePassword(config, titanConf.get(GraphDatabaseConfiguration.AUTH_PASSWORD)); // Copy keyspace, force the CF setting to edgestore, honor widerows when set final boolean wideRows = config.getBoolean(INPUT_WIDEROWS_CONFIG, false); // Use the setInputColumnFamily overload that includes a widerows argument; using the overload without this argument forces it false ConfigHelper.setInputColumnFamily(config, titanConf.get(AbstractCassandraStoreManager.CASSANDRA_KEYSPACE), mrConf.get(TitanHadoopConfiguration.COLUMN_FAMILY_NAME), wideRows); log.debug("Set keyspace: {}", titanConf.get(AbstractCassandraStoreManager.CASSANDRA_KEYSPACE)); // Set the column slice bounds via Faunus's vertex query filter final SlicePredicate predicate = new SlicePredicate(); final int rangeBatchSize = config.getInt(RANGE_BATCH_SIZE_CONFIG, Integer.MAX_VALUE); predicate.setSlice_range(getSliceRange(TitanHadoopSetupCommon.DEFAULT_SLICE_QUERY, rangeBatchSize)); // TODO stop slicing the whole row ConfigHelper.setInputSlicePredicate(config, predicate); }
connection.getClient().get_range_slices(new ColumnParent(columnFamily), new SlicePredicate() .setSlice_range(sliceRange), keyRange, ConsistencyLevel.QUORUM);
range.setStart(query.getSliceStart().asByteBuffer()); range.setFinish(query.getSliceEnd().asByteBuffer()); predicate.setSlice_range(range);
SlicePredicate predicate = new SlicePredicate().setSlice_range(columnSlice);
@Override public Map<ByteBuffer, SuperColumn> multigetSuperColumn(List<ByteBuffer> keys, ColumnPath columnPath, boolean reversed, int size) throws HectorException { //valideSuperColumnPath(columnPath); // only can get supercolumn by multigetSuperSlice ColumnParent clp = new ColumnParent(columnPath.getColumn_family()); clp.setSuper_column(columnPath.getSuper_column()); SliceRange sr = new SliceRange(ByteBuffer.wrap(new byte[0]), ByteBuffer.wrap(new byte[0]), reversed, size); SlicePredicate sp = new SlicePredicate(); sp.setSlice_range(sr); Map<ByteBuffer, List<SuperColumn>> sclist = multigetSuperSlice(keys, clp, sp); if (sclist == null || sclist.isEmpty()) { return Collections.emptyMap(); } Map<ByteBuffer, SuperColumn> result = new HashMap<ByteBuffer, SuperColumn>(keys.size() * 2); for (Map.Entry<ByteBuffer, List<SuperColumn>> entry : sclist.entrySet()) { List<SuperColumn> sclistByKey = entry.getValue(); if (sclistByKey.size() > 0) { result.put(entry.getKey(), sclistByKey.get(0)); } } return result; }
public static SlicePredicate create(Range range, Limit limit) { SliceRange slice = new SliceRange( range.start(), range.end(), false, limit.value()); SlicePredicate predicate = new SlicePredicate(); predicate.setSlice_range(slice); return predicate; }
@Override public SuperColumn execute(Cassandra.Client cassandra) throws HectorException { ColumnParent clp = new ColumnParent(columnPath.getColumn_family()); clp.setSuper_column(columnPath.getSuper_column()); SlicePredicate sp = new SlicePredicate(); sp.setSlice_range(sliceRange); try { List<ColumnOrSuperColumn> cosc = cassandra.get_slice(key, clp, sp, getThriftCl(OperationType.READ)); if (cosc == null || cosc.isEmpty()) { return null; } return new SuperColumn(ByteBuffer.wrap(columnPath.getSuper_column()), getColumnList(cosc)); } catch (Exception e) { throw xtrans.translate(e); } } };
/** * {@inheritDoc} */ @Override public <N> Mutator<K> addDeletion(K key, String cf, N columnNameStart, N columnNameFinish, Serializer<N> nameSerializer, long clock) { SlicePredicate sp = new SlicePredicate(); sp.setSlice_range(new SliceRange(nameSerializer.toByteBuffer(columnNameStart), nameSerializer.toByteBuffer(columnNameFinish), false, Integer.MAX_VALUE)); Deletion d = new Deletion().setTimestamp(clock).setPredicate(sp); getPendingMutations().addDeletion(key, Arrays.asList(cf), d); return this; }
sliceRange.setStart(start); sliceRange.setFinish(finish); colPredicate.setSlice_range(sliceRange);
sliceRange.setStart(ByteBufferUtil.EMPTY_BYTE_BUFFER); sliceRange.setFinish(ByteBufferUtil.EMPTY_BYTE_BUFFER); slicePredicate.setSlice_range(sliceRange);
predicate.setSlice_range(new SliceRange(ByteBufferUtil.EMPTY_BYTE_BUFFER, ByteBufferUtil.EMPTY_BYTE_BUFFER, true, 10000));
@Test public void testMultigetCount() { // insert 25 columns into 10 rows List<ByteBuffer> keys = new ArrayList<ByteBuffer>(); for ( int j=0; j < 10; j++ ) { for (int i = 0; i < 25; i++) { ColumnPath cp = new ColumnPath("Standard1"); cp.setColumn(StringSerializer.get().toByteBuffer("testMultigetCount_column_" + i)); keyspace.insert("testMultigetCount_key_"+j, cp, StringSerializer.get().toByteBuffer("testMultigetCount_value_" + i)); } if (j % 2 == 0) { keys.add(StringSerializer.get().toByteBuffer("testMultigetCount_key_"+j)); } } // get value ColumnParent clp = new ColumnParent("Standard1"); SlicePredicate slicePredicate = new SlicePredicate(); SliceRange sr = new SliceRange(ByteBuffer.wrap(new byte[0]), ByteBuffer.wrap(new byte[0]), false, 150); slicePredicate.setSlice_range(sr); Map<ByteBuffer,Integer> counts = keyspace.multigetCount(keys, clp, slicePredicate); assertEquals(5,counts.size()); assertEquals(new Integer(25),counts.entrySet().iterator().next().getValue()); slicePredicate.setSlice_range(new SliceRange(StringSerializer.get().toByteBuffer(""), StringSerializer.get().toByteBuffer(""), false, 5)); counts = keyspace.multigetCount(keys, clp, slicePredicate); assertEquals(5,counts.size()); assertEquals(new Integer(5),counts.entrySet().iterator().next().getValue()); }
/** * Will throw a runtime exception if neither columnsNames nor count were set. * @return */ public SlicePredicate toThrift() { SlicePredicate pred = new SlicePredicate(); switch (predicateType) { case ColumnNames: if (columnNames == null ) { return null; } pred.setColumn_names(toThriftColumnNames(columnNames)); break; case Range: Assert.isTrue(countSet, "Count was not set, neither were column-names set, can't execute"); SliceRange range = new SliceRange(findBytes(start), findBytes(finish), reversed, count); pred.setSlice_range(range); break; case Unknown: default: throw new HectorException( "Neither column names nor range were set, this is an invalid slice predicate"); } return pred; }
@Test public void testGetSlice() throws HectorException { // insert value ArrayList<String> columnnames = new ArrayList<String>(100); for (int i = 0; i < 100; i++) { ColumnPath cp = new ColumnPath("Standard1"); cp.setColumn(bytes("testGetSlice_" + i)); keyspace.insert("testGetSlice", cp, StringSerializer.get().toByteBuffer("testGetSlice_Value_" + i)); columnnames.add("testGetSlice_" + i); } // get value ColumnParent clp = new ColumnParent("Standard1"); SliceRange sr = new SliceRange(ByteBuffer.wrap(new byte[0]), ByteBuffer.wrap(new byte[0]), false, 150); SlicePredicate sp = new SlicePredicate(); sp.setSlice_range(sr); List<Column> cols = keyspace.getSlice("testGetSlice", clp, sp); assertNotNull(cols); assertEquals(100, cols.size()); Collections.sort(columnnames); ArrayList<String> gotlist = new ArrayList<String>(100); for (int i = 0; i < 100; i++) { gotlist.add(string(cols.get(i).getName())); } assertEquals(columnnames, gotlist); ColumnPath cp = new ColumnPath("Standard1"); keyspace.remove("testGetSlice_", cp); keyspace.remove("testGetSlice", cp); }
@Test public void testMultigetSlice() throws HectorException { // insert value ColumnPath cp = new ColumnPath("Standard1"); cp.setColumn(bytes("testMultigetSlice")); ArrayList<String> keys = new ArrayList<String>(100); for (int i = 0; i < 100; i++) { keyspace.insert("testMultigetSlice_" + i, cp, StringSerializer.get().toByteBuffer("testMultigetSlice_value_" + i)); keys.add("testMultigetSlice_" + i); } // get value ColumnParent clp = new ColumnParent("Standard1"); SliceRange sr = new SliceRange(ByteBuffer.wrap(new byte[0]), ByteBuffer.wrap(new byte[0]), false, 150); SlicePredicate sp = new SlicePredicate(); sp.setSlice_range(sr); Map<String, List<Column>> ms = se.fromBytesMap(keyspace.multigetSlice(se.toBytesList(keys), clp, sp)); for (int i = 0; i < 100; i++) { List<Column> cl = ms.get(keys.get(i)); assertNotNull(cl); assertEquals(1, cl.size()); assertTrue(string(cl.get(0).getValue()).startsWith("testMultigetSlice_")); } // remove value for (int i = 0; i < 100; i++) { keyspace.remove("testMultigetSlice_" + i, cp); } }
@Test public void testGetSuperRangeSlices() throws HectorException { for (int i = 0; i < 10; i++) { ColumnPath cp = new ColumnPath("Super1"); cp.setSuper_column(bytes("SuperColumn_1")); cp.setColumn(bytes("testGetSuperRangeSlices_" + i)); keyspace.insert("testGetSuperRangeSlices0", cp, StringSerializer.get().toByteBuffer("testGetSuperRangeSlices_Value_" + i)); keyspace.insert("testGetSuperRangeSlices1", cp, StringSerializer.get().toByteBuffer("testGetSuperRangeSlices_Value_" + i)); } // get value ColumnParent clp = new ColumnParent("Super1"); SliceRange sr = new SliceRange(ByteBuffer.wrap(new byte[0]), ByteBuffer.wrap(new byte[0]), false, 150); SlicePredicate sp = new SlicePredicate(); sp.setSlice_range(sr); KeyRange range = new KeyRange(); range.setStart_key( "".getBytes()); range.setEnd_key( "".getBytes()); Map<String, List<SuperColumn>> keySlices = se.fromBytesMap(keyspace.getSuperRangeSlices(clp, sp, range)); assertNotNull(keySlices); assertNotNull("testGetSuperRangSlices0 is null", keySlices.get("testGetSuperRangeSlices0")); assertEquals("testGetSuperRangeSlices_Value_0", string(keySlices.get("testGetSuperRangeSlices0").get(0).getColumns().get(0).getValue())); assertEquals(1, keySlices.get("testGetSuperRangeSlices1").size()); assertEquals(10, keySlices.get("testGetSuperRangeSlices1").get(0).getColumns().size()); ColumnPath cp = new ColumnPath("Super1"); keyspace.remove("testGetSuperRangeSlices0", cp); keyspace.remove("testGetSuperRangeSlices1", cp); }
@Test public void testGetRangeSlices() throws HectorException { for (int i = 0; i < 10; i++) { ColumnPath cp = new ColumnPath("Standard1"); cp.setColumn(bytes("testGetRangeSlices_" + i)); keyspace.insert("testGetRangeSlices0", cp, StringSerializer.get().toByteBuffer("testGetRangeSlices_Value_" + i)); keyspace.insert("testGetRangeSlices1", cp, StringSerializer.get().toByteBuffer("testGetRangeSlices_Value_" + i)); keyspace.insert("testGetRangeSlices2", cp, StringSerializer.get().toByteBuffer("testGetRangeSlices_Value_" + i)); } // get value ColumnParent clp = new ColumnParent("Standard1"); SliceRange sr = new SliceRange(ByteBuffer.wrap(new byte[0]), ByteBuffer.wrap(new byte[0]), false, 150); SlicePredicate sp = new SlicePredicate(); sp.setSlice_range(sr); KeyRange range = new KeyRange(); range.setStart_key( "".getBytes()); range.setEnd_key( "".getBytes()); Map<String, List<Column>> keySlices = se.fromBytesMap(keyspace.getRangeSlices(clp, sp, range)); assertNotNull(keySlices); assertNotNull("testGetRangeSlices1 is null", keySlices.get("testGetRangeSlices1")); assertEquals("testGetRangeSlices_Value_0", string(keySlices.get("testGetRangeSlices1").get(0).getValue())); assertEquals(10, keySlices.get("testGetRangeSlices1").size()); ColumnPath cp = new ColumnPath("Standard1"); keyspace.remove("testGetRanageSlices0", cp); keyspace.remove("testGetRanageSlices1", cp); keyspace.remove("testGetRanageSlices2", cp); }
SliceRange sr = new SliceRange(ByteBuffer.wrap(new byte[0]), ByteBuffer.wrap(new byte[0]), false, 150); SlicePredicate sp = new SlicePredicate(); sp.setSlice_range(sr); List<SuperColumn> cols = keyspace.getSuperSlice("testGetSuperSlice", clp, sp);
@Test public void testGetSuperRangeSlice() throws HectorException { for (int i = 0; i < 10; i++) { ColumnPath cp = new ColumnPath("Super1"); cp.setSuper_column(bytes("SuperColumn_1")); cp.setColumn(bytes("testGetSuperRangeSlice_" + i)); keyspace.insert("testGetSuperRangeSlice0", cp, StringSerializer.get().toByteBuffer("testGetSuperRangeSlice_Value_" + i)); keyspace.insert("testGetSuperRangeSlice1", cp, StringSerializer.get().toByteBuffer("testGetSuperRangeSlice_Value_" + i)); } // get value ColumnParent clp = new ColumnParent("Super1"); SliceRange sr = new SliceRange(ByteBuffer.wrap(new byte[0]), ByteBuffer.wrap(new byte[0]), false, 150); SlicePredicate sp = new SlicePredicate(); sp.setSlice_range(sr); /* @SuppressWarnings("deprecation") Map<String, List<SuperColumn>> keySlices = keyspace.getSuperRangeSlice(clp, sp, "testGetSuperRangeSlice0", "testGetSuperRangeSlice3", 5); assertNotNull(keySlices); assertEquals(2, keySlices.size()); assertNotNull("testGetSuperRangSlice0 is null", keySlices.get("testGetSuperRangeSlice0")); assertEquals("testGetSuperRangeSlice_Value_0", string(keySlices.get("testGetSuperRangeSlice0").get(0).getColumns().get(0).getValue())); assertEquals(1, keySlices.get("testGetSuperRangeSlice1").size()); assertEquals(10, keySlices.get("testGetSuperRangeSlice1").get(0).getColumns().size()); */ ColumnPath cp = new ColumnPath("Super1"); keyspace.remove("testGetSuperRangeSlice0", cp); keyspace.remove("testGetSuperRangeSlice1", cp); }
@Test public void testGetRangeSlice() throws HectorException { for (int i = 0; i < 10; i++) { ColumnPath cp = new ColumnPath("Standard1"); cp.setColumn(bytes("testGetRangeSlice_" + i)); keyspace.insert("testGetRangeSlice0", cp, StringSerializer.get().toByteBuffer("testGetRangeSlice_Value_" + i)); keyspace.insert("testGetRangeSlice1", cp, StringSerializer.get().toByteBuffer("testGetRangeSlice_Value_" + i)); keyspace.insert("testGetRangeSlice2", cp, StringSerializer.get().toByteBuffer("testGetRangeSlice_Value_" + i)); } // get value ColumnParent clp = new ColumnParent("Standard1"); SliceRange sr = new SliceRange(ByteBuffer.wrap(new byte[0]), ByteBuffer.wrap(new byte[0]), false, 150); SlicePredicate sp = new SlicePredicate(); sp.setSlice_range(sr); /* @SuppressWarnings("deprecation") Map<String, List<Column>> keySlices = keyspace.getRangeSlice(clp, sp, "testGetRangeSlice0", "testGetRangeSlice3", 5); assertNotNull(keySlices); assertEquals(3, keySlices.size()); assertNotNull("testGetRangeSlice1 is null", keySlices.get("testGetRangeSlice1")); assertEquals("testGetRangeSlice_Value_0", string(keySlices.get("testGetRangeSlice1").get(0).getValue())); assertEquals(10, keySlices.get("testGetRangeSlice1").size()); */ ColumnPath cp = new ColumnPath("Standard1"); keyspace.remove("testGetRanageSlice0", cp); keyspace.remove("testGetRanageSlice1", cp); keyspace.remove("testGetRanageSlice2", cp); }