tarantool 0.2.5 → 0.3.0.7

data/lib/tarantool/request.rb

@@ -1,78 +1,377 @@
-class Tarantool
-  class Request
+require 'tarantool/util'
+require 'tarantool/serializers'
 
-    class << self
-      def request_type(name = nil)
-        if name
-          @request_type = Tarantool::Requests::REQUEST_TYPES[name] || raise(UndefinedRequestType)
+module Tarantool
+  module Request
+    include Util::Packer
+    include Util::TailGetter
+    include Serializers
+    INT32 = 'V'.freeze
+    INT64 = 'Q<'.freeze
+    SELECT_HEADER = 'VVVVV'.freeze
+    INSERT_HEADER = 'VV'.freeze
+    UPDATE_HEADER = 'VV'.freeze
+    DELETE_HEADER = 'VV'.freeze
+    CALL_HEADER = 'Vwa*'.freeze
+    INT32_0 = "\x00\x00\x00\x00".freeze
+    INT32_1 = "\x01\x00\x00\x00".freeze
+    BER4 = "\x04".freeze
+    BER8 = "\x08".freeze
+    ZERO = "\x00".freeze
+    EMPTY = "".freeze
+    PACK_STRING = 'wa*'.freeze
+    LEST_INT32 = -(2**31)
+    GREATEST_INT32 = 2**32
+    TYPES_AUTO = [:auto].freeze
+    TYPES_FALLBACK = [:str].freeze
+    TYPES_STR_STR = [:str, :str].freeze
+    TYPES_STR_AUTO = [:str, :auto].freeze
+
+    REQUEST_SELECT = 17
+    REQUEST_INSERT = 13
+    REQUEST_UPDATE = 19
+    REQUEST_DELETE = 21
+    REQUEST_CALL   = 22
+    REQUEST_PING   = 65280
+
+    BOX_RETURN_TUPLE = 0x01
+    BOX_ADD = 0x02
+    BOX_REPLACE = 0x04
+
+    UPDATE_OPS = {
+      :"=" => 0, :+   => 1, :&   => 2, :^   => 3, :|  => 4, :[]     => 5,
+      :set => 0, :add => 1, :and => 2, :xor => 3, :or => 4, :splice => 5,
+      :delete => 6, :insert => 7,
+      :del    => 6, :ins    => 7,
+       '=' => 0, '+'  => 1, '&'  => 2, '^'  => 3, '|' => 4, '[]'    => 5,
+                                                            ':'     => 5,
+      'set'=> 0, 'add'=> 1, 'and'=> 2, 'xor'=> 3, 'or'=> 4, 'splice'=> 5,
+      '#'     => 6, '!'     => 7,
+      'delete'=> 6, 'insert'=> 7,
+      'del'   => 6, 'ins'   => 7,
+       0 => 0, 1 => 1, 2 => 2, 3 => 3, 4 => 4, 5 => 5, 6 => 6, 7 => 7
+    }
+    UPDATE_FIELDNO_OP = 'VC'.freeze
+
+    def _select(space_no, index_no, offset, limit, keys, cb, fields, index_fields, translators = [])
+      get_tuples = limit == :first ? (limit = 1; :first) : :all
+      keys = [*keys]
+      body = [space_no, index_no, offset, limit, keys.size].pack(SELECT_HEADER)
+
+      for key in keys
+        pack_tuple(body, key, index_fields, index_no)
+      end
+      cb = Response.new(cb, get_tuples, fields, translators)
+      _send_request(REQUEST_SELECT, body, cb)
+    end
+
+    class IndexIndexError < StandardError; end
+    def pack_tuple(body, key, types, index_no = 0)
+      if Integer === types.last
+        *types, tail = types
+      else
+        tail = 1
+      end
+      case key
+      when Array
+        if index_no != :space && nili = key.index(nil)
+          key = key.slice(0, nili)
+        end
+        body << [key_size = key.size].pack(INT32)
+        i = 0
+        while i < key_size
+          field = types[i] || get_tail_item(types, i, tail)
+          pack_field(body, field, key[i])
+          i += 1
+        end
+      when nil
+        body << INT32_0
+      else
+        body << INT32_1
+        pack_field(body, types[0], key)
+      end
+    rescue IndexIndexError => e
+      raise ArgumentError, "tuple #{key} has more entries than index #{index_no}"
+    end
+
+    MAX_BYTE_SIZE = 1024 * 1024
+    def pack_field(body, field_kind, value)
+      if value.nil?
+        body << ZERO
+        return
+      end
+      case field_kind
+      when :int, :integer
+        value = value.to_i
+        if LEST_INT32 <= value && value < GREATEST_INT32
+          body << BER4 << [value].pack(INT32)
         else
-          @request_type
+          body << BER8 << [value].pack(INT64)
         end
+      when :str, :string, :bytes
+        value = value.to_s
+        raise StringTooLong  if value.bytesize > MAX_BYTE_SIZE
+        body << [value.bytesize, value].pack(PACK_STRING)
+      when :error
+        raise IndexIndexError
+      when :auto
+        case value
+        when Integer
+          pack_field(body, :int, value)
+        when String
+          pack_field(body, :str, value)
+        when Util::AutoType
+          pack_field(body, :str, value.data)
+        else
+          raise ArgumentError, "Could auto detect only Integer and String"
+        end
+      else
+        value = get_serializer(field_kind).encode(value).to_s
+        raise StringTooLong  if value.bytesize > MAX_BYTE_SIZE
+        body << [value.bytesize, value].pack(PACK_STRING)
+      end
+    end
+
+    def _modify_request(type, body, fields, ret_tuple, cb, translators)
+      cb = Response.new(cb, ret_tuple && (ret_tuple != :all ? :first : :all),
+                            fields, translators)
+      _send_request(type, body, cb)
+    end
+
+    def _insert(space_no, flags, tuple, fields, cb, ret_tuple, translators = [])
+      flags |= BOX_RETURN_TUPLE  if ret_tuple
+      fields = [*fields]
+
+      tuple = [*tuple]
+      tuple_size = tuple.size
+      body = [space_no, flags].pack(INSERT_HEADER)
+      pack_tuple(body, tuple, fields, :space)
+
+      _modify_request(REQUEST_INSERT, body, fields, ret_tuple, cb, translators)
+    end
+
+    def _update(space_no, pk, operations, fields, pk_fields, cb, ret_tuple, translators = [])
+      flags = ret_tuple ? BOX_RETURN_TUPLE : 0
+
+      if Array === operations && !(Array === operations.first)
+        operations = [operations]
       end
 
-      def pack_tuple(*values)
-        [values.size].pack('L') + values.map { |v| pack_field(v) }.join
+      body = [space_no, flags].pack(UPDATE_HEADER)
+      pack_tuple(body, pk, pk_fields, 0)
+      body << [operations.size].pack(INT32)
+
+      _pack_operations(body, operations, fields)
+
+      _modify_request(REQUEST_UPDATE, body, fields, ret_tuple, cb, translators)
+    end
+
+    def _pack_operations(body, operations, fields)
+      if Integer === fields.last
+        *fields, tail = fields
+      else
+        tail = 1
       end
+      for operation in operations
+        if Array === operation[0]
+          operation = operation[0] + operation.drop(1)
+        elsif Array === operation[1]
+          if operation.size == 2
+            operation = [operation[0]] + operation[1]
+          else
+            raise ArgumentError, "Could not understand operation #{operation}"
+          end
+        end
 
-      def pack_field(value)
-        if String === value
-          raise StringTooLong.new if value.bytesize > 1024 * 1024
-          [value.bytesize, value].pack('wa*')
-        elsif Integer === value
-          if value < 4294967296 # 2 ^ 32
-            [4, value].pack('wL')
+        field_no = operation[0]
+        if operation.size == 2
+          if (Integer === field_no || field_no =~ /\A\d/)
+            unless Symbol === operation[1] && UPDATE_OPS[operation[1]] == 6
+              body << [field_no, 0].pack(UPDATE_FIELDNO_OP)
+              type = fields[field_no] || get_tail_item(fields, field_no, tail) ||
+                _detect_type(operation[1])
+              pack_field(body, type, operation[1])
+              next
+            end
+          elsif String === field_no
+            operation.insert(1, field_no.slice(0, 1))
+            field_no = field_no.slice(1..-1).to_i
           else
-            [8, value].pack('wQ')
+            raise ArgumentError, "Could not understand field number #{field_no.inspect}"
           end
-        elsif value.is_a?(Tarantool::Field)
-          [value.data.bytesize].pack('w') + value.data
-        else
-          raise ArgumentError.new("Field should be integer or string")
         end
-      end 
-    end
 
-    attr_reader :space, :params, :args
-    attr_reader :space_no
-    def initialize(space, *args)
-      @space = space      
-      @args = args
-      @params = if args.last.is_a? Hash
-        args.pop
-      else
-        {}
+        op = operation[1]
+        op = UPDATE_OPS[op]  unless Integer === op
+        raise ArgumentError, "Unknown operation #{operation[1]}" unless op
+        body << [field_no, op].pack(UPDATE_FIELDNO_OP)
+        case op
+        when 0
+          if (type = fields[field_no]).nil?
+            if operation.size == 4 && Symbol === operation.last
+              *operation, type = operation
+            else
+              type = get_tail_item(fields, field_no, tail) || _detect_type(operation[2])
+            end
+          end
+          unless operation.size == 3
+            raise ArgumentError, "wrong arguments for set or insert operation #{operation.inspect}"
+          end
+          pack_field(body, type, operation[2])
+        when 1, 2, 3, 4
+          unless operation.size == 3 && !operation[2].nil?
+            raise ArgumentError, "wrong arguments for integer operation #{operation.inspect}"
+          end
+          pack_field(body, :int, operation[2])
+        when 5
+          unless operation.size == 5 && !operation[2].nil? && !operation[3].nil?
+            raise ArgumentError, "wrong arguments for slice operation #{operation.inspect}"
+          end
+
+          str = operation[4].to_s
+          body << [ 10 + ber_size(str.bytesize) + str.bytesize ].pack('w')
+          pack_field(body, :int, operation[2])
+          pack_field(body, :int, operation[3])
+          pack_field(body, :str, str)
+        when 7
+          old_field_no = field_no + 
+            (inserted ||= []).count{|i| i <= field_no} -
+            (deleted ||= []).count{|i| i <= field_no}
+          inserted << field_no
+          if (type = fields[old_field_no]).nil?
+            if operation.size == 4 && Symbol === operation.last
+              *operation, type = operation
+            else
+              type = get_tail_item(fields, old_field_no, tail)
+            end
+          end
+          unless operation.size == 3
+            raise ArgumentError, "wrong arguments for set or insert operation #{operation.inspect}"
+          end
+          pack_field(body, type, operation[2])
+        when 6
+          body << ZERO
+          # pass
+        end
       end
-      @space_no = params.delete(:space_no) || space.space_no || raise(UndefinedSpace.new)
-      parse_args
     end
 
-    def perform
-      data = connection.send_request self.class.request_type, make_body
-      make_response data
+    def _delete(space_no, pk, fields, pk_fields, cb, ret_tuple, translators = [])
+      flags = ret_tuple ? BOX_RETURN_TUPLE : 0
+
+      body = [space_no, flags].pack(DELETE_HEADER)
+      pack_tuple(body, pk, pk_fields, 0)
+
+      _modify_request(REQUEST_DELETE, body, fields, ret_tuple, cb, translators)
+    end
+
+    def _space_call_fix_values(values, space_no, opts)
+      opts = opts.dup
+      space_no = opts[:space_no]  if opts.has_key?(:space_no)
+      if space_no
+        values = [space_no].concat([*values])
+        if opts[:types]
+          opts[:types] = [:str].concat([*opts[:types]]) # cause lua could convert it to integer by itself
+        else
+          opts[:types] = TYPES_STR_STR
+        end
+      end
+      [values, opts]
     end
 
-    def parse_args
+    def _call(func_name, values, cb, opts={})
+      return_tuple = opts[:return_tuple] && :all
+      flags = return_tuple ? BOX_RETURN_TUPLE : 0
       
+      values = [*values]
+      value_types = opts[:types] ? [*opts[:types]] :
+                                  _detect_types(values)
+      return_types = [*opts[:returns] || TYPES_AUTO]
+
+      func_name = func_name.to_s
+      body = [flags, func_name.size, func_name].pack(CALL_HEADER)
+      pack_tuple(body, values, value_types, :func_call)
+
+      _modify_request(REQUEST_CALL, body, return_types, return_tuple, cb, opts[:translators] || [])
     end
 
-    def make_response(data)
-      return_code, = data[0,4].unpack('L')
-      if return_code == 0
-        Response.new(data[4, data.size], response_params)
-      else
-        msg = data[4, data.size].unpack('A*')
-        raise BadReturnCode.new("Error code #{return_code}: #{msg}")
-      end
+    def _ping(cb)
+      _send_request(REQUEST_PING, EMPTY, cb)
     end
+    alias ping_cb _ping
 
-    def response_params
-      res = {}
-      res[:return_tuple] = true if params[:return_tuple]
+    def _detect_types(values)
+      values.map{|v| Integer === v ? :int : :str}
+    end
+
+    def _detect_type(value)
+      Integer === v ? :int :
+      Util::AutoType === v ? :auto :
+      :str
+    end
+
+    def _parse_hash_definition(returns)
+      field_names = []
+      field_types = []
+      returns.each{|name, type|
+        field_names << name
+        field_types << type
+      }
+      field_types << if field_names.include?(:_tail)
+          unless field_names.last == :_tail
+            raise ArgumentError, "_tail should be de declared last"
+          end
+          field_names.pop
+          [*field_types.last].size
+        else
+          1
+        end
+      field_types.flatten!
+      [field_types, TranslateToHash.new(field_names, field_types.last)]
+    end
+
+    def _raise_or_return(res)
+      raise res  if Exception === res
       res
     end
+  end
+
+  module CommonSpaceBlockMethods
+    def all_by_pks_blk(keys, opts={}, &block)
+      all_by_pks_cb(keys, block, opts)
+    end
 
-    def connection
-      space.connection
+    def by_pk_blk(key_array, &block)
+      by_pk_cb(key_array, block)
+    end
+
+    def insert_blk(tuple, opts={}, &block)
+      insert_cb(tuple, block, opts)
+    end
+
+    def replace_blk(tuple, opts={}, &block)
+      replace_cb(tuple, block, opts)
+    end
+
+    def update_blk(pk, operations, opts={}, &block)
+      update_cb(pk, operations, block, opts)
+    end
+
+    def delete_blk(pk, opts={}, &block)
+      delete_cb(pk, block, opts)
+    end
+
+    def invoke_blk(func_name, values = [], opts={}, &block)
+      invoke_cb(func_name, values, block, opts)
+    end
+
+    def call_blk(func_name, values = [], opts={}, &block)
+      call_cb(func_name, values, block, opts)
+    end
+
+    def ping_blk(&block)
+      ping_cb(block)
     end
   end
-end
+
+end

data/lib/tarantool/response.rb

@@ -1,61 +1,124 @@
-class Tarantool
-  class Field
-    attr_reader :data
-    def initialize(data)
-      @data = data
-    end
+require 'tarantool/util'
+require 'tarantool/exceptions'
+require 'tarantool/serializers'
 
-    def to_i
-      case data.bytesize
-      when 8
-        data.unpack('Q')[0]
-      when 4
-        data.unpack('L')[0]
-      when 2
-        data.unpack('S')[0]
+module Tarantool
+  class Response < Struct.new(:cb, :get_tuples, :fields, :translators)
+    include Util::Packer
+    include Util::TailGetter
+    include Serializers
+    def call(data)
+      if Exception === data
+        cb.call(data)
       else
-        raise ValueError.new("Unable to cast field to int: length must be 2, 4 or 8 bytes, field length is #{data.size}")
+        if (ret = return_code(data)) == 0
+          cb.call parse_response(data)
+        else
+          data.gsub!("\x00", "")
+          cb.call CODE_TO_EXCEPTION[ret].new(ret, data)
+        end
       end
     end
 
-    def to_s
-      data.dup.force_encoding('utf-8')
+    def translators
+      super || (self.translators = [])
     end
-  end
-  class Response
-    attr_reader :tuples_affected, :offset, :tuples
-    def initialize(data, params = {})
-      @offset = 0
-      @tuples_affected, = data[0, 4].unpack('L')
-      @offset += 4
-      if params[:return_tuple]
-        @tuples = (1..tuples_affected).map do
-          unpack_tuple(data)
-        end
+
+    def parse_response(data)
+      unless get_tuples
+        unpack_int32(data)
       else
-        tuples_affected
+        tuples = unpack_tuples(data)
+        if translators
+          translators.each{|trans|
+            tuples.map!{|tuple| trans.call(tuple)}
+          }
+        end
+        get_tuples == :first ? tuples.first : tuples
       end
     end
 
-    # Only select request can return many tuples
-    def tuple
-      tuples.first
-    end
+    def unpack_tuples(data)
+      tuples_affected = unpack_int32!(data)
+      tuples = []
+      fields = fields()
+      if Integer === fields.last
+        *fields, tail = fields
+      else
+        tail = 1
+      end
 
-    def unpack_tuple(data)
-      byte_size, cardinality = data[offset, 8].unpack("LL")
-      @offset += 8
-      tuple_data = data[offset, byte_size]
-      @offset += byte_size
-      (1..cardinality).map do
-        Field.new unpack_field(tuple_data)
+      while tuples_affected > 0
+        byte_size = unpack_int32!(data)
+        fields_num = unpack_int32!(data)
+        tuple_str = data.slice!(0, byte_size)
+        i = 0
+        tuple = []
+        while i < fields_num
+          field_size = unpack_ber!(tuple_str)
+
+          field = fields[i] || get_tail_item(fields, i, tail)
+
+          tuple << (field_size == 0 ? nil :
+            case field
+            when :int, :integer
+              case field_size
+              when 8
+                unpack_int64!(tuple_str)
+              when 4
+                unpack_int32!(tuple_str)
+              when 2
+                unpack_int16!(tuple_str)
+              else
+                raise ValueError, "Bad field size #{field_size} for integer field ##{i}"
+              end
+            when :str, :string
+              tuple_str.slice!(0, field_size).force_encoding('utf-8')
+            when :bytes
+              tuple_str.slice!(0, field_size)
+            when :auto
+              str = tuple_str.slice!(0, field_size).force_encoding('utf-8')
+              case field_size
+              when 8, 4, 2
+                Util::AutoType.new(str)
+              else
+                str
+              end
+            else
+              get_serializer(field).decode(tuple_str.slice!(0, field_size))
+            end)
+          i += 1
+        end
+        tuples << tuple
+        tuples_affected -= 1
       end
+      tuples
+    end
+
+    def return_code(data)
+      unpack_int32!(data)
     end
+  end
 
-    def unpack_field(data)
-      byte_size,  = data.unpack('w')
-      data.slice!(0, [byte_size].pack('w').bytesize) # ololo
-      data.slice!(0, byte_size)
+  # note that :_tail should not be in field_names
+  class TranslateToHash < Struct.new(:field_names, :tail_size)
+    def call(tuple)
+      i = 0
+      hash = {}
+      tuple_size = tuple.size
+      names = field_names
+      while i < tuple_size
+        if name = names[i]
+          hash[name] = tuple[i]
+        else
+          tail = tuple.slice(i..-1)
+          hash[:_tail] = tail_size == 1 ? tail :
+                         tail.each_slice(tail_size).to_a
+          break
+        end
+        i += 1
+      end
+      hash
     end
   end
-end
+end

data/lib/tarantool/serializers/bson.rb

@@ -1,5 +1,5 @@
 require 'bson'
-class Tarantool
+module Tarantool
   module Serializers
     class BSON
       Serializers::MAP[:bson] = self
@@ -12,4 +12,4 @@ class Tarantool
       end
     end
   end
-end
+end

data/lib/tarantool/serializers.rb

@@ -1,9 +1,37 @@
-class Tarantool
+module Tarantool
   module Serializers
     MAP = {}
-    %w{string integer}.each do |v|
-      require "tarantool/serializers/#{v}"
+
+    def check_type(type)
+      type = type.to_sym  if String === type
+      return :int  if Integer == type
+      return :str  if String  == type
+
+      case type
+      when :int, :integer, :str, :string, :bytes, :auto
+        # pass
+      when Symbol
+        unless MAP.include?(type)
+          raise ArgumentError, "Unknown type name #{type.inspect}"
+        end
+      else
+        unless type.respond_to?(:encode) && type.respond_to?(:decode)
+          raise ArgumentError, "Wrong serializer object #{type.inspect} (must respond to #encode and #decode)"
+        end
+      end
+      type
+    end
+
+    def get_serializer(type)
+      if Symbol === type
+        MAP.fetch(type){ raise ArgumentError, "Unknown type name #{type.inspect}" }
+      elsif type.respond_to?(:encode) && type.respond_to?(:decode)
+        type
+      else
+        raise ArgumentError, "Wrong serializer object #{type.inspect} (must respond to #encode and #decode)"
+      end
     end
 
+    extend self
   end
-end
+end