tarantool16 0.0.1

data/lib/tarantool16/errors.rb

@@ -0,0 +1,82 @@
+
+module Tarantool16
+  class Error < ::StandardError; end
+  class ConnectionError < Error; end
+  DBErrors = {}
+  class SchemaError < Error; end
+  class DBError < Error
+    class KnownDBError < DBError
+      class << self
+        attr_accessor :return_code
+      end
+      def return_code
+        self.class.return_code
+      end
+    end
+    class UnknownDBError < DBError
+      attr_accessor :return_code
+    end
+
+    {
+       1=> :ER_ILLEGAL_PARAMS,
+       2=> :ER_MEMORY_ISSUE,
+       3=> :ER_TUPLE_FOUND,
+       4=> :ER_TUPLE_NOT_FOUND,
+       5=> :ER_UNSUPPORTED,
+       6=> :ER_NONMASTER,
+       7=> :ER_SECONDARY,
+       8=> :ER_INJECTION,
+       9=> :ER_CREATE_SPACE,
+      10=> :ER_SPACE_EXISTS,
+      11=> :ER_DROP_SPACE,
+      12=> :ER_ALTER_SPACE,
+      13=> :ER_INDEX_TYPE,
+      14=> :ER_MODIFY_INDEX,
+      15=> :ER_LAST_DROP,
+      16=> :ER_TUPLE_FORMAT_LIMIT,
+      17=> :ER_DROP_PRIMARY_KEY,
+      18=> :ER_KEY_FIELD_TYPE,
+      19=> :ER_EXACT_MATCH,
+      20=> :ER_INVALID_MSGPACK,
+      21=> :ER_PROC_RET,
+      22=> :ER_TUPLE_NOT_ARRAY,
+      23=> :ER_FIELD_TYPE,
+      24=> :ER_FIELD_TYPE_MISMATCH,
+      25=> :ER_SPLICE,
+      26=> :ER_ARG_TYPE,
+      27=> :ER_TUPLE_IS_TOO_LONG,
+      28=> :ER_UNKNOWN_UPDATE_OP,
+      29=> :ER_UPDATE_FIELD,
+      30=> :ER_FIBER_STACK,
+      31=> :ER_KEY_PART_COUNT,
+      32=> :ER_PROC_LUA,
+      33=> :ER_NO_SUCH_PROC,
+      34=> :ER_NO_SUCH_TRIGGER,
+      35=> :ER_NO_SUCH_INDEX,
+      36=> :ER_NO_SUCH_SPACE,
+      37=> :ER_NO_SUCH_FIELD,
+      38=> :ER_SPACE_ARITY,
+      39=> :ER_INDEX_ARITY,
+      40=> :ER_WAL_IO,
+      41=> :ER_MORE_THAN_ONE_TUPLE,
+    }.each do |n, s|
+      klass = Class.new(KnownDBError)
+      klass.return_code = n
+      Tarantool16::DBErrors[n] = klass
+      Tarantool16.const_set(s, klass)
+    end
+    def self.with_code_message(n, m="")
+      if klass = DBErrors[n]
+        klass.new(m)
+      else
+        e = UnknownDBError.new(m)
+        e.return_code = n
+        e
+      end
+    end
+
+    def inspect
+      "<#{self.class.name} return_code=#{return_code} message=#{message}>"
+    end
+  end
+end

data/lib/tarantool16/query.rb

@@ -0,0 +1,8 @@
+relative_require 'consts'
+
+module Tarantool16
+  class Query
+    def initialize(db)
+    end
+  end
+end

data/lib/tarantool16/response.rb

@@ -0,0 +1,36 @@
+module Tarantool16
+  class Option
+    attr :error, :data
+    def initialize(err, data)
+      @error = err
+      @data = data
+    end
+
+    def ok?
+      !@error
+    end
+
+    def raise_if_error!
+      raise @error if @error
+    end
+
+    def self.ok(data)
+      new(nil, data)
+    end
+
+    def self.error(err, message = nil)
+      if err.is_a? Class
+        err = err.new message
+      end
+      new(err, nil)
+    end
+
+    def inspect
+      if ok?
+        "<Option data=#{@data.inspect}>"
+      else
+        "<Option error=#{@error.inspect}>"
+      end
+    end
+  end
+end

data/lib/tarantool16/schema.rb

@@ -0,0 +1,269 @@
+require_relative 'response'
+require_relative 'consts'
+module Tarantool16
+  class SchemaSpace
+    attr :sid, :name, :indices, :fields
+    def initialize(sid, name, fields)
+      @sid = sid
+      @name = name
+      @has_tail = false
+      self.fields = fields
+    end
+
+    # imitate Option
+    def ok?; true; end
+    def data; self; end
+
+    def fields=(flds)
+      @field_names = {}
+      @fields = []
+      @has_tail = false
+      flds.each_with_index do |fld, i|
+        if @has_tail
+          raise "no fields allowed after tail: #{flds}"
+        end
+        case fld
+        when String, Symbol
+          name = fld.to_s
+          type = nil
+        when Array
+          name, type = fld
+        when Hash
+          name = fld['name'] || fld[:name]
+          type = fld['type'] || fld[:type]
+          tail = fld['tail'] || fld[:tail]
+        end
+        name_s = name.to_sym
+        field = Field.new(name_s, i, type)
+        @field_names[name] = field
+        @field_names[name_s] = field
+        @field_names[i] = field
+        @fields << field
+        @has_tail = true if tail
+      end
+      if @index_defs
+        self.indices= @index_defs
+      end
+      flds
+    end
+
+    def indices=(inds)
+      @index_defs = inds
+      @index_names = {}
+      @indices = []
+      @_fields_2_ino = {}
+      inds.each do |name, nom, type, parts|
+        if @fields && @fields.size > parts.max
+          part_names = parts.map{|p| @fields[p].name}
+        else
+          part_names = []
+        end
+        index = Index.new(name, nom, type, parts, part_names)
+        @index_names[name] = index
+        @index_names[name.to_sym] = index
+        @index_names[nom] = index
+        @indices[nom] = index
+      end
+    end
+
+    def indices?
+      @indices && !@indices.empty?
+    end
+
+    def get_ino(ino, key, iter, cb)
+      if ino.nil?
+        unless key.is_a?(Hash)
+          opt = Option.error(SchemaError, "Could not detect index without field names and iterator: #{key.inspect} in #{name_sid}")
+          return cb.call(opt)
+        end
+        unless iter.is_a?(Integer)
+          iter = ::Tarantool16.iter(iter)
+        end
+        # key should be Hash here
+        keys = key.keys
+        _ino = @_fields_2_ino[keys]
+        if _ino
+          ind = @indices[_ino]
+          return yield(_ino, ind.map_key(key))
+        elsif _ino == false
+          opt = Option.error(SchemaError, "Could not detect index for fields #{key.keys} in #{name_sid}")
+          return cb.call(opt)
+        end
+
+        fields = keys.map{|fld|
+          case fld
+          when Integer
+            fld
+          when Symbol, String
+            @field_names[fld].pos
+          else
+            return cb.call(Option.error(SchemaError, "Unknown field #{fld.inspect} in query key #{key.inspect}"))
+          end
+        }
+
+        index = nil
+        for ind in @indices
+          next unless ind
+          first_fields = ind.parts[0,fields.size]
+          if ind.can_iterator?(iter)
+            if fields == first_fields
+              index = ind
+              break
+            elsif (fields - first_fields).empty?
+              index = ind
+            end
+          end
+        end
+        if index
+          @_fields_2_ino[keys.freeze] = index.pos
+          yield index.pos, index.map_key(key)
+        else
+          @_fields_2_ino[keys.freeze] = false
+          cb.call(Option.error(SchemaError, "Could not detect index for fields #{key.keys} in #{name_sid}"))
+        end
+      elsif index = @index_names[ino]
+        yield index.pos, index.map_key(key)
+      else
+        cb.call(Option.error(SchemaError, "Could not find index #{ino} for spacefor fields #{key.keys}"))
+      end
+    end
+
+    def tuple2hash(ar)
+      raise "No fields defined for #{name_sid}" unless @fields && !@fields.empty?
+      res = {}
+      i = 0
+      flds = @fields
+      s = flds.size - (@has_tail ? 1 : 0)
+      while i < s
+        res[flds[i].name] = ar[i]
+        i += 1
+      end
+      if @has_tail
+        tail = flds[s]
+        unless tail.type.is_a?(Array)
+          res[tail.name] = ar[s..-1]
+        else
+          res[tail.name] = ar[s..-1].each_slice(tail.type.size).to_a
+        end
+      end
+      res
+    end
+
+    def name_sid
+      @_np ||= "space #{@name}:#{@sid}"
+    end
+
+    def map_tuple(tuple)
+      row = []
+      unless @has_tail
+        tuple.each_key do |k|
+          field = @field_names[k]
+          row[field.pos] = tuple[k]
+        end
+      else
+        tail = @fields.last
+        tuple.each do |k|
+          field = @field_names[k]
+          val = tuple[k]
+          if field.equal? tail
+            unless tail.type.is_a?(Array)
+              row[field.pos,0] = val
+            else
+              row[field.pos,0] = val.flatten(1)
+            end
+          else
+            row[field.pos] = tuple[k]
+          end
+        end
+      end
+      row
+    end
+
+    def map_ops(ops)
+      ops.map do |op|
+        case _1 = op[1]
+        when Integer
+          op
+        when Symbol, String
+          _op = op.dup
+          _op[1] = @field_names[_1].pos
+          _op
+        when Array
+          _1.dup.insert(1, @field_names[op[0]].pos)
+        end
+      end
+    end
+
+    def wrap_cb(cb)
+      CallbackWrapper.new(self, cb)
+    end
+
+    class Field
+      attr :name, :pos, :type
+      def initialize(name, pos, type)
+        @name = name
+        @pos = pos
+        @type = type
+      end
+
+      def to_s
+        "<Fields #{@name}@#{pos}>"
+      end
+    end
+
+    class Index
+      attr :name, :pos, :parts, :type, :part_names, :part_positions
+      ITERS = {
+        tree:   (ITERATOR_EQ..ITERATOR_GT).freeze,
+        hash:   [ITERATOR_ALL, ITERATOR_EQ, ITERATOR_GT].freeze,
+        bitset: [ITERATOR_ALL, ITERATOR_EQ, ITERATOR_BITS_ALL_SET,
+                 ITERATOR_BITS_ANY_SET, ITERATOR_BITS_ALL_NOT_SET].freeze,
+        rtree:  [ITERATOR_ALL, ITERATOR_EQ, ITERATOR_GT, ITERATOR_GE, ITERATOR_LT, ITERATOR_LE,
+                 ITERATOR_RTREE_OVERLAPS, ITERATOR_RTREE_NEIGHBOR].freeze
+      }
+      def initialize(name, pos, type, parts, part_names)
+        @name = name
+        @pos = pos
+        @type = type.downcase.to_sym
+        @iters = ITERS[@type] or raise "Unknown index type #{type.inspect}"
+        @parts = parts
+        @part_names = part_names
+        @part_positions = {}
+        parts.each_with_index{|p, i| @part_positions[p] = i}
+        part_names.each_with_index{|p, i|
+          @part_positions[p.to_s] = i
+          @part_positions[p.to_sym] = i
+        }
+      end
+
+      def can_iterator?(iter)
+        @iters.include?(iter)
+      end
+
+      def map_key(key)
+        return key if key.is_a?(Array)
+        res = []
+        positions = @part_positions
+        key.each_key do |k|
+          res[positions[k]] = key[k]
+        end
+        res
+      end
+    end
+
+    class CallbackWrapper
+      def initialize(space, cb)
+        @space = space
+        @cb = cb
+      end
+
+      def call(r)
+        if r.ok?
+          sp = @space
+          r = Option.ok(r.data.map{|row| sp.tuple2hash(row)})
+        end
+        @cb.call r
+      end
+    end
+  end
+end

data/lib/tarantool16/version.rb

@@ -0,0 +1,3 @@
+module Tarantool16
+  VERSION = "0.0.1"
+end

data/lib/tarantool16.rb

@@ -0,0 +1,17 @@
+require "tarantool16/version"
+require "tarantool16/db"
+
+module Tarantool16
+  autoload :DumbDB, 'tarantool16/dumb_db'
+  def self.new(opts = {})
+    opts = opts.dup
+    hosts = opts[:host]
+    type = opts[:type] && opts[:type].to_s || 'dumb'
+    case type
+    when 'dumb'
+      DumbDB.new hosts, opts
+    else
+      raise "Unknown DB type"
+    end
+  end
+end

data/tarantool16.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tarantool16/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tarantool16"
+  spec.version       = Tarantool16::VERSION
+  spec.authors       = ["Sokolov Yura aka funny_falcon"]
+  spec.email         = ["funny.falcon@gmail.com"]
+  spec.summary       = %q{adapter for Tarantool 1.6}
+  spec.description   = %q{adapter for Tarantool 1.6}
+  spec.homepage      = "https://github.com/funny-falcon/tarantool16-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_dependency "msgpack"
+end