Refine search
expressions.add(ie); IndexClause ix = new IndexClause(); ix.setStart_key(ByteBufferUtil.EMPTY_BYTE_BUFFER); ix.setCount(Integer.MAX_VALUE); ix.setExpressions(expressions); ColumnParent columnParent = new ColumnParent(tableName); Connection conn = null; try
public int getRowCount() { return indexClause.getCount(); }
public List<SearchResult> search(EntityMetadata m, String persistenceUnit, ConsistencyLevel consistencyLevel, Map<Boolean, List<IndexClause>> indexClauseMap) { String columnFamilyName = m.getTableName() + Constants.INDEX_TABLE_SUFFIX; List<SearchResult> searchResults = new ArrayList<SearchResult>(); boolean isRowKeyQuery = indexClauseMap.keySet().iterator().next(); for (IndexClause o : indexClauseMap.get(isRowKeyQuery)) { for (IndexExpression expression : o.getExpressions()) { searchAndAddToResults(m, persistenceUnit, consistencyLevel, columnFamilyName, searchResults, expression, isRowKeyQuery); } } return searchResults; }
public IndexClause toThrift() { if (!indexClause.isSetStart_key()) { indexClause.setStart_key(new byte[0]); } return indexClause; } }
@Override public OrderedRows<K, N, V> doInKeyspace(KeyspaceService ks) throws HectorException { Map<ByteBuffer, List<Column>> ret = null; if (!indexClause.isSetStart_key()) { indexClause.setStart_key(new byte[0]); } ColumnParent columnParent = new ColumnParent(columnFamilyName); ret = ks .getIndexedSlices(columnParent, indexClause, getPredicate()); Map<K, List<Column>> thriftRet = keySerializer.fromBytesMap(ret); return new OrderedRowsImpl<K, N, V>( (LinkedHashMap<K, List<Column>>) thriftRet, columnNameSerializer, valueSerializer); } }, consistency), this);
new IndexClause(new ArrayList<IndexExpression>(), ByteBufferUtil.EMPTY_BYTE_BUFFER, maxResult); indexClause.setExpressions(expr); clauses.add(indexClause);
IndexClause clause = new IndexClause(); String columnFamily = CliCompiler.getColumnFamily(statement, currentCfDefs()); clause.addToExpressions(new IndexExpression(columnName, idxOperator, value)); clause.setStart_key(new byte[] {}); clause.setCount(limitValue); ColumnParent parent = new ColumnParent(columnFamily); slices = thriftClient.get_indexed_slices(parent, clause, predicate, consistencyLevel); printSliceList(columnFamilyDef, slices);
public void setFieldValue(_Fields field, Object value) { switch (field) { case EXPRESSIONS: if (value == null) { unsetExpressions(); } else { setExpressions((List<IndexExpression>)value); } break; case START_KEY: if (value == null) { unsetStart_key(); } else { setStart_key((ByteBuffer)value); } break; case COUNT: if (value == null) { unsetCount(); } else { setCount((Integer)value); } break; } }
protected void setNextStartKey(ByteBuffer byteBuffer) { indexClause.setStart_key(byteBuffer); if (firstPage) { firstPage = false; if (indexClause.getCount() != Integer.MAX_VALUE) indexClause.setCount(indexClause.getCount() + 1); } }
public List<KeySlice> indexGet(ByteBuffer columnName, ByteBuffer value, ByteBuffer startOffset, int limit, boolean isReverse) throws Exception { SlicePredicate predicate = new SlicePredicate().setSlice_range(new SliceRange(ByteBufferUtil.EMPTY_BYTE_BUFFER, ByteBufferUtil.EMPTY_BYTE_BUFFER, isReverse, limit)); ColumnParent parent = new ColumnParent(cfName); IndexExpression expression = new IndexExpression(columnName, IndexOperator.EQ, value); IndexClause clause = new IndexClause(Arrays.asList(expression), startOffset, limit); return client.get_indexed_slices(parent, clause, predicate, cl); }
public IndexedSlicesPredicate<K,N,V> startKey(K key) { indexClause.setStart_key(keySerializer.toByteBuffer(key)); return this; } public IndexedSlicesPredicate<K,N,V> addExpression(N columnName, IndexOperator op, V value) {
public IndexedSlicesPredicate<K,N,V> count(int count) { indexClause.setCount(count); return this; } public IndexedSlicesPredicate<K,N,V> startKey(K key) {
if (startSessionIfRequested()) Map<String, String> traceParameters = ImmutableMap.of("column_parent", column_parent.toString(), "index_clause", index_clause.toString(), "slice_predicate", column_predicate.toString(), "consistency_level", consistency_level.name()); ColumnFilter columns = makeColumnFilter(metadata, column_parent, column_predicate); ClusteringIndexFilter filter = toInternalFilter(metadata, column_parent, column_predicate); DataLimits limits = getLimits(index_clause.count, metadata.isSuper() && !column_parent.isSetSuper_column(), column_predicate);
public Object getFieldValue(_Fields field) { switch (field) { case EXPRESSIONS: return getExpressions(); case START_KEY: return getStart_key(); case COUNT: return Integer.valueOf(getCount()); } throw new IllegalStateException(); }
/** convert a list of index expression to string */ private static String indexExpressionsToString(List<IndexExpression> indexExpressions) throws IOException { assert indexExpressions != null; // oh, you thought cfdefToString was awful? IndexClause indexClause = new IndexClause(); indexClause.setExpressions(indexExpressions); indexClause.setStart_key("".getBytes()); TSerializer serializer = new TSerializer(new TBinaryProtocol.Factory()); try { return Hex.bytesToHex(serializer.serialize(indexClause)); } catch (TException e) { throw new IOException(e); } }
/** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); } switch (field) { case EXPRESSIONS: return isSetExpressions(); case START_KEY: return isSetStart_key(); case COUNT: return isSetCount(); } throw new IllegalStateException(); }
public boolean equals(IndexClause that) { if (that == null) return false; boolean this_present_expressions = true && this.isSetExpressions(); boolean that_present_expressions = true && that.isSetExpressions(); if (this_present_expressions || that_present_expressions) { if (!(this_present_expressions && that_present_expressions)) return false; if (!this.expressions.equals(that.expressions)) return false; } boolean this_present_start_key = true && this.isSetStart_key(); boolean that_present_start_key = true && that.isSetStart_key(); if (this_present_start_key || that_present_start_key) { if (!(this_present_start_key && that_present_start_key)) return false; if (!this.start_key.equals(that.start_key)) return false; } boolean this_present_count = true; boolean that_present_count = true; if (this_present_count || that_present_count) { if (!(this_present_count && that_present_count)) return false; if (this.count != that.count) return false; } return true; }
public IndexedSlicesPredicate<K,N,V> addExpression(N columnName, IndexOperator op, V value) { indexClause.addToExpressions(new IndexExpression(nameSerializer.toByteBuffer(columnName), op, valueSerializer.toByteBuffer(value))); return this; } public IndexClause toThrift() {
public IndexedSlicesQuery(Keyspace k, Serializer<K> keySerializer, Serializer<N> nameSerializer, Serializer<V> valueSerializer) { super(k, keySerializer, nameSerializer, valueSerializer); indexClause = new IndexClause(); }
/** convert string to a list of index expression */ private static List<IndexExpression> indexExpressionsFromString(String ie) throws IOException { assert ie != null; TDeserializer deserializer = new TDeserializer(new TBinaryProtocol.Factory()); IndexClause indexClause = new IndexClause(); try { deserializer.deserialize(indexClause, Hex.hexToBytes(ie)); } catch (TException e) { throw new IOException(e); } return indexClause.getExpressions(); }