tarantool 0.3.0.7 → 0.4.2.1

data/lib/tarantool/fiber_db.rb

@@ -1,8 +1,12 @@
-require 'iproto/core-ext'
+require 'tarantool/core-ext'
 require 'tarantool/em_db'
 
 module Tarantool
   class FiberDB < EMDB
+    def primary_interface
+      :synchronous
+    end
+
     module CommonSpaceFiberMethods
       def all_by_pks(pks, opts={})
         all_by_pks_cb(pks, ::Fiber.current, opts)
@@ -24,6 +28,11 @@ module Tarantool
         _raise_or_return ::Fiber.yield
       end
 
+      def store(tuple, opts={})
+        store_cb(tuple, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
       def update(pk, operations, opts={})
         update_cb(pk, operations, ::Fiber.current, opts)
         _raise_or_return ::Fiber.yield
@@ -123,6 +132,11 @@ module Tarantool
         _raise_or_return ::Fiber.yield
       end
 
+      def store(space_no, tuple, opts={})
+        store_cb(space_no, tuple, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
       def update(space_no, pk, operation, opts={})
         update_cb(space_no, pk, operation, ::Fiber.current, opts)
         _raise_or_return ::Fiber.yield

data/lib/tarantool/light_record.rb

@@ -22,20 +22,37 @@ module Tarantool
     end
 
     def save
+      return false  unless before_save
       if @__new_record
+        return false  unless before_create
         self.class.insert(@attributes)
         @__new_record = false
+        after_create
       else
+        return false  unless before_update
         self.class.replace(@attributes)
+        after_update
       end
+      after_save
       self
     end
 
     def destroy
+      return false  unless before_destroy
       self.class.delete id
+      after_destroy
       true
     end
 
+    def before_save; true end
+    def before_create; true end
+    def before_update; true end
+    def after_create; end
+    def after_update; end
+    def after_save; end
+    def before_destroy; true end
+    def after_destroy; end
+
     class << self
       def generated_attribute_methods
         @generated_attribute_methods ||= begin

data/lib/tarantool/query.rb

@@ -6,10 +6,7 @@ module Tarantool
     include Request
     def initialize(tarantool)
       @tarantool = tarantool
-    end
-
-    def _send_request(type, body, cb)
-      @tarantool._send_request(type, body, cb)
+      _init_shard_vars(nil, false)
     end
 
     def select_cb(space_no, index_no, keys, offset, limit, cb, opts={})
@@ -20,7 +17,7 @@ module Tarantool
         returns, *translators = _parse_hash_definition(returns)
       end
       _select(space_no, index_no, offset, limit, keys, cb, returns,
-              types, translators)
+              types, all_shards, translators)
     end
 
     def all_cb(space_no, index_no, keys, cb, opts={})
@@ -35,12 +32,17 @@ module Tarantool
 
     def insert_cb(space_no, tuple, cb, opts={})
       types = opts[:types] || _detect_types(tuple)
-      _insert(space_no, BOX_ADD, tuple, types, cb, opts[:return_tuple])
+      _insert(space_no, BOX_ADD, tuple, types, cb, opts[:return_tuple], all_shards)
     end
 
     def replace_cb(space_no, tuple, cb, opts={})
       types = opts[:types] || _detect_types(tuple)
-      _insert(space_no, BOX_REPLACE, tuple, types, cb, opts[:return_tuple])
+      _insert(space_no, BOX_REPLACE, tuple, types, cb, opts[:return_tuple], all_shards)
+    end
+
+    def store_cb(space_no, tuple, cb, opts={})
+      types = opts[:types] || _detect_types(tuple)
+      _insert(space_no, 0, tuple, types, cb, opts[:return_tuple], all_shards)
     end
 
     def update_cb(space_no, pk, operations, cb, opts={})
@@ -51,7 +53,7 @@ module Tarantool
         returns, *translators = _parse_hash_definition(returns)
       end
       _update(space_no, pk, operations, returns, pk_types, cb,
-              opts[:return_tuple], translators)
+              opts[:return_tuple], all_shards, translators)
     end
 
     def delete_cb(space_no, pk, cb, opts={})
@@ -62,7 +64,7 @@ module Tarantool
         returns, *translators = _parse_hash_definition(returns)
       end
       _delete(space_no, pk, returns, pk_types, cb,
-              opts[:return_tuple], translators)
+              opts[:return_tuple], all_shards, translators)
     end
 
     def invoke_cb(func_name, values, cb, opts={})
@@ -104,6 +106,10 @@ module Tarantool
       replace_cb(space_no, tuple, block, opts)
     end
 
+    def store_blk(space_no, tuple, opts={}, &block)
+      store_cb(space_no, tuple, block, opts)
+    end
+
     def update_blk(space_no, pk, operation, opts={}, &block)
       update_cb(space_no, pk, operation, block, opts={})
     end

data/lib/tarantool/record/select.rb

@@ -24,6 +24,11 @@ module Tarantool
           end
       end
 
+      def reset!
+        @results = nil
+        self
+      end
+
       def each
         return to_enum  unless block_given?
         results.each{|a| yield a}
@@ -45,14 +50,27 @@ module Tarantool
         self.class.new(@record, @params.merge(where: params))
       end
 
+      def shard(params)
+        self.class.new(@record, @params.merge(shard: params))
+      end
+
+      def auto_shard
+        params = @params.dup
+        params.delte :shard
+        self.class.new(@record, params)
+      end
+
       def all
         results.dup
       end
 
       def first
-        @record.auto_space.
-          select(@params[:where], @params[:offset] || 0, 1).
-          first
+        space.select(@params[:where], @params[:offset] || 0, 1).first
+      end
+
+      def space
+        space = @record.auto_space
+        @params[:shard] ? space.shard(@params[:shard]) : space
       end
     end
   end

data/lib/tarantool/request.rb

@@ -1,13 +1,16 @@
 require 'tarantool/util'
+require 'tarantool/shards_support'
 require 'tarantool/serializers'
 
 module Tarantool
+  module CommonSpace
+    attr_reader :tarantool, :space_no
+  end
+
   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
@@ -15,17 +18,16 @@ module Tarantool
     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
+    ONE  = "\x01".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
+    TYPES_FALLBACK = [:string].freeze
+    TYPES_STR_STR = [:string, :string].freeze
+    TYPES_STR_AUTO = [:string, :auto].freeze
 
     REQUEST_SELECT = 17
     REQUEST_INSERT = 13
@@ -53,7 +55,11 @@ module Tarantool
     }
     UPDATE_FIELDNO_OP = 'VC'.freeze
 
-    def _select(space_no, index_no, offset, limit, keys, cb, fields, index_fields, translators = [])
+    def _send_request(shard_numbers, read_write, cb)
+      @tarantool._send_request(shard_numbers, read_write, cb)
+    end
+
+    def _select(space_no, index_no, offset, limit, keys, cb, fields, index_fields, shard_nums, translators = [])
       get_tuples = limit == :first ? (limit = 1; :first) : :all
       keys = [*keys]
       body = [space_no, index_no, offset, limit, keys.size].pack(SELECT_HEADER)
@@ -61,8 +67,8 @@ module Tarantool
       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)
+      response = Response.new(cb, REQUEST_SELECT, body, get_tuples, fields, translators)
+      _send_request(shard_nums, :read, response)
     end
 
     class IndexIndexError < StandardError; end
@@ -90,7 +96,7 @@ module Tarantool
         body << INT32_1
         pack_field(body, types[0], key)
       end
-    rescue IndexIndexError => e
+    rescue IndexIndexError
       raise ArgumentError, "tuple #{key} has more entries than index #{index_no}"
     end
 
@@ -103,25 +109,62 @@ module Tarantool
       case field_kind
       when :int, :integer
         value = value.to_i
-        if LEST_INT32 <= value && value < GREATEST_INT32
-          body << BER4 << [value].pack(INT32)
-        else
-          body << BER8 << [value].pack(INT64)
-        end
-      when :str, :string, :bytes
+        _raise_integer_overflow(value, MIN_INT, MAX_INT32)  if value > MAX_INT32 or value < 0
+        append_ber_int32!(body, value)
+      when :string, :bytes, :str
         value = value.to_s
-        raise StringTooLong  if value.bytesize > MAX_BYTE_SIZE
+        value = ZERO + value  if value < ONE
+        raise StringTooLong  if value.bytesize >= MAX_BYTE_SIZE
         body << [value.bytesize, value].pack(PACK_STRING)
+      when :bytes
+        value = value.to_s
+        raise StringTooLong  if value.bytesize >= MAX_BYTE_SIZE
+        body << [value.bytesize, value].pack(PACK_STRING)
+      when :int64
+        value = value.to_i
+        _raise_integer_overflow(value, MIN_INT, MAX_INT64)  if value > MAX_INT64 or value < 0
+        append_ber_int64!(body, value)
+      when :int16
+        value = value.to_i
+        _raise_integer_overflow(value, MIN_INT, MAX_INT16)  if value > MAX_INT16 or value < 0
+        append_ber_int16!(body, value)
+      when :int8
+        value = value.to_i
+        _raise_integer_overflow(value, MIN_INT, MAX_INT8)  if value > MAX_INT8 or value < 0
+        append_ber_int8!(body, value)
+      when :sint
+        value = value.to_i
+        _raise_integer_overflow(value, MIN_SINT32, MAX_SINT32)  if value > MAX_SINT32 or value < MIN_SINT32
+        append_ber_sint32!(body, value)
+      when :sint64
+        value = value.to_i
+        _raise_integer_overflow(value, MIN_SINT64, MAX_SINT64)  if value > MAX_SINT64 or value < MIN_SINT64
+        append_ber_sint64!(body, value)
+      when :sint16
+        value = value.to_i
+        _raise_integer_overflow(value, MIN_SINT16, MAX_SINT16)  if value > MAX_SINT16 or value < MIN_SINT16
+        append_ber_sint16!(body, value)
+      when :sint8
+        value = value.to_i
+        _raise_integer_overflow(value, MIN_SINT8, MAX_SINT8)  if value > MAX_SINT8 or value < MIN_SINT8
+        append_ber_sint8!(body, value)
+      when :varint
+        value = value.to_i
+        if 0 <= value && value < MAX_INT32
+          append_ber_int32!(body, value)
+        else
+          append_ber_sint64!(body, value)
+        end
       when :error
         raise IndexIndexError
       when :auto
         case value
         when Integer
-          pack_field(body, :int, value)
+          pack_field(body, :varint, value)
         when String
-          pack_field(body, :str, value)
+          pack_field(body, :bytes, value)
         when Util::AutoType
-          pack_field(body, :str, value.data)
+          pack_field(body, :bytes, value.data)
         else
           raise ArgumentError, "Could auto detect only Integer and String"
         end
@@ -132,25 +175,29 @@ module Tarantool
       end
     end
 
-    def _modify_request(type, body, fields, ret_tuple, cb, translators)
-      cb = Response.new(cb, ret_tuple && (ret_tuple != :all ? :first : :all),
+    def _raise_integer_overflow(value, min, max)
+        raise IntegerFieldOverflow, "#{value} not in (#{min}..#{max})"
+    end
+
+    def _modify_request(type, body, fields, ret_tuple, cb, shard_nums, read_write, translators)
+      response = Response.new(cb, type, body, ret_tuple && (ret_tuple != :all ? :first : :all),
                             fields, translators)
-      _send_request(type, body, cb)
+      _send_request(shard_nums, read_write, response)
     end
 
-    def _insert(space_no, flags, tuple, fields, cb, ret_tuple, translators = [])
+    def _insert(space_no, flags, tuple, fields, cb, ret_tuple, shard_nums, in_any_shard = nil, 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)
+      _modify_request(REQUEST_INSERT, body, fields, ret_tuple, cb, shard_nums,
+                      in_any_shard ? :replace : :write, translators)
     end
 
-    def _update(space_no, pk, operations, fields, pk_fields, cb, ret_tuple, translators = [])
+    def _update(space_no, pk, operations, fields, pk_fields, cb, ret_tuple, shard_nums, translators = [])
       flags = ret_tuple ? BOX_RETURN_TUPLE : 0
 
       if Array === operations && !(Array === operations.first)
@@ -159,11 +206,11 @@ module Tarantool
 
       body = [space_no, flags].pack(UPDATE_HEADER)
       pack_tuple(body, pk, pk_fields, 0)
-      body << [operations.size].pack(INT32)
+      append_int32!(body, operations.size)
 
       _pack_operations(body, operations, fields)
 
-      _modify_request(REQUEST_UPDATE, body, fields, ret_tuple, cb, translators)
+      _modify_request(REQUEST_UPDATE, body, fields, ret_tuple, cb, shard_nums, :write, translators)
     end
 
     def _pack_operations(body, operations, fields)
@@ -222,7 +269,7 @@ module Tarantool
           unless operation.size == 3 && !operation[2].nil?
             raise ArgumentError, "wrong arguments for integer operation #{operation.inspect}"
           end
-          pack_field(body, :int, operation[2])
+          pack_field(body, :sint, operation[2])
         when 5
           unless operation.size == 5 && !operation[2].nil? && !operation[3].nil?
             raise ArgumentError, "wrong arguments for slice operation #{operation.inspect}"
@@ -230,9 +277,9 @@ module Tarantool
 
           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)
+          append_ber_sint32!(body, operation[2].to_i)
+          append_ber_sint32!(body, operation[3].to_i)
+          body << [str.bytesize, str.to_s].pack(PACK_STRING)
         when 7
           old_field_no = field_no + 
             (inserted ||= []).count{|i| i <= field_no} -
@@ -256,13 +303,13 @@ module Tarantool
       end
     end
 
-    def _delete(space_no, pk, fields, pk_fields, cb, ret_tuple, translators = [])
+    def _delete(space_no, pk, fields, pk_fields, cb, ret_tuple, shard_nums, 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)
+      _modify_request(REQUEST_DELETE, body, fields, ret_tuple, cb, shard_nums, :write, translators)
     end
 
     def _space_call_fix_values(values, space_no, opts)
@@ -271,11 +318,24 @@ module Tarantool
       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
+          opts[:types] = [:string].concat([*opts[:types]]) # cause lua could convert it to integer by itself
         else
           opts[:types] = TYPES_STR_STR
         end
       end
+
+      # scheck for shards hints
+      opts[:shards] ||= _get_shard_nums do
+          if opts[:shard_for_insert]
+            opts[:shard_keys] ? _detect_shards_for_insert(opts[:shard_keys]) :
+            opts[:shard_key]  ? _detect_shard_for_insert( opts[:shard_key]) :
+                                 _all_shards
+          else
+            opts[:shard_keys] ? _detect_shards(opts[:shard_keys]) :
+            opts[:shard_key]  ? _detect_shard( opts[:shard_key]) :
+                                 _all_shards
+          end
+        end
       [values, opts]
     end
 
@@ -292,22 +352,45 @@ module Tarantool
       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] || [])
+      shard_nums = opts[:shards] || all_shards
+      read_write = case opts[:readonly]
+                   when nil, false, :write
+                     :write
+                   when true, :read
+                     :read
+                   when :replace
+                     :replace
+                   else
+                     raise ArgumentError, "space#call :readonly options accepts nil, false, :write, true, :read and :replace, but #{opts[:readonly].inspect} were sent"
+                   end
+
+      _modify_request(REQUEST_CALL, body, return_types, return_tuple, cb, shard_nums, read_write, opts[:translators] || [])
     end
 
+    class WrapPing < Struct.new(:cb)
+      def call(data)
+        cb.call data
+      end
+      def call_callback(data)
+        cb.call data
+      end
+      def parse_response(data)
+        data
+      end
+    end
     def _ping(cb)
-      _send_request(REQUEST_PING, EMPTY, cb)
+      _send_request(all_shards, :write, REQUEST_PING, EMPTY, WrapPing.new(cb))
     end
     alias ping_cb _ping
 
     def _detect_types(values)
-      values.map{|v| Integer === v ? :int : :str}
+      values.map{|v| Integer === v ? :varint : :string}
     end
 
     def _detect_type(value)
-      Integer === v ? :int :
+      Integer === v ? :varint :
       Util::AutoType === v ? :auto :
-      :str
+      :string
     end
 
     def _parse_hash_definition(returns)
@@ -353,6 +436,10 @@ module Tarantool
       replace_cb(tuple, block, opts)
     end
 
+    def store_blk(tuple, opts={}, &block)
+      store_cb(tuple, block, opts)
+    end
+
     def update_blk(pk, operations, opts={}, &block)
       update_cb(pk, operations, block, opts)
     end