View Javadoc

1   /**
2    *
3    * Licensed to the Apache Software Foundation (ASF) under one
4    * or more contributor license agreements.  See the NOTICE file
5    * distributed with this work for additional information
6    * regarding copyright ownership.  The ASF licenses this file
7    * to you under the Apache License, Version 2.0 (the
8    * "License"); you may not use this file except in compliance
9    * with the License.  You may obtain a copy of the License at
10   *
11   *     http://www.apache.org/licenses/LICENSE-2.0
12   *
13   * Unless required by applicable law or agreed to in writing, software
14   * distributed under the License is distributed on an "AS IS" BASIS,
15   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   * See the License for the specific language governing permissions and
17   * limitations under the License.
18   */
19  package org.apache.hadoop.hbase.filter;
20  
21  import java.io.IOException;
22  import java.util.ArrayList;
23  
24  import org.apache.hadoop.hbase.Cell;
25  import org.apache.hadoop.hbase.classification.InterfaceAudience;
26  import org.apache.hadoop.hbase.classification.InterfaceStability;
27  import org.apache.hadoop.hbase.exceptions.DeserializationException;
28  import org.apache.hadoop.hbase.protobuf.generated.FilterProtos;
29  
30  import com.google.common.base.Preconditions;
31  import com.google.protobuf.InvalidProtocolBufferException;
32  /**
33   * Implementation of Filter interface that limits results to a specific page
34   * size. It terminates scanning once the number of filter-passed rows is >
35   * the given page size.
36   * <p>
37   * Note that this filter cannot guarantee that the number of results returned
38   * to a client are &lt;= page size. This is because the filter is applied
39   * separately on different region servers. It does however optimize the scan of
40   * individual HRegions by making sure that the page size is never exceeded
41   * locally.
42   */
43  @InterfaceAudience.Public
44  @InterfaceStability.Stable
45  public class PageFilter extends FilterBase {
46    private long pageSize = Long.MAX_VALUE;
47    private int rowsAccepted = 0;
48  
49    /**
50     * Constructor that takes a maximum page size.
51     *
52     * @param pageSize Maximum result size.
53     */
54    public PageFilter(final long pageSize) {
55      Preconditions.checkArgument(pageSize >= 0, "must be positive %s", pageSize);
56      this.pageSize = pageSize;
57    }
58  
59    public long getPageSize() {
60      return pageSize;
61    }
62  
63    @Override
64    public boolean filterRowKey(Cell cell) throws IOException {
65      // Impl in FilterBase might do unnecessary copy for Off heap backed Cells.
66      if (filterAllRemaining()) return true;
67      return false;
68    }
69
70    @Override
71    public ReturnCode filterKeyValue(Cell ignored) throws IOException {
72      return ReturnCode.INCLUDE;
73    }
74
75    public boolean filterAllRemaining() {
76      return this.rowsAccepted >= this.pageSize;
77    }
78
79    public boolean filterRow() {
80      this.rowsAccepted++;
81      return this.rowsAccepted > this.pageSize;
82    }
83
84    public boolean hasFilterRow() {
85      return true;
86    }
87
88    public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) {
89      Preconditions.checkArgument(filterArguments.size() == 1,
90                                  "Expected 1 but got: %s", filterArguments.size());
91      long pageSize = ParseFilter.convertByteArrayToLong(filterArguments.get(0));
92      return new PageFilter(pageSize);
93    }
94
95    /**
96     * @return The filter serialized using pb
97     */
98    public byte [] toByteArray() {
99      FilterProtos.PageFilter.Builder builder =
100       FilterProtos.PageFilter.newBuilder();
101     builder.setPageSize(this.pageSize);
102     return builder.build().toByteArray();
103   }
104
105   /**
106    * @param pbBytes A pb serialized {@link PageFilter} instance
107    * @return An instance of {@link PageFilter} made from <code>bytes</code>
108    * @throws DeserializationException
109    * @see #toByteArray
110    */
111   public static PageFilter parseFrom(final byte [] pbBytes)
112   throws DeserializationException {
113     FilterProtos.PageFilter proto;
114     try {
115       proto = FilterProtos.PageFilter.parseFrom(pbBytes);
116     } catch (InvalidProtocolBufferException e) {
117       throw new DeserializationException(e);
118     }
119     return new PageFilter(proto.getPageSize());
120   }
121
122   /**
123    * @param other
124    * @return true if and only if the fields of the filter that are serialized
125    * are equal to the corresponding fields in other.  Used for testing.
126    */
127   boolean areSerializedFieldsEqual(Filter o) {
128     if (o == this) return true;
129     if (!(o instanceof PageFilter)) return false;
130
131     PageFilter other = (PageFilter)o;
132     return this.getPageSize() == other.getPageSize();
133   }
134
135   @Override
136   public String toString() {
137     return this.getClass().getSimpleName() + " " + this.pageSize;
138   }
139 }