@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 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); }
@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<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<HColumn<N, V>> execute() { return new QueryResultImpl<HColumn<N, V>>( keyspace.doExecute(new KeyspaceOperationCallback<HColumn<N, V>>() { @Override public HColumn<N, V> doInKeyspace(KeyspaceService ks) throws HectorException { try { Column thriftColumn = ks.getColumn(keySerializer.toByteBuffer(key), ThriftFactory.createColumnPath(columnFamilyName, name, columnNameSerializer)); return new HColumnImpl<N, V>(thriftColumn, columnNameSerializer, valueSerializer); } 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); }
@Override public QueryResult<OrderedSuperRows<K, SN,N, V>> execute() { Assert.notNull(columnFamilyName, "columnFamilyName can't be null"); return new QueryResultImpl<OrderedSuperRows<K, SN,N,V>>(keyspace.doExecute( new KeyspaceOperationCallback<OrderedSuperRows<K, SN,N,V>>() { @Override public OrderedSuperRows<K, SN,N,V> doInKeyspace(KeyspaceService ks) throws HectorException { ColumnParent columnParent = new ColumnParent(columnFamilyName); Map<K, List<SuperColumn>> thriftRet = keySerializer.fromBytesMap( ks.getSuperRangeSlices(columnParent, getPredicate(), keyRange.toThrift())); return new OrderedSuperRowsImpl<K, SN, N, V>( (LinkedHashMap<K, List<SuperColumn>>) thriftRet, keySerializer, columnNameSerializer, nameSerializer, valueSerializer); } }, 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<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<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<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<HColumn<N, V>> execute() { Assert.isTrue(subSliceQuery.getColumnNames().size() == 1, "There should be exactly one column name set. Call setColumn"); QueryResult<ColumnSlice<N, V>> r = subSliceQuery.execute(); ColumnSlice<N, V> slice = r.get(); List<HColumn<N,V>> columns = slice.getColumns(); HColumn<N, V> column = columns.size() == 0 ? null : columns.get(0); return new QueryResultImpl<HColumn<N,V>>( new ExecutionResult<HColumn<N,V>>(column, r.getExecutionTimeNano(), r.getHostUsed()), 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); }