public <T> ExecutionResult<T> doExecute(KeyspaceOperationCallback<T> koc) throws HectorException { return doExecute(koc, null); }
@Override public QueryResult<CounterSlice<N>> execute() { return new QueryResultImpl<CounterSlice<N>>(keyspace.doExecute( new KeyspaceOperationCallback<CounterSlice<N>>() { @Override public CounterSlice<N> doInKeyspace(KeyspaceService ks) throws HectorException { ColumnParent columnParent = new ColumnParent(columnFamilyName); List<CounterColumn> thriftRet = ks.getCounterSlice(keySerializer.toByteBuffer(key), columnParent, getPredicate()); return new CounterSliceImpl<N>(thriftRet, columnNameSerializer); } }, consistency), this); }
@Override public QueryResult<ColumnSlice<N, V>> execute() { return new QueryResultImpl<ColumnSlice<N, V>>(keyspace.doExecute( new KeyspaceOperationCallback<ColumnSlice<N, V>>() { @Override public ColumnSlice<N, V> doInKeyspace(KeyspaceService ks) throws HectorException { ColumnParent columnParent = new ColumnParent(columnFamilyName); List<Column> thriftRet = ks.getSlice(keySerializer.toByteBuffer(key), columnParent, getPredicate()); return new ColumnSliceImpl<N, V>(thriftRet, columnNameSerializer, valueSerializer); } }, consistency), this); }
@Override public QueryResult<CounterSuperSlice<SN, N>> execute() { return new QueryResultImpl<CounterSuperSlice<SN,N>>(keyspace.doExecute( new KeyspaceOperationCallback<CounterSuperSlice<SN,N>>() { @Override public CounterSuperSlice<SN, N> doInKeyspace(KeyspaceService ks) throws HectorException { ColumnParent columnParent = new ColumnParent(columnFamilyName); List<CounterSuperColumn> thriftRet = ks.getCounterSuperSlice(keySerializer.toByteBuffer(key), columnParent, getPredicate()); return new CounterSuperSliceImpl<SN, N>(thriftRet, columnNameSerializer, nameSerializer); } }, consistency), this); }
@Override public QueryResult<SuperSlice<SN, N, V>> execute() { return new QueryResultImpl<SuperSlice<SN,N,V>>(keyspace.doExecute( new KeyspaceOperationCallback<SuperSlice<SN,N,V>>() { @Override public SuperSlice<SN, N, V> doInKeyspace(KeyspaceService ks) throws HectorException { ColumnParent columnParent = new ColumnParent(columnFamilyName); List<SuperColumn> thriftRet = ks.getSuperSlice(keySerializer.toByteBuffer(key), columnParent, getPredicate()); return new SuperSliceImpl<SN, N, V>(thriftRet, columnNameSerializer, nameSerializer, valueSerializer); } }, consistency), this); }
@Override public <SN> MutationResult superDelete(final K key, final String cf, final SN supercolumnName, final Serializer<SN> sNameSerializer) { return new MutationResultImpl(keyspace.doExecute(new KeyspaceOperationCallback<Void>() { @Override public Void doInKeyspace(KeyspaceService ks) throws HectorException { // Remove a Super Column. ks.remove( keySerializer.toByteBuffer(key), ThriftFactory.createSuperColumnPath(cf, supercolumnName, sNameSerializer)); return null; } }, consistency)); }
@Override public QueryResult<SuperRows<K, SN, N, V>> execute() { return new QueryResultImpl<SuperRows<K, SN, N, V>>( keyspace.doExecute(new KeyspaceOperationCallback<SuperRows<K, SN, N, V>>() { @Override public SuperRows<K, SN, N, V> doInKeyspace(KeyspaceService ks) throws HectorException { List<K> keysList = new ArrayList<K>(); keysList.addAll(keys); ColumnParent columnParent = new ColumnParent(columnFamilyName); Map<K, List<SuperColumn>> thriftRet = keySerializer.fromBytesMap(ks.multigetSuperSlice( keySerializer.toBytesList(keysList), columnParent, getPredicate())); return new SuperRowsImpl<K, SN, N, V>(thriftRet, keySerializer, columnNameSerializer, nameSerializer, valueSerializer); } }, consistency), this); }
/** * Deletes a subcolumn of a supercolumn * @param <SN> super column type * @param <N> subcolumn type */ @Override public <SN,N> MutationResult subDelete(final K key, final String cf, final SN supercolumnName, final N columnName, final Serializer<SN> sNameSerializer, final Serializer<N> nameSerializer) { return new MutationResultImpl(keyspace.doExecute(new KeyspaceOperationCallback<Void>() { @Override public Void doInKeyspace(KeyspaceService ks) throws HectorException { ks.remove(keySerializer.toByteBuffer(key), ThriftFactory.createSuperColumnPath(cf, supercolumnName, columnName, sNameSerializer, nameSerializer)); return null; } }, consistency)); }
@Override public QueryResult<CounterSuperRows<K, SN, N>> execute() { return new QueryResultImpl<CounterSuperRows<K, SN, N>>( keyspace.doExecute(new KeyspaceOperationCallback<CounterSuperRows<K, SN, N>>() { @Override public CounterSuperRows<K, SN, N> doInKeyspace(KeyspaceService ks) throws HectorException { List<K> keysList = new ArrayList<K>(); keysList.addAll(keys); ColumnParent columnParent = new ColumnParent(columnFamilyName); Map<K, List<CounterSuperColumn>> thriftRet = keySerializer.fromBytesMap(ks.multigetCounterSuperSlice( keySerializer.toBytesList(keysList), columnParent, getPredicate())); return new CounterSuperRowsImpl<K, SN, N>(thriftRet, keySerializer, columnNameSerializer, nameSerializer); } }, consistency), this); }
@Override public QueryResult<HCounterColumn<N>> execute() { return new QueryResultImpl<HCounterColumn<N>>( keyspace.doExecute(new KeyspaceOperationCallback<HCounterColumn<N>>() { @Override public HCounterColumn<N> doInKeyspace(KeyspaceService ks) throws HectorException { try { CounterColumn thriftCounter = ks.getCounter(keySerializer.toByteBuffer(key), ThriftFactory.createColumnPath(columnFamilyName, name, columnNameSerializer)); return new HCounterColumnImpl<N>(thriftCounter, columnNameSerializer); } catch (HNotFoundException e) { return null; } } }, consistency), this); }
@Override public QueryResult<OrderedRows<K, N, V>> execute() { Assert.notNull(columnFamilyName, "columnFamilyName can't be null"); return new QueryResultImpl<OrderedRows<K, N,V>>(keyspace.doExecute( new KeyspaceOperationCallback<OrderedRows<K, N,V>>() { @Override public OrderedRows<K, N,V > doInKeyspace(KeyspaceService ks) throws HectorException { ColumnParent columnParent = new ColumnParent(columnFamilyName); Map<K, List<Column>> thriftRet = keySerializer.fromBytesMap( ks.getRangeSlices(columnParent, getPredicate(), keyRange.toThrift())); return new OrderedRowsImpl<K,N,V>((LinkedHashMap<K, List<Column>>) thriftRet, columnNameSerializer, valueSerializer); } }, consistency), this); }
@Override public QueryResult<OrderedCounterRows<K, N>> execute() { Assert.notNull(columnFamilyName, "columnFamilyName can't be null"); return new QueryResultImpl<OrderedCounterRows<K, N>>(keyspace.doExecute( new KeyspaceOperationCallback<OrderedCounterRows<K, N>>() { @Override public OrderedCounterRows<K, N> doInKeyspace(KeyspaceService ks) throws HectorException { ColumnParent columnParent = new ColumnParent(columnFamilyName); Map<K, List<CounterColumn>> thriftRet = keySerializer.fromBytesMap( ks.getRangeCounterSlices(columnParent, getPredicate(), keyRange.toThrift())); return new OrderedCounterRowsImpl<K,N>((LinkedHashMap<K, List<CounterColumn>>) thriftRet, columnNameSerializer); } }, consistency), this); }
@Override public QueryResult<OrderedCounterSuperRows<K, SN,N>> execute() { Assert.notNull(columnFamilyName, "columnFamilyName can't be null"); return new QueryResultImpl<OrderedCounterSuperRows<K, SN,N>>(keyspace.doExecute( new KeyspaceOperationCallback<OrderedCounterSuperRows<K, SN,N>>() { @Override public OrderedCounterSuperRows<K, SN,N> doInKeyspace(KeyspaceService ks) throws HectorException { ColumnParent columnParent = new ColumnParent(columnFamilyName); Map<K, List<CounterSuperColumn>> thriftRet = keySerializer.fromBytesMap( ks.getSuperRangeCounterSlices(columnParent, getPredicate(), keyRange.toThrift())); return new OrderedCounterSuperRowsImpl<K, SN, N>( (LinkedHashMap<K, List<CounterSuperColumn>>) thriftRet, keySerializer, columnNameSerializer, nameSerializer); } }, consistency), this); }
protected QueryResult<Integer> countColumns() { Assert.notNull(key, "key is null"); Assert.notNull(columnFamily, "columnFamily is null"); return new QueryResultImpl<Integer>(keyspace.doExecute( new KeyspaceOperationCallback<Integer>() { @Override public Integer doInKeyspace(KeyspaceService ks) throws HectorException { ColumnParent columnParent = new ColumnParent(columnFamily); return ks.getCount(keySerializer.toByteBuffer(key), columnParent, slicePredicate.toThrift()); } }, consistency), this); }
@Override public QueryResult<CounterSlice<N>> execute() { Assert.notNull(key, "Key cannot be null"); Assert.notNull(superColumn, "Supercolumn cannot be null"); return new QueryResultImpl<CounterSlice<N>>(keyspace.doExecute( new KeyspaceOperationCallback<CounterSlice<N>>() { @Override public CounterSlice<N> doInKeyspace(KeyspaceService ks) throws HectorException { ColumnParent columnParent = new ColumnParent(columnFamilyName); columnParent.setSuper_column(sNameSerializer.toByteBuffer(superColumn)); List<CounterColumn> thriftRet = ks.getCounterSlice(keySerializer.toByteBuffer(key), columnParent, getPredicate()); return new CounterSliceImpl<N>(thriftRet, columnNameSerializer); } }, consistency), this); }
@Override public QueryResult<ColumnSlice<N, V>> execute() { Assert.notNull(key, "Key cannot be null"); Assert.notNull(superColumn, "Supercolumn cannot be null"); return new QueryResultImpl<ColumnSlice<N, V>>(keyspace.doExecute( new KeyspaceOperationCallback<ColumnSlice<N, V>>() { @Override public ColumnSlice<N, V> doInKeyspace(KeyspaceService ks) throws HectorException { ColumnParent columnParent = new ColumnParent(columnFamilyName); columnParent.setSuper_column(sNameSerializer.toByteBuffer(superColumn)); List<Column> thriftRet = ks.getSlice(keySerializer.toByteBuffer(key), columnParent, getPredicate()); return new ColumnSliceImpl<N, V>(thriftRet, columnNameSerializer, valueSerializer); } }, consistency), this); }
@Override public QueryResult<Map<K, Integer>> execute() { Assert.notNull(keys, "keys list is null"); Assert.notNull(columnFamily, "columnFamily is null"); return new QueryResultImpl<Map<K,Integer>>(keyspace.doExecute( new KeyspaceOperationCallback<Map<K,Integer>>() { @Override public Map<K,Integer> doInKeyspace(KeyspaceService ks) throws HectorException { ColumnParent columnParent = new ColumnParent(columnFamily); Map<K,Integer> counts = keySerializer.fromBytesMap( ks.multigetCount(keySerializer.toBytesList(keys), columnParent, slicePredicate.toThrift())); return counts; } }, consistency), this); }
@Override public QueryResult<OrderedRows<K,N, V>> execute() { Assert.notNull(columnFamilyName, "columnFamilyName can't be null"); Assert.notNull(superColumn, "superColumn cannot be null"); return new QueryResultImpl<OrderedRows<K,N,V>>(keyspace.doExecute( new KeyspaceOperationCallback<OrderedRows<K,N,V>>() { @Override public OrderedRows<K,N,V> doInKeyspace(KeyspaceService ks) throws HectorException { ColumnParent columnParent = new ColumnParent(columnFamilyName); columnParent.setSuper_column(sNameSerializer.toByteBuffer(superColumn)); Map<K, List<Column>> thriftRet = keySerializer.fromBytesMap( ks.getRangeSlices(columnParent, getPredicate(), keyRange.toThrift())); return new OrderedRowsImpl<K,N,V>((LinkedHashMap<K, List<Column>>) thriftRet, columnNameSerializer, valueSerializer); } }, consistency), this); }
@Override public QueryResult<OrderedCounterRows<K,N>> execute() { Assert.notNull(columnFamilyName, "columnFamilyName can't be null"); Assert.notNull(superColumn, "superColumn cannot be null"); return new QueryResultImpl<OrderedCounterRows<K,N>>(keyspace.doExecute( new KeyspaceOperationCallback<OrderedCounterRows<K,N>>() { @Override public OrderedCounterRows<K,N> doInKeyspace(KeyspaceService ks) throws HectorException { ColumnParent columnParent = new ColumnParent(columnFamilyName); columnParent.setSuper_column(sNameSerializer.toByteBuffer(superColumn)); Map<K, List<CounterColumn>> thriftRet = keySerializer.fromBytesMap( ks.getRangeCounterSlices(columnParent, getPredicate(), keyRange.toThrift())); return new OrderedCounterRowsImpl<K,N>((LinkedHashMap<K, List<CounterColumn>>) thriftRet, columnNameSerializer); } }, consistency), this); }
@Override public QueryResult<Integer> execute() { Assert.notNull(key, "key is null"); Assert.notNull(columnFamily, "columnFamily is null"); Assert.notNull(superColumnName, "superColumnName is null"); return new QueryResultImpl<Integer>(keyspace.doExecute( new KeyspaceOperationCallback<Integer>() { @Override public Integer doInKeyspace(KeyspaceService ks) throws HectorException { ColumnParent columnParent = new ColumnParent(columnFamily); columnParent.setSuper_column(superNameSerializer.toByteBuffer(superColumnName)); Integer count = ks.getCount(keySerializer.toByteBuffer(key), columnParent, slicePredicate.toThrift()); return count; } }, consistency), this); }