tarantool 0.2.5 → 0.3.0.7

data/lib/tarantool/space_array.rb

@@ -0,0 +1,153 @@
+require 'tarantool/util'
+require 'tarantool/request'
+require 'tarantool/response'
+require 'tarantool/serializers'
+require 'tarantool/core-ext'
+
+module Tarantool
+  class SpaceArray
+    include Request
+    include Util::Array
+
+    def initialize(tarantool, space_no, fields, indexes)
+      @tarantool = tarantool
+      @space_no = space_no
+
+      fields = ([*fields].empty? ? TYPES_AUTO : fields).dup
+      tail_size = Integer === fields.last ? fields.pop : 1
+      fields.map!{|type| check_type(type)}
+      fields << tail_size
+      @fields = fields
+
+      indexes = [*indexes].map{|ind| frozen_array(ind) }.freeze
+      if !indexes.empty?
+        @index_fields = indexes
+        @indexes = _map_indexes(indexes)
+      else
+        @index_fields = nil
+        @indexes = [TYPES_FALLBACK]
+      end
+    end
+
+    def _map_indexes(indexes)
+      indexes.map do |index|
+        (index.map do |i|
+          unless (field = @fields[i]) && !field.is_a?(Integer)
+            raise ArgumentError, "Wrong index field number: #{index} #{i}"
+          end
+          field
+        end << :error).freeze
+      end.freeze
+    end
+
+    def _send_request(type, body, cb)
+      @tarantool._send_request(type, body, cb)
+    end
+
+    def all_by_pks_cb(keys, cb, opts={})
+      all_by_keys_cb(0, keys, cb, opts)
+    end
+
+    def by_pk_cb(pk, cb)
+      first_by_key_cb(0, pk, cb)
+    end
+
+    def all_by_key_cb(index_no, key, cb, opts={})
+      select_cb(index_no, [key], opts[:offset] || 0, opts[:limit] || -1, cb)
+    end
+
+    def first_by_key_cb(index_no, key, cb)
+      select_cb(index_no, [key], 0, :first, cb)
+    end
+
+    def all_by_keys_cb(index_no, keys, cb, opts = {})
+      select_cb(index_no, keys, opts[:offset] || 0, opts[:limit] || -1, cb)
+    end
+
+    def _fix_index_fields(index_fields, keys)
+      sorted = index_fields.sort
+      if index_no = @index_fields.index{|fields| fields.take(index_fields.size).sort == sorted}
+        real_fields = @index_fields[index_no]
+        permutation = index_fields.map{|i| real_fields.index(i)}
+        keys = [*keys].map{|v| [*v].values_at(*permutation)}
+        [index_no, keys]
+      end
+    end
+
+    def select_cb(index_no, keys, offset, limit, cb)
+      if Array === index_no
+        raise ArgumentError, "Has no defined indexes to search index #{index_no}"  unless @index_fields
+        index_fields = index_no
+        index_no = @index_fields.index{|fields| fields.take(index_fields.size) == index_fields}
+        unless index_no || index_fields.size == 1
+          index_no, keys = _fix_index_fields(index_fields, keys)
+          unless index_no
+             raise(ArgumentError, "Not found index with field numbers #{index_no}, " +
+                               "(defined indexes #{@index_fields})")
+          end
+        end
+      end
+      if @index_fields
+        unless index_types = @indexes[index_no]
+          raise ArgumentError, "No index ##{index_no}"
+        end
+      else
+        index_types = _detect_types([*[*keys][0]])
+      end
+
+      _select(@space_no, index_no, offset, limit, keys, cb, @fields, index_types)
+    end
+
+    def insert_cb(tuple, cb, opts = {})
+      _insert(@space_no, BOX_ADD, tuple, @fields, cb, opts[:return_tuple])
+    end
+
+    def replace_cb(tuple, cb, opts = {})
+      _insert(@space_no, BOX_REPLACE, tuple, @fields, cb, opts[:return_tuple])
+    end
+
+    def update_cb(pk, operations, cb, opts = {})
+      _update(@space_no, pk, operations, @fields,
+              @indexes[0] || _detect_types([*pk]),
+              cb, opts[:return_tuple])
+    end
+
+    def delete_cb(pk, cb, opts = {})
+      _delete(@space_no, pk, @fields,
+              @indexes[0] || _detect_types([*pk]),
+              cb, opts[:return_tuple])
+    end
+
+    def invoke_cb(func_name, values, cb, opts = {})
+      values, opts = _space_call_fix_values(values, @space_no, opts)
+      _call(func_name, values, cb, opts)
+    end
+
+    def call_cb(func_name, values, cb, opts = {})
+      values, opts = _space_call_fix_values(values, @space_no, opts)
+
+      opts[:return_tuple] = true  if opts[:return_tuple].nil?
+      opts[:returns] ||= @fields   if opts[:return_tuple]
+
+      _call(func_name, values, cb, opts)
+    end
+
+    include CommonSpaceBlockMethods
+    # callback with block api
+    def all_by_key_blk(index_no, key, opts={}, &block)
+      all_by_key_cb(index_no, key, block, opts)
+    end
+
+    def first_by_key_blk(index_no, key, &block)
+      first_by_key_cb(index_no, key, block)
+    end
+
+    def all_by_keys_blk(index_no, keys, opts={}, &block)
+      all_by_keys_cb(index_no, keys, block, opts)
+    end
+
+    def select_blk(index_no, keys, offset=0, limit=-1, &block)
+      select_cb(index_no, keys, offset, limit, block)
+    end
+  end
+end

data/lib/tarantool/space_hash.rb

@@ -0,0 +1,262 @@
+require 'tarantool/util'
+require 'tarantool/request'
+require 'tarantool/response'
+require 'tarantool/core-ext'
+
+module Tarantool
+  class SpaceHash
+    include Request
+
+    def initialize(tarantool, space_no, fields_def, indexes)
+      @tarantool = tarantool
+      @space_no = space_no
+
+      field_to_pos = {}
+      field_to_type = {}
+      field_types = []
+      i = 0
+      last_type = nil
+      for k, t in fields_def
+        k = k.to_sym
+        unless k == :_tail
+          raise ArgumentError, ":_tail field should be defined last"  if field_to_pos[:_tail]
+          t = check_type(t)
+          last_type = t
+          field_to_pos[k] = i
+          field_to_type[k] = t
+          field_types << t
+        else
+          t = [*t].map{|tt| check_type(tt)}
+          field_to_pos[:_tail] = i
+          field_to_type[:_tail] = t
+          field_types.concat t
+          field_types << t.size
+        end
+        i += 1
+      end
+      field_to_pos[:_tail] ||= i
+      field_to_type[:_tail] ||= [last_type]
+      @field_to_pos = field_to_pos
+      @field_to_type = field_to_type
+      @field_names = field_to_pos.keys
+      @field_types = field_types
+      @tail_pos  = field_to_pos[:_tail]
+      @tail_size = field_to_type[:_tail].size
+
+      @index_fields = [*indexes].map{|ind| [*ind].map{|fld| fld.to_sym}.freeze}.freeze
+      @indexes = _map_indexes(@index_fields)
+      @translators = [TranslateToHash.new(@field_names - [:_tail], @tail_size)].freeze
+    end
+
+    def _add_translator(v)
+      @translators += [v]
+    end
+
+    def with_translator(cb = nil, &block)
+      copy = dup
+      copy._add_translator(cb || block)
+      copy
+    end
+
+    def _map_indexes(indexes)
+      indexes.map do |index|
+        (index.map do |name|
+          @field_to_type[name.to_sym] or raise "Wrong index field name: #{index} #{name}"
+        end << :error).freeze
+      end.freeze
+    end
+
+    def _send_request(type, body, cb)
+      @tarantool._send_request(type, body, cb)
+    end
+
+    def select_cb(keys, offset, limit, cb)
+      index_names = Hash === keys ? keys.keys : keys.first.keys
+      index_no = @index_fields.index{|fields|
+        fields.take(index_names.size) == index_names
+      }
+      unless index_no
+        index_names.sort!
+        index_no = @index_fields.index{|fields|
+          fields.take(index_names.size).sort == index_names
+        }
+        raise ArgumentError, "Could not find index for keys #{index_names}"  unless index_no
+        index_names = @index_fields[index_no].take(index_names.size)
+      end
+      index_types = @indexes[index_no]
+
+      unless Hash === keys
+        keys = keys.map{|key| key.values_at(*index_names)}
+      else
+        keys = keys.values_at(*index_names)
+        if keys.all?{|v| Array === v}
+          if (max_size = keys.map{|v| v.size}.max) > 1
+            keys.map!{|v| v.size == max_size ? v :
+                          v.size == 1        ? v*max_size :
+                          raise(ArgumentError, "size of array keys ought to be 1 or equal to others")
+            }
+          end
+          keys = keys.transpose
+        else
+          keys = [keys]
+        end
+      end
+
+      _select(@space_no, index_no, offset, limit, keys, cb, @field_types, index_types, @translators)
+    end
+
+    def all_cb(keys, cb, opts = {})
+      select_cb(keys, opts[:offset] || 0, opts[:limit] || -1, cb)
+    end
+
+    def first_cb(key, cb)
+      select_cb([key], 0, :first, cb)
+    end
+
+    def all_by_pks_cb(keys, cb, opts={})
+      keys = [*keys].map{|key| _prepare_pk(key)}
+      _select(@space_no, 0, 
+              opts[:offset] || 0, opts[:limit] || -1,
+              keys, cb, @field_types, @indexes[0], @translators)
+    end
+
+    def by_pk_cb(key_array, cb)
+      key_array = _prepare_pk(key_array)
+      _select(@space_no, 0, 0, :first, [key_array], cb, @field_types, @indexes[0], @translators)
+    end
+
+    def _prepare_tuple(tuple)
+      unless (exc = (tuple.keys - @field_names)).empty?
+        raise ArgumentError, "wrong keys #{exc} for tuple"
+      end
+      tuple_ar = tuple.values_at(*@field_names)
+      case tail = tuple_ar.pop
+      when Array
+        tail = tail.flatten(1)  if @tail_size > 1
+        tuple_ar.concat tail
+      when nil
+      else
+        raise ArgumentError, "_tail ought to be an array, but it == #{tail.inspect}"
+      end
+      tuple_ar
+    end
+
+    def insert_cb(tuple, cb, opts = {})
+      _insert(@space_no, BOX_ADD, _prepare_tuple(tuple),
+              @field_types, cb, opts[:return_tuple], @translators)
+    end
+
+    def replace_cb(tuple, cb, opts = {})
+      _insert(@space_no, BOX_REPLACE, _prepare_tuple(tuple),
+              @field_types, cb, opts[:return_tuple], @translators)
+    end
+
+    def _prepare_pk(pk)
+      if Hash === pk
+        pk_fields = pk.keys
+        unless (pindex = @index_fields[0]) == pk_fields
+          if !(exc = (pk_fields - pindex)).empty?
+            raise ArgumentError, "Wrong keys #{exc} for primary index"
+          elsif !(exc = (pindex - pk_fields)).empty?
+            raise ArgumentError, "you should provide values for all keys of primary index (missed #{exc})"
+          end
+        end
+        pk.values_at *pindex
+      else
+        [*pk]
+      end
+    end
+
+    def update_cb(pk, operations, cb, opts = {})
+      pk = _prepare_pk(pk)
+      opers = []
+      operations.each{|oper|
+        if Array === oper[0]
+          oper = oper[0] + oper.drop(1)
+        elsif Array === oper[1] && oper.size == 2 && UPDATE_OPS[oper[1][0]]
+          oper = [oper[0]] + oper[1]
+        end
+        case oper[0]
+        when Integer
+          opers << oper[1..-1].unshift(oper[0] + @tail_pos)
+        when :_tail
+          if UPDATE_OPS[oper[1]] == 0
+            tail = oper[2]
+            unless Array === tail[0] && @tail_size > 1
+              tail.each_with_index{|val, i| opers << [i + @tail_pos, :set, val]}
+            else
+              tail.each_with_index{|vals, i|
+                vals.each_with_index{|val, j|
+                  opers << [i*@tail_size + j + @tail_pos, :set, val]
+                }
+              }
+            end
+          else
+            raise ArgumentError, "_tail update should be array with operations" unless Array === oper[1] && Array === oper[1][0]
+            if @tail_size == 1 || !(Array === oper[1][0][0])
+              oper[1].each_with_index{|op, i| opers << [i + @tail_pos, op]}
+            else
+              oper[1].each_with_index{|ops, i|
+                ops.each_with_index{|op, j|
+                  opers << [i*@tail_size + j + @tail_pos, op]
+                }
+              }
+            end
+          end
+        else
+          opers << oper[1..-1].unshift(
+            @field_to_pos[oper[0]]  || raise(ArgumentError, "Not defined field name #{oper[0]}")
+          )
+        end
+      }
+      _update(@space_no, pk, opers, @field_types,
+              @indexes[0], cb, opts[:return_tuple], @translators)
+    end
+
+    def delete_cb(pk, cb, opts = {})
+      _delete(@space_no, _prepare_pk(pk), @field_types,
+              @indexes[0], cb, opts[:return_tuple], @translators)
+    end
+
+    def invoke_cb(func_name, values, cb, opts = {})
+      values, opts = _space_call_fix_values(values, @space_no, opts)
+      _call(func_name, values, cb, opts)
+    end
+
+    def call_cb(func_name, values, cb, opts = {})
+      values, opts = _space_call_fix_values(values, @space_no, opts)
+
+      opts[:return_tuple] = true  if opts[:return_tuple].nil?
+      if opts[:return_tuple]
+        if opts[:returns]
+          if Hash === opts[:returns]
+            opts[:returns], *opts[:translators] =
+                _parse_hash_definition(opts[:returns])
+          end
+        else
+          types = @field_to_type.values
+          types << [*types.last].size
+          types.flatten!
+          opts[:returns] = types.flatten
+          opts[:translators] = @translators
+        end
+      end
+      
+      _call(func_name, values, cb, opts)
+    end
+
+    include CommonSpaceBlockMethods
+    # callback with block api
+    def all_blk(keys, opts = {}, &block)
+      all_cb(keys, block, opts)
+    end
+
+    def first_blk(key, &block)
+      first_blk(key, block)
+    end
+
+    def select_blk(keys, offset=0, limit=1, &block)
+      select_cb(keys, offset, limit, block)
+    end
+  end
+end

data/lib/tarantool/util.rb

@@ -0,0 +1,182 @@
+module Tarantool
+  module Util
+    module Packer
+    private
+      EMPTY = ''.freeze
+      def unpack_int16(data)
+        data.getbyte(0) + data.getbyte(1) * 256
+      end
+
+      def unpack_int16!(data)
+        int = data.getbyte(0) + data.getbyte(1) * 256
+        data[0, 2] = EMPTY
+        data
+      end
+
+      def unpack_int32(int)
+        (int.getbyte(0) + int.getbyte(1) * 256 +
+         int.getbyte(2) * 65536 + int.getbyte(3) * 16777216)
+      end
+
+      def unpack_int32!(data)
+        int = (data.getbyte(0) + data.getbyte(1) * 256 +
+               data.getbyte(2) * 65536 + data.getbyte(3) * 16777216)
+        data[0, 4] = EMPTY
+        int
+      end
+
+      def unpack_int64!(data)
+        int = (data.getbyte(0) + data.getbyte(1) * 256 +
+               data.getbyte(2) * 65536 + data.getbyte(3) * 16777216 +
+               data.getbyte(4) << 32 + data.getbyte(5) << 40 +
+               data.getbyte(6) << 48 + data.getbyte(7) << 56
+              )
+        data[0, 8] = EMPTY
+        int
+      end
+
+      def unpack_int64(data)
+        data.getbyte(0) + data.getbyte(1) * 256 +
+        data.getbyte(2) * 65536 + data.getbyte(3) * 16777216 +
+        data.getbyte(4) << 32 + data.getbyte(5) << 40 +
+        data.getbyte(6) << 48 + data.getbyte(7) << 56
+      end
+
+      def ber_size(int)
+        int < 128 ? 1 :
+        int < 16384 ? 2 :
+        int < 2097153 ? 3 :
+        int < 268435456 ? 4 : 5
+      end
+
+      def unpack_ber!(data)
+        res = 0
+        pos = 0
+        while true
+          if (byte = data.getbyte(pos)) <= 127
+            res += byte
+            break
+          else
+            res = (res + (byte - 128)) * 128
+            pos += 1
+          end
+        end
+        data[0, pos+1] = EMPTY
+        res
+      end
+    end
+
+    module TailGetter
+      private
+      def get_tail_item(array, index, tail)
+        tail == 1 ?
+          array.last :
+          array[array.size - tail + (index - array.size) % tail]
+      end
+    end
+
+    module Array
+      def frozen_array(obj)
+        (Array === obj ? obj.dup : [*obj]).freeze
+      end
+    end
+
+    class AutoType
+      include Packer
+      include Comparable
+
+      attr_reader :data
+      def initialize(data)
+        @data = data
+      end
+
+      def to_int
+        case @data.bytesize
+        when 8
+          unpack_int64(@data)
+        when 4
+          unpack_int32(@data)
+        when 2
+          unpack_int16(@data)
+        else
+          raise ValueError, "Bad field size #{field_size} for integer field ##{i}"
+        end
+      end
+      alias to_i to_int
+
+      def coerce(oth)
+        case oth
+        when Numeric
+          [oth, to_i]
+        when String
+          [oth, @data]
+        end
+      end
+
+      alias to_str data
+      alias to_s data
+      def inspect
+        "<#{self.class.name} data=#{@data.inspect}>"
+      end
+
+      def ==(oth)
+        case oth
+        when Numeric
+          to_i == oth
+        when String
+          @data == oth
+        when AutoType
+          @data == oth.data
+        end
+      end
+      alias eql? ==
+
+      def <=>(oth)
+        case oth
+        when Numeric
+          to_i <=> oth
+        when String
+          @data <=> oth
+        when AutoType
+          @data <=> oth.data
+        end
+      end
+
+      def +(oth)
+        case oth
+        when Numeric
+          to_i + oth
+        when String
+          @data + oth
+        when AutoType
+          @data + oth.data
+        end
+      end
+
+      def -(oth) to_i - oth end
+      def *(oth) to_i * oth end
+      def /(oth) to_i / oth end
+      def %(oth) to_i % oth end
+      def **(oth) to_i ** oth end
+
+      def empty?;   @data.empty?    end
+      def bytesize; @data.bytesize  end
+      def size;     @data.size      end
+      def length;   @data.length    end
+      def hash;     @data.hash      end
+      %w{[] sub gsub slice =~ match scan split upcase downcase bytes each_byte
+        byteslice capitalize casecmp center chars each_char chomp chop chr
+        codepoints each_codepoint count crypt delete dump each_line lines
+        empty? encode end_with? getbyte hex include? index intern to_sym
+        ljust lstrip succ next oct ord partition reverse rindex
+        rjust rpartition rstrip squeeze start_with? strip swapcase to_c to_f
+        to_r intern to_sym tr unpack upto}.each do |meth|
+        class_eval <<-EOF, __FILE__, __LINE__
+          def #{meth}(*args, &block)
+            @data.#{meth}(*args, &block)
+          end
+        EOF
+      end
+    end
+  end
+end

data/lib/tarantool/version.rb

@@ -0,0 +1,3 @@
+module Tarantool
+  VERSION = "0.3.0.7"
+end