You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hbase.apache.org by te...@apache.org on 2011/11/02 05:26:28 UTC
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...
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) {
+ }
+ }
+}