View Javadoc

1   /*
2    * Copyright (c) 2011.  The Apache Software Foundation
3    *
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *     http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing, software
15   * distributed under the License is distributed on an "AS IS" BASIS,
16   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17   * See the License for the specific language governing permissions and
18   * limitations under the License.
19   */
20  
21  package org.apache.expreval.expr.compare;
22  
23  import org.apache.commons.logging.Log;
24  import org.apache.commons.logging.LogFactory;
25  import org.apache.expreval.client.NullColumnValueException;
26  import org.apache.expreval.client.ResultMissingColumnException;
27  import org.apache.expreval.expr.Operator;
28  import org.apache.expreval.expr.node.GenericValue;
29  import org.apache.expreval.expr.node.StringValue;
30  import org.apache.expreval.expr.var.DelegateColumn;
31  import org.apache.expreval.expr.var.GenericColumn;
32  import org.apache.hadoop.hbase.filter.CompareFilter;
33  import org.apache.hadoop.hbase.filter.Filter;
34  import org.apache.hadoop.hbase.hbql.client.HBqlException;
35  import org.apache.hadoop.hbase.hbql.impl.HConnectionImpl;
36  import org.apache.hadoop.hbase.hbql.impl.Utils;
37  import org.apache.hadoop.hbase.hbql.io.IO;
38  import org.apache.hadoop.hbase.hbql.mapping.FieldType;
39  
40  import java.io.DataInput;
41  import java.io.DataOutput;
42  import java.io.IOException;
43  
44  public class StringCompare extends GenericCompare {
45  
46      private static final Log LOG = LogFactory.getLog(StringCompare.class);
47  
48      public StringCompare(final GenericValue arg0, final Operator operator, final GenericValue arg1) {
49          super(arg0, operator, arg1);
50      }
51  
52      public Class<? extends GenericValue> validateTypes(final GenericValue parentExpr,
53                                                         final boolean allowCollections) throws HBqlException {
54          return this.validateType(StringValue.class);
55      }
56  
57      public Boolean getValue(final HConnectionImpl conn, final Object object) throws HBqlException,
58                                                                                      ResultMissingColumnException,
59                                                                                      NullColumnValueException {
60          final String val0 = (String)this.getValue(0, conn, object);
61          final String val1 = (String)this.getValue(1, conn, object);
62  
63          switch (this.getOperator()) {
64              case EQ:
65                  return val0.equals(val1);
66              case NOTEQ:
67                  return !val0.equals(val1);
68              case GT:
69                  return val0.compareTo(val1) > 0;
70              case GTEQ:
71                  return val0.compareTo(val1) >= 0;
72              case LT:
73                  return val0.compareTo(val1) < 0;
74              case LTEQ:
75                  return val0.compareTo(val1) <= 0;
76              default:
77                  throw new HBqlException("Invalid operator: " + this.getOperator());
78          }
79      }
80  
81      public Filter getFilter() throws HBqlException {
82  
83          this.validateArgsForCompareFilter();
84  
85          final GenericColumn<? extends GenericValue> column;
86          final Object constant;
87          final CompareFilter.CompareOp compareOp;
88  
89          if (this.getExprArg(0).isAColumnReference()) {
90              column = ((DelegateColumn)this.getExprArg(0)).getTypedColumn();
91              constant = this.getConstantValue(1);
92              compareOp = this.getOperator().getCompareOpLeft();
93          }
94          else {
95              column = ((DelegateColumn)this.getExprArg(1)).getTypedColumn();
96              constant = this.getConstantValue(0);
97              compareOp = this.getOperator().getCompareOpRight();
98          }
99  
100         return this.newSingleColumnValueFilter(column.getColumnAttrib(),
101                                                compareOp,
102                                                new StringComparable((String)constant));
103     }
104 
105     private static class StringComparable extends GenericComparable<String> {
106 
107         public StringComparable() {
108         }
109 
110         public StringComparable(final String value) {
111             this.setTypedValue(value);
112         }
113 
114         public int compareTo(final byte[] bytes) {
115 
116             if (this.equalValues(bytes))
117                 return 0;
118 
119             try {
120                 final String columnValue = IO.getSerialization().getStringFromBytes(bytes);
121                 return (this.getTypedValue().compareTo(columnValue));
122             }
123             catch (HBqlException e) {
124                 e.printStackTrace();
125                 Utils.logException(LOG, e);
126                 return 1;
127             }
128         }
129 
130         public void write(final DataOutput dataOutput) throws IOException {
131             dataOutput.writeUTF(this.getTypedValue());
132         }
133 
134         public void readFields(final DataInput dataInput) throws IOException {
135             this.setTypedValue(dataInput.readUTF());
136 
137             this.setValueInBytes(FieldType.StringType, this.getTypedValue());
138         }
139     }
140 }