tarantool 0.2.5 → 0.3.0.7

data/lib/tarantool/record.rb

@@ -1,99 +1,8 @@
 require 'active_model'
-require 'tarantool'
-class Tarantool
-  class Select
-    include Enumerable
-    attr_reader :record
-    def initialize(record)
-      @record = record
-    end
-
-    def space_no
-      record.space_no
-    end
-
-    def each(&blk)
-      to_records(record.space.select(*@tuples, index_no: @index_no, limit: @limit, offset: @offset).tuples).each do |r|
-        blk.call r
-      end
-    end
-
-    def call(proc_name, *args)
-      to_records record.space.call(proc_name, *args, return_tuple: true).tuples
-    end
-
-    def limit(limit)
-      @limit = limit
-      self
-    end
-
-    def offset(offset)
-      @offset = offset
-      self
-    end
-
-    # id: 1
-    # id: [1, 2, 3]
-    # [{ name: 'a', email: 'a'}, { name: 'b', email: 'b'}]
-    def where(params)
-      raise SelectError.new('Where condition already setted') if @index_no # todo?
-      keys, @tuples = case params
-      when Hash
-        ordered_keys = record.ordered_keys params.keys
-        # name: ['a', 'b'], email: ['c', 'd'] => [['a', 'c'], ['b', 'd']]
-        if params.values.first.is_a?(Array)          
-          [ordered_keys, params[ordered_keys.first].zip(*ordered_keys[1, ordered_keys.size].map { |k| params[k] })]
-        else
-          [ordered_keys, [record.hash_to_tuple(params)]]
-        end
-      when Array
-        [params.first.keys, params.map { |v| record.hash_to_tuple(v) }]
-      end
-      @index_no = detect_index_no keys
-      raise ArgumentError.new("Undefined index for keys #{keys}") unless @index_no
-      self
-    end
-
-    # # works fine only on TREE index
-    # def batches(count = 1000, &blk)
-    #   raise ArgumentError.new("Only one tuple provided in batch selects") if @tuples.size > 1
-      
-    # end
-
-    # def _batch_exec
-    #   Tarantool.call proc_name: 'box.select_range', args: [space_no.to_s, @index_no.to_s, count.to_s] + @tuples.first.map(&:to_s), return_tuple: true
-    # end
-
-    def batches_each(&blk)
-      batches { |records| records.each(&blk) }
-    end
-
-    def all
-      to_a
-    end
-
-    def first
-      limit(1).all.first
-    end
+require 'tarantool/base_record'
 
-    def detect_index_no(keys)
-      record.indexes.each.with_index do |v, i|
-        keys_inst = keys.dup
-        v.each do |index_part|
-          break unless keys_inst.delete(index_part)
-          return i if keys_inst.empty?
-        end
-      end
-      nil
-    end
-
-    def to_records(tuples)
-      tuples.map do |tuple|
-        record.from_server(tuple)
-      end
-    end
-  end
-  class Record
+module Tarantool
+  class Record < BaseRecord
     extend ActiveModel::Naming
     include ActiveModel::AttributeMethods
     include ActiveModel::Validations
@@ -107,195 +16,114 @@ class Tarantool
     define_model_callbacks :save, :create, :update, :destroy
     define_model_callbacks :initialize, :only => :after
 
-    class_attribute :fields
-    self.fields = {}
-
-    class_attribute :default_values    
-    self.default_values = {}
-
-    class_attribute :primary_index    
-    class_attribute :indexes
-    self.indexes = []
-
-    class_attribute :space_no
-    class_attribute :tarantool
     class << self
       def set_space_no(val)
         self.space_no = val
       end
 
       def set_tarantool(val)
-        self.tarantool = val
-      end
-
-      def field(name, type, params = {})
-        define_attribute_method name
-        self.fields = fields.merge name => { type: type, field_no: fields.size, params: params }
-        unless self.primary_index
-          self.primary_index = name
-          index name
-        end
-        if params[:default]
-          self.default_values = default_values.merge name => params[:default]
-        end
-        define_method name do
-          attributes[name]
-        end
-        define_method "#{name}=" do |v|
-          send("#{name}_will_change!") unless v == attributes[name]
-          attributes[name] = v
-        end
-      end
-
-      def index(*fields)
-        options = {}
-        options = fields.pop if Hash === fields.last
-        if options[:primary]
-          self.indexes[0] = fields
-          self.primary_index = fields
+        case val.class.name
+        when 'Tarantool::BlockDB', 'Tarantool::FiberDB'
+          self.tarantool = val
         else
-          self.indexes = (indexes.dup << fields)
+          raise "Tarantool should be blocking of fibered!!! (i.e. of class Tarantool::BlockDB or Tarantool::FiberDB) (got #{val.class})"
         end
       end
 
-      def find(*keys)
-        res = space.select(*keys)
-        if keys.size == 1
-          if res.tuple
-            from_server res.tuple
-          else
-            nil
+      def define_field_accessor(name, type)
+        generated_attribute_methods.class_eval <<-"EOF", __FILE__, __LINE__ - 1
+          def #{name}
+            @attributes[:"#{name}"]
           end
+        EOF
+
+        if Symbol === type
+          convert_code = case type
+             when :int, :integer
+               "v = v.to_i  if String === v"
+             when :str, :string, :bytes
+               ""
+             else
+               if serializer = Serializers::MAP[type]
+                 "v = Serializers::MAP[#{type.inspect}].decode(v)  if String === v"
+               else
+                 raise ArgumentError, "unknown field type #{type.inspect}"
+               end
+             end
+
+          generated_attribute_methods.class_eval <<-"EOF", __FILE__, __LINE__ - 1
+            def #{name}=(v)
+              #{convert_code}
+              #{name}_will_change!  unless v == @attributes[:"#{name}"] || new_record?
+              @attributes[:"#{name}"] = v
+            end
+          EOF
         else
-          res.tuples.map { |tuple| from_server tuple }
-        end
-      end
-
-      def select
-        Select.new(self)
-      end
-
-      %w{where limit offset call first}.each do |v|
-        define_method v do |*args|
-          select.send(v, *args)
-        end
-      end
-
-      def create(attribites = {})
-        new(attribites).tap { |o| o.save }
-      end
-
-      def from_server(tuple)
-        new(tuple_to_hash(tuple).merge __new_record: false)
-      end
-
-      def space
-        @space ||= tarantool.space(space_no)
-      end
-
-      def tuple_to_hash(tuple)
-        fields.keys.zip(tuple).inject({}) do |memo, (k, v)|
-          memo[k] = _cast(k, v) unless v.nil?
-          memo
-        end
-      end
-
-      def hash_to_tuple(hash, with_nils = false)
-        res = []
-        fields.keys.each do |k|
-          v = hash[k]
-          res << _cast(k, v) if with_nils || !v.nil?
-        end
-        res
-      end
-
-      def ordered_keys(keys)
-        fields.keys.inject([]) do |memo, k|
-          keys.each do |k2|
-            memo << k2 if k2 == k
+          generated_attribute_methods.class_eval do
+            define_method("#{name}=") do |v|
+              v = type.decode(v)  if String === v
+              send(:"#{name}_will_change!") unless v == @attributes[name]
+              @attributes[name] = v
+            end
           end
-          memo
         end
-      end
-
-      def _cast(name, value)
-        type = self.fields[name][:type]
-        serializer = _get_serializer(type)
-        if value.is_a?(Field)
-          return nil if value.data == "\0"
-          serializer.decode(value)
-        else
-          return "\0" if value.nil?
-          serializer.encode(value)
-        end
-      end
-
-      def _get_serializer(type)
-        Serializers::MAP[type] || raise(TarantoolError.new("Undefind serializer #{type}"))
+        define_attribute_method name
       end
     end
 
-    attr_accessor :__new_record
     def initialize(attributes = {})
+      @__new_record = true
+      @attributes = self.class.default_values.dup
       run_callbacks(:initialize) do
         init attributes
       end
     end
 
     def init(attributes)
-      @__new_record = attributes.delete(:__new_record)
-      @__new_record = true if @__new_record.nil?
-      attributes.each do |k, v|
-        send("#{k}=", v)
-      end      
+      set_attributes(attributes)
     end
 
-    def id
-      primary = self.class.primary_index
-      case primary
-      when Array
-        primary.map{ |p| attributes[p] }
-      else
-        attributes[primary]
+    def __fetched(attributes)
+      @__new_record = false
+      # well, initalize callback could call #attributes
+      @attributes = self.class.default_values.dup
+      run_callbacks(:initialize) do
+        @attributes = attributes
       end
+      self
     end
 
-    def space
-      self.class.space
-    end
-
-    def new_record?
-      @__new_record
-    end
-
-    def attributes
-      @attributes ||= self.class.default_values.dup
-    end
-
-    def new_record!
-      @__new_record = true
-    end
-
-    def old_record!
-      @__new_record = false
+    def _in_callbacks(&blk)
+      run_callbacks(:save) {
+        run_callbacks(new_record? ? :create : :update, &blk)
+      }
     end
 
-    def save
-      def in_callbacks(&blk)
-        run_callbacks(:save) { run_callbacks(new_record? ? :create : :update, &blk)}
-      end
-      in_callbacks do
+    def save(and_reload = true)
+      _in_callbacks do
         if valid?
+          changes = changes()
           if new_record?
-            space.insert(*to_tuple)
+            if and_reload
+              @attributes = space.insert(@attributes, return_tuple: true)
+            else
+              space.insert(@attributes)
+            end
           else
-            return true if changed.size == 0
-            ops = changed.inject([]) do |memo, k|
-              k = k.to_sym
-              memo << [field_no(k), :set, self.class._cast(k, attributes[k])] if attributes[k]
-              memo
+            return true if changes.size == 0
+            ops = []
+            changes.each do |k, (old, new)|
+              ops << [k.to_sym, :set, new]
+            end
+            if and_reload
+              unless new_attrs = space.update(id, ops, return_tuple: true)
+                _raise_doesnt_exists
+              end
+            else
+              if space.update(id, ops) == 0
+                _raise_doesnt_exists
+              end
             end
-            space.update id, ops: ops
           end
           @previously_changed = changes
           @changed_attributes.clear
@@ -307,47 +135,30 @@ class Tarantool
       end
     end
 
-    def update_attribute(field, value)
-      self.send("#{field}=", value)
-      save
-    end
-
-    def update_attributes(attributes)
-      attributes.each do |k, v|
-        self.send("#{k}=", v)
+    # update record in db first, reload updated fileds then
+    # (Contrasting with LightRecord, where it reloads all fields)
+    # Consider that update operation does not count changes made by
+    # attr setters in your code, only field values in DB.
+    #
+    #   record.update({:state => 'sleep', :sleep_count => [:+, 1]})
+    #   record.update([[:state, 'sleep'], [:sleep_count, :+, 1]])
+    def update(ops)
+      raise UpdateNewRecord, "Could not call update on new record"  if @__new_record
+      unless new_attrs = space.update(id, ops, return_tuple: true)
+        _raise_doesnt_exists
       end
-      save
-    end
-
-    def increment(field, by = 1)
-      space.update id, ops: [[field_no(field), :add, by]]
+      for op in ops
+        field = op.flatten.first
+        @attributes[field] = new_attrs[field]
+      end
+      self
     end
 
     def destroy
       run_callbacks :destroy do
-        space.delete id
+        self.class.delete id
         true
       end
     end
-
-    def to_tuple
-      self.class.hash_to_tuple attributes, true
-    end
-
-    def field_no(name)
-      self.class.fields[name][:field_no]
-    end
-
-    def reload
-      tuple = space.select(id).tuple
-      return false unless tuple
-      init self.class.tuple_to_hash(tuple).merge __new_record: false
-      self
-    end
-
-    def ==(other)
-      self.id == other.id
-    end
-
   end
 end