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 <= 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 ReturnCode filterKeyValue(Cell ignored) throws IOException {
65      return ReturnCode.INCLUDE;
66    }
67    
68    public boolean filterAllRemaining() {
69      return this.rowsAccepted >= this.pageSize;
70    }
71  
72    public boolean filterRow() {
73      this.rowsAccepted++;
74      return this.rowsAccepted > this.pageSize;
75    }
76    
77    public boolean hasFilterRow() {
78      return true;
79    }
80  
81    public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) {
82      Preconditions.checkArgument(filterArguments.size() == 1,
83                                  "Expected 1 but got: %s", filterArguments.size());
84      long pageSize = ParseFilter.convertByteArrayToLong(filterArguments.get(0));
85      return new PageFilter(pageSize);
86    }
87  
88    /**
89     * @return The filter serialized using pb
90     */
91    public byte [] toByteArray() {
92      FilterProtos.PageFilter.Builder builder =
93        FilterProtos.PageFilter.newBuilder();
94      builder.setPageSize(this.pageSize);
95      return builder.build().toByteArray();
96    }
97  
98    /**
99     * @param pbBytes A pb serialized {@link PageFilter} instance
100    * @return An instance of {@link PageFilter} made from <code>bytes</code>
101    * @throws DeserializationException
102    * @see #toByteArray
103    */
104   public static PageFilter parseFrom(final byte [] pbBytes)
105   throws DeserializationException {
106     FilterProtos.PageFilter proto;
107     try {
108       proto = FilterProtos.PageFilter.parseFrom(pbBytes);
109     } catch (InvalidProtocolBufferException e) {
110       throw new DeserializationException(e);
111     }
112     return new PageFilter(proto.getPageSize());
113   }
114 
115   /**
116    * @param other
117    * @return true if and only if the fields of the filter that are serialized
118    * are equal to the corresponding fields in other.  Used for testing.
119    */
120   boolean areSerializedFieldsEqual(Filter o) {
121     if (o == this) return true;
122     if (!(o instanceof PageFilter)) return false;
123 
124     PageFilter other = (PageFilter)o;
125     return this.getPageSize() == other.getPageSize();
126   }
127 
128   @Override
129   public String toString() {
130     return this.getClass().getSimpleName() + " " + this.pageSize;
131   }
132 }