tarantool16 0.0.1

data/lib/tarantool16/connection/response.rb

@@ -0,0 +1,47 @@
+require 'tarantool16/errors'
+require 'tarantool16/response'
+
+module Tarantool16
+  module Connection
+    class Option
+      attr :sync, :error, :data
+      def initialize(sync, err, data)
+        @sync = sync
+        @error = err
+        @data = data
+      end
+
+      def ok?
+        !@error
+      end
+
+      def raise_if_error!
+        raise @error if @error
+      end
+
+      def self.ok(sync, code, data)
+        if code == 0
+          new(sync, nil, data)
+        else
+          new(sync, ::Tarantool16::DBError.with_code_message(code, data), nil)
+        end
+      end
+
+      def self.error(sync, err, message = nil)
+        if err.is_a? Class
+          err = err.new message
+        end
+        new(sync, err, nil)
+      end
+
+      def inspect
+        s = @sync ? " sync=#{sync}" : ""
+        if ok?
+          "<Option#{s} data=#{@data.inspect}>"
+        else
+          "<Option#{s} error=#{@error.inspect}>"
+        end
+      end
+    end
+  end
+end

data/lib/tarantool16/consts.rb

@@ -0,0 +1,94 @@
+module Tarantool16
+  IPROTO_CODE = 0x00
+  IPROTO_SYNC = 0x01
+  IPROTO_SPACE_ID = 0x10
+  IPROTO_INDEX_ID = 0x11
+  IPROTO_LIMIT = 0x12
+  IPROTO_OFFSET = 0x13
+  IPROTO_ITERATOR = 0x14
+  IPROTO_KEY = 0x20
+  IPROTO_TUPLE = 0x21
+  IPROTO_FUNCTION_NAME = 0x22
+  IPROTO_USER_NAME = 0x23
+  IPROTO_DATA = 0x30
+  IPROTO_ERROR = 0x31
+
+  IPROTO_GREETING_SIZE = 128
+
+  REQUEST_TYPE_OK = 0
+  REQUEST_TYPE_PING = 64
+  REQUEST_TYPE_SELECT = 1
+  REQUEST_TYPE_INSERT = 2
+  REQUEST_TYPE_REPLACE = 3
+  REQUEST_TYPE_UPDATE = 4
+  REQUEST_TYPE_DELETE = 5
+  REQUEST_TYPE_CALL = 6
+  REQUEST_TYPE_AUTHENTICATE = 7
+  REQUEST_TYPE_ERROR = 1 << 15
+
+
+  SPACE_SCHEMA  = 272
+  SPACE_SPACE   = 280
+  SPACE_INDEX   = 288
+  SPACE_FUNC    = 296
+  SPACE_USER    = 304
+  SPACE_PRIV    = 312
+  SPACE_CLUSTER = 320
+
+  INDEX_SPACE_PRIMARY = 0
+  INDEX_SPACE_NAME    = 2
+  INDEX_INDEX_PRIMARY = 0
+  INDEX_INDEX_NAME    = 2
+
+  ITERATOR_EQ  = 0
+  ITERATOR_REQ = 1
+  ITERATOR_ALL = 2
+  ITERATOR_LT  = 3
+  ITERATOR_LE  = 4
+  ITERATOR_GE  = 5
+  ITERATOR_GT  = 6
+  ITERATOR_BITS_ALL_SET     = 7
+  ITERATOR_BITS_ANY_SET     = 8
+  ITERATOR_BITS_ALL_NOT_SET = 9
+  ITERATOR_RTREE_OVERLAPS = 10
+  ITERATOR_RTREE_NEIGHBOR = 11
+
+  Iterators = {}
+  [
+    [ITERATOR_EQ, %w[eq ==]],
+    [ITERATOR_REQ, %w[req rev ==<]],
+    [ITERATOR_ALL, %w[all *]],
+    [ITERATOR_LT, %w[<  lt]],
+    [ITERATOR_LE, %w[<= le]],
+    [ITERATOR_GE, %w[>= ge]],
+    [ITERATOR_GT, %w[>  gt]],
+    [ITERATOR_BITS_ALL_SET, %w[ball &=]],
+    [ITERATOR_BITS_ANY_SET, %w[bany &]],
+    [ITERATOR_BITS_ALL_NOT_SET, %w[bnotany !&]],
+    [ITERATOR_RTREE_OVERLAPS, %w[roverlaps here &&]],
+    [ITERATOR_RTREE_NEIGHBOR, %w[rneighbor near <->]],
+  ].each do |it, names|
+    names.each do |name|
+      Iterators[it] = it
+      Iterators[name] = it
+      Iterators[name.to_sym] = it
+    end
+  end
+  Iterators[nil] = ITERATOR_EQ
+  def self.iter(iter)
+    unless it = Iterators[iter]
+      raise "Unknown iterator #{iter.inspect}"
+    end
+    it
+  end
+
+  # Default value for socket timeout (seconds)
+  SOCKET_TIMEOUT = nil
+  # Default maximum number of attempts to reconnect
+  RECONNECT_MAX_ATTEMPTS = 10
+  # Default delay between attempts to reconnect (seconds)
+  RECONNECT_DELAY = 0.1
+  # Number of reattempts in case of server
+  # return completion_status == 1 (try again)
+  RETRY_MAX_ATTEMPTS = 10
+end

data/lib/tarantool16/db.rb

@@ -0,0 +1,198 @@
+require_relative 'schema'
+module Tarantool16
+  class DB
+    attr :conn
+
+    def initialize(host, opts = {})
+      @host = host
+      @opts = opts.dup
+      @future = nil
+      @spaces = nil
+      @defined_fields = {}
+      _fill_standard_spaces
+      @conn = self.class::Connection.new(@host, @opts)
+    end
+
+    def define_fields(sid, fields)
+      sid = sid.to_s if sid.is_a?(Symbol)
+      @defined_fields[sid] = fields
+      if @spaces && (sp = @spaces[sid])
+        if sp.sid && sp.name && !sp.name.empty?
+          rf1 = @defined_fields[sp.sid]
+          rf2 = @defined_fields[sp.name]
+          if rf1 && rf2 && rf1 != rf2
+            raise "Misconfigured defined fields for #{sp.name_sid}"
+          end
+        end
+        sp.fields = fields
+      end
+    end
+
+    def _fill_standard_spaces
+      rf = @defined_fields
+      rf[SPACE_INDEX] =
+        [%w{sid num}, %w{iid num}, %w{name str},
+         %w{type str}, %w{unique num}, %w{part_count num},
+         {name: 'parts', type: [:num, :str], tail: true}]
+    end
+
+    def _synchronized
+      raise "Override #_synchronized"
+    end
+
+    UNDEF = Object.new.freeze
+    def _with_space(name, cb)
+      future = @future || _space_future
+      future.then_blk do |r|
+        unless r.ok?
+          cb.call r
+        else
+          sps = r.data
+          sp = sps[name]
+          if sp.nil? && Symbol == name
+            sp = sps[name.to_s]
+            sps[name] = sp unless sp.nil?
+          end
+          if sp.nil?
+            cb.call Option.error(SchemaError, "space #{name} not found")
+          else
+            yield sp
+          end
+        end
+      end
+    end
+
+    def _space_future
+      _synchronized do
+        return @future if @future
+        future = @future = self.class::SchemaFuture.new
+        fill_indexes = nil
+        spaces = nil
+        fill_spaces = lambda do|r|
+          unless r.ok?
+            future.set r
+            _synchronized do
+              @future = nil
+            end
+          else
+            _synchronized do
+              _fill_spaces(r.data)
+              spaces = @spaces
+              _select(SPACE_INDEX, 0, [], 0, 2**30, :all, false, fill_indexes)
+            end
+          end
+        end
+        fill_indexes = lambda do |r|
+          unless r.ok?
+            future.set r
+            _synchronized do
+              @future = nil
+              @spaces = nil
+            end
+          else
+            _synchronized do
+              _fill_indices(spaces, r.data)
+              future.set Option.ok(spaces)
+            end
+          end
+        end
+        _select(SPACE_SPACE, 0, [], 0, 2**30, :all, false, fill_spaces)
+        return future
+      end
+    end
+
+    def _fill_spaces(rows)
+      @spaces = {}
+      rows.each do |row|
+        fields = @defined_fields[row[0]] || @defined_fields[row[2]] || row[6]
+        sp = SchemaSpace.new(row[0], row[2], fields)
+        @spaces[row[0]] = sp
+        @spaces[sp.name] = sp
+        @spaces[sp.name.to_sym] = sp
+      end
+    end
+
+    def _fill_indices(spaces, rows)
+      rows.
+        map{|row| [row[0], [row[2], row[1], row[3], 6.step(row.size-1, 2).map{|i| row[i]}]]}.
+        group_by{|sid, _| sid}.
+        each do |sid, inds|
+          sp = spaces[sid]
+          sp.indices = inds.map{|_sid, ind| ind}
+        end 
+    end
+
+    def _insert(sno, tuple, need_hash, cb)
+      if !need_hash && sno.is_a?(Integer) && tuple.is_a?(Array)
+        return conn._insert(sno, tuple, cb)
+      end
+      _with_space(sno, cb) do |sp|
+        _tuple = tuple.is_a?(Hash) ? sp.map_tuple(tuple) : tuple
+        _cb = need_hash ? sp.wrap_cb(cb) : cb
+        conn._insert(sp.sid, _tuple, _cb)
+      end
+    end
+
+    def _replace(sno, tuple, need_hash, cb)
+      if !need_hash && sno.is_a?(Integer) && tuple.is_a?(Array)
+        return conn._replace(sno, tuple, cb)
+      end
+      _with_space(sno, cb) do |sp|
+        _tuple = tuple.is_a?(Hash) ? sp.map_tuple(tuple) : tuple
+        _cb = need_hash ? sp.wrap_cb(cb) : cb
+        conn.insert(sp.sid, _tuple, _cb)
+      end
+    end
+
+    def _delete(sno, ino, key, need_hash, cb)
+      ino = 0 if ino.nil? && key.is_a?(Array)
+      if !need_hash && sno.is_a?(Integer) && ino.is_a?(Integer) && key.is_a?(Array)
+        return conn._delete(sno, ino, key, cb)
+      end
+      _with_space(sno, cb) do |sp|
+        sp.get_ino(ino, key, ITERATOR_EQ, cb) do |_ino, _key|
+          _cb = need_hash ? sp.wrap_cb(cb) : cb
+          conn._delete(sp.sid, _ino, _key, _cb)
+        end
+      end
+    end
+
+    def _select(sno, ino, key, offset, limit, iterator, need_hash, cb)
+      key = [] if key.nil?
+      ino = 0 if ino.nil? && key.is_a?(Array)
+      iterator = ::Tarantool16.iter(iterator) unless iterator.is_a?(Integer)
+      if sno.is_a?(Integer) && ino.is_a?(Integer) && (key.is_a?(Array) || key.nil?)
+        return conn._select(sno, ino, key, offset, limit, iterator, cb)
+      end
+      _with_space(sno, cb) do |sp|
+        sp.get_ino(ino, key, iterator, cb) do |_ino, _key|
+          _cb = need_hash ? sp.wrap_cb(cb) : cb
+          conn._select(sp.sid, _ino, _key, offset, limit, iterator, _cb)
+        end
+      end
+    end
+
+    def _update(sno, ino, key, ops, need_hash, cb)
+      ino = 0 if ino.nil? && key.is_a?(Array)
+      ops_good = ops.is_a?(Array) && ops.all?{|a| ops[1].is_a?(Integer)}
+      if sno.is_a?(Integer) && ino.is_a?(Integer) && key.is_a?(Array) && ops_good
+        return conn._update(sno, ino, key, ops, cb)
+      end
+      _with_space(sno, cb) do |sp|
+        sp.get_ino(ino, key, ITERATOR_EQ, cb) do |_ino, _key|
+          _ops = ops_good ? ops : sp.map_ops(ops)
+          _cb = need_hash ? sp.wrap_cb(cb) : cb
+          conn._update(sp.sid, _ino, _key, _ops, _cb)
+        end
+      end
+    end
+
+    def _call(name, args, cb)
+      conn._call(name, args, cb)
+    end
+
+    def _ping(cb)
+      conn._ping(cb)
+    end
+  end
+end

data/lib/tarantool16/dumb_db.rb

@@ -0,0 +1,118 @@
+require_relative 'db'
+require_relative 'connection/dumb'
+
+module Tarantool16
+  class DumbDB < DB
+    Connection = Tarantool16::Connection::Dumb
+
+    RETURN_OR_RAISE = lambda{|r|
+      raise r.error unless r.ok?
+      r.data
+    }
+    RETURN_ONE_OR_RAISE = lambda{|r|
+      raise r.error unless r.ok?
+      r.data[0]
+    }
+    HUGE_LIMIT = 2**30
+
+    def select(sno, key, opts={})
+      ino = opts[:index]
+      offset = opts[:offset] || 0
+      limit = opts[:limit] || 2**30
+      iterator = opts[:iterator]
+      need_hash = opts[:hash]
+      key = case key
+            when nil
+              []
+            when Array
+              key
+            when Hash
+              need_hash = true
+              key
+            else
+              [key]
+            end
+      _select(sno, ino, key, offset, limit, iterator, need_hash, RETURN_OR_RAISE)
+    end
+
+    def get(sno, key, opts={})
+      ino = opts[:index]
+      iterator = opts[:iterator]
+      need_hash = opts[:hash]
+      key = case key
+            when nil
+              []
+            when Array
+              key
+            when Hash
+              need_hash = true
+              key
+            else
+              [key]
+            end
+      _select(sno, ino, key, 0, 1, iterator, need_hash, RETURN_ONE_OR_RAISE)
+    end
+
+    def insert(sno, tuple, opts = {})
+      need_hash = opts[:hash] || tuple.is_a?(Hash)
+      _insert(sno, tuple, need_hash, RETURN_OR_RAISE)
+    end
+
+    def replace(sno, tuple, opts = {})
+      need_hash = opts[:hash] || tuple.is_a?(Hash)
+      _replace(sno, tuple, need_hash, RETURN_OR_RAISE)
+    end
+
+    def delete(sno, key, opts = {})
+      ino = opts[:index]
+      need_hash = opts[:hash] || tkey.is_a?(Hash)
+      _delete(sno, ino, key, need_hash, RETURN_OR_RAISE)
+    end
+
+    def update(sno, key, ops, opts = {})
+      ino = opts[:index]
+      need_hash = opts[:hash] || key.is_a?(Hash)
+      _update(sno, ino, key, ops, need_hash, RETURN_OR_RAISE)
+    end
+
+    def _synchronized
+      yield
+    end
+
+    class SchemaFuture
+      UNDEF = Object.new.freeze
+      def initialize
+        @r = UNDEF
+        @cb = nil
+      end
+      def then(cb)
+        unless @r.equal? UNDEF
+          return cb.call(@r)
+        end
+        if @cb
+          raise "Blocking future accepts only 1 callback"
+        end
+        @cb = cb
+      end
+
+      def then_blk
+        unless @r.equal? UNDEF
+          return yield @r
+        end
+        if @cb
+          raise "Blocking future accepts only 1 callback"
+        end
+        @cb = lambda{|r| yield r}
+      end
+
+      def set(r)
+        @r = r
+        if cb = @cb
+          @cb = nil
+          cb.call(r)
+        end
+      end
+    end
+
+  end
+end