Ejemplo n.º 1
 public List<Row> search(
     List<IndexExpression> clause,
     AbstractBounds<RowPosition> range,
     int maxResults,
     IFilter dataFilter,
     boolean maxIsColumns) {
   assert clause != null && !clause.isEmpty();
   ExtendedFilter filter =
       ExtendedFilter.create(baseCfs, dataFilter, clause, maxResults, maxIsColumns, false);
   return baseCfs.filter(getIndexedIterator(range, filter), filter);
Ejemplo n.º 2
  public ColumnFamilyStore.AbstractScanIterator getIndexedIterator(
      final AbstractBounds<RowPosition> range, final ExtendedFilter filter) {
    // Start with the most-restrictive indexed clause, then apply remaining clauses
    // to each row matching that clause.
    // TODO: allow merge join instead of just one index + loop
    final IndexExpression primary = highestSelectivityPredicate(filter.getClause());
    final SecondaryIndex index = indexManager.getIndexForColumn(primary.column_name);
    if (logger.isDebugEnabled())
          "Primary scan clause is " + baseCfs.getComparator().getString(primary.column_name));
    assert index != null;
    final DecoratedKey indexKey = indexManager.getIndexKeyFor(primary.column_name, primary.value);

     * XXX: If the range requested is a token range, we'll have to start at the beginning (and stop at the end) of
     * the indexed row unfortunately (which will be inefficient), because we have not way to intuit the small
     * possible key having a given token. A fix would be to actually store the token along the key in the
     * indexed row.
    final ByteBuffer startKey =
        range.left instanceof DecoratedKey
            ? ((DecoratedKey) range.left).key
            : ByteBufferUtil.EMPTY_BYTE_BUFFER;
    final ByteBuffer endKey =
        range.right instanceof DecoratedKey
            ? ((DecoratedKey) range.right).key
            : ByteBufferUtil.EMPTY_BYTE_BUFFER;

    return new ColumnFamilyStore.AbstractScanIterator() {
      private ByteBuffer lastSeenKey = startKey;
      private Iterator<IColumn> indexColumns;
      private final QueryPath path = new QueryPath(baseCfs.columnFamily);
      private int columnsRead = Integer.MAX_VALUE;

      protected Row computeNext() {
        int meanColumns = Math.max(index.getIndexCfs().getMeanColumns(), 1);
        // We shouldn't fetch only 1 row as this provides buggy paging in case the first row doesn't
        // satisfy all clauses
        int rowsPerQuery =
            Math.max(Math.min(filter.maxRows(), filter.maxColumns() / meanColumns), 2);
        while (true) {
          if (indexColumns == null || !indexColumns.hasNext()) {
            if (columnsRead < rowsPerQuery) {
                  "Read only {} (< {}) last page through, must be done", columnsRead, rowsPerQuery);
              return endOfData();

            if (logger.isDebugEnabled())
                      "Scanning index %s starting with %s",

            QueryFilter indexFilter =
                    new QueryPath(index.getIndexCfs().getColumnFamilyName()),
            ColumnFamily indexRow = index.getIndexCfs().getColumnFamily(indexFilter);
            logger.debug("fetched {}", indexRow);
            if (indexRow == null) {
              logger.debug("no data, all done");
              return endOfData();

            Collection<IColumn> sortedColumns = indexRow.getSortedColumns();
            columnsRead = sortedColumns.size();
            indexColumns = sortedColumns.iterator();
            IColumn firstColumn = sortedColumns.iterator().next();

            // Paging is racy, so it is possible the first column of a page is not the last seen
            // one.
            if (lastSeenKey != startKey && lastSeenKey.equals(firstColumn.name())) {
              // skip the row we already saw w/ the last page of results
                  "Skipping {}", baseCfs.metadata.getKeyValidator().getString(firstColumn.name()));
            } else if (range instanceof Range
                && indexColumns.hasNext()
                && firstColumn.name().equals(startKey)) {
              // skip key excluded by range
              logger.debug("Skipping first key as range excludes it");

          while (indexColumns.hasNext()) {
            IColumn column = indexColumns.next();
            lastSeenKey = column.name();
            if (column.isMarkedForDelete()) {
              logger.debug("skipping {}", column.name());

            DecoratedKey dk = baseCfs.partitioner.decorateKey(lastSeenKey);
            if (!range.right.isMinimum(baseCfs.partitioner) && range.right.compareTo(dk) < 0) {
              logger.debug("Reached end of assigned scan range");
              return endOfData();
            if (!range.contains(dk)) {
              logger.debug("Skipping entry {} outside of assigned scan range", dk.token);

            logger.debug("Returning index hit for {}", dk);
            ColumnFamily data =
                baseCfs.getColumnFamily(new QueryFilter(dk, path, filter.initialFilter()));
            // While the column family we'll get in the end should contains the primary clause
            // column, the initialFilter may not have found it and can thus be null
            if (data == null) data = ColumnFamily.create(baseCfs.metadata);
            return new Row(dk, data);

      public void close() throws IOException {}