tablestore-ruby-sdk 0.0.0 → 0.0.1

data/lib/protobuf/{ots_filiter.proto → table_store_filiter.proto}

@@ -1,14 +1,11 @@
-syntax = "proto3";
 
 enum FilterType {
-    FT_DEFAULT = 0;
     FT_SINGLE_COLUMN_VALUE = 1;
     FT_COMPOSITE_COLUMN_VALUE = 2;
     FT_COLUMN_PAGINATION = 3;
 }
 
 enum ComparatorType {
-    CT_DEFAULT                  = 0;
     CT_EQUAL                    = 1;
     CT_NOT_EQUAL                = 2;
     CT_GREATER_THAN             = 3;
@@ -18,31 +15,30 @@ enum ComparatorType {
 }
 
 message SingleColumnValueFilter {
-     ComparatorType comparator     = 1;
-     string column_name        = 2;
-     bytes column_value        = 3; // Serialized SQLVariant
-     bool filter_if_missing        = 4;
-     bool latest_version_only      = 5;
+    required ComparatorType comparator     = 1;
+    required string column_name        = 2;
+    required bytes column_value        = 3; // Serialized SQLVariant
+    required bool filter_if_missing        = 4;
+    required bool latest_version_only      = 5;
 }
 
 enum LogicalOperator {
-    LO_DEFAULT                  = 0;
     LO_NOT                      = 1;
     LO_AND                      = 2;
     LO_OR                       = 3;
 }
 
 message CompositeColumnValueFilter {
-    LogicalOperator combinator    = 1;
+    required LogicalOperator combinator    = 1;
     repeated Filter sub_filters            = 2;
 }
 
 message ColumnPaginationFilter {
-     int32 offset = 1;
-     int32 limit = 2;
+    required int32 offset = 1;
+    required int32 limit = 2;
 }
 
 message Filter {
-     FilterType type    = 1;
-     bytes filter       = 2;  // Serialized string of filter of the type
+    required FilterType type    = 1;
+    required bytes filter       = 2;  // Serialized string of filter of the type
 }

data/lib/tablestore-ruby-sdk.rb

@@ -2,7 +2,7 @@ require 'rest-client'
 require 'openssl'
 require 'base64'
 require 'tablestore/error'
-require 'tablestore/ots'
+require 'tablestore/table_store_client'
 require 'tablestore/metadata'
 
 class TableStore
@@ -13,12 +13,12 @@ class TableStore
 
 
   def initialize(end_point, access_key_id, access_key_secret, instance_name, **kwargs)
-    # 初始化OTSClient实例。
-    # end_point是OTS服务的地址（例如 'http://instance.cn-hangzhou.ots.aliyun.com'），必须以'http://'或'https://'开头。
-    # access_key_id是访问OTS服务的accessid，通过官方网站申请或通过管理员获取。
-    # access_key_secret是访问OTS服务的accesskey，通过官方网站申请或通过管理员获取。
+    # 初始化TableStoreClient实例。
+    # end_point是TableStoreClient服务的地址（例如 'http://instance.cn-hangzhou.TableStoreClient.aliyun.com'），必须以'http://'或'https://'开头。
+    # access_key_id是访问TableStoreClient服务的accessid，通过官方网站申请或通过管理员获取。
+    # access_key_secret是访问TableStoreClient服务的accesskey，通过官方网站申请或通过管理员获取。
     # instance_name是要访问的实例名，通过官方网站控制台创建或通过管理员获取。
-    # sts_token是访问OTS服务的STS token，从STS服务获取，具有有效期，过期后需要重新获取。
+    # sts_token是访问TableStoreClient服务的STS token，从STS服务获取，具有有效期，过期后需要重新获取。
     # encoding请求参数的字符串编码类型，默认是utf8。
     # socket_timeout是连接池中每个连接的Socket超时，单位为秒，可以为int或float。默认值为50。
     # max_connection是连接池的最大连接数。默认为50，
@@ -28,21 +28,21 @@ class TableStore
     #self.validate_parameter(end_point, access_key_id, access_key_secret, instance_name)
     #sts_token = kwargs.get('sts_token')
 
-    #示例：创建一个OTSClient实例
-    # from tablestore.client import OTSClient
-    # client = OTSClient('your_instance_endpoint', 'your_user_id', 'your_user_key', 'your_instance_name')
+    #示例：创建一个TableStoreClient实例
+    # from tablestore.client import TableStoreClient
+    # client = TableStoreClient('your_instance_endpoint', 'your_user_id', 'your_user_key', 'your_instance_name')
   end
 
   def _get_range(request)
     api_name = 'GetRange'
-    body = OTS.new.encode_get_range_request(request)
+    body = TableStoreClient.new.encode_get_range_request(request)
     response = post_request(body, api_name)
-    OTS.new.decode_get_range_request(api_name, response.headers, response.body)
+    TableStoreClient.new.decode_get_range_request(api_name, response.headers, response.body)
   end
 
   def _put_row(table_name, row, condition)
     api_name = 'PutRow'
-    body = OTS.new.encode_put_row(table_name, row, condition)
+    body = TableStoreClient.new.encode_put_row(table_name, row, condition)
     response = post_request(body, api_name)
     if response.code == 200
       'write succeed!'
@@ -51,21 +51,21 @@ class TableStore
 
   def _get_row(table_name, primary_key, columns_to_get=nil, column_filter=nil, max_version=1)
     api_name = 'GetRow'
-    body = OTS.new.encode_get_row(table_name, primary_key, columns_to_get, column_filter, max_version)
+    body = TableStoreClient.new.encode_get_row(table_name, primary_key, columns_to_get, column_filter, max_version)
     response = post_request(body, api_name)
-    OTS.new.decode_get_row(response.body)
+    TableStoreClient.new.decode_get_row(response.body)
   end
 
   def _batch_get_row(request)
     api_name = 'BatchGetRow'
-    body = OTS.new.make_batch_get_row(request)
+    body = TableStoreClient.new.make_batch_get_row(request)
     response = post_request(body, api_name)
-    OTS.new.decode_batch_get_row(response.body)
+    TableStoreClient.new.decode_batch_get_row(response.body)
   end
 
   def _batch_write_row(request)
     api_name = 'BatchWriteRow'
-    body = OTS.new.make_batch_write_row(request)
+    body = TableStoreClient.new.make_batch_write_row(request)
     response = post_request(body, api_name)
     if response.code == 200
       'write succeed!'
@@ -82,7 +82,7 @@ class TableStore
 
   def get_headers(md5, api_name)
     headers = {
-        "x-ots-date": Time.now.getutc.strftime('%Y-%m-%dT%H:%M:%S.000Z'),
+        "x-ots-date": '2018-01-09T14:48:12.000Z',#Time.now.getutc.strftime('%Y-%m-%dT%H:%M:%S.000Z'),
         "x-ots-apiversion": '2015-12-31',
         "x-ots-accesskeyid": UserID,
         "x-ots-contentmd5": md5,

data/lib/tablestore/error.rb

@@ -1,5 +1,5 @@
 
-class OTSError
+class TableStoreError
 
 end
 

data/lib/tablestore/metadata.rb

@@ -110,7 +110,7 @@ module Metadata
 
       set_row_existence_expectation(row_existence_expectation)
 
-      set_column_condition(column_condition) if @column_condition.present?
+      set_column_condition(column_condition) if @column_condition
     end
 
     def set_row_existence_expectation(row_existence_expectation)

data/lib/tablestore/plain_buffer_coded_output_stream.rb

@@ -156,38 +156,25 @@ class  PlainBufferCodedOutputStream
     write_tag(TAG_CELL)
     cell_check_sum = write_cell_name(column_name, cell_check_sum)
     timestamp = nil
-    if column_value.present?
+    if column_value
       if column_value.is_a?(Array)
-        if column_value[0].present?
+        if column_value[0]
           cell_check_sum = write_column_value_with_checksum(column_value[0], cell_check_sum)
         end
-        if column_value[1].present?
+        if column_value[1]
           timestamp = column_value[1]
         end
       else
         cell_check_sum = write_column_value_with_checksum(column_value, cell_check_sum)
       end
     end
-    if update_type == UpdateType.DELETE
-      write_tag(TAG_CELL_TYPE)
-      @output_stream.write_raw_byte(const.DELETE_ONE_VERSION)
-    elsif update_type == UpdateType.DELETE_ALL
-      write_tag(TAG_CELL_TYPE)
-      @output_stream.write_raw_byte(const.DELETE_ALL_VERSION)
-    end
-    if timestamp.present?
+    if timestamp
       write_tag(TAG_CELL_TIMESTAMP)
       @output_stream.write_raw_little_endian64(timestamp)
     end
-    if timestamp.present?
+    if timestamp
       cell_check_sum = PlainBufferCrc8.crc_int64(cell_check_sum, timestamp)
     end
-    if update_type == UpdateType.DELETE
-      cell_check_sum = PlainBufferCrc8.crc_int8(cell_check_sum, const.DELETE_ONE_VERSION)
-    end
-    if update_type == UpdateType.DELETE_ALL
-      cell_check_sum = PlainBufferCrc8.crc_int8(cell_check_sum, const.DELETE_ALL_VERSION)
-    end
     write_tag(TAG_CELL_CHECKSUM)
     @output_stream.write_raw_byte(cell_check_sum)
     PlainBufferCrc8.crc_int8(row_check_sum, cell_check_sum)
@@ -202,7 +189,7 @@ class  PlainBufferCodedOutputStream
   end
 
   def write_columns(columns, row_check_sum)
-    if columns.present? and columns.length != 0
+    if columns and columns.length != 0
       write_tag(TAG_ROW_DATA)
       columns.each do |column|
         if column.length == 2

data/lib/tablestore/protocol.rb

@@ -62,7 +62,7 @@ class OTSProtocol
       'x-ots-contentmd5': md5,
     }
 
-    headers['x-ots-ststoken'] = @sts_token if @sts_token.present?
+    headers['x-ots-ststoken'] = @sts_token if @sts_token
 
     signature = make_request_signature(query, headers)
     headers['x-ots-signature'] = signature

data/lib/tablestore/{ots.rb → table_store_client.rb}

@@ -1,14 +1,13 @@
-require 'protobuf'
 require 'os'
-require 'protobuf/ots_pb'
-require 'protobuf/ots_filiter_pb'
+require 'protobuf/table_store.pb'
+require 'protobuf/table_store_filiter.pb'
 require 'consts'
 require 'tablestore/plain_buffer_coded_output_stream'
 require 'tablestore/plain_buffer_output_stream'
 require 'tablestore/plain_buffer_coded_input_stream'
 require 'tablestore/plain_buffer_input_stream'
 
-class OTS
+class TableStoreClient
   def encode_get_range_request(request)
     proto = GetRangeRequest.new
     proto.table_name = request[:table_name]
@@ -17,15 +16,12 @@ class OTS
     proto.exclusive_end_primary_key = serialize_primary_key(request[:exclusive_end_primary_key])
     proto.max_versions = request[:max_version]
     proto.limit = request[:limit]
-    proto_string = GetRangeRequest.encode(proto)
-    if proto_string.match("#{request[:table_name]}\x10\x02")
-      proto_string.sub("#{request[:table_name]}\x10\x02", "#{request[:table_name]}\x10\x00")
-    end
-    proto_string.sub("#{request[:table_name]}\x10\x02", "#{request[:table_name]}\x10\x00")
+    proto.serialize_to_string
   end
 
   def decode_get_range_request(api_name, headers, body)
-    proto = GetRangeResponse.decode(body)
+    proto = GetRangeResponse.new
+    proto.parse_from_string(body)
     #capacity_unit = parse_capacity_unit(proto.consumed.capacity_unit)
 
     next_start_pk = nil
@@ -55,26 +51,24 @@ class OTS
     contion_proto = Condition.new
     proto.condition = make_condition(contion_proto, condition)
     proto.row = serialize_for_put_row(row.primary_key, row.attribute_columns)
-    proto_string = PutRowRequest.encode(proto)
-    proto_string = proto_string[0..-2] + [0].pack('C') if proto_string[-1] == "\x03"
-    proto_string
+    proto.serialize_to_string
   end
 
   def encode_get_row(table_name, primary_key, columns_to_get, column_filter, max_version)
     proto = GetRowRequest.new
     proto.table_name = table_name
     make_repeated_column_names(proto.columns_to_get, columns_to_get)
-    if column_filter.present?
-      pb_filter = make_column_condition(column_filter)
-      proto.filter = Filter.encode(pb_filter)
+    if column_filter
+      proto.filter = make_column_condition(column_filter).serialize_to_string
     end
     proto.primary_key = serialize_primary_key(primary_key)
-    proto.max_versions = max_version if max_version.present?
-    GetRowRequest.encode(proto)
+    proto.max_versions = max_version if max_version
+    proto.serialize_to_string
   end
 
   def decode_get_row(body)
-    proto = GetRowResponse.decode(body)
+    proto = GetRowResponse.new
+    proto.parse_from_string(body)
 
     return_row = nil
     if proto.row.length > 0
@@ -86,7 +80,8 @@ class OTS
   end
 
   def decode_put_row(body)
-    proto = PutRowResponse.decode(body)
+    proto = PutRowResponse.new
+    proto.parse_from_string(body)
     return_row = nil
     if proto.row.length != 0
       inputStream = PlainBufferInputStream.new(proto.row)
@@ -104,24 +99,23 @@ class OTS
       table_item.table_name = table_value.table_name
       make_repeated_column_names(table_item.columns_to_get, table_value.columns_to_get)
 
-      if table_value.column_filter.present?
-        pb_filter = make_column_condition(table_value.column_filter)
-        table_item.filter = Filter.encode(pb_filter)
+      if table_value.column_filter
+        table_item.filter = make_column_condition(table_value.column_filter).serialize_to_string
       end
 
       table_value.primary_keys.each do |pk|
         table_item.primary_key << serialize_primary_key(pk)
       end
 
-      if table_value.token.present?
+      if table_value.token
         table_value.token.each do |tk|
           table_item.token << tk
         end
       end
-      if table_value.max_version.present?
+      if table_value.max_version
           table_item.max_versions = table_value.max_version
       end
-      if table_value.time_range.present?
+      if table_value.time_range
         if table_value.time_range.is_a?(Array)
           table_item.time_range.start_time = table_value.time_range[0]
           table_item.time_range.end_time = table_value.time_range[1]
@@ -129,19 +123,20 @@ class OTS
           table_item.time_range.specific_time = table_value.time_range
         end
       end
-      if table_value.start_column.present?
+      if table_value.start_column
         table_item.start_column = table_value.start_column
       end
-      if table_value.end_column.present?
+      if table_value.end_column
           table_item.end_column = table_value.end_column
       end
       proto.tables << table_item
     end
-    BatchGetRowRequest.encode(proto)
+    proto.serialize_to_string
   end
 
   def decode_batch_get_row(body)
-    proto = BatchGetRowResponse.decode(body)
+    proto = BatchGetRowResponse.new
+    proto.parse_from_string(body)
     rows = []
     proto.tables.each do |table_item|
       rows << parse_get_row_item(table_item.rows)
@@ -168,8 +163,7 @@ class OTS
       end
       proto.tables << table_item
     end
-    batch_string = BatchWriteRowRequest.encode(proto)
-    batch_string.gsub("\x08\x03", "\x08\x00")
+    proto.serialize_to_string
   end
 
   def make_put_row_item(proto, put_row_item)
@@ -180,28 +174,28 @@ class OTS
     condition_proto = Condition.new
     proto.condition = make_condition(condition_proto, condition)
     if put_row_item.return_type == ReturnType::RT_PK
-        proto.return_content.return_type = :RT_PK
+        proto.return_content.return_type = RT_PK
     end
 
     proto.row_change = serialize_for_put_row(put_row_item.row.primary_key, put_row_item.row.attribute_columns)
-    proto.type = :PUT
+    proto.type = PUT
     proto
   end
 
   def make_update_row_item(proto, update_row_item)
     condition = update_row_item.condition
     if condition.nil?
-      condition = Metadata::Condition(Metadata::RowExistenceExpectation::IGNORE, nil)
+      condition = Condition.new(RowExistenceExpectation::IGNORE, nil)
     end
+    condition_proto = Condition.new
+    proto.condition = make_condition(condition_proto, condition)
 
-    make_condition(proto.condition, condition)
-
-    if update_row_item.return_type == Metadata::ReturnType::RT_PK
-        proto.return_content.return_type = :RT_PK
+    if update_row_item.return_type == ReturnType::RT_PK
+        proto.return_content.return_type = RT_PK
     end
 
     proto.row_change = serialize_for_update_row(update_row_item.row.primary_key, update_row_item.row.attribute_columns)
-    proto.type = :UPDATE
+    proto.type = UPDATE
     proto
   end
 
@@ -221,9 +215,8 @@ class OTS
     proto.row_existence = expectation_str
     raise TableStoreClientError.new("row_existence_expectation should be one of [#{join(', ')}], not #{expectation_str}") if proto.row_existence.nil?
 
-    if condition.get_column_condition.present?
-      pb_filter = make_column_condition(condition.column_condition)
-      proto.column_condition = Filter.encode(pb_filter)
+    if condition.get_column_condition
+      proto.column_condition = make_column_condition(condition.column_condition).serialize_to_string
     end
     proto
   end
@@ -252,7 +245,7 @@ class OTS
       proto.sub_filters << make_column_condition(sub)
     end
 
-    CompositeColumnValueFilter.encode(proto)
+    proto.serialize_to_string
   end
 
   def make_relation_condition(condition)
@@ -263,17 +256,8 @@ class OTS
     proto.column_value = serialize_column_value(condition.get_column_value)
     proto.filter_if_missing = !condition.pass_if_missing
     proto.latest_version_only = condition.latest_version_only
-    filter_string = SingleColumnValueFilter.encode(proto)
-
-    if proto.filter_if_missing.blank? && proto.latest_version_only.blank?
-      filter_string += [32, 0, 40, 0].pack("C*")
-    elsif proto.filter_if_missing.blank?
-      filter_string.insert(-3, [32, 0].pack("C*"))
-    elsif proto.latest_version_only.blank?
-      filter_string += [40, 0].pack("C*")
-    end
+    proto.serialize_to_string
 
-    filter_string
   end
 
   def parse_get_row_item(proto)
@@ -302,7 +286,7 @@ class OTS
         # end
       end
 
-      row_list << {pk: primary_key_columns, attr: attribute_columns} if primary_key_columns.present?
+      row_list << {pk: primary_key_columns, attr: attribute_columns} if primary_key_columns
     end
     row_list
   end
@@ -365,6 +349,34 @@ class OTS
     stream.get_buffer.join('')
   end
 
+  def serialize_for_update_row(primary_key, attribute_columns)
+    unless attribute_columns.is_a?(Hash)
+      raise TableStoreClientError.new("the attribute columns of UpdateRow is not hash, but is #{attribute_columns.class}")
+    end
+
+    attribute_columns.keys.each do |key|
+      if attribute_columns[key] && !attribute_columns[key].is_a?(Hash)
+        raise TableStoreClientError.new("the columns value of update-row must be hash, but is #{attribute_columns[key].class}")
+      end
+      attribute_columns[key].each do |cell|
+        # if  cell.is_a?(Array)
+        #   raise TableStoreClientError.new("the cell of update-row must be array, but is #{cell.class}")
+        # end
+      end
+    end
+
+    buf_size = compute_update_row_size(primary_key, attribute_columns)
+    output_stream = PlainBufferOutputStream.new(buf_size)
+    coded_output_stream = PlainBufferCodedOutputStream.new(output_stream)
+    row_checksum = 0
+    coded_output_stream.write_header
+    row_checksum = coded_output_stream.write_primary_key(primary_key, row_checksum)
+    row_checksum = coded_output_stream.write_update_columns(attribute_columns, row_checksum)
+    row_checksum = PlainBufferCrc8.crc_int8(row_checksum, 0)
+    coded_output_stream.write_row_checksum(row_checksum)
+    output_stream.get_buffer.join('')
+  end
+
   def compute_variant_value_size(value)
     compute_primary_key_value_size(value) - LITTLE_ENDIAN_SIZE - 1
   end
@@ -474,8 +486,40 @@ class OTS
     elsif value.is_a?(Float)
       size += LITTLE_ENDIAN_64_SIZE
     else
-      raise TableStoreClientError("Unsupported column type: " + value.class)
+      raise TableStoreClientError.new("Unsupported column type: " + value.class)
+    end
+    size
+  end
+
+  def compute_update_row_size(primary_key, attribute_columns)
+    size = LITTLE_ENDIAN_SIZE
+    size += compute_primary_key_size(primary_key)
+
+    if attribute_columns.length != 0
+      size += 1
+      attribute_columns.keys.each do |update_type|
+        columns = attribute_columns[update_type]
+        if columns.is_a?(String)
+          size += compute_column_size2(column, nil, update_type)
+        elsif columns.is_a?(Array)
+          columns.each do |column|
+            if column.length == 1
+              size += compute_column_size2(column[0], nil, update_type)
+            elsif columns.length >= 2
+              compute_column_size2(column[0], column[1], update_type)
+            else
+              #raise OTSClientError("Unsupported column type:" + str(type(columns)))
+            end
+          end
+        end
+      end
     end
+    size += 2
     size
   end
+
+  def compute_column_size2(column_name, column_value, update_type)
+    compute_column_size(column_name, column_value)
+  end
+
 end