spiderfw 0.5.19 → 0.6.0

data/lib/spiderfw/model/mappers/db_mapper.rb

@@ -16,6 +16,10 @@ module Spider; module Model; module Mappers
             true
         end
         
+        def pk
+            [Fixnum, {:autoincrement => true}]
+        end
+        
         # Checks if the schema has some key to reach element. 
         def have_references?(element) #:nodoc:
             element = @model.elements[element] unless element.is_a?(Element)
@@ -65,6 +69,11 @@ module Spider; module Model; module Mappers
             storage.execute(sql, *values)
         end
         
+        def truncate!
+            sql = storage.sql_truncate(schema.table)
+            storage.execute(sql)
+        end
+        
         # def delete_all!
         #     storage.execute("DELETE FROM #{schema.table}")
         # end
@@ -93,7 +102,6 @@ module Spider; module Model; module Mappers
                         # next if (element.model? && (!(element_val = obj.get(element)) || !))
                         next if (element.integrated?)
                         element_val = nil if element.model? && element_val.is_a?(BaseModel) && !element_val.primary_keys_set?
-                        
                         if (element.model?)
                             element.model.primary_keys.each do |key|
                                 # FIXME! only works with one primary key
@@ -231,17 +239,18 @@ module Spider; module Model; module Mappers
             result.each do |row|
                 set << map(nil, row, @model)
             end
+            set.modified = false
             return set
         end
         
         # Implements the Mapper#map method.
         # Converts a DB result row to an object.
-        def map(request, result, obj)
-            if (!request)
+        def map(request, result, obj_or_model)
+            if (!request || request == true)
                 request = Request.new
                 @model.elements_array.each{ |el| request.request(el.name) }
             end
-            model = obj.is_a?(Class) ? obj : obj.model
+            model = obj_or_model.is_a?(Class) ? obj_or_model : obj_or_model.model
             data = {}
             request.keys.each do |element_name|
                 element = @model.elements[element_name]
@@ -317,6 +326,10 @@ module Spider; module Model; module Mappers
                 end
             end
             order, order_joins = prepare_order(query)
+            cnt = 0
+            order_joins.each do |oj|
+                oj[:as] ||= "ORD#{cnt+=1}" if joins.select{ |j| j[:to] == oj[:to] }.length > 0
+            end
             joins += order_joins if order_joins
             seen_fields = {}
             model_pks = []
@@ -792,6 +805,7 @@ module Spider; module Model; module Mappers
         # Returns a type accepted by the storage for type.
         def map_type(type)
             st = type
+            return Fixnum if st <= Spider::DataTypes::PK
             while (st && !storage.class.base_types.include?(st))
                 st = Model.simplify_type(st)
             end
@@ -802,66 +816,26 @@ module Spider; module Model; module Mappers
         # Converts a value in one accepted by the storage.
         def map_value(type, value, mode=nil)
             return value if value.nil?
-             if (type < Spider::DataType && value)
-                 value = type.from_value(value) unless value.is_a?(type)
-                 value = value.map(self.type)
-             elsif type.class == Class && type.subclass_of?(Spider::Model::BaseModel)
-                 value = type.primary_keys.map{ |key| value.send(key.name) }
-             else
-                 case type.name
-                 when 'Spider::DataTypes::Bool'
-                     value = value ? 1 : 0
-                 end
-             end
-             return value
-        end
-        
-        # Prepares a value going to be bound to an insert or update statement
-         def map_save_value(type, value, save_mode)
-             value = map_value(type, value, :save)
-             return @storage.value_for_save(Model.simplify_type(type), value, save_mode)
-         end
-
-        # Prepares a value for a condition.
-        def map_condition_value(type, value)
-            if value.is_a?(Range)
-                return Range.new(map_condition_value(type, value.first), map_condition_value(type, value.last))
+            
+            case type.name
+            when 'Spider::DataTypes::Bool'
+                value = value ? 1 : 0
+            else
+                value = super
             end
-            return value if ( type.class == Class && type.subclass_of?(Spider::Model::BaseModel) )
-            value = map_value(type, value, :condition)
-            return @storage.value_for_condition(Model.simplify_type(type), value)
-        end
-
-        def storage_value_to_mapper(type, value)
-            storage.value_to_mapper(type, value)
+            
+            return value
         end
-
-        # Converts a storage value back to the corresponding base type or DataType.
+        
         def map_back_value(type, value)
-            value = value[0] if value.class == Array
-            value = storage_value_to_mapper(Model.simplify_type(type), value)
-            if (type < Spider::DataType && type.maps_back_to)
-                type = type.maps_back_to
-            end
             case type.name
-            when 'Fixnum'
-                return value ? value.to_i : nil
-            when 'Float'
-                return value ? value.to_f : nil
             when 'Spider::DataTypes::Bool'
                 return value if value.nil?
                 return value == 1 ? true : false
             end
-            return nil unless value
-            case type.name
-            when 'Date', 'DateTime'
-                return type.parse(value) unless value.is_a?(Date)
-            end
-            if (type < Spider::DataType)
-                value = type.from_value(value)
-            end
-            return value
-        end        
+            return super
+        end
+      
         
         ##############################################################
         #   Primary keys                                             #
@@ -878,9 +852,10 @@ module Spider; module Model; module Mappers
         ##############################################################
         
         # UnitOfWork dependencies.
-        def get_dependencies(obj, action)
+        def get_dependencies(task)
             deps = []
-            task = MapperTask.new(obj, action)
+            obj = task.object
+            action = task.action
             deps = []
             case action
             when :keys
@@ -888,27 +863,50 @@ module Spider; module Model; module Mappers
             when :save
                 @model.primary_keys.each do |key|
                     if key.integrated? && !obj.element_has_value?(key)
-                        deps << [task, MapperTask.new(obj.get(key.integrated_from), :save)]
-                    end
-                end
-                elements = @model.elements.select{ |n, el| el.model? && obj.element_has_value?(el) && obj.element_modified?(el)}
-                # n <-> n and n|1 <-> 1
-                elements.select{ |n, el| !el.has_single_reverse? }.each do |name, element|
-                    set = obj.send(element.name)
-                    set = [set] unless set.is_a?(Enumerable)
-                    set.each do |set_obj|
-                        # set_obj.set(el.reverse, obj) if el.reverse
-                        deps << [task, MapperTask.new(set_obj, :keys)]                        
+                        obj.get(key.integrated_from) # ensure super object is instantiated, so it gets processed later
                     end
                 end
-                elements.select{ |n, el| el.has_single_reverse? }.each do |name, element|
-                    if (element.model? && element.type.mapper && element.type.mapper.class.write?)
-                        set = obj.send(element.name)
-                        set = [set] unless set.is_a?(Enumerable)
-                        set.each do |set_obj|
-                            # set_obj.set(el.reverse, obj) if el.reverse
-                            sub_task = MapperTask.new(set_obj, :save)
-                            deps << [sub_task, MapperTask.new(obj, :keys)]
+                
+                elements = @model.elements.select{ |n, el| !el.integrated? && el.model? && obj.element_has_value?(el) && obj.element_modified?(el)}
+                
+                elements.each do |name, element|
+                    if have_references?(element)
+                        el_obj = obj.send(element.name)
+                        sub_task = MapperTask.new(el_obj, :keys)
+                        deps << [task, sub_task]
+                    else
+                        if element.type.mapper && element.type.mapper.class.write?
+                            el_val = obj.send(element.name)
+                            if element.multiple?
+                                set = el_val
+                                if element.junction? && !element.attributes[:keep_junction]
+                                    set = obj.send("#{element.name}_junction")
+                                end
+                                delete_ass = nil
+                                if set.modified # queryset modified
+                                    delete_ass = MapperTask.new(obj, :delete_associations, :element => element.name)
+                                    deps << [task, delete_ass]
+                                end
+                                prev_task = nil
+                                set.each do |set_obj|
+                                    sub_task = MapperTask.new(set_obj, :save)
+                                    set_obj.set_modified(element.reverse) if element.reverse
+                                    if set_obj.class.attributes[:junction] && delete_ass
+                                        set_obj.class.primary_keys.each{ |pk| set_obj.set(pk, nil) }
+                                    end
+                                    if prev_task
+                                        deps << [sub_task, prev_task]
+                                    elsif delete_ass
+                                        deps << [sub_task, delete_ass]
+                                    else
+                                        deps << [sub_task, task]
+                                    end
+                                    prev_task = sub_task
+                                end
+                            else
+                                el_val.set_modified(element.reverse)
+                                deps << [task, MapperTask.new(el_val, :save)]
+                            end
                         end
                     end
                 end
@@ -916,6 +914,12 @@ module Spider; module Model; module Mappers
             return deps
         end
         
+        def execute_action(action, object, params={})
+            return super unless action == :delete_associations
+            el = object.class.elements[params[:element]]
+            delete_element_associations(object, el)
+        end
+        
         
         ##############################################################
         #   Schema management                                        #
@@ -962,6 +966,14 @@ module Spider; module Model; module Mappers
         def storage_column_type(type, attributes)
             @storage.column_type(type, attributes)
         end
+        
+        def base_type(type)
+            if type <= Spider::DataTypes::PK
+                Fixnum
+            else
+                super
+            end
+        end
 
         # Autogenerates schema. Returns a DbSchema.
         def generate_schema(schema=nil)
@@ -983,7 +995,7 @@ module Spider; module Model; module Mappers
                 next if element.attributes[:added_reverse] && element.has_single_reverse?
                 if (!element.model?)
                     column = schema.columns[element.name]
-                    storage_type = Spider::Model.base_type(element.type)
+                    storage_type = base_type(element.type)
                     db_attributes = column.attributes if column
                     if (!db_attributes || db_attributes.empty?)
                         db_attributes = @storage.column_attributes(storage_type, element.attributes)
@@ -1005,6 +1017,7 @@ module Spider; module Model; module Mappers
                     if (!element.multiple? && !element.attributes[:junction] && !element.attributes[:condition]) # 1/n <-> 1
                         current_schema = schema.foreign_keys[element.name] || {}
                         foreign_key_constraints = {}
+                        el_mapper = element.type.mapper
                         element.type.primary_keys.each do |key|
                             if key.model? # fixme: only works with single primary key model (after the first)
                                 curr_key = key
@@ -1023,7 +1036,8 @@ module Spider; module Model; module Mappers
                                 :precision => key_attributes[:precision]
                             }
                             column = current_schema[key.name]
-                            column_type = element.attributes[:db_column_type] || @storage.column_type(key_type, key_attributes)
+                            key_storage_type = el_mapper.base_type(key_type)
+                            column_type = element.attributes[:db_column_type] || storage_column_type(key_storage_type, key_attributes)
                             unless column
                                 column_name = element.attributes[:db_column_name] || @storage.column_name("#{element.name}_#{key.name}")
                                 column_attributes = @storage.column_attributes(key_type, key_attributes)
@@ -1181,11 +1195,12 @@ module Spider; module Model; module Mappers
                         # Spider.logger.debug(fields[field])
                         unless @storage.safe_schema_conversion?(current_fields[field], fields[field]) || force
                             unsafe << field 
+                            next
                         end
                         alter_fields << field_hash
                     end
                 end
-                raise SchemaSyncUnsafeConversion.new(unsafe) unless unsafe.empty?
+                
             end
             alter_attributes = {}
             if (current[:primary_keys] != attributes[:primary_keys])
@@ -1203,6 +1218,7 @@ module Spider; module Model; module Mappers
                 :attributes => alter_attributes,
                 :current => current
             })
+            raise SchemaSyncUnsafeConversion.new(unsafe) unless unsafe.empty?
         end
         
         ##############################################################

data/lib/spiderfw/model/mappers/document_mapper.rb

@@ -0,0 +1,315 @@
+require 'spiderfw/model/mappers/mapper'
+require 'fileutils'
+
+
+module Spider; module Model; module Mappers
+
+    class DocumentMapper < Spider::Model::Mapper
+        include Spider::Model::Storage::Document
+                
+        def embedding(obj)
+            embedder_el = obj.embedder
+            return nil unless embedder_el
+            first_embedder = obj.get(embedder_el)
+            while first_embedder._subclass_object
+                first_embedder = first_embedder._subclass_object
+            end
+            reverse_el = embedder_el.type.elements[embedder_el.reverse]
+            path = "#{reverse_el.name}.#{obj.get(reverse_el.attributes[:embed_key])}"
+            parent_obj = obj.get(embedder_el)
+            # while parent_obj._subclass_object
+            #     parent_obj = parent_obj._subclass_object
+            # end
+            parent_embedding = parent_obj.mapper.embedding(parent_obj)
+            if parent_embedding
+                first_embedder = parent_embedding[0]            
+                path = "#{parent_embedding[0]}.#{path}"
+            end
+            [first_embedder, path]
+        end
+
+        def do_update(obj)
+            search_obj = obj
+            emb = embedding(obj)
+            path = nil
+            search_obj, path = emb if emb
+            condition = {}
+            # search_obj.class.primary_keys.each do |pk|
+            #     name = pk.name == :id ? '_id' : pk.name
+            #     condition[name] = map_condition_value(pk.type, search_obj.get(pk))
+            # end
+            condition["_id"] = obj.keys_string
+            set = {}
+            document_elements(obj).select{ |el| obj.element_modified?(el) }.each do |el|
+                name = el.name
+                name = "#{path}.#{name}" if path
+                if el.model?
+                    if el.attributes[:embedded]
+                        set[name] = obj_to_hash(obj.get(el), :embed_key => el.attributes[:embed_key])
+                    else
+                        set[name] = obj.get(el).keys_string
+                    end
+                else
+                    set[name] = map_save_value(el.type, obj.get(el), :update)
+                end
+            end
+            storage.update(search_obj.class.name, condition, set)
+        end
+
+        def do_insert(obj)
+            storage.insert(obj.class.name, obj_to_hash(obj)) 
+        end
+        
+        def assign_pk(obj)
+            if obj.is_a?(QuerySet)
+                obj.each{ |o| assign_pk(o) }
+                return
+            end
+            obj.class.elements_array.select{ |el| el.type <= Spider::DataTypes::PK }.each do |el|
+                obj.set(el, storage.generate_pk) unless obj.element_has_value?(el)
+            end
+        end
+
+        def do_delete(condition, force)
+            query = Spider::Model::Query.new(condition)
+            objs = self.find(query)
+            return unless objs
+            objs.each do |obj|
+                storage.delete(obj.class.name, obj_to_hash(obj)) 
+            end
+        end
+        
+        def before_save(obj, mode)
+            super
+            obj.class.elements_array.select{ |el| 
+                el.attributes[:embedded] && !el.attributes[:extended_model] && obj.element_has_value?(el)
+            }.each do |el|
+                if el.multiple?
+                    obj.get(el).each do |o|
+                        o.mapper.before_save(o, mode)
+                    end
+                else
+                    o = obj.get(el)
+                    next unless o
+                    o.mapper.before_save(o, mode)
+                end
+            end
+        end
+        
+        def document_elements(obj)
+            obj.class.elements_array.select{ |el| document_element?(el, obj.class) }
+        end
+        
+        def document_element?(el, model=@model)
+            return true if el.attributes[:document_element]
+            return false if el.multiple? && !el.attributes[:embedded]
+            return false if el.attributes[:extended_model]
+            return false if el.attributes[:added_reverse]
+            return false if el.attributes[:computed_from]
+            return false if el.integrated? && !el.integrated_from.attributes[:extended_model]
+            return true
+
+        end
+        
+        def embed?(element, val=nil)
+            return false unless element.attributes[:embedded] && element.model.embeddable?
+            return false if element.integrated?
+            model = nil
+            if val
+                model = val.is_a?(QuerySet) ? val.model : val.class
+            else
+                model = element.model
+            end
+            return false unless model.embeddable?
+            
+            return true
+        end
+
+
+        def obj_to_hash(obj, options={})
+            h = {}
+            if obj.class == QuerySet
+                res = obj.map{ |obj| obj_to_hash(obj) } 
+                if options[:embed_key]
+                    h = {}
+                    res.each do |val|
+                        h[val[options[:embed_key].to_s]] = val
+                    end
+                    return h
+                end
+                return res
+            end
+            
+            document_elements(obj).each do |el|
+                next if el.primary_key?
+                name = el.name
+                next if options[:skip] && options[:skip].include?(el.name)
+                val = obj.get(el)
+                sub_options = {}
+                hval = if el.model? && val
+                    if embed?(el, val)
+                        if el.multiple?
+                            # if el.junction?
+                            #     sub_options[:skip] = [el.reverse]
+                            # end
+                            if el.attributes[:embed_key]
+                                el_h = {}
+                                val.each do |row|
+                                    el_h[row.get(el.attributes[:embed_key])] = row.mapper.obj_to_hash(row, sub_options)
+                                end
+                                el_h
+                            else
+                                h_mapper = val[0] && val[0].mapper.respond_to?(:obj_to_hash) ? val[0].mapper : self
+                                val.map{ |row| h_mapper.obj_to_hash(row, sub_options) }
+                            end
+                        else
+                            sub_mapper = val.mapper.respond_to?(:obj_to_hash) ? val.mapper : self
+                            sub_mapper.obj_to_hash(val, sub_options)
+                        end
+                    else
+                        val.keys_string
+                    end
+                else
+                    map_save_value(el.type, val)
+                end
+                h[name] = hval
+            end
+            
+            assign_pk(obj)
+            h["_id"] = obj.keys_string
+            
+            h
+        end
+
+        def have_references?(element)
+            element = @model.elements[element] unless element.is_a?(Element)
+            document_element?(element)
+        end
+        
+        def someone_have_references?(element)
+            element = @model.elements[element] unless element.is_a?(Element)
+            if (element.integrated?)
+                return element.model.someone_have_references?(element.attributes[:integrated_from_element])
+            end
+            return have_references?(element)
+        end
+        
+        
+        def map(request, result, obj_or_model)
+            # FIXME: ignores request for now
+            model = obj_or_model.is_a?(Class) ? obj_or_model : obj_or_model.model
+            if (!request || request == true)
+                request = Request.new
+                model.elements_array.each{ |el| request.request(el.name) }
+            end
+            subclass_type_el = model.elements_array.select{ |cel| cel.attributes[:subclass_type] }.first
+            if subclass_type_el && subclass_type = result[subclass_type_el.name]
+                model = const_get_full(subclass_type)
+            end
+            embedded = {}
+            embedded_keys = model.elements_array.select{ |el| embed?(el) && !el.attributes[:extended_model] }.map{ |el| el.name }
+            # debugger
+            # embed?(:civilia_open_persona) if $DO_DEBUG
+            embedded_keys.each do |k|
+                embedded[k] = result.delete(k)
+            end
+            data = {}
+            request.keys.each do |element_name|
+                element = model.elements[element_name]
+                result_value = nil
+                next if !element || (element.integrated? && !element.integrated_from.embedded?) || !have_references?(element)
+                next if embedded[element_name]
+                if element.model?
+                    pks = {}
+                    keys_str = result[element_name]
+                    next if keys_str.blank?
+                    pks_array = element.model.split_keys_string(keys_str)
+                    element.model.primary_keys.each_with_index do |key, i|
+                        key_val = pks_array[i]
+                        pks[key.name] = map_back_value(key.type, key_val)
+                    end
+#                    begin
+                    data[element_name] = Spider::Model.get(element.model, pks, true)
+#                    rescue IdentityMapperException
+                        # null keys, nothing to set
+#                    end
+                elsif !element.model?
+                    data[element_name] = map_back_value(element.type, result[element_name])
+                end
+            end
+            obj = Spider::Model.get(model, data, true)
+            embedded.each do |k, v|
+                if !v
+                    obj.set_loaded_value(k, nil) if request[k]
+                    next
+                end
+                next if v.is_a?(Array) && v.empty?
+                el = obj.class.elements[k]
+                if el.multiple?
+                    vals = []
+                    if el.attributes[:embed_key]
+                        vals = v.values
+                    else
+                        vals = v
+                    end
+                    qs = QuerySet.static(el.model)
+                    el_model = el.model
+                    el_mapper = el.model.mapper
+                    if el.junction? && !el.attributes[:keep_junction]
+                        el_model = el.type
+                        el_mapper = el.model.mapper
+                    end
+                    vals.each do |val|
+                        # FIXME: pass sub request
+                        sub_obj = el_mapper.map(true, val, el_model)#Spider::Model.get(el_model, val, true)
+                        qs << sub_obj
+                    end
+                    obj.set_loaded_value(k, qs)
+                else
+                    # FIXME: pass sub request request[el.name]
+                    sub_obj = el.model.mapper.map(true, v, el.model)
+                    obj.set_loaded_value(k, sub_obj)
+                end
+                
+            end
+            obj
+        end
+        
+        
+        def save_extended_models(obj, mode)
+            return
+        end
+        
+        def children_for_unit_of_work(obj, action)
+            obj.class.elements_array.select{ |el| 
+                el.model? && obj.element_has_value?(el) && !el.attributes[:embedded]  && !el.attributes[:added_reverse]
+            }.map do |el|
+                obj.get(el)
+            end
+        end
+        
+        def get_external_element(element, query, objects)
+            return objects if element.attributes[:embedded] || element.attributes[:extended_model]
+            super
+        end
+
+        def determine_save_mode(obj)
+            if @model.extended_models && !@model.extended_models.empty?
+                has_pks = true
+                @model.primary_keys.each do |pk|
+                    if pk.integrated? && pk.integrated_from.attributes[:extended_model]
+                        return super unless pk.integrated_from.attributes[:embedded]
+                        unless obj.element_has_value?(pk)
+                            has_pks = false
+                            break
+                        end
+                    end
+                end
+                return has_pks ? :update : :insert
+            end
+        end
+
+
+    end
+
+end; end; end