tablestore-ruby-sdk 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f7be149c8559324647e8e01f7a5478659af2752
-  data.tar.gz: 35c6271e490bb2788487c9b5027a03ac1ac04d81
+  metadata.gz: 393f04a53a6fc7a96b9dd44076b620f52b59508b
+  data.tar.gz: f9a9535ba93b0ad7b0e2188d379d050ea156ae66
 SHA512:
-  metadata.gz: 57db261be3591b37f77f4e652e0962ffb31eff63e3c36e9ba503a8c5b404ad9a8efe2c18d9173aefecfc76c18212dbfb1b716874ba6dbeb14a8aa06f56d76bb0
-  data.tar.gz: b264e2454e8a6f2709af4b3140139faf173193e5ad14fbb94a3e351d6bda69ec43fae11be68cf09bddb94761a558ecddb9f49be326997bb977bb138ae49aa84e
+  metadata.gz: 3e20aebbf6e247c5165bf23d633afa2f4b6328db19504215ec039442c4531edb663ae4d6aa9f9b25e3b6f3b7d51371979d266ebecb26d45a8f3eaf63b835d093
+  data.tar.gz: 56181e730229258de469909715ab42570ce972fb5d992a79614a192af30bdfbed9eee2f103f692cd10382b9b9d6c89fd560a7eac59369d15ec5ab93d640eb534

data/lib/tablestore/metadata.rb

@@ -40,6 +40,39 @@ ALL = [
 ]
 
 module Metadata
+  class TableMeta
+    attr_accessor :table_name, :schema_of_primary_key
+    def initialize(table_name, schema_of_primary_key)
+      # schema_of_primary_key: [('PK0', 'STRING'), ('PK1', 'INTEGER'), ...]
+      self.table_name = table_name
+      self.schema_of_primary_key = schema_of_primary_key
+    end
+  end
+
+  class TableOptions
+    attr_accessor :time_to_live, :max_version, :max_time_deviation
+    def initialize(time_to_live = -1, max_version = 1, max_time_deviation = 86400)
+      self.time_to_live = time_to_live
+      self.max_version = max_version
+      self.max_time_deviation = max_time_deviation
+    end
+  end
+
+  class CapacityUnit
+    attr_accessor :read, :write
+    def initialize(read=0, write=0)
+      self.read = read
+      self.write = write
+    end
+  end
+
+  class ReservedThroughput
+    attr_accessor :capacity_unit
+    def initialize(capacity_unit)
+       self.capacity_unit = capacity_unit
+    end
+  end
+
   class RowExistenceExpectation
     IGNORE = "IGNORE"
     EXPECT_EXIST = "EXPECT_EXIST"
@@ -104,70 +137,38 @@ module Metadata
   end
 
   class Condition
+    attr_accessor :row_existence_expectation, :column_condition
+
     def initialize(row_existence_expectation, column_condition = nil)
-      @row_existence_expectation = nil
-      @column_condition = nil
+      self.row_existence_expectation = nil
+      self.column_condition = column_condition
 
       set_row_existence_expectation(row_existence_expectation)
-
-      set_column_condition(column_condition) if @column_condition
     end
 
     def set_row_existence_expectation(row_existence_expectation)
       raise TableStoreClientError.new("Expect input row_existence_expectation should be one of #{RowExistenceExpectation::MEMBERS.to_s}, but #{row_existence_expectation}")  unless RowExistenceExpectation::VALUES.include? row_existence_expectation
-      @row_existence_expectation = row_existence_expectation
+      self.row_existence_expectation = row_existence_expectation
     end
 
-    def set_column_condition(column_condition)
-      @column_condition = column_condition
-    end
-
-    def get_row_existence_expectation
-      @row_existence_expectation
-    end
-
-    def get_column_condition
-      @column_condition
-    end
   end
 
   class Row
+    attr_accessor :primary_key, :attribute_columns
     def initialize(primary_key, attribute_columns=nil)
-      @primary_key = primary_key
-      @attribute_columns = attribute_columns
+      self.primary_key = primary_key
+      self.attribute_columns = attribute_columns
     end
 
-    def primary_key
-      @primary_key
-    end
-
-    def attribute_columns
-      @attribute_columns
-    end
   end
 
   class RowItem
+    attr_accessor :type, :row, :condition, :return_type
     def initialize(row_type, row, condition, return_type = nil)
-      @type = row_type
-      @condition = condition
-      @row = row
-      @return_type = return_type
-    end
-
-    def type
-      @type
-    end
-
-    def condition
-      @condition
-    end
-
-    def row
-      @row
-    end
-
-    def return_type
-      @return_type
+      self.type = row_type
+      self.condition = condition
+      self.row = row
+      self.return_type = return_type
     end
   end
 
@@ -306,23 +307,18 @@ module Metadata
   end
 
   class TableInBatchWriteRowItem
+    attr_accessor :table_name, :row_items
     def initialize(table_name, row_items)
-      @table_name = table_name
-      @row_items = row_items
-    end
-
-    def row_items
-      @row_items
-    end
-
-    def table_name
-      @table_name
+      self.table_name = table_name
+      self.row_items = row_items
     end
   end
 
   class BatchWriteRowRequest
+    attr_accessor :items
+
     def initialize
-      @items = {}
+      self.items = {}
     end
 
     def add(table_item)
@@ -335,12 +331,9 @@ module Metadata
           raise TableStoreClientError.new("The input table_item should be an instance of TableInBatchWriteRowItem, not #{table_item.class}")
         end
 
-      @items[table_item.table_name] = table_item
+      self.items[table_item.table_name] = table_item
     end
 
-    def items
-      @items
-    end
   end
 
   class TableInBatchGetRowItem

data/lib/tablestore/plain_buffer_coded_output_stream.rb

@@ -168,11 +168,18 @@ class  PlainBufferCodedOutputStream
         cell_check_sum = write_column_value_with_checksum(column_value, cell_check_sum)
       end
     end
+    if update_type == "DELETE"
+      write_tag(TAG_CELL_TYPE)
+      @output_stream.write_raw_byte(DELETE_ONE_VERSION)
+      cell_check_sum = PlainBufferCrc8.crc_int8(cell_check_sum, DELETE_ONE_VERSION)
+    elsif update_type == "DELETE_ALL"
+      write_tag(TAG_CELL_TYPE)
+      @output_stream.write_raw_byte(DELETE_ALL_VERSION)
+      cell_check_sum = PlainBufferCrc8.crc_int8(cell_check_sum, DELETE_ALL_VERSION)
+    end
     if timestamp
       write_tag(TAG_CELL_TIMESTAMP)
       @output_stream.write_raw_little_endian64(timestamp)
-    end
-    if timestamp
       cell_check_sum = PlainBufferCrc8.crc_int64(cell_check_sum, timestamp)
     end
     write_tag(TAG_CELL_CHECKSUM)
@@ -215,7 +222,7 @@ class  PlainBufferCodedOutputStream
           elsif column.length == 3
             row_check_sum = write_update_column(update_type, column[0], [column[1], column[2]], row_check_sum)
           else
-              raise TableStoreClientError.new("Unsupported column format: " + column.to_s)
+            raise TableStoreClientError.new("Unsupported column format: #{column.to_s}")
           end
         end
       end

data/lib/tablestore/plain_buffer_input_stream.rb

@@ -74,7 +74,9 @@ class PlainBufferInputStream
     raise TableStoreClientError.new("Read bytes encountered EOF.") if @buffer.length - @cur_pos < size
     utf_str = @buffer[@cur_pos, size]
     @cur_pos += size
-    utf_str.encode('utf-8')   if utf_str.is_a?(String)
+    if utf_str.is_a?(String)
+      utf_str = utf_str.force_encoding('UTF-8')
+    end
     utf_str
   end
 

data/lib/tablestore/table_store_client.rb

@@ -8,6 +8,52 @@ require 'tablestore/plain_buffer_coded_input_stream'
 require 'tablestore/plain_buffer_input_stream'
 
 class TableStoreClient
+
+  ##Encode
+  def encode_create_table(table_meta, table_options, reserved_throughput)
+    proto = CreateTableRequest.new
+
+    meta_proto = TableMeta.new
+    meta_proto.table_name = table_meta.table_name
+    meta_proto.table_name = table_meta.table_name
+    table_meta.schema_of_primary_key.each do |primary_key|
+      meta_proto.primary_key << make_schemas_with_list(primary_key)
+    end
+    proto.table_meta = meta_proto
+
+    proto.table_options = make_table_options(table_options)
+
+    rt_proto = ReservedThroughput.new
+    rt_proto.capacity_unit = make_capacity_unit(reserved_throughput.capacity_unit)
+    proto.reserved_throughput = rt_proto
+    proto.serialize_to_string
+  end
+
+  def encode_list_table
+    proto = ListTableRequest.new
+    proto.serialize_to_string
+  end
+
+  def encode_update_table(table_name, table_options, reserved_throughput)
+    proto = UpdateTableRequest.new
+    proto.table_name = table_name
+    if reserved_throughput
+      rt_proto = ReservedThroughput.new
+      rt_proto.capacity_unit = make_capacity_unit(reserved_throughput.capacity_unit)
+      proto.reserved_throughput = rt_proto
+    end
+    if table_options
+      proto.table_options = make_table_options(table_options)
+    end
+    proto.serialize_to_string
+  end
+
+  def encode_delete_table(table_name)
+    proto = DeleteTableRequest.new
+    proto.table_name = table_name
+    proto.serialize_to_string
+  end
+
   def encode_get_range_request(request)
     proto = GetRangeRequest.new
     proto.table_name = request[:table_name]
@@ -22,31 +68,6 @@ class TableStoreClient
     proto.serialize_to_string
   end
 
-  def decode_get_range_request(api_name, headers, body)
-    proto = GetRangeResponse.new
-    proto.parse_from_string(body)
-    #capacity_unit = parse_capacity_unit(proto.consumed.capacity_unit)
-
-    next_start_pk = nil
-    row_list = []
-
-    # if proto.next_start_primary_key.length != 0
-    #   inputStream = PlainBufferInputStream.new(proto.next_start_primary_key)
-    #   codedInputStream = PlainBufferCodedInputStream.new(inputStream)
-    #   next_start_pk, att = codedInputStream.read_row
-    # end
-    if proto.rows.length != 0
-      inputStream = PlainBufferInputStream.new(proto.rows)
-      codedInputStream = PlainBufferCodedInputStream.new(inputStream)
-      row_list = codedInputStream.read_rows
-    end
-
-    #next_token = proto.next_token
-
-    row_list
-    #return capacity_unit, next_start_pk, row_list, next_token
-  end
-
   def encode_put_row(table_name, row, condition)
     proto = PutRowRequest.new
     proto.table_name = table_name
@@ -71,14 +92,57 @@ class TableStoreClient
 
   def encode_update_row(teble_name, row, condition)
     proto = UpdateRowRequest.new
-    proto.table_name = table_name
+    proto.table_name = teble_name
     condition = Condition.new(RowExistenceExpectation::IGNORE) if condition.nil?
-    proto.condition = condition
+    condition_proto = Condition.new
+    proto.condition = make_condition(condition_proto, condition)
     if return_type == ReturnType::RT_PK
-        proto.return_content.return_type = RT_PK
+      return_content = ReturnContent.new
+      return_content.return_type = RT_PK
+      proto.return_content = return_content
     end
     proto.row_change = serialize_for_update_row(row.primary_key, row.attribute_columns)
-    proto
+    proto.serialize_to_string
+  end
+
+  def encode_delete_row(table_name, row, condition)
+    proto = DeleteRowRequest.new
+    proto.table_name = table_name
+    condition = Condition.new(RowExistenceExpectation::IGNORE) if condition.nil?
+    condition_proto = Condition.new
+    proto.condition = make_condition(condition_proto, condition)
+    proto.primary_key = serialize_for_delete_row(row.primary_key)
+    proto.serialize_to_string
+  end
+
+  ##Decode
+  def decode_list_table(body)
+    proto = ListTableResponse.new
+    proto.parse_from_string(body)
+    names = proto.table_names
+    names
+  end
+
+  def decode_get_range_request(body)
+    proto = GetRangeResponse.new
+    proto.parse_from_string(body)
+
+    next_start_pk = nil
+    row_list = []
+
+    if proto.next_start_primary_key.length != 0
+      inputStream = PlainBufferInputStream.new(proto.next_start_primary_key)
+      codedInputStream = PlainBufferCodedInputStream.new(inputStream)
+      next_start_pk, att = codedInputStream.read_row
+    end
+
+    if proto.rows.length != 0
+      inputStream = PlainBufferInputStream.new(proto.rows)
+      codedInputStream = PlainBufferCodedInputStream.new(inputStream)
+      row_list = codedInputStream.read_rows
+    end
+
+    return next_start_pk, row_list
   end
 
   def decode_get_row(body)
@@ -106,6 +170,17 @@ class TableStoreClient
     return_row
   end
 
+  def decode_batch_get_row(body)
+    proto = BatchGetRowResponse.new
+    proto.parse_from_string(body)
+    rows = []
+    proto.tables.each do |table_item|
+      rows << parse_get_row_item(table_item.rows)
+    end
+    rows
+  end
+
+  ##Make
   def make_batch_get_row(request)
     proto = BatchGetRowRequest.new
     request.items.each do |item|
@@ -122,11 +197,6 @@ class TableStoreClient
         table_item.primary_key << serialize_primary_key(pk)
       end
 
-      if table_value.token
-        table_value.token.each do |tk|
-          table_item.token << tk
-        end
-      end
       if table_value.max_version
           table_item.max_versions = table_value.max_version
       end
@@ -149,16 +219,6 @@ class TableStoreClient
     proto.serialize_to_string
   end
 
-  def decode_batch_get_row(body)
-    proto = BatchGetRowResponse.new
-    proto.parse_from_string(body)
-    rows = []
-    proto.tables.each do |table_item|
-      rows << parse_get_row_item(table_item.rows)
-    end
-    rows
-  end
-
   def make_batch_write_row(request)
     proto = BatchWriteRowRequest.new
     request.items.each do |item|
@@ -175,6 +235,10 @@ class TableStoreClient
           row = RowInBatchWriteRowRequest.new
           table_item.rows << make_update_row_item(row, row_item)
         end
+        if row_item.type == Metadata::BatchWriteRowType::DELETE
+          row = RowInBatchWriteRowRequest.new
+          table_item.rows << make_delete_row_item(row, row_item)
+        end
       end
       proto.tables << table_item
     end
@@ -184,12 +248,14 @@ class TableStoreClient
   def make_put_row_item(proto, put_row_item)
     condition = put_row_item.condition
     if condition.nil?
-      condition = Metadata::Condition.new(Metadata::RowExistenceExpectation::IGNORE, nil)
+      condition = Condition.new(Metadata::RowExistenceExpectation::IGNORE)
     end
     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
+      return_content = ReturnContent.new
+      return_content.return_type = RT_PK
+      proto.return_content = return_content
     end
 
     proto.row_change = serialize_for_put_row(put_row_item.row.primary_key, put_row_item.row.attribute_columns)
@@ -200,20 +266,42 @@ class TableStoreClient
   def make_update_row_item(proto, update_row_item)
     condition = update_row_item.condition
     if condition.nil?
-      condition = Condition.new(RowExistenceExpectation::IGNORE, nil)
+      condition = Condition.new(RowExistenceExpectation::IGNORE)
     end
     condition_proto = Condition.new
     proto.condition = make_condition(condition_proto, condition)
 
     if update_row_item.return_type == ReturnType::RT_PK
-        proto.return_content.return_type = RT_PK
+      return_content = ReturnContent.new
+      return_content.return_type = RT_PK
+      proto.return_content = return_content
     end
-
+    update_row_item.row.attribute_columns
     proto.row_change = serialize_for_update_row(update_row_item.row.primary_key, update_row_item.row.attribute_columns)
     proto.type = UPDATE
     proto
   end
 
+  def make_delete_row_item(proto, delete_row_item)
+    condition = delete_row_item.condition
+    if condition.nil?
+      condition = Metadata::Condition.new(RowExistenceExpectation::IGNORE)
+    end
+    condition_proto = Condition.new
+    proto.condition = make_condition(condition_proto, condition)
+
+    if delete_row_item.return_type == ReturnType::RT_PK
+      return_content = ReturnContent.new
+      return_content.return_type = RT_PK
+      proto.return_content = return_content
+    end
+
+    proto.row_change = serialize_for_delete_row(delete_row_item.row.primary_key)
+    proto.type = DELETE
+    proto
+
+  end
+
   def make_repeated_column_names(proto, columns_to_get)
     if columns_to_get.nil?
       return
@@ -226,11 +314,11 @@ class TableStoreClient
 
   def make_condition(proto, condition)
     raise TableStoreClientError.new("condition should be an instance of Condition, not #{condition.class}") unless condition.is_a?(Metadata::Condition)
-    expectation_str = condition.get_row_existence_expectation
+    expectation_str = condition.row_existence_expectation
     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
+    if condition.column_condition
       proto.column_condition = make_column_condition(condition.column_condition).serialize_to_string
     end
     proto
@@ -272,9 +360,52 @@ class TableStoreClient
     proto.filter_if_missing = !condition.pass_if_missing
     proto.latest_version_only = condition.latest_version_only
     proto.serialize_to_string
+  end
 
+  def make_schemas_with_list(schema)
+    schema_proto = PrimaryKeySchema.new
+    schema_proto.name = schema[0]
+    schema_proto.type = schema[1]
+    if schema.size == 3
+      schema_proto.option = 1
+    end
+    schema_proto
+  end
+
+  def make_table_options(options)
+    option_proto = TableOptions.new
+    unless options.is_a?(Metadata::TableOptions)
+      raise TableStoreClientError.new("table_option should be an instance of Meta::TableOptions, not #{options.class}" )
+    end
+    if options.time_to_live
+      unless options.time_to_live.is_a?(Fixnum)
+        raise TableStoreClientError("time_to_live should be an instance of int, not #{options.time_to_live.class}")
+      end
+      option_proto.time_to_live = options.time_to_live
+    end
+    if options.max_version
+      unless options.max_version.is_a?(Fixnum)
+        raise TableStoreClientError("max_version should be an instance of int, not #{options.max_version.class}")
+      end
+      option_proto.max_versions = options.max_version
+    end
+    if options.max_time_deviation
+      unless options.max_time_deviation.is_a?(Fixnum)
+        raise TableStoreClientError("max_time_deviation should be an instance of int, not #{options.max_version.class}")
+      end
+      option_proto.deviation_cell_version_in_sec = options.max_time_deviation
+    end
+    option_proto
+  end
+
+  def make_capacity_unit(capacity_unit)
+    proto = CapacityUnit.new
+    proto.read = capacity_unit.read if capacity_unit.read
+    proto.write = capacity_unit.write if capacity_unit.write
+    proto
   end
 
+  ##Parse
   def parse_get_row_item(proto)
     row_list = []
     proto.each do |row_item|
@@ -374,7 +505,7 @@ class TableStoreClient
         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)
+        if key.upcase != "DELETE" and key.upcase != "DELETE_ALL" && !cell.is_a?(Array)
           raise TableStoreClientError.new("the cell of update-row must be array, but is #{cell.class}")
         end
       end
@@ -455,6 +586,21 @@ class TableStoreClient
     output_stream.get_buffer.join('')
   end
 
+  def serialize_for_delete_row(primary_key)
+    buf_size = compute_delete_row_size(primary_key)
+    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_delete_marker(row_checksum)
+    coded_output_stream.write_row_checksum(row_checksum)
+
+    output_stream.get_buffer.join('')
+  end
+
+  ##Compute
   def compute_put_row_size(primary_key, attribute_columns)
     size = LITTLE_ENDIAN_SIZE
     size += compute_primary_key_size(primary_key)
@@ -534,7 +680,17 @@ class TableStoreClient
   end
 
   def compute_column_size2(column_name, column_value, update_type)
-    compute_column_size(column_name, column_value)
+    size = compute_column_size(column_name, column_value)
+    if update_type == "DELETE" || update_type == "DELETE_ALL"
+      size += 2
+    end
+    size
   end
 
+  def compute_delete_row_size(primary_key)
+    size = LITTLE_ENDIAN_SIZE
+    size += compute_primary_key_size(primary_key)
+    size += 3
+    size
+  end
 end

data/lib/tablestore-ruby-sdk.rb

@@ -39,11 +39,47 @@ class TableStore
     # client = TableStoreClient('your_instance_endpoint', 'your_user_id', 'your_user_key', 'your_instance_name')
   end
 
+  ##tables
+  def _create_table(table_meta, table_option, reserved_throughput)
+    api_name = 'CreateTable'
+    body = TableStoreClient.new.encode_create_table(table_meta, table_option, reserved_throughput)
+    response = post_request(body, api_name)
+    if response.code == 200
+      "create table #{table_meta.table_name} succeed!"
+    end
+  end
+
+  def _list_table
+    api_name = "ListTable"
+    body = TableStoreClient.new.encode_list_table
+    response = post_request(body, api_name)
+    TableStoreClient.new.decode_list_table(response.body)
+  end
+
+  def _update_table(table_name, table_option, reserved_throughput=nil)
+    api_name = 'UpdateTable'
+    body = TableStoreClient.new.encode_update_table(table_name, table_option, reserved_throughput)
+    response = post_request(body, api_name)
+    if response.code == 200
+      "update table #{table_name} succeed!"
+    end
+  end
+
+  def _delete_table(table_name)
+    api_name = 'DeleteTable'
+    body = TableStoreClient.new.encode_delete_table(table_name)
+    response = post_request(body, api_name)
+    if response.code == 200
+      "delete table #{table_name} succeed!"
+    end
+  end
+
+  ##rows
   def _get_range(request)
     api_name = 'GetRange'
     body = TableStoreClient.new.encode_get_range_request(request)
     response = post_request(body, api_name)
-    TableStoreClient.new.decode_get_range_request(api_name, response.headers, response.body)
+    TableStoreClient.new.decode_get_range_request(response.body)
   end
 
   def _put_row(table_name, row, condition)
@@ -71,6 +107,15 @@ class TableStore
     end
   end
 
+  def _delete_row(table_name, row, condition)
+    api_name = 'DeleteRow'
+    body = TableStoreClient.new.encode_delete_row(table_name, row, condition)
+    response = post_request(body, api_name)
+    if response.code == 200
+      'delete succeed!'
+    end
+  end
+
   def _batch_get_row(request)
     api_name = 'BatchGetRow'
     body = TableStoreClient.new.make_batch_get_row(request)
@@ -112,7 +157,7 @@ class TableStore
     signature_string += headers_string + "\n"
     salt1 = OpenSSL::HMAC.digest('sha1', access_key_secret, signature_string)
     signature = Base64.encode64(salt1).gsub(/\n/, '')
-    headers.merge!({'User-Agent': 'aliyun-tablestore-sdk-ruby', 'x-ots-signature': signature})
+    headers.merge!({'User-Agent': 'aliyun-tablestore-sdk-ruby', 'x-ots-signature': signature, "Content-Type": 'application/x-www-form-urlencoded',})
     headers
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tablestore-ruby-sdk
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - seveninches
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-15 00:00:00.000000000 Z
+date: 2018-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client