hbase-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From te...@apache.org
Subject svn commit: r1196451 [5/5] - in /hbase/trunk: ./ bin/ src/examples/thrift2/ src/main/java/org/apache/hadoop/hbase/thrift2/ src/main/java/org/apache/hadoop/hbase/thrift2/generated/ src/main/resources/org/apache/hadoop/hbase/thrift2/ src/test/java/org/ap...
Date Wed, 02 Nov 2011 04:26:28 GMT
Added: hbase/trunk/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TScan.java
URL: http://svn.apache.org/viewvc/hbase/trunk/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TScan.java?rev=1196451&view=auto
==============================================================================
--- hbase/trunk/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TScan.java (added)
+++ hbase/trunk/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TScan.java Wed Nov  2 04:26:26 2011
@@ -0,0 +1,831 @@
+/**
+ * Autogenerated by Thrift Compiler (0.7.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Any timestamps in the columns are ignored, use timeRange to select by timestamp.
+ * Max versions defaults to 1.
+ */
+public class TScan implements org.apache.thrift.TBase<TScan, TScan._Fields>, java.io.Serializable, Cloneable {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TScan");
+
+  private static final org.apache.thrift.protocol.TField START_ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("startRow", org.apache.thrift.protocol.TType.STRING, (short)1);
+  private static final org.apache.thrift.protocol.TField STOP_ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("stopRow", org.apache.thrift.protocol.TType.STRING, (short)2);
+  private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3);
+  private static final org.apache.thrift.protocol.TField CACHING_FIELD_DESC = new org.apache.thrift.protocol.TField("caching", org.apache.thrift.protocol.TType.I32, (short)4);
+  private static final org.apache.thrift.protocol.TField MAX_VERSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("maxVersions", org.apache.thrift.protocol.TType.I32, (short)5);
+  private static final org.apache.thrift.protocol.TField TIME_RANGE_FIELD_DESC = new org.apache.thrift.protocol.TField("timeRange", org.apache.thrift.protocol.TType.STRUCT, (short)6);
+
+  public ByteBuffer startRow; // required
+  public ByteBuffer stopRow; // required
+  public List<TColumn> columns; // required
+  public int caching; // required
+  public int maxVersions; // required
+  public TTimeRange timeRange; // required
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    START_ROW((short)1, "startRow"),
+    STOP_ROW((short)2, "stopRow"),
+    COLUMNS((short)3, "columns"),
+    CACHING((short)4, "caching"),
+    MAX_VERSIONS((short)5, "maxVersions"),
+    TIME_RANGE((short)6, "timeRange");
+
+    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+    static {
+      for (_Fields field : EnumSet.allOf(_Fields.class)) {
+        byName.put(field.getFieldName(), field);
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, or null if its not found.
+     */
+    public static _Fields findByThriftId(int fieldId) {
+      switch(fieldId) {
+        case 1: // START_ROW
+          return START_ROW;
+        case 2: // STOP_ROW
+          return STOP_ROW;
+        case 3: // COLUMNS
+          return COLUMNS;
+        case 4: // CACHING
+          return CACHING;
+        case 5: // MAX_VERSIONS
+          return MAX_VERSIONS;
+        case 6: // TIME_RANGE
+          return TIME_RANGE;
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, throwing an exception
+     * if it is not found.
+     */
+    public static _Fields findByThriftIdOrThrow(int fieldId) {
+      _Fields fields = findByThriftId(fieldId);
+      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+      return fields;
+    }
+
+    /**
+     * Find the _Fields constant that matches name, or null if its not found.
+     */
+    public static _Fields findByName(String name) {
+      return byName.get(name);
+    }
+
+    private final short _thriftId;
+    private final String _fieldName;
+
+    _Fields(short thriftId, String fieldName) {
+      _thriftId = thriftId;
+      _fieldName = fieldName;
+    }
+
+    public short getThriftFieldId() {
+      return _thriftId;
+    }
+
+    public String getFieldName() {
+      return _fieldName;
+    }
+  }
+
+  // isset id assignments
+  private static final int __CACHING_ISSET_ID = 0;
+  private static final int __MAXVERSIONS_ISSET_ID = 1;
+  private BitSet __isset_bit_vector = new BitSet(2);
+
+  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+  static {
+    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+    tmpMap.put(_Fields.START_ROW, new org.apache.thrift.meta_data.FieldMetaData("startRow", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , true)));
+    tmpMap.put(_Fields.STOP_ROW, new org.apache.thrift.meta_data.FieldMetaData("stopRow", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , true)));
+    tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
+            new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TColumn.class))));
+    tmpMap.put(_Fields.CACHING, new org.apache.thrift.meta_data.FieldMetaData("caching", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+    tmpMap.put(_Fields.MAX_VERSIONS, new org.apache.thrift.meta_data.FieldMetaData("maxVersions", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+    tmpMap.put(_Fields.TIME_RANGE, new org.apache.thrift.meta_data.FieldMetaData("timeRange", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTimeRange.class)));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TScan.class, metaDataMap);
+  }
+
+  public TScan() {
+    this.maxVersions = 1;
+
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public TScan(TScan other) {
+    __isset_bit_vector.clear();
+    __isset_bit_vector.or(other.__isset_bit_vector);
+    if (other.isSetStartRow()) {
+      this.startRow = org.apache.thrift.TBaseHelper.copyBinary(other.startRow);
+;
+    }
+    if (other.isSetStopRow()) {
+      this.stopRow = org.apache.thrift.TBaseHelper.copyBinary(other.stopRow);
+;
+    }
+    if (other.isSetColumns()) {
+      List<TColumn> __this__columns = new ArrayList<TColumn>();
+      for (TColumn other_element : other.columns) {
+        __this__columns.add(new TColumn(other_element));
+      }
+      this.columns = __this__columns;
+    }
+    this.caching = other.caching;
+    this.maxVersions = other.maxVersions;
+    if (other.isSetTimeRange()) {
+      this.timeRange = new TTimeRange(other.timeRange);
+    }
+  }
+
+  public TScan deepCopy() {
+    return new TScan(this);
+  }
+
+  @Override
+  public void clear() {
+    this.startRow = null;
+    this.stopRow = null;
+    this.columns = null;
+    setCachingIsSet(false);
+    this.caching = 0;
+    this.maxVersions = 1;
+
+    this.timeRange = null;
+  }
+
+  public byte[] getStartRow() {
+    setStartRow(org.apache.thrift.TBaseHelper.rightSize(startRow));
+    return startRow == null ? null : startRow.array();
+  }
+
+  public ByteBuffer bufferForStartRow() {
+    return startRow;
+  }
+
+  public TScan setStartRow(byte[] startRow) {
+    setStartRow(startRow == null ? (ByteBuffer)null : ByteBuffer.wrap(startRow));
+    return this;
+  }
+
+  public TScan setStartRow(ByteBuffer startRow) {
+    this.startRow = startRow;
+    return this;
+  }
+
+  public void unsetStartRow() {
+    this.startRow = null;
+  }
+
+  /** Returns true if field startRow is set (has been assigned a value) and false otherwise */
+  public boolean isSetStartRow() {
+    return this.startRow != null;
+  }
+
+  public void setStartRowIsSet(boolean value) {
+    if (!value) {
+      this.startRow = null;
+    }
+  }
+
+  public byte[] getStopRow() {
+    setStopRow(org.apache.thrift.TBaseHelper.rightSize(stopRow));
+    return stopRow == null ? null : stopRow.array();
+  }
+
+  public ByteBuffer bufferForStopRow() {
+    return stopRow;
+  }
+
+  public TScan setStopRow(byte[] stopRow) {
+    setStopRow(stopRow == null ? (ByteBuffer)null : ByteBuffer.wrap(stopRow));
+    return this;
+  }
+
+  public TScan setStopRow(ByteBuffer stopRow) {
+    this.stopRow = stopRow;
+    return this;
+  }
+
+  public void unsetStopRow() {
+    this.stopRow = null;
+  }
+
+  /** Returns true if field stopRow is set (has been assigned a value) and false otherwise */
+  public boolean isSetStopRow() {
+    return this.stopRow != null;
+  }
+
+  public void setStopRowIsSet(boolean value) {
+    if (!value) {
+      this.stopRow = null;
+    }
+  }
+
+  public int getColumnsSize() {
+    return (this.columns == null) ? 0 : this.columns.size();
+  }
+
+  public java.util.Iterator<TColumn> getColumnsIterator() {
+    return (this.columns == null) ? null : this.columns.iterator();
+  }
+
+  public void addToColumns(TColumn elem) {
+    if (this.columns == null) {
+      this.columns = new ArrayList<TColumn>();
+    }
+    this.columns.add(elem);
+  }
+
+  public List<TColumn> getColumns() {
+    return this.columns;
+  }
+
+  public TScan setColumns(List<TColumn> columns) {
+    this.columns = columns;
+    return this;
+  }
+
+  public void unsetColumns() {
+    this.columns = null;
+  }
+
+  /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+  public boolean isSetColumns() {
+    return this.columns != null;
+  }
+
+  public void setColumnsIsSet(boolean value) {
+    if (!value) {
+      this.columns = null;
+    }
+  }
+
+  public int getCaching() {
+    return this.caching;
+  }
+
+  public TScan setCaching(int caching) {
+    this.caching = caching;
+    setCachingIsSet(true);
+    return this;
+  }
+
+  public void unsetCaching() {
+    __isset_bit_vector.clear(__CACHING_ISSET_ID);
+  }
+
+  /** Returns true if field caching is set (has been assigned a value) and false otherwise */
+  public boolean isSetCaching() {
+    return __isset_bit_vector.get(__CACHING_ISSET_ID);
+  }
+
+  public void setCachingIsSet(boolean value) {
+    __isset_bit_vector.set(__CACHING_ISSET_ID, value);
+  }
+
+  public int getMaxVersions() {
+    return this.maxVersions;
+  }
+
+  public TScan setMaxVersions(int maxVersions) {
+    this.maxVersions = maxVersions;
+    setMaxVersionsIsSet(true);
+    return this;
+  }
+
+  public void unsetMaxVersions() {
+    __isset_bit_vector.clear(__MAXVERSIONS_ISSET_ID);
+  }
+
+  /** Returns true if field maxVersions is set (has been assigned a value) and false otherwise */
+  public boolean isSetMaxVersions() {
+    return __isset_bit_vector.get(__MAXVERSIONS_ISSET_ID);
+  }
+
+  public void setMaxVersionsIsSet(boolean value) {
+    __isset_bit_vector.set(__MAXVERSIONS_ISSET_ID, value);
+  }
+
+  public TTimeRange getTimeRange() {
+    return this.timeRange;
+  }
+
+  public TScan setTimeRange(TTimeRange timeRange) {
+    this.timeRange = timeRange;
+    return this;
+  }
+
+  public void unsetTimeRange() {
+    this.timeRange = null;
+  }
+
+  /** Returns true if field timeRange is set (has been assigned a value) and false otherwise */
+  public boolean isSetTimeRange() {
+    return this.timeRange != null;
+  }
+
+  public void setTimeRangeIsSet(boolean value) {
+    if (!value) {
+      this.timeRange = null;
+    }
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case START_ROW:
+      if (value == null) {
+        unsetStartRow();
+      } else {
+        setStartRow((ByteBuffer)value);
+      }
+      break;
+
+    case STOP_ROW:
+      if (value == null) {
+        unsetStopRow();
+      } else {
+        setStopRow((ByteBuffer)value);
+      }
+      break;
+
+    case COLUMNS:
+      if (value == null) {
+        unsetColumns();
+      } else {
+        setColumns((List<TColumn>)value);
+      }
+      break;
+
+    case CACHING:
+      if (value == null) {
+        unsetCaching();
+      } else {
+        setCaching((Integer)value);
+      }
+      break;
+
+    case MAX_VERSIONS:
+      if (value == null) {
+        unsetMaxVersions();
+      } else {
+        setMaxVersions((Integer)value);
+      }
+      break;
+
+    case TIME_RANGE:
+      if (value == null) {
+        unsetTimeRange();
+      } else {
+        setTimeRange((TTimeRange)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case START_ROW:
+      return getStartRow();
+
+    case STOP_ROW:
+      return getStopRow();
+
+    case COLUMNS:
+      return getColumns();
+
+    case CACHING:
+      return Integer.valueOf(getCaching());
+
+    case MAX_VERSIONS:
+      return Integer.valueOf(getMaxVersions());
+
+    case TIME_RANGE:
+      return getTimeRange();
+
+    }
+    throw new IllegalStateException();
+  }
+
+  /** 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 START_ROW:
+      return isSetStartRow();
+    case STOP_ROW:
+      return isSetStopRow();
+    case COLUMNS:
+      return isSetColumns();
+    case CACHING:
+      return isSetCaching();
+    case MAX_VERSIONS:
+      return isSetMaxVersions();
+    case TIME_RANGE:
+      return isSetTimeRange();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof TScan)
+      return this.equals((TScan)that);
+    return false;
+  }
+
+  public boolean equals(TScan that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_startRow = true && this.isSetStartRow();
+    boolean that_present_startRow = true && that.isSetStartRow();
+    if (this_present_startRow || that_present_startRow) {
+      if (!(this_present_startRow && that_present_startRow))
+        return false;
+      if (!this.startRow.equals(that.startRow))
+        return false;
+    }
+
+    boolean this_present_stopRow = true && this.isSetStopRow();
+    boolean that_present_stopRow = true && that.isSetStopRow();
+    if (this_present_stopRow || that_present_stopRow) {
+      if (!(this_present_stopRow && that_present_stopRow))
+        return false;
+      if (!this.stopRow.equals(that.stopRow))
+        return false;
+    }
+
+    boolean this_present_columns = true && this.isSetColumns();
+    boolean that_present_columns = true && that.isSetColumns();
+    if (this_present_columns || that_present_columns) {
+      if (!(this_present_columns && that_present_columns))
+        return false;
+      if (!this.columns.equals(that.columns))
+        return false;
+    }
+
+    boolean this_present_caching = true && this.isSetCaching();
+    boolean that_present_caching = true && that.isSetCaching();
+    if (this_present_caching || that_present_caching) {
+      if (!(this_present_caching && that_present_caching))
+        return false;
+      if (this.caching != that.caching)
+        return false;
+    }
+
+    boolean this_present_maxVersions = true && this.isSetMaxVersions();
+    boolean that_present_maxVersions = true && that.isSetMaxVersions();
+    if (this_present_maxVersions || that_present_maxVersions) {
+      if (!(this_present_maxVersions && that_present_maxVersions))
+        return false;
+      if (this.maxVersions != that.maxVersions)
+        return false;
+    }
+
+    boolean this_present_timeRange = true && this.isSetTimeRange();
+    boolean that_present_timeRange = true && that.isSetTimeRange();
+    if (this_present_timeRange || that_present_timeRange) {
+      if (!(this_present_timeRange && that_present_timeRange))
+        return false;
+      if (!this.timeRange.equals(that.timeRange))
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    return 0;
+  }
+
+  public int compareTo(TScan other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+    TScan typedOther = (TScan)other;
+
+    lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(typedOther.isSetStartRow());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetStartRow()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startRow, typedOther.startRow);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetStopRow()).compareTo(typedOther.isSetStopRow());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetStopRow()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.stopRow, typedOther.stopRow);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetColumns()).compareTo(typedOther.isSetColumns());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetColumns()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetCaching()).compareTo(typedOther.isSetCaching());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetCaching()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.caching, typedOther.caching);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetMaxVersions()).compareTo(typedOther.isSetMaxVersions());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetMaxVersions()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.maxVersions, typedOther.maxVersions);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetTimeRange()).compareTo(typedOther.isSetTimeRange());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetTimeRange()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timeRange, typedOther.timeRange);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    return 0;
+  }
+
+  public _Fields fieldForId(int fieldId) {
+    return _Fields.findByThriftId(fieldId);
+  }
+
+  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+    org.apache.thrift.protocol.TField field;
+    iprot.readStructBegin();
+    while (true)
+    {
+      field = iprot.readFieldBegin();
+      if (field.type == org.apache.thrift.protocol.TType.STOP) { 
+        break;
+      }
+      switch (field.id) {
+        case 1: // START_ROW
+          if (field.type == org.apache.thrift.protocol.TType.STRING) {
+            this.startRow = iprot.readBinary();
+          } else { 
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 2: // STOP_ROW
+          if (field.type == org.apache.thrift.protocol.TType.STRING) {
+            this.stopRow = iprot.readBinary();
+          } else { 
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 3: // COLUMNS
+          if (field.type == org.apache.thrift.protocol.TType.LIST) {
+            {
+              org.apache.thrift.protocol.TList _list20 = iprot.readListBegin();
+              this.columns = new ArrayList<TColumn>(_list20.size);
+              for (int _i21 = 0; _i21 < _list20.size; ++_i21)
+              {
+                TColumn _elem22; // required
+                _elem22 = new TColumn();
+                _elem22.read(iprot);
+                this.columns.add(_elem22);
+              }
+              iprot.readListEnd();
+            }
+          } else { 
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 4: // CACHING
+          if (field.type == org.apache.thrift.protocol.TType.I32) {
+            this.caching = iprot.readI32();
+            setCachingIsSet(true);
+          } else { 
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 5: // MAX_VERSIONS
+          if (field.type == org.apache.thrift.protocol.TType.I32) {
+            this.maxVersions = iprot.readI32();
+            setMaxVersionsIsSet(true);
+          } else { 
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 6: // TIME_RANGE
+          if (field.type == org.apache.thrift.protocol.TType.STRUCT) {
+            this.timeRange = new TTimeRange();
+            this.timeRange.read(iprot);
+          } else { 
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        default:
+          org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+      }
+      iprot.readFieldEnd();
+    }
+    iprot.readStructEnd();
+
+    // check for required fields of primitive type, which can't be checked in the validate method
+    validate();
+  }
+
+  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+    validate();
+
+    oprot.writeStructBegin(STRUCT_DESC);
+    if (this.startRow != null) {
+      if (isSetStartRow()) {
+        oprot.writeFieldBegin(START_ROW_FIELD_DESC);
+        oprot.writeBinary(this.startRow);
+        oprot.writeFieldEnd();
+      }
+    }
+    if (this.stopRow != null) {
+      if (isSetStopRow()) {
+        oprot.writeFieldBegin(STOP_ROW_FIELD_DESC);
+        oprot.writeBinary(this.stopRow);
+        oprot.writeFieldEnd();
+      }
+    }
+    if (this.columns != null) {
+      if (isSetColumns()) {
+        oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+        {
+          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.columns.size()));
+          for (TColumn _iter23 : this.columns)
+          {
+            _iter23.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+    }
+    if (isSetCaching()) {
+      oprot.writeFieldBegin(CACHING_FIELD_DESC);
+      oprot.writeI32(this.caching);
+      oprot.writeFieldEnd();
+    }
+    if (isSetMaxVersions()) {
+      oprot.writeFieldBegin(MAX_VERSIONS_FIELD_DESC);
+      oprot.writeI32(this.maxVersions);
+      oprot.writeFieldEnd();
+    }
+    if (this.timeRange != null) {
+      if (isSetTimeRange()) {
+        oprot.writeFieldBegin(TIME_RANGE_FIELD_DESC);
+        this.timeRange.write(oprot);
+        oprot.writeFieldEnd();
+      }
+    }
+    oprot.writeFieldStop();
+    oprot.writeStructEnd();
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder("TScan(");
+    boolean first = true;
+
+    if (isSetStartRow()) {
+      sb.append("startRow:");
+      if (this.startRow == null) {
+        sb.append("null");
+      } else {
+        org.apache.thrift.TBaseHelper.toString(this.startRow, sb);
+      }
+      first = false;
+    }
+    if (isSetStopRow()) {
+      if (!first) sb.append(", ");
+      sb.append("stopRow:");
+      if (this.stopRow == null) {
+        sb.append("null");
+      } else {
+        org.apache.thrift.TBaseHelper.toString(this.stopRow, sb);
+      }
+      first = false;
+    }
+    if (isSetColumns()) {
+      if (!first) sb.append(", ");
+      sb.append("columns:");
+      if (this.columns == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.columns);
+      }
+      first = false;
+    }
+    if (isSetCaching()) {
+      if (!first) sb.append(", ");
+      sb.append("caching:");
+      sb.append(this.caching);
+      first = false;
+    }
+    if (isSetMaxVersions()) {
+      if (!first) sb.append(", ");
+      sb.append("maxVersions:");
+      sb.append(this.maxVersions);
+      first = false;
+    }
+    if (isSetTimeRange()) {
+      if (!first) sb.append(", ");
+      sb.append("timeRange:");
+      if (this.timeRange == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.timeRange);
+      }
+      first = false;
+    }
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+  }
+
+  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+    try {
+      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+    try {
+      // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+      __isset_bit_vector = new BitSet(1);
+      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+}
+

Added: hbase/trunk/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTimeRange.java
URL: http://svn.apache.org/viewvc/hbase/trunk/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTimeRange.java?rev=1196451&view=auto
==============================================================================
--- hbase/trunk/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTimeRange.java (added)
+++ hbase/trunk/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTimeRange.java Wed Nov  2 04:26:26 2011
@@ -0,0 +1,411 @@
+/**
+ * Autogenerated by Thrift Compiler (0.7.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TTimeRange implements org.apache.thrift.TBase<TTimeRange, TTimeRange._Fields>, java.io.Serializable, Cloneable {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TTimeRange");
+
+  private static final org.apache.thrift.protocol.TField MIN_STAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("minStamp", org.apache.thrift.protocol.TType.I64, (short)1);
+  private static final org.apache.thrift.protocol.TField MAX_STAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("maxStamp", org.apache.thrift.protocol.TType.I64, (short)2);
+
+  public long minStamp; // required
+  public long maxStamp; // required
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    MIN_STAMP((short)1, "minStamp"),
+    MAX_STAMP((short)2, "maxStamp");
+
+    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+    static {
+      for (_Fields field : EnumSet.allOf(_Fields.class)) {
+        byName.put(field.getFieldName(), field);
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, or null if its not found.
+     */
+    public static _Fields findByThriftId(int fieldId) {
+      switch(fieldId) {
+        case 1: // MIN_STAMP
+          return MIN_STAMP;
+        case 2: // MAX_STAMP
+          return MAX_STAMP;
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, throwing an exception
+     * if it is not found.
+     */
+    public static _Fields findByThriftIdOrThrow(int fieldId) {
+      _Fields fields = findByThriftId(fieldId);
+      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+      return fields;
+    }
+
+    /**
+     * Find the _Fields constant that matches name, or null if its not found.
+     */
+    public static _Fields findByName(String name) {
+      return byName.get(name);
+    }
+
+    private final short _thriftId;
+    private final String _fieldName;
+
+    _Fields(short thriftId, String fieldName) {
+      _thriftId = thriftId;
+      _fieldName = fieldName;
+    }
+
+    public short getThriftFieldId() {
+      return _thriftId;
+    }
+
+    public String getFieldName() {
+      return _fieldName;
+    }
+  }
+
+  // isset id assignments
+  private static final int __MINSTAMP_ISSET_ID = 0;
+  private static final int __MAXSTAMP_ISSET_ID = 1;
+  private BitSet __isset_bit_vector = new BitSet(2);
+
+  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+  static {
+    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+    tmpMap.put(_Fields.MIN_STAMP, new org.apache.thrift.meta_data.FieldMetaData("minStamp", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    tmpMap.put(_Fields.MAX_STAMP, new org.apache.thrift.meta_data.FieldMetaData("maxStamp", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TTimeRange.class, metaDataMap);
+  }
+
+  public TTimeRange() {
+  }
+
+  public TTimeRange(
+    long minStamp,
+    long maxStamp)
+  {
+    this();
+    this.minStamp = minStamp;
+    setMinStampIsSet(true);
+    this.maxStamp = maxStamp;
+    setMaxStampIsSet(true);
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public TTimeRange(TTimeRange other) {
+    __isset_bit_vector.clear();
+    __isset_bit_vector.or(other.__isset_bit_vector);
+    this.minStamp = other.minStamp;
+    this.maxStamp = other.maxStamp;
+  }
+
+  public TTimeRange deepCopy() {
+    return new TTimeRange(this);
+  }
+
+  @Override
+  public void clear() {
+    setMinStampIsSet(false);
+    this.minStamp = 0;
+    setMaxStampIsSet(false);
+    this.maxStamp = 0;
+  }
+
+  public long getMinStamp() {
+    return this.minStamp;
+  }
+
+  public TTimeRange setMinStamp(long minStamp) {
+    this.minStamp = minStamp;
+    setMinStampIsSet(true);
+    return this;
+  }
+
+  public void unsetMinStamp() {
+    __isset_bit_vector.clear(__MINSTAMP_ISSET_ID);
+  }
+
+  /** Returns true if field minStamp is set (has been assigned a value) and false otherwise */
+  public boolean isSetMinStamp() {
+    return __isset_bit_vector.get(__MINSTAMP_ISSET_ID);
+  }
+
+  public void setMinStampIsSet(boolean value) {
+    __isset_bit_vector.set(__MINSTAMP_ISSET_ID, value);
+  }
+
+  public long getMaxStamp() {
+    return this.maxStamp;
+  }
+
+  public TTimeRange setMaxStamp(long maxStamp) {
+    this.maxStamp = maxStamp;
+    setMaxStampIsSet(true);
+    return this;
+  }
+
+  public void unsetMaxStamp() {
+    __isset_bit_vector.clear(__MAXSTAMP_ISSET_ID);
+  }
+
+  /** Returns true if field maxStamp is set (has been assigned a value) and false otherwise */
+  public boolean isSetMaxStamp() {
+    return __isset_bit_vector.get(__MAXSTAMP_ISSET_ID);
+  }
+
+  public void setMaxStampIsSet(boolean value) {
+    __isset_bit_vector.set(__MAXSTAMP_ISSET_ID, value);
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case MIN_STAMP:
+      if (value == null) {
+        unsetMinStamp();
+      } else {
+        setMinStamp((Long)value);
+      }
+      break;
+
+    case MAX_STAMP:
+      if (value == null) {
+        unsetMaxStamp();
+      } else {
+        setMaxStamp((Long)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case MIN_STAMP:
+      return Long.valueOf(getMinStamp());
+
+    case MAX_STAMP:
+      return Long.valueOf(getMaxStamp());
+
+    }
+    throw new IllegalStateException();
+  }
+
+  /** 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 MIN_STAMP:
+      return isSetMinStamp();
+    case MAX_STAMP:
+      return isSetMaxStamp();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof TTimeRange)
+      return this.equals((TTimeRange)that);
+    return false;
+  }
+
+  public boolean equals(TTimeRange that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_minStamp = true;
+    boolean that_present_minStamp = true;
+    if (this_present_minStamp || that_present_minStamp) {
+      if (!(this_present_minStamp && that_present_minStamp))
+        return false;
+      if (this.minStamp != that.minStamp)
+        return false;
+    }
+
+    boolean this_present_maxStamp = true;
+    boolean that_present_maxStamp = true;
+    if (this_present_maxStamp || that_present_maxStamp) {
+      if (!(this_present_maxStamp && that_present_maxStamp))
+        return false;
+      if (this.maxStamp != that.maxStamp)
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    return 0;
+  }
+
+  public int compareTo(TTimeRange other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+    TTimeRange typedOther = (TTimeRange)other;
+
+    lastComparison = Boolean.valueOf(isSetMinStamp()).compareTo(typedOther.isSetMinStamp());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetMinStamp()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.minStamp, typedOther.minStamp);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetMaxStamp()).compareTo(typedOther.isSetMaxStamp());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetMaxStamp()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.maxStamp, typedOther.maxStamp);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    return 0;
+  }
+
+  public _Fields fieldForId(int fieldId) {
+    return _Fields.findByThriftId(fieldId);
+  }
+
+  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+    org.apache.thrift.protocol.TField field;
+    iprot.readStructBegin();
+    while (true)
+    {
+      field = iprot.readFieldBegin();
+      if (field.type == org.apache.thrift.protocol.TType.STOP) { 
+        break;
+      }
+      switch (field.id) {
+        case 1: // MIN_STAMP
+          if (field.type == org.apache.thrift.protocol.TType.I64) {
+            this.minStamp = iprot.readI64();
+            setMinStampIsSet(true);
+          } else { 
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 2: // MAX_STAMP
+          if (field.type == org.apache.thrift.protocol.TType.I64) {
+            this.maxStamp = iprot.readI64();
+            setMaxStampIsSet(true);
+          } else { 
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        default:
+          org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+      }
+      iprot.readFieldEnd();
+    }
+    iprot.readStructEnd();
+
+    // check for required fields of primitive type, which can't be checked in the validate method
+    if (!isSetMinStamp()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'minStamp' was not found in serialized data! Struct: " + toString());
+    }
+    if (!isSetMaxStamp()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'maxStamp' was not found in serialized data! Struct: " + toString());
+    }
+    validate();
+  }
+
+  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+    validate();
+
+    oprot.writeStructBegin(STRUCT_DESC);
+    oprot.writeFieldBegin(MIN_STAMP_FIELD_DESC);
+    oprot.writeI64(this.minStamp);
+    oprot.writeFieldEnd();
+    oprot.writeFieldBegin(MAX_STAMP_FIELD_DESC);
+    oprot.writeI64(this.maxStamp);
+    oprot.writeFieldEnd();
+    oprot.writeFieldStop();
+    oprot.writeStructEnd();
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder("TTimeRange(");
+    boolean first = true;
+
+    sb.append("minStamp:");
+    sb.append(this.minStamp);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("maxStamp:");
+    sb.append(this.maxStamp);
+    first = false;
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+    // alas, we cannot check 'minStamp' because it's a primitive and you chose the non-beans generator.
+    // alas, we cannot check 'maxStamp' because it's a primitive and you chose the non-beans generator.
+  }
+
+  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+    try {
+      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+    try {
+      // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+      __isset_bit_vector = new BitSet(1);
+      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+}
+

Added: hbase/trunk/src/main/java/org/apache/hadoop/hbase/thrift2/package.html
URL: http://svn.apache.org/viewvc/hbase/trunk/src/main/java/org/apache/hadoop/hbase/thrift2/package.html?rev=1196451&view=auto
==============================================================================
--- hbase/trunk/src/main/java/org/apache/hadoop/hbase/thrift2/package.html (added)
+++ hbase/trunk/src/main/java/org/apache/hadoop/hbase/thrift2/package.html Wed Nov  2 04:26:26 2011
@@ -0,0 +1,84 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<html>
+
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+-->
+
+<head />
+<body bgcolor="white">
+Provides an HBase <a href="http://thrift.apache.org/">Thrift</a>
+service.
+
+This package contains a Thrift interface definition file for an HBase RPC
+service and a Java server implementation.
+
+There is currently 2 thrift server implementations in HBase, the packages:
+
+<ul>
+  <li>org.apache.hadoop.hbase.thrift - This may one day be marked as depreceated.</li>
+  <li>org.apache.hadoop.hbase.thrift2 - This is intended to closely match to the HTable interface.</li>  
+</ul>
+
+<h2><a name="whatisthrift">What is Thrift?</a></h2>
+
+<p>From http://thrift.apache.org/</p> 
+  
+<p>"Thrift is a software framework for scalable cross-language services 
+development. It combines a software stack with a code generation engine to
+build services that work efficiently and seamlessly between C++, Java, Python,
+PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript, Node.js, Smalltalk,
+and OCaml. Originally developed at Facebook, Thrift was open sourced in April
+2007 and entered the Apache Incubator in May, 2008"</p>
+
+<h2><a name="description">Description</a></h2>
+
+<p>The <a href="generated/THBaseService.Iface.html">HBase API</a> is defined in the
+file hbase.thrift. A server-side implementation of the API is in
+<code>org.apache.hadoop.hbase.thrift2.ThriftHBaseServiceHandler</code> with the
+server boiler plate in <code>org.apache.hadoop.hbase.thrift2.ThriftServer</code>.
+The generated interfaces, types, and RPC utility files are checked into SVN under the
+<code>org.apache.hadoop.hbase.thrift2.generated</code> directory.
+
+</p>
+
+<p>The files were generated by running the commands:
+<pre>
+  thrift -strict --gen java src/main/resources/org/apache/hadoop/hbase/thrift2/hbase.thrift
+  mv gen-java/org/apache/hadoop/hbase/thrift2/generated src/main/java/org/apache/hadoop/hbase/thrift2/generated
+  rm -rf gen-java
+</pre>
+</p>
+
+<p>The 'thrift' binary is the Thrift compiler, and it is distributed separately from HBase
+in a Thrift release. Additionally, specific language runtime libraries are a
+part of a Thrift release. A version of the Java runtime is included in HBase via maven.
+</p>
+
+<p>To start ThriftServer, use:
+<pre>
+  ./bin/hbase-daemon.sh start thrift2 [--port=PORT]
+</pre>
+The default port is 9090.
+</p>
+
+<p>To stop, use:
+<pre>
+  ./bin/hbase-daemon.sh stop thrift
+</pre>
+</p>
+</body>
+</html>

Added: hbase/trunk/src/main/resources/org/apache/hadoop/hbase/thrift2/hbase.thrift
URL: http://svn.apache.org/viewvc/hbase/trunk/src/main/resources/org/apache/hadoop/hbase/thrift2/hbase.thrift?rev=1196451&view=auto
==============================================================================
--- hbase/trunk/src/main/resources/org/apache/hadoop/hbase/thrift2/hbase.thrift (added)
+++ hbase/trunk/src/main/resources/org/apache/hadoop/hbase/thrift2/hbase.thrift Wed Nov  2 04:26:26 2011
@@ -0,0 +1,411 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// NOTE: The "required" and "optional" keywords for the service methods are purely for documentation
+
+namespace java org.apache.hadoop.hbase.thrift2.generated
+namespace cpp apache.hadoop.hbase.thrift2
+namespace rb Apache.Hadoop.Hbase.Thrift2
+namespace py hbase
+namespace perl Hbase
+
+struct TTimeRange {
+  1: required i64 minStamp,
+  2: required i64 maxStamp
+}
+
+/**
+ * Addresses a single cell or multiple cells
+ * in a HBase table by column family and optionally
+ * a column qualifier and timestamp
+ */
+struct TColumn {
+  1: required binary family,
+  2: optional binary qualifier,
+  3: optional i64 timestamp
+}
+
+/**
+ * Represents a single cell and its value.
+ */
+struct TColumnValue {
+  1: required binary family,
+  2: required binary qualifier,
+  3: required binary value,
+  4: optional i64 timestamp
+}
+
+/**
+ * Represents a single cell and the amount to increment it by
+ */ 
+struct TColumnIncrement {
+  1: required binary family,
+  2: required binary qualifier,
+  3: optional i64 amount = 1
+}
+
+/**
+ * if no Result is found, row and columnValues will not be set.
+ */
+struct TResult {
+  1: optional binary row,
+  2: required list<TColumnValue> columnValues
+}
+
+/**
+ * Specify type of delete:
+ *  - DELETE_COLUMN means exactly one version will be removed,
+ *  - DELETE_COLUMNS means previous versions will also be removed.
+ */
+enum TDeleteType {
+  DELETE_COLUMN = 0,
+  DELETE_COLUMNS = 1
+}
+
+/**
+ * Used to perform Get operations on a single row.
+ *
+ * The scope can be further narrowed down by specifying a list of
+ * columns or column families.
+ *
+ * To get everything for a row, instantiate a Get object with just the row to get.
+ * To further define the scope of what to get you can add a timestamp or time range
+ * with an optional maximum number of versions to return.
+ *
+ * If you specify a time range and a timestamp the range is ignored.
+ * Timestamps on TColumns are ignored.
+ *
+ * TODO: Filter, Locks
+ */
+struct TGet {
+  1: required binary row,
+  2: optional list<TColumn> columns,
+
+  3: optional i64 timestamp,
+  4: optional TTimeRange timeRange,
+
+  5: optional i32 maxVersions,
+}
+
+/**
+ * Used to perform Put operations for a single row.
+ *
+ * Add column values to this object and they'll be added.
+ * You can provide a default timestamp if the column values
+ * don't have one. If you don't provide a default timestamp
+ * the current time is inserted.
+ *
+ * You can also specify if this Put should be written
+ * to the write-ahead Log (WAL) or not. It defaults to true.
+ */
+struct TPut {
+  1: required binary row,
+  2: required list<TColumnValue> columnValues
+  3: optional i64 timestamp,
+  4: optional bool writeToWal = 1
+}
+
+/**
+ * Used to perform Delete operations on a single row.
+ *
+ * The scope can be further narrowed down by specifying a list of
+ * columns or column families as TColumns.
+ *
+ * Specifying only a family in a TColumn will delete the whole family.
+ * If a timestamp is specified all versions with a timestamp less than
+ * or equal to this will be deleted. If no timestamp is specified the
+ * current time will be used.
+ *
+ * Specifying a family and a column qualifier in a TColumn will delete only
+ * this qualifier. If a timestamp is specified only versions equal
+ * to this timestamp will be deleted. If no timestamp is specified the
+ * most recent version will be deleted.  To delete all previous versions,
+ * specify the DELETE_COLUMNS TDeleteType.
+ *
+ * The top level timestamp is only used if a complete row should be deleted
+ * (i.e. no columns are passed) and if it is specified it works the same way
+ * as if you had added a TColumn for every column family and this timestamp
+ * (i.e. all versions older than or equal in all column families will be deleted)
+ *
+ */
+struct TDelete {
+  1: required binary row,
+  2: optional list<TColumn> columns,
+  3: optional i64 timestamp,
+  4: optional TDeleteType deleteType = 1
+}
+
+/**
+ * Used to perform Increment operations for a single row.
+ * 
+ * You can specify if this Increment should be written
+ * to the write-ahead Log (WAL) or not. It defaults to true.
+ */
+struct TIncrement {
+  1: required binary row,
+  2: required list<TColumnIncrement> columns,
+  3: optional bool writeToWal = 1
+}
+
+/**
+ * Any timestamps in the columns are ignored, use timeRange to select by timestamp.
+ * Max versions defaults to 1.
+ */
+struct TScan {
+  1: optional binary startRow,
+  2: optional binary stopRow,
+  3: optional list<TColumn> columns
+  4: optional i32 caching,
+  5: optional i32 maxVersions=1,
+  6: optional TTimeRange timeRange,
+}
+
+//
+// Exceptions
+//
+
+/**
+ * A TIOError exception signals that an error occurred communicating
+ * to the HBase master or a HBase region server. Also used to return
+ * more general HBase error conditions.
+ */
+exception TIOError {
+  1: optional string message
+}
+
+/**
+ * A TIllegalArgument exception indicates an illegal or invalid
+ * argument was passed into a procedure.
+ */
+exception TIllegalArgument {
+  1: optional string message
+}
+
+service THBaseService {
+
+  /**
+   * Test for the existence of columns in the table, as specified in the TGet.
+   *
+   * @return true if the specified TGet matches one or more keys, false if not
+   */
+  bool exists(
+    /** the table to check on */
+    1: required binary table,
+
+    /** the TGet to check for */
+    2: required TGet get
+  ) throws (1:TIOError io)
+
+  /**
+   * Method for getting data from a row.
+   *
+   * If the row cannot be found an empty Result is returned.
+   * This can be checked by the empty field of the TResult
+   *
+   * @return the result
+   */
+  TResult get(
+    /** the table to get from */
+    1: required binary table,
+
+    /** the TGet to fetch */
+    2: required TGet get
+  ) throws (1: TIOError io)
+
+  /**
+   * Method for getting multiple rows.
+   *
+   * If a row cannot be found there will be a null
+   * value in the result list for that TGet at the
+   * same position.
+   *
+   * So the Results are in the same order as the TGets.
+   */
+  list<TResult> getMultiple(
+    /** the table to get from */
+    1: required binary table,
+
+    /** a list of TGets to fetch, the Result list
+        will have the Results at corresponding positions
+        or null if there was an error */
+    2: required list<TGet> gets
+  ) throws (1: TIOError io)
+
+  /**
+   * Commit a TPut to a table.
+   */
+  void put(
+    /** the table to put data in */
+    1: required binary table,
+
+    /** the TPut to put */
+    2: required TPut put
+  ) throws (1: TIOError io)
+
+  /**
+   * Atomically checks if a row/family/qualifier value matches the expected
+   * value. If it does, it adds the TPut.
+   *
+   * @return true if the new put was executed, false otherwise
+   */
+  bool checkAndPut(
+    /** to check in and put to */
+    1: required binary table,
+
+    /** row to check */
+    2: required binary row,
+
+    /** column family to check */
+    3: required binary family,
+
+    /** column qualifier to check */
+    4: required binary qualifier,
+
+    /** the expected value, if not provided the
+        check is for the non-existence of the
+        column in question */
+    5: binary value,
+
+    /** the TPut to put if the check succeeds */
+    6: required TPut put
+  ) throws (1: TIOError io)
+
+  /**
+   * Commit a List of Puts to the table.
+   */
+  void putMultiple(
+    /** the table to put data in */
+    1: required binary table,
+
+    /** a list of TPuts to commit */
+    2: required list<TPut> puts
+  ) throws (1: TIOError io)
+
+  /**
+   * Deletes as specified by the TDelete.
+   *
+   * Note: "delete" is a reserved keyword and cannot be used in Thrift
+   * thus the inconsistent naming scheme from the other functions.
+   */
+  void deleteSingle(
+    /** the table to delete from */
+    1: required binary table,
+
+    /** the TDelete to delete */
+    2: required TDelete deleteSingle
+  ) throws (1: TIOError io)
+
+  /**
+   * Bulk commit a List of TDeletes to the table.
+   *
+   * This returns a list of TDeletes that were not
+   * executed. So if everything succeeds you'll
+   * receive an empty list.
+   */
+  list<TDelete> deleteMultiple(
+    /** the table to delete from */
+    1: required binary table,
+
+    /** list of TDeletes to delete */
+    2: required list<TDelete> deletes
+  ) throws (1: TIOError io)
+
+  /**
+   * Atomically checks if a row/family/qualifier value matches the expected
+   * value. If it does, it adds the delete.
+   *
+   * @return true if the new delete was executed, false otherwise
+   */
+  bool checkAndDelete(
+    /** to check in and delete from */
+    1: required binary table,
+
+    /** row to check */
+    2: required binary row,
+
+    /** column family to check */
+    3: required binary family,
+
+    /** column qualifier to check */
+    4: required binary qualifier,
+
+    /** the expected value, if not provided the
+        check is for the non-existence of the
+        column in question */
+    5: binary value,
+
+    /** the TDelete to execute if the check succeeds */
+    6: required TDelete deleteSingle
+  ) throws (1: TIOError io)
+  
+  TResult increment(
+    /** the table to increment the value on */
+    1: required binary table,
+
+    /** the TIncrement to increment */
+    2: required TIncrement increment
+  ) throws (1: TIOError io)
+
+  /**
+   * Get a Scanner for the provided TScan object.
+   *
+   * @return Scanner Id to be used with other scanner procedures
+   */
+  i32 openScanner(
+    /** the table to get the Scanner for */
+    1: required binary table,
+
+    /** the scan object to get a Scanner for */
+    2: required TScan scan,
+  ) throws (1: TIOError io)
+
+  /**
+   * Grabs multiple rows from a Scanner.
+   *
+   * @return Between zero and numRows TResults
+   */
+  list<TResult> getScannerRows(
+    /** the Id of the Scanner to return rows from. This is an Id returned from the openScanner function. */
+    1: required i32 scannerId,
+
+    /** number of rows to return */
+    2: i32 numRows = 1
+  ) throws (
+    1: TIOError io,
+
+    /** if the scannerId is invalid */
+    2: TIllegalArgument ia
+  )
+
+  /**
+   * Closes the scanner. Should be called if you need to close
+   * the Scanner before all results are read.
+   *
+   * Exhausted scanners are closed automatically.
+   */
+  void closeScanner(
+    /** the Id of the Scanner to close **/
+    1: required i32 scannerId
+  ) throws (
+    1: TIOError io,
+
+    /** if the scannerId is invalid */
+    2: TIllegalArgument ia
+  )
+
+}

Added: hbase/trunk/src/test/java/org/apache/hadoop/hbase/thrift2/TestThriftHBaseServiceHandler.java
URL: http://svn.apache.org/viewvc/hbase/trunk/src/test/java/org/apache/hadoop/hbase/thrift2/TestThriftHBaseServiceHandler.java?rev=1196451&view=auto
==============================================================================
--- hbase/trunk/src/test/java/org/apache/hadoop/hbase/thrift2/TestThriftHBaseServiceHandler.java (added)
+++ hbase/trunk/src/test/java/org/apache/hadoop/hbase/thrift2/TestThriftHBaseServiceHandler.java Wed Nov  2 04:26:26 2011
@@ -0,0 +1,511 @@
+/*
+ * Copyright 2009 The Apache Software Foundation
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.thrift2;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hbase.HBaseTestingUtility;
+import org.apache.hadoop.hbase.HColumnDescriptor;
+import org.apache.hadoop.hbase.HTableDescriptor;
+import org.apache.hadoop.hbase.client.HBaseAdmin;
+import org.apache.hadoop.hbase.thrift2.generated.TColumn;
+import org.apache.hadoop.hbase.thrift2.generated.TColumnIncrement;
+import org.apache.hadoop.hbase.thrift2.generated.TColumnValue;
+import org.apache.hadoop.hbase.thrift2.generated.TDelete;
+import org.apache.hadoop.hbase.thrift2.generated.TDeleteType;
+import org.apache.hadoop.hbase.thrift2.generated.TGet;
+import org.apache.hadoop.hbase.thrift2.generated.TIOError;
+import org.apache.hadoop.hbase.thrift2.generated.TIllegalArgument;
+import org.apache.hadoop.hbase.thrift2.generated.TIncrement;
+import org.apache.hadoop.hbase.thrift2.generated.TPut;
+import org.apache.hadoop.hbase.thrift2.generated.TResult;
+import org.apache.hadoop.hbase.thrift2.generated.TScan;
+import org.apache.hadoop.hbase.util.Bytes;
+import org.apache.thrift.TException;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Unit testing for ThriftServer.HBaseHandler, a part of the org.apache.hadoop.hbase.thrift2 package.
+ */
+public class TestThriftHBaseServiceHandler {
+  private static final HBaseTestingUtility UTIL = new HBaseTestingUtility();
+
+  // Static names for tables, columns, rows, and values
+  private static byte[] tableAname = Bytes.toBytes("tableA");
+  private static byte[] familyAname = Bytes.toBytes("familyA");
+  private static byte[] familyBname = Bytes.toBytes("familyB");
+  private static byte[] qualifierAname = Bytes.toBytes("qualifierA");
+  private static byte[] qualifierBname = Bytes.toBytes("qualifierB");
+  private static byte[] valueAname = Bytes.toBytes("valueA");
+  private static byte[] valueBname = Bytes.toBytes("valueB");
+  private static HColumnDescriptor[] families = new HColumnDescriptor[] {
+      new HColumnDescriptor(familyAname),
+      new HColumnDescriptor(familyBname, 2, HColumnDescriptor.DEFAULT_COMPRESSION, HColumnDescriptor.DEFAULT_IN_MEMORY,
+          HColumnDescriptor.DEFAULT_BLOCKCACHE, HColumnDescriptor.DEFAULT_TTL, HColumnDescriptor.DEFAULT_BLOOMFILTER) };
+
+  public void assertTColumnValuesEqual(List<TColumnValue> columnValuesA, List<TColumnValue> columnValuesB) {
+    assertEquals(columnValuesA.size(), columnValuesB.size());
+    Comparator<TColumnValue> comparator = new Comparator<TColumnValue>() {
+      @Override
+      public int compare(TColumnValue o1, TColumnValue o2) {
+        return Bytes.compareTo(Bytes.add(o1.getFamily(), o1.getQualifier()),
+            Bytes.add(o2.getFamily(), o2.getQualifier()));
+      }
+    };
+    Collections.sort(columnValuesA, comparator);
+    Collections.sort(columnValuesB, comparator);
+
+    for (int i = 0; i < columnValuesA.size(); i++) {
+      TColumnValue a = columnValuesA.get(i);
+      TColumnValue b = columnValuesB.get(i);
+      assertArrayEquals(a.getFamily(), b.getFamily());
+      assertArrayEquals(a.getQualifier(), b.getQualifier());
+      assertArrayEquals(a.getValue(), b.getValue());
+    }
+  }
+
+  @BeforeClass
+  public static void beforeClass() throws Exception {
+    UTIL.startMiniCluster();
+    HBaseAdmin admin = new HBaseAdmin(new Configuration());
+    HTableDescriptor tableDescriptor = new HTableDescriptor(tableAname);
+    for (HColumnDescriptor family : families) {
+      tableDescriptor.addFamily(family);
+    }
+    admin.createTable(tableDescriptor);
+  }
+
+  @AfterClass
+  public static void afterClass() throws Exception {
+    UTIL.shutdownMiniCluster();
+  }
+
+  @Before
+  public void setup() throws Exception {
+
+  }
+
+  @Test
+  public void testExists() throws TIOError, TException {
+    ThriftHBaseServiceHandler handler = new ThriftHBaseServiceHandler();
+    byte[] rowName = "testExists".getBytes();
+    ByteBuffer table = ByteBuffer.wrap(tableAname);
+
+    TGet get = new TGet(ByteBuffer.wrap(rowName));
+    assertFalse(handler.exists(table, get));
+
+    List<TColumnValue> columnValues = new ArrayList<TColumnValue>();
+    columnValues.add(new TColumnValue(ByteBuffer.wrap(familyAname), ByteBuffer.wrap(qualifierAname), ByteBuffer
+        .wrap(valueAname)));
+    columnValues.add(new TColumnValue(ByteBuffer.wrap(familyBname), ByteBuffer.wrap(qualifierBname), ByteBuffer
+        .wrap(valueBname)));
+    TPut put = new TPut(ByteBuffer.wrap(rowName), columnValues);
+    put.setColumnValues(columnValues);
+
+    handler.put(table, put);
+
+    assertTrue(handler.exists(table, get));
+  }
+
+  @Test
+  public void testPutGet() throws Exception {
+    ThriftHBaseServiceHandler handler = new ThriftHBaseServiceHandler();
+    byte[] rowName = "testPutGet".getBytes();
+    ByteBuffer table = ByteBuffer.wrap(tableAname);
+
+    List<TColumnValue> columnValues = new ArrayList<TColumnValue>();
+    columnValues.add(new TColumnValue(ByteBuffer.wrap(familyAname), ByteBuffer.wrap(qualifierAname), ByteBuffer
+        .wrap(valueAname)));
+    columnValues.add(new TColumnValue(ByteBuffer.wrap(familyBname), ByteBuffer.wrap(qualifierBname), ByteBuffer
+        .wrap(valueBname)));
+    TPut put = new TPut(ByteBuffer.wrap(rowName), columnValues);
+
+    put.setColumnValues(columnValues);
+
+    handler.put(table, put);
+
+    TGet get = new TGet(ByteBuffer.wrap(rowName));
+
+    TResult result = handler.get(table, get);
+    assertArrayEquals(rowName, result.getRow());
+    List<TColumnValue> returnedColumnValues = result.getColumnValues();
+    assertTColumnValuesEqual(columnValues, returnedColumnValues);
+  }
+
+  @Test
+  public void testPutGetMultiple() throws Exception {
+    ThriftHBaseServiceHandler handler = new ThriftHBaseServiceHandler();
+    ByteBuffer table = ByteBuffer.wrap(tableAname);
+    byte[] rowName1 = "testPutGetMultiple1".getBytes();
+    byte[] rowName2 = "testPutGetMultiple2".getBytes();
+
+    List<TColumnValue> columnValues = new ArrayList<TColumnValue>();
+    columnValues.add(new TColumnValue(ByteBuffer.wrap(familyAname), ByteBuffer.wrap(qualifierAname), ByteBuffer
+        .wrap(valueAname)));
+    columnValues.add(new TColumnValue(ByteBuffer.wrap(familyBname), ByteBuffer.wrap(qualifierBname), ByteBuffer
+        .wrap(valueBname)));
+    List<TPut> puts = new ArrayList<TPut>();
+    puts.add(new TPut(ByteBuffer.wrap(rowName1), columnValues));
+    puts.add(new TPut(ByteBuffer.wrap(rowName2), columnValues));
+
+    handler.putMultiple(table, puts);
+
+    List<TGet> gets = new ArrayList<TGet>();
+    gets.add(new TGet(ByteBuffer.wrap(rowName1)));
+    gets.add(new TGet(ByteBuffer.wrap(rowName2)));
+
+    List<TResult> results = handler.getMultiple(table, gets);
+    assertEquals(2, results.size());
+
+    assertArrayEquals(rowName1, results.get(0).getRow());
+    assertTColumnValuesEqual(columnValues, results.get(0).getColumnValues());
+
+    assertArrayEquals(rowName2, results.get(1).getRow());
+    assertTColumnValuesEqual(columnValues, results.get(1).getColumnValues());
+  }
+
+  @Test
+  public void testDeleteMultiple() throws Exception {
+    ThriftHBaseServiceHandler handler = new ThriftHBaseServiceHandler();
+    ByteBuffer table = ByteBuffer.wrap(tableAname);
+    byte[] rowName1 = "testDeleteMultiple1".getBytes();
+    byte[] rowName2 = "testDeleteMultiple2".getBytes();
+
+    List<TColumnValue> columnValues = new ArrayList<TColumnValue>();
+    columnValues.add(new TColumnValue(ByteBuffer.wrap(familyAname), ByteBuffer.wrap(qualifierAname), ByteBuffer
+        .wrap(valueAname)));
+    columnValues.add(new TColumnValue(ByteBuffer.wrap(familyBname), ByteBuffer.wrap(qualifierBname), ByteBuffer
+        .wrap(valueBname)));
+    List<TPut> puts = new ArrayList<TPut>();
+    puts.add(new TPut(ByteBuffer.wrap(rowName1), columnValues));
+    puts.add(new TPut(ByteBuffer.wrap(rowName2), columnValues));
+
+    handler.putMultiple(table, puts);
+
+    List<TDelete> deletes = new ArrayList<TDelete>();
+    deletes.add(new TDelete(ByteBuffer.wrap(rowName1)));
+    deletes.add(new TDelete(ByteBuffer.wrap(rowName2)));
+
+    List<TDelete> deleteResults = handler.deleteMultiple(table, deletes);
+    // 0 means they were all successfully applies
+    assertEquals(0, deleteResults.size());
+
+    assertFalse(handler.exists(table, new TGet(ByteBuffer.wrap(rowName1))));
+    assertFalse(handler.exists(table, new TGet(ByteBuffer.wrap(rowName2))));
+  }
+
+  @Test
+  public void testDelete() throws Exception {
+    ThriftHBaseServiceHandler handler = new ThriftHBaseServiceHandler();
+    byte[] rowName = "testDelete".getBytes();
+    ByteBuffer table = ByteBuffer.wrap(tableAname);
+
+    List<TColumnValue> columnValues = new ArrayList<TColumnValue>();
+    TColumnValue columnValueA = new TColumnValue(ByteBuffer.wrap(familyAname), ByteBuffer.wrap(qualifierAname),
+        ByteBuffer.wrap(valueAname));
+    TColumnValue columnValueB = new TColumnValue(ByteBuffer.wrap(familyBname), ByteBuffer.wrap(qualifierBname),
+        ByteBuffer.wrap(valueBname));
+    columnValues.add(columnValueA);
+    columnValues.add(columnValueB);
+    TPut put = new TPut(ByteBuffer.wrap(rowName), columnValues);
+
+    put.setColumnValues(columnValues);
+
+    handler.put(table, put);
+
+    TDelete delete = new TDelete(ByteBuffer.wrap(rowName));
+    List<TColumn> deleteColumns = new ArrayList<TColumn>();
+    TColumn deleteColumn = new TColumn(ByteBuffer.wrap(familyAname));
+    deleteColumn.setQualifier(qualifierAname);
+    deleteColumns.add(deleteColumn);
+    delete.setColumns(deleteColumns);
+
+    handler.deleteSingle(table, delete);
+
+    TGet get = new TGet(ByteBuffer.wrap(rowName));
+    TResult result = handler.get(table, get);
+    assertArrayEquals(rowName, result.getRow());
+    List<TColumnValue> returnedColumnValues = result.getColumnValues();
+    List<TColumnValue> expectedColumnValues = new ArrayList<TColumnValue>();
+    expectedColumnValues.add(columnValueB);
+    assertTColumnValuesEqual(expectedColumnValues, returnedColumnValues);
+  }
+
+  @Test
+  public void testDeleteAllTimestamps() throws Exception {
+    ThriftHBaseServiceHandler handler = new ThriftHBaseServiceHandler();
+    byte[] rowName = "testDeleteAllTimestamps".getBytes();
+    ByteBuffer table = ByteBuffer.wrap(tableAname);
+
+    List<TColumnValue> columnValues = new ArrayList<TColumnValue>();
+    TColumnValue columnValueA = new TColumnValue(ByteBuffer.wrap(familyAname), ByteBuffer.wrap(qualifierAname),
+        ByteBuffer.wrap(valueAname));
+    columnValueA.setTimestamp(System.currentTimeMillis() - 10);
+    columnValues.add(columnValueA);
+    TPut put = new TPut(ByteBuffer.wrap(rowName), columnValues);
+
+    put.setColumnValues(columnValues);
+
+    handler.put(table, put);
+    columnValueA.setTimestamp(System.currentTimeMillis());
+    handler.put(table, put);
+
+    TGet get = new TGet(ByteBuffer.wrap(rowName));
+    get.setMaxVersions(2);
+    TResult result = handler.get(table, get);
+    assertEquals(2, result.getColumnValuesSize());
+
+    TDelete delete = new TDelete(ByteBuffer.wrap(rowName));
+    List<TColumn> deleteColumns = new ArrayList<TColumn>();
+    TColumn deleteColumn = new TColumn(ByteBuffer.wrap(familyAname));
+    deleteColumn.setQualifier(qualifierAname);
+    deleteColumns.add(deleteColumn);
+    delete.setColumns(deleteColumns);
+    delete.setDeleteType(TDeleteType.DELETE_COLUMNS); // This is the default anyway.
+
+    handler.deleteSingle(table, delete);
+
+    get = new TGet(ByteBuffer.wrap(rowName));
+    result = handler.get(table, get);
+    assertNull(result.getRow());
+    assertEquals(0, result.getColumnValuesSize());
+  }
+
+  @Test
+  public void testDeleteSingleTimestamp() throws Exception {
+    ThriftHBaseServiceHandler handler = new ThriftHBaseServiceHandler();
+    byte[] rowName = "testDeleteSingleTimestamp".getBytes();
+    ByteBuffer table = ByteBuffer.wrap(tableAname);
+
+    long timestamp1 = System.currentTimeMillis() - 10;
+    long timestamp2 = System.currentTimeMillis();
+    
+    List<TColumnValue> columnValues = new ArrayList<TColumnValue>();
+    TColumnValue columnValueA = new TColumnValue(ByteBuffer.wrap(familyAname), ByteBuffer.wrap(qualifierAname),
+        ByteBuffer.wrap(valueAname));
+    columnValueA.setTimestamp(timestamp1);
+    columnValues.add(columnValueA);
+    TPut put = new TPut(ByteBuffer.wrap(rowName), columnValues);
+
+    put.setColumnValues(columnValues);
+
+    handler.put(table, put);
+    columnValueA.setTimestamp(timestamp2);
+    handler.put(table, put);
+
+    TGet get = new TGet(ByteBuffer.wrap(rowName));
+    get.setMaxVersions(2);
+    TResult result = handler.get(table, get);
+    assertEquals(2, result.getColumnValuesSize());
+
+    TDelete delete = new TDelete(ByteBuffer.wrap(rowName));
+    List<TColumn> deleteColumns = new ArrayList<TColumn>();
+    TColumn deleteColumn = new TColumn(ByteBuffer.wrap(familyAname));
+    deleteColumn.setQualifier(qualifierAname);
+    deleteColumns.add(deleteColumn);
+    delete.setColumns(deleteColumns);
+    delete.setDeleteType(TDeleteType.DELETE_COLUMN);
+
+    handler.deleteSingle(table, delete);
+
+    get = new TGet(ByteBuffer.wrap(rowName));
+    result = handler.get(table, get);
+    assertArrayEquals(rowName, result.getRow());
+    assertEquals(1, result.getColumnValuesSize());
+    // the older timestamp should remain.
+    assertEquals(timestamp1, result.getColumnValues().get(0).getTimestamp());
+  }
+
+  @Test
+  public void testIncrement() throws Exception {
+    ThriftHBaseServiceHandler handler = new ThriftHBaseServiceHandler();
+    byte[] rowName = "testIncrement".getBytes();
+    ByteBuffer table = ByteBuffer.wrap(tableAname);
+
+    List<TColumnValue> columnValues = new ArrayList<TColumnValue>();
+    columnValues.add(new TColumnValue(ByteBuffer.wrap(familyAname), ByteBuffer.wrap(qualifierAname), ByteBuffer
+        .wrap(Bytes.toBytes(1L))));
+    TPut put = new TPut(ByteBuffer.wrap(rowName), columnValues);
+    put.setColumnValues(columnValues);
+    handler.put(table, put);
+
+    List<TColumnIncrement> incrementColumns = new ArrayList<TColumnIncrement>();
+    incrementColumns.add(new TColumnIncrement(ByteBuffer.wrap(familyAname), ByteBuffer.wrap(qualifierAname)));
+    TIncrement increment = new TIncrement(ByteBuffer.wrap(rowName), incrementColumns);
+    handler.increment(table, increment);
+
+    TGet get = new TGet(ByteBuffer.wrap(rowName));
+    TResult result = handler.get(table, get);
+
+    assertArrayEquals(rowName, result.getRow());
+    assertEquals(1, result.getColumnValuesSize());
+    TColumnValue columnValue = result.getColumnValues().get(0);
+    assertArrayEquals(Bytes.toBytes(2L), columnValue.getValue());
+  }
+
+  /**
+   * check that checkAndPut fails if the cell does not exist, then put in the cell, then check that the checkAndPut
+   * succeeds.
+   * 
+   * @throws Exception
+   */
+  @Test
+  public void testCheckAndPut() throws Exception {
+    ThriftHBaseServiceHandler handler = new ThriftHBaseServiceHandler();
+    byte[] rowName = "testCheckAndPut".getBytes();
+    ByteBuffer table = ByteBuffer.wrap(tableAname);
+
+    List<TColumnValue> columnValuesA = new ArrayList<TColumnValue>();
+    TColumnValue columnValueA = new TColumnValue(ByteBuffer.wrap(familyAname), ByteBuffer.wrap(qualifierAname),
+        ByteBuffer.wrap(valueAname));
+    columnValuesA.add(columnValueA);
+    TPut putA = new TPut(ByteBuffer.wrap(rowName), columnValuesA);
+    putA.setColumnValues(columnValuesA);
+
+    List<TColumnValue> columnValuesB = new ArrayList<TColumnValue>();
+    TColumnValue columnValueB = new TColumnValue(ByteBuffer.wrap(familyBname), ByteBuffer.wrap(qualifierBname),
+        ByteBuffer.wrap(valueBname));
+    columnValuesB.add(columnValueB);
+    TPut putB = new TPut(ByteBuffer.wrap(rowName), columnValuesB);
+    putB.setColumnValues(columnValuesB);
+
+    assertFalse(handler.checkAndPut(table, ByteBuffer.wrap(rowName), ByteBuffer.wrap(familyAname),
+        ByteBuffer.wrap(qualifierAname), ByteBuffer.wrap(valueAname), putB));
+
+    TGet get = new TGet(ByteBuffer.wrap(rowName));
+    TResult result = handler.get(table, get);
+    assertEquals(0, result.getColumnValuesSize());
+
+    handler.put(table, putA);
+
+    assertTrue(handler.checkAndPut(table, ByteBuffer.wrap(rowName), ByteBuffer.wrap(familyAname),
+        ByteBuffer.wrap(qualifierAname), ByteBuffer.wrap(valueAname), putB));
+
+    result = handler.get(table, get);
+    assertArrayEquals(rowName, result.getRow());
+    List<TColumnValue> returnedColumnValues = result.getColumnValues();
+    List<TColumnValue> expectedColumnValues = new ArrayList<TColumnValue>();
+    expectedColumnValues.add(columnValueA);
+    expectedColumnValues.add(columnValueB);
+    assertTColumnValuesEqual(expectedColumnValues, returnedColumnValues);
+  }
+
+  /**
+   * check that checkAndDelete fails if the cell does not exist, then put in the cell, then check that the
+   * checkAndDelete succeeds.
+   * 
+   * @throws Exception
+   */
+  @Test
+  public void testCheckAndDelete() throws Exception {
+    ThriftHBaseServiceHandler handler = new ThriftHBaseServiceHandler();
+    byte[] rowName = "testCheckAndDelete".getBytes();
+    ByteBuffer table = ByteBuffer.wrap(tableAname);
+
+    List<TColumnValue> columnValuesA = new ArrayList<TColumnValue>();
+    TColumnValue columnValueA = new TColumnValue(ByteBuffer.wrap(familyAname), ByteBuffer.wrap(qualifierAname),
+        ByteBuffer.wrap(valueAname));
+    columnValuesA.add(columnValueA);
+    TPut putA = new TPut(ByteBuffer.wrap(rowName), columnValuesA);
+    putA.setColumnValues(columnValuesA);
+
+    List<TColumnValue> columnValuesB = new ArrayList<TColumnValue>();
+    TColumnValue columnValueB = new TColumnValue(ByteBuffer.wrap(familyBname), ByteBuffer.wrap(qualifierBname),
+        ByteBuffer.wrap(valueBname));
+    columnValuesB.add(columnValueB);
+    TPut putB = new TPut(ByteBuffer.wrap(rowName), columnValuesB);
+    putB.setColumnValues(columnValuesB);
+
+    // put putB so that we know whether the row has been deleted or not
+    handler.put(table, putB);
+
+    TDelete delete = new TDelete(ByteBuffer.wrap(rowName));
+
+    assertFalse(handler.checkAndDelete(table, ByteBuffer.wrap(rowName), ByteBuffer.wrap(familyAname),
+        ByteBuffer.wrap(qualifierAname), ByteBuffer.wrap(valueAname), delete));
+
+    TGet get = new TGet(ByteBuffer.wrap(rowName));
+    TResult result = handler.get(table, get);
+    assertArrayEquals(rowName, result.getRow());
+    assertTColumnValuesEqual(columnValuesB, result.getColumnValues());
+
+    handler.put(table, putA);
+
+    assertTrue(handler.checkAndDelete(table, ByteBuffer.wrap(rowName), ByteBuffer.wrap(familyAname),
+        ByteBuffer.wrap(qualifierAname), ByteBuffer.wrap(valueAname), delete));
+
+    result = handler.get(table, get);
+    assertFalse(result.isSetRow());
+    assertEquals(0, result.getColumnValuesSize());
+  }
+
+  @Test
+  public void testScan() throws Exception {
+    ThriftHBaseServiceHandler handler = new ThriftHBaseServiceHandler();
+    ByteBuffer table = ByteBuffer.wrap(tableAname);
+
+    TScan scan = new TScan();
+    List<TColumn> columns = new ArrayList<TColumn>();
+    TColumn column = new TColumn();
+    column.setFamily(familyAname);
+    column.setQualifier(qualifierAname);
+    columns.add(column);
+    scan.setColumns(columns);
+    scan.setStartRow("testScan".getBytes());
+
+    TColumnValue columnValue = new TColumnValue(ByteBuffer.wrap(familyAname), ByteBuffer.wrap(qualifierAname),
+        ByteBuffer.wrap(valueAname));
+    List<TColumnValue> columnValues = new ArrayList<TColumnValue>();
+    columnValues.add(columnValue);
+    for (int i = 0; i < 10; i++) {
+      TPut put = new TPut(ByteBuffer.wrap(("testScan" + i).getBytes()), columnValues);
+      handler.put(table, put);
+    }
+
+    int scanId = handler.openScanner(table, scan);
+    List<TResult> results = handler.getScannerRows(scanId, 10);
+    assertEquals(10, results.size());
+    for (int i = 0; i < 10; i++) {
+      assertArrayEquals(("testScan" + i).getBytes(), results.get(i).getRow());
+    }
+
+    results = handler.getScannerRows(scanId, 10);
+    assertEquals(0, results.size());
+
+    handler.closeScanner(scanId);
+
+    try {
+      handler.getScannerRows(scanId, 10);
+      fail("Scanner id should be invalid");
+    } catch (TIllegalArgument e) {
+    }
+  }
+}



Mime
View raw message