tarantool 0.2.5 → 0.3.0.7

data/lib/tarantool/callback_db.rb

@@ -0,0 +1,47 @@
+require 'tarantool/em_db'
+
+module Tarantool
+  class CallbackDB < EMDB
+    class SpaceArray < ::Tarantool::SpaceArray
+      alias by_pk        by_pk_blk
+      alias all_by_key   all_by_key_blk
+      alias first_by_key first_by_key_blk
+      alias all_by_keys  all_by_keys_blk
+      alias select       select_blk
+      alias insert       insert_blk
+      alias replace      replace_blk
+      alias update       update_blk
+      alias delete       delete_blk
+      alias invoke       invoke_blk
+      alias call         call_blk
+      alias ping         ping_blk
+    end
+
+    class SpaceHash < ::Tarantool::SpaceHash
+      alias by_pk   by_pk_blk
+      alias all     all_blk
+      alias first   first_blk
+      alias select  select_blk
+      alias insert  insert_blk
+      alias replace replace_blk
+      alias update  update_blk
+      alias delete  delete_blk
+      alias invoke  invoke_blk
+      alias call    call_blk
+      alias ping    ping_blk
+    end
+
+    class Query < ::Tarantool::Query
+      alias select  select_blk
+      alias all     all_blk
+      alias first   first_blk
+      alias insert  insert_blk
+      alias replace replace_blk
+      alias update  update_blk
+      alias delete  delete_blk
+      alias invoke  invoke_blk
+      alias call    call_blk
+      alias ping    ping_blk
+    end
+  end
+end

data/lib/tarantool/core-ext.rb

@@ -0,0 +1,12 @@
+require 'fiber'
+
+class Fiber
+  alias call resume
+end
+
+module Kernel
+  def fiber_yield
+    Fiber.yield
+  end
+  alias fyield fiber_yield
+end

data/lib/tarantool/em_db.rb

@@ -0,0 +1,37 @@
+module Tarantool
+  class EMDB < DB
+    def establish_connection
+      @connection_waiters = []
+      EM.schedule do
+        unless @closed
+          @connection = IProto.get_connection(@host, @port, :em_callback)
+          while waiter = @connection_waiters.shift
+            _send_request(*waiter)
+          end
+        end
+      end
+    end
+
+    def close_connection
+      EM.schedule do
+        if @connection
+          @connection.close
+          @connection = nil
+        end
+        unless @connection_waiters.empty?
+          while waiter = @connection_waiters.shift
+            waiter.last.call(::IProto::Disconnected)
+          end
+        end
+      end
+    end
+
+    def _send_request(request_type, body, cb)
+      if @connection
+        @connection.send_request(request_type, body, cb)
+      else
+        @connection_waiters << [request_type, body, cb]
+      end
+    end
+  end
+end

data/lib/tarantool/exceptions.rb

@@ -1,9 +1,54 @@
-class Tarantool
+module Tarantool
+  class ArgumentError < ::ArgumentError; end
+  class StringTooLong < ArgumentError; end
+
   class TarantoolError < StandardError; end
-  class UndefinedRequestType < TarantoolError; end
-  class BadReturnCode < TarantoolError; end
-  class StringTooLong < TarantoolError; end
-  class ArgumentError < TarantoolError; end
-  class UndefinedSpace < TarantoolError; end
   class ValueError < TarantoolError; end
-end
+  class StatusCode < TarantoolError
+    attr_reader :code
+    def initialize(code, msg)
+      super(msg)
+      @code = code
+    end
+    def to_s
+      "#{super} [#{code}]"
+    end
+  end
+  # try again return codes
+  class TryAgain < StatusCode; end
+  class TupleReadOnly < TryAgain; end
+  class TupleIsLocked < TryAgain; end
+  class MemoryIssue   < TryAgain; end
+  # general error return codes
+  class BadReturnCode < StatusCode; end
+  class NonMaster     < BadReturnCode; end
+  class IllegalParams < BadReturnCode; end
+  class UnsupportedCommand < BadReturnCode; end
+  class WrongField    < BadReturnCode; end
+  class WrongNumber   < BadReturnCode; end
+  class Duplicate     < BadReturnCode; end # it is rather useful
+  class WrongVersion  < BadReturnCode; end
+  class WalIO         < BadReturnCode; end
+  class LuaError      < BadReturnCode; end
+  class StoredProcedureNotDefined < BadReturnCode; end
+  class TupleExists   < BadReturnCode; end
+  class TupleDoesntExists < BadReturnCode; end
+  CODE_TO_EXCEPTION = {
+    0x0401 => TupleReadOnly,
+    0x0601 => TupleIsLocked,
+    0x0701 => MemoryIssue,
+    0x0102 => NonMaster,
+    0x0202 => IllegalParams,
+    0x0a02 => UnsupportedCommand,
+    0x1e02 => WrongField,
+    0x1f02 => WrongNumber,
+    0x2002 => Duplicate,
+    0x2602 => WrongVersion,
+    0x2702 => WalIO,
+    0x3102 => TupleDoesntExists,
+    0x3202 => StoredProcedureNotDefined,
+    0x3302 => LuaError,
+    0x3702 => TupleExists,
+  }
+  CODE_TO_EXCEPTION.default = BadReturnCode
+end

data/lib/tarantool/fiber_db.rb

@@ -0,0 +1,152 @@
+require 'iproto/core-ext'
+require 'tarantool/em_db'
+
+module Tarantool
+  class FiberDB < EMDB
+    module CommonSpaceFiberMethods
+      def all_by_pks(pks, opts={})
+        all_by_pks_cb(pks, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def by_pk(pk)
+        by_pk_cb(pk, ::Fiber.current)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def insert(tuple, opts={})
+        insert_cb(tuple, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def replace(tuple, opts={})
+        replace_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
+      end
+
+      def delete(pk, opts={})
+        delete_cb(pk, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def invoke(func_name, values = [], opts = {})
+        invoke_cb(func_name, values, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def call(func_name, values = [], opts = {})
+        call_cb(func_name, values, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def ping
+        ping_cb(::Fiber.current)
+        _raise_or_return ::Fiber.yield
+      end
+    end
+
+    class SpaceArray < ::Tarantool::SpaceArray
+      include CommonSpaceFiberMethods
+      def all_by_key(index_no, key, opts={})
+        all_by_key_cb(index_no, key, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def first_by_key(index_no, key)
+        first_by_key_cb(index_no, key, ::Fiber.current)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def all_by_keys(index_no, key, opts={})
+        all_by_keys_cb(index_no, key, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def select(index_no, keys, offset=0, limit=-1)
+        select_cb(index_no, keys, offset, limit, ::Fiber.current)
+        _raise_or_return ::Fiber.yield
+      end
+    end
+
+    class SpaceHash < ::Tarantool::SpaceHash
+      include CommonSpaceFiberMethods
+
+      def by_pk(key_array)
+        by_pk_cb(key_array, ::Fiber.current)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def all(keys, opts = {})
+        all_cb(keys, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def first(key)
+        first_cb(key, ::Fiber.current)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def select(keys, offset=0, limit=-1)
+        select_cb(keys, offset, limit, ::Fiber.current)
+        _raise_or_return ::Fiber.yield
+      end
+    end
+
+    class Query < ::Tarantool::Query
+      def select(space_no, index_no, keys, offset, limit, opts={})
+        select_cb(space_no, index_no, keys, offset, limit, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def all(space_no, index_no, keys, opts={})
+        all_cb(space_no, index_no, keys, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def first(space_no, index_no, key, opts={})
+        first_cb(space_no, index_no, key, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def insert(space_no, tuple, opts={})
+        insert_cb(space_no, tuple, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def replace(space_no, tuple, opts={})
+        replace_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
+      end
+
+      def delete(space_no, pk, opts={})
+        delete_cb(space_no, pk, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def invoke(func_name, values, opts={})
+        invoke_cb(func_name, values, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def call(func_name, values, opts={})
+        call_cb(func_name, values, ::Fiber.current, opts)
+        _raise_or_return ::Fiber.yield
+      end
+
+      def ping
+        ping_cb(::Fiber.current)
+        _raise_or_return ::Fiber.yield
+      end
+    end
+  end
+end

data/lib/tarantool/light_record.rb

@@ -0,0 +1,68 @@
+require 'tarantool/base_record'
+
+module Tarantool
+  class LightRecord < BaseRecord
+    def initialize(attributes = nil)
+      @__new_record = true
+      @attributes = self.class.default_values.dup
+      set_attributes(attributes)  if attributes
+      after_init
+    end
+
+    def __fetched(attributes)
+      @__new_record = false
+      @attributes = attributes
+      after_init
+      self
+    end
+
+    # callback which runs both after initialization and after
+    # fetching from database
+    def after_init
+    end
+
+    def save
+      if @__new_record
+        self.class.insert(@attributes)
+        @__new_record = false
+      else
+        self.class.replace(@attributes)
+      end
+      self
+    end
+
+    def destroy
+      self.class.delete id
+      true
+    end
+
+    class << self
+      def generated_attribute_methods
+        @generated_attribute_methods ||= begin
+            include (mod = Module.new)
+            mod
+          end
+      end
+
+      def define_field_accessor(name, type)
+        generated_attribute_methods.class_eval <<-"EOF", __FILE__, __LINE__ - 1
+          def #{name}
+            @attributes[:"#{name}"]
+          end
+
+          def #{name}=(v)
+            @attributes[:"#{name}"] = v
+          end
+        EOF
+      end
+
+      def create(attrs)
+        new(attrs).save
+      end
+
+      def from_fetched(attributes)
+        attributes && allocate.__fetched(attributes)
+      end
+    end
+  end
+end

data/lib/tarantool/query.rb

@@ -0,0 +1,127 @@
+require 'tarantool/request'
+require 'tarantool/response'
+
+module Tarantool
+  class Query
+    include Request
+    def initialize(tarantool)
+      @tarantool = tarantool
+    end
+
+    def _send_request(type, body, cb)
+      @tarantool._send_request(type, body, cb)
+    end
+
+    def select_cb(space_no, index_no, keys, offset, limit, cb, opts={})
+      keys = [*keys]
+      types = opts[:types] || _detect_types(keys)
+      returns = opts[:returns] || TYPES_AUTO
+      if Hash === returns
+        returns, *translators = _parse_hash_definition(returns)
+      end
+      _select(space_no, index_no, offset, limit, keys, cb, returns,
+              types, translators)
+    end
+
+    def all_cb(space_no, index_no, keys, cb, opts={})
+      select_cb(space_no, index_no, keys,
+                opts[:offset] || 0, opts[:limit] || -1,
+                cb, opts)
+    end
+
+    def first_cb(space_no, index_no, key, cb, opts={})
+      select_cb(space_no, index_no, [key], 0, :first, cb, opts)
+    end
+
+    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])
+    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])
+    end
+
+    def update_cb(space_no, pk, operations, cb, opts={})
+      pk = [*pk]
+      pk_types = opts[:pk_types] || _detect_types(pk)
+      returns = opts[:returns] || TYPES_AUTO
+      if Hash === returns && opts[:return_tuple]
+        returns, *translators = _parse_hash_definition(returns)
+      end
+      _update(space_no, pk, operations, returns, pk_types, cb,
+              opts[:return_tuple], translators)
+    end
+
+    def delete_cb(space_no, pk, cb, opts={})
+      pk = [*pk]
+      pk_types = opts[:pk_types] || _detect_types(pk)
+      returns = opts[:returns] || TYPES_AUTO
+      if Hash === returns && opts[:return_tuple]
+        returns, *translators = _parse_hash_definition(returns)
+      end
+      _delete(space_no, pk, returns, pk_types, cb,
+              opts[:return_tuple], translators)
+    end
+
+    def invoke_cb(func_name, values, cb, opts={})
+      opts = opts.dup
+      values = [*values]
+      opts[:types] ||= _detect_types(values)
+      _call(func_name, values, cb, opts)
+    end
+
+    def call_cb(func_name, values, cb, opts={})
+      opts = opts.dup
+      values = [*values]
+      opts[:return_tuple] = true  if opts[:return_tuple].nil?
+      opts[:types] ||= _detect_types(values)
+      opts[:returns] ||= TYPES_AUTO
+      if Hash === opts[:returns] && opts[:return_tuple]
+        opts[:returns], *opts[:translators] = _parse_hash_definition(opts[:returns])
+      end
+      _call(func_name, values, cb, opts)
+    end
+
+    def select_blk(space_no, index_no, keys, offset, limit, opts={}, &block)
+      select_cb(space_no, index_no, keys, offset, limit, block, opts)
+    end
+
+    def all_blk(space_no, index_no, keys, opts={}, &block)
+      all_cb(space_no, index_no, keys, block, opts)
+    end
+
+    def first_blk(space_no, index_no, key, opts={}, &block)
+      first_cb(space_no, index_no, key, block, opts)
+    end
+
+    def insert_blk(space_no, tuple, opts={}, &block)
+      insert_cb(space_no, tuple, block, opts)
+    end
+
+    def replace_blk(space_no, tuple, opts={}, &block)
+      replace_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
+
+    def delete_blk(space_no, pk, opts={}, &block)
+      delete_cb(space_no, 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

data/lib/tarantool/record/select.rb

@@ -0,0 +1,59 @@
+module Tarantool
+  class BaseRecord
+    class Select
+      include Enumerable
+
+      attr_reader :record, :params
+      def initialize(record, params={})
+        @record = record
+        @params = params
+      end
+
+      def space_no
+        @record.space_no
+      end
+
+      def results
+        @results ||= begin
+            raise "Condition is not set"  unless @params[:where]
+            @record.auto_space.select(
+              @params[:where],
+              @params[:offset] || 0,
+              @params[:limit] || -1
+            )
+          end
+      end
+
+      def each
+        return to_enum  unless block_given?
+        results.each{|a| yield a}
+      end
+
+      def call(*args)
+        @record.call(*args)
+      end
+
+      def limit(limit)
+        self.class.new(@record, @params.merge(limit: limit))
+      end
+
+      def offset(offset)
+        self.class.new(@record, @params.merge(offset: offset))
+      end
+
+      def where(params)
+        self.class.new(@record, @params.merge(where: params))
+      end
+
+      def all
+        results.dup
+      end
+
+      def first
+        @record.auto_space.
+          select(@params[:where], @params[:offset] || 0, 1).
+          first
+      end
+    end
+  end
+end