tablestore-ruby-sdk 0.0.0

data/lib/tablestore/ots.rb

@@ -0,0 +1,481 @@
+require 'protobuf'
+require 'os'
+require 'protobuf/ots_pb'
+require 'protobuf/ots_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
+  def encode_get_range_request(request)
+    proto = GetRangeRequest.new
+    proto.table_name = request[:table_name]
+    proto.direction = request[:direction]
+    proto.inclusive_start_primary_key = serialize_primary_key(request[:inclusive_start_primary_key])
+    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")
+  end
+
+  def decode_get_range_request(api_name, headers, body)
+    proto = GetRangeResponse.decode(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
+    condition = Condition(RowExistenceExpectation::IGNORE, nil) if condition.nil?
+    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
+  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)
+    end
+    proto.primary_key = serialize_primary_key(primary_key)
+    proto.max_versions = max_version if max_version.present?
+    GetRowRequest.encode(proto)
+  end
+
+  def decode_get_row(body)
+    proto = GetRowResponse.decode(body)
+
+    return_row = nil
+    if proto.row.length > 0
+      inputStream = PlainBufferInputStream.new(proto.row)
+      codedInputStream = PlainBufferCodedInputStream.new(inputStream)
+      return_row = codedInputStream.read_row
+    end
+    return_row
+  end
+
+  def decode_put_row(body)
+    proto = PutRowResponse.decode(body)
+    return_row = nil
+    if proto.row.length != 0
+      inputStream = PlainBufferInputStream.new(proto.row)
+      codedInputStream = PlainBufferCodedInputStream.new(inputStream)
+      return_row = codedInputStream.read_row
+    end
+    return_row
+  end
+
+  def make_batch_get_row(request)
+    proto = BatchGetRowRequest.new
+    request.items.each do |item|
+      table_value = item[1]
+      table_item = TableInBatchGetRowRequest.new
+      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)
+      end
+
+      table_value.primary_keys.each do |pk|
+        table_item.primary_key << serialize_primary_key(pk)
+      end
+
+      if table_value.token.present?
+        table_value.token.each do |tk|
+          table_item.token << tk
+        end
+      end
+      if table_value.max_version.present?
+          table_item.max_versions = table_value.max_version
+      end
+      if table_value.time_range.present?
+        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]
+        elsif table_value.is_a?(Fixnum)
+          table_item.time_range.specific_time = table_value.time_range
+        end
+      end
+      if table_value.start_column.present?
+        table_item.start_column = table_value.start_column
+      end
+      if table_value.end_column.present?
+          table_item.end_column = table_value.end_column
+      end
+      proto.tables << table_item
+    end
+    BatchGetRowRequest.encode(proto)
+  end
+
+  def decode_batch_get_row(body)
+    proto = BatchGetRowResponse.decode(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|
+      table_value = item[1]
+      table_item = TableInBatchWriteRowRequest.new
+      table_item.table_name = table_value.table_name
+
+      table_value.row_items.each do |row_item|
+        if row_item.type == Metadata::BatchWriteRowType::PUT
+          row = RowInBatchWriteRowRequest.new
+          table_item.rows << make_put_row_item(row, row_item)
+        end
+        if row_item.type == Metadata::BatchWriteRowType::UPDATE
+          row = RowInBatchWriteRowRequest.new
+          table_item.rows << make_update_row_item(row, row_item)
+        end
+      end
+      proto.tables << table_item
+    end
+    batch_string = BatchWriteRowRequest.encode(proto)
+    batch_string.gsub("\x08\x03", "\x08\x00")
+  end
+
+  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)
+    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
+    end
+
+    proto.row_change = serialize_for_put_row(put_row_item.row.primary_key, put_row_item.row.attribute_columns)
+    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)
+    end
+
+    make_condition(proto.condition, condition)
+
+    if update_row_item.return_type == Metadata::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
+  end
+
+  def make_repeated_column_names(proto, columns_to_get)
+    if columns_to_get.nil?
+      return
+    end
+
+    columns_to_get.each do |column_name|
+      proto << column_name
+    end
+  end
+
+  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
+    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)
+    end
+    proto
+  end
+
+  def make_column_condition(column_condition)
+    return if column_condition.nil?
+    proto = Filter.new
+    proto.type = column_condition.get_type
+
+    # condition
+    if column_condition.is_a?(Metadata::CompositeColumnCondition)
+      proto.filter = make_composite_condition(column_condition)
+    elsif column_condition.is_a?(Metadata::SingleColumnCondition)
+      proto.filter = make_relation_condition(column_condition)
+    else
+      raise TableStoreClientError.new("expect CompositeColumnCondition, SingleColumnCondition but not #{column_condition.class}")
+    end
+    proto
+  end
+
+  def make_composite_condition(condition)
+    proto = CompositeColumnValueFilter.new
+    proto.combinator = condition.get_combinator
+
+    condition.sub_conditions.each do |sub|
+      proto.sub_filters << make_column_condition(sub)
+    end
+
+    CompositeColumnValueFilter.encode(proto)
+  end
+
+  def make_relation_condition(condition)
+    proto = SingleColumnValueFilter.new
+    proto.comparator = condition.get_comparator
+
+    proto.column_name = condition.get_column_name
+    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
+
+    filter_string
+  end
+
+  def parse_get_row_item(proto)
+    row_list = []
+    proto.each do |row_item|
+      primary_key_columns = nil
+      attribute_columns = nil
+
+      if row_item.is_ok
+        # error_code = nil
+        # error_message = nil
+        # capacity_unit = parse_capacity_unit(row_item.consumed.capacity_unit)
+
+        if row_item.row.length != 0
+          inputStream = PlainBufferInputStream.new(row_item.row)
+          codedInputStream = PlainBufferCodedInputStream.new(inputStream)
+          primary_key_columns, attribute_columns = codedInputStream.read_row
+        end
+      else
+        # error_code = row_item.error.code
+        # error_message = row_item.error.HasField('message') ? row_item.error.message : ''
+        # if row_item.HasField('consumed')
+        #   capacity_unit = parse_capacity_unit(row_item.consumed.capacity_unit)
+        # else
+        #   capacity_unit = nil
+        # end
+      end
+
+      row_list << {pk: primary_key_columns, attr: attribute_columns} if primary_key_columns.present?
+    end
+    row_list
+  end
+
+  def parse_batch_write_row(proto)
+    result_list = {}
+    proto.each do |table_item|
+      table_name = table_item.table_name
+      result_list[table_name] = []
+
+      table_item.rows.each do |row_item|
+        row = parse_write_row_item(row_item)
+        result_list[table_name] << row
+      end
+    end
+
+    result_list
+  end
+
+  def parse_write_row_item(row_item)
+    primary_key_columns = nil
+
+    if row_item.is_ok
+      error_code = nil
+      error_message = nil
+
+      if row_item.row.length != 0
+        inputStream = PlainBufferInputStream.new(row_item.row)
+        codedInputStream = PlainBufferCodedInputStream.new(inputStream)
+        primary_key_columns, attribute_columns = codedInputStream.read_row
+      end
+    end
+    primary_key_columns
+
+    #BatchWriteRowResponseItem.new(row_item.is_ok, error_code, error_message, consumed, primary_key_columns)
+  end
+
+  private
+  def serialize_primary_key(primary_key)
+    buf_size = LITTLE_ENDIAN_SIZE
+    buf_size += compute_primary_key_size(primary_key)
+    buf_size += 2
+    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.crc_int8(row_checksum, 0)
+    coded_output_stream.write_row_checksum(row_checksum)
+    output_stream.get_buffer.join('')
+  end
+
+  def serialize_column_value(value)
+    buf_size = compute_variant_value_size(value)
+    stream = PlainBufferOutputStream.new(buf_size)
+    coded_stream = PlainBufferCodedOutputStream.new(stream)
+
+    coded_stream.write_column_value(value)
+    stream.get_buffer.join('')
+  end
+
+  def compute_variant_value_size(value)
+    compute_primary_key_value_size(value) - LITTLE_ENDIAN_SIZE - 1
+  end
+
+  def parse_capacity_unit(proto)
+    if proto.nil?
+      capacity_unit = nil
+    else
+      cu_read = proto.HasField('read') ? proto.read : 0
+      cu_write = proto.HasField('write') ? proto.write : 0
+      capacity_unit = CapacityUnit(cu_read, cu_write)
+    end
+    capacity_unit
+  end
+
+  def compute_primary_key_size(primary_key)
+    size = 1
+    primary_key.each do |pk|
+      size += compute_primary_key_column_size(pk[0], pk[1])
+    end
+    size
+  end
+
+  def compute_primary_key_column_size(pk_name, pk_value)
+    size = 1
+    size += 1 + LITTLE_ENDIAN_SIZE
+    size += pk_name.length
+    size += compute_primary_key_value_size(pk_value)
+    size += 2
+    size
+  end
+
+  def compute_primary_key_value_size(value)
+    size = 1
+    size += LITTLE_ENDIAN_SIZE + 1
+    if ["INF_MIN", "INF_MAX", "PK_AUTO_INCR"].include?value
+      size += 1
+      return size
+    end
+    if value.is_a?(Numeric)
+      size += 8
+    elsif value.is_a?(String)
+      size += LITTLE_ENDIAN_SIZE
+      size += value.length
+    end
+    size
+  end
+
+  def serialize_for_put_row(primary_key, attribute_columns)
+    buf_size = compute_put_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_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_put_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.each do |attr|
+        if attr.length == 2
+          size += compute_column_size(attr[0], attr[1])
+        else
+          size += compute_column_size(attr[0], attr[1], attr[2])
+        end
+      end
+    end
+    size += 2
+    size
+  end
+
+  def compute_column_size(column_name, column_value, timestamp = nil)
+    size = 1
+    size += 1 + LITTLE_ENDIAN_SIZE
+    size += column_name.length
+    unless column_value.nil?
+      size += compute_column_value_size(column_value)
+    end
+    unless timestamp.nil?
+      size += 1 + LITTLE_ENDIAN_64_SIZE
+    end
+    size += 2
+    size
+  end
+
+  def compute_column_value_size(value)
+    size = 1
+    size += LITTLE_ENDIAN_SIZE + 1
+
+    if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      size += 1
+    elsif value.is_a?(Fixnum)
+      size += LITTLE_ENDIAN_64_SIZE
+    elsif value.is_a?(String)
+      size += LITTLE_ENDIAN_SIZE
+      size += value.length
+    elsif value.is_a?(Float)
+      size += LITTLE_ENDIAN_64_SIZE
+    else
+      raise TableStoreClientError("Unsupported column type: " + value.class)
+    end
+    size
+  end
+end