spiderfw 0.6.21 → 0.6.22

data/lib/spiderfw/controller/home_controller.rb

@@ -30,9 +30,9 @@ module Spider
             @app_routes ||= []
         end
         
-        def self.print_app_routes
-            max_length = app_routes.inject(0){ |m, r| m > r[0].length ? m : r[0].length }
-            app_routes.map{ |r| "#{r[0].ljust(max_length+3)} -> #{r[1]}"}.sort.join("\n")
+        def self.print_app_routes(routes=app_routes)
+            max_length = routes.inject(0){ |m, r| m > r[0].length ? m : r[0].length }
+            routes.map{ |r| "#{r[0].ljust(max_length+3)} -> #{r[1]}"}.sort.join("\n")
         end
 
     end

data/lib/spiderfw/controller/http_controller.rb

@@ -99,6 +99,16 @@ module Spider
                 @request.format = $2.to_sym
             end
 #            Spider.reload_sources if Spider.conf.get('webserver.reload_sources')
+            static_level = Spider.conf.get('log.static_extensions')
+            if @request.format && @request.get? && static_level != true
+                allowed = Spider.conf.get('log.non_static_extensions_list')
+                unless allowed.include?(@request.format.to_s)
+                    Spider.logger.info("GET #{@request.path}")
+                    @logger_static_prev = Spider.logger.set_thread_level(static_level)
+                end
+            end
+            Spider::Logger.debug("REQUEST:")
+            Spider::Logger.debug(@request.env)
             Spider.logger.info("Request: #{@request.http_method} #{@request.http_host} #{@request.path}")
             super(action, *arguments)
         end
@@ -116,6 +126,7 @@ module Spider
             action = $1 if (action =~ /(.+)\.(\w+)$/) # strip extension, set format
             @request.session.persist if @request.session && @request.session.respond_to?(:persist)
             super(action, *arguments)
+            @Spider.logger.set_thread_level(@logger_static_prev) if @logger_static_prev
         end
         
         def ensure(action='', *arguments)

data/lib/spiderfw/controller/mixins/static_content.rb

@@ -10,8 +10,8 @@ module Spider; module ControllerMixins
         
         def self.included(klass)
             super
-            klass.route('public/', :serve_static, :do => lambda{ @serving_static = true })
-            klass.route('w/', :serve_widget_static, :do => lambda{ @serving_static = true })
+            @static_content_route ||= 'public/'
+            klass.route(@static_content_route, :serve_static, :do => lambda{ @serving_static = true })
             if (klass < Visual)
                 klass.no_layout('public')
                 klass.no_layout('serve_static')
@@ -61,14 +61,6 @@ module Spider; module ControllerMixins
             output_static(full_path)
         end
         
-        def serve_widget_static(path)
-            path = sanitize_path(path)
-            parts = path.split('/public/', 2)
-            raise Spider::Controller::NotFound.new(path) unless parts[1]
-            full_path = self.class.app.widgets_path+'/'+parts[0]+'/public/'+parts[1]
-            output_static(full_path)
-        end
-        
         def output_static(full_path, file_name=nil)
             file_name ||= File.basename(full_path)
             @request.misc[:is_static] = true
@@ -89,11 +81,10 @@ module Spider; module ControllerMixins
                 begin
                   if_modified = Time.httpdate(@request.env['HTTP_IF_MODIFIED_SINCE'])
                 rescue ArgumentError # Passenger with IE6 has this header wrong
-                  if_modified = 0
                 end
                 max_age = nil
                 fresh = true
-                if fresh && mtime <= if_modified
+                if fresh && if_modified && mtime <= if_modified
                     debug("Not modified since #{if_modified}: #{full_path}")
                     #@response.status = Spider::HTTP::NOT_MODIFIED
                     @response.headers.delete("Content-Type")

data/lib/spiderfw/controller/mixins/visual.rb

@@ -43,6 +43,16 @@ module Spider; module ControllerMixins
             if Spider.runmode != 'devel' && File.exists?(File.join(Spider.paths[:tmp], 'maintenance.txt'))
                 raise Spider::Controller::Maintenance
             end
+            n_route = dispatch_next(action)
+            obj = n_route.obj if n_route
+            if obj.is_a?(Visual) && !(obj.respond_to?(:serving_static?) && obj.serving_static?(n_route.path))
+                set_layout = @layout || @dispatcher_layout
+                if set_layout
+                    set_layout = [set_layout] unless set_layout.is_a?(Array)
+                    set_layout.map{ |l| self.class.load_layout(l) }
+                    obj.dispatcher_layout = set_layout
+                end
+            end
             super
         end
         
@@ -210,13 +220,12 @@ module Spider; module ControllerMixins
             end
             init_widgets(template, layout)
             return template if done?
-            Spider::GetText.in_domain(self.class.app.short_name){
-                if layout
-                    layout.render(scene)
-                else
-                    template.render(scene)
-                end
-            }
+        
+            if layout
+                layout.render(scene)
+            else
+                template.render(scene)
+            end
             return template
         end
         
@@ -236,21 +245,12 @@ module Spider; module ControllerMixins
         
         
         
-        def dispatched_object(route)
-            obj = super
-            if (obj.is_a?(Visual))
-                set_layout = @layout || @dispatcher_layout
-                if set_layout
-                    set_layout = [set_layout] unless set_layout.is_a?(Array)
-                    set_layout.map{ |l| self.class.load_layout(l) }
-                    obj.dispatcher_layout = set_layout
-                end
-            end
-            return obj
-        end
         
         def try_rescue(exc)
-            exc.uuid = UUIDTools::UUID.random_create.to_s if exc.respond_to?(:uuid=)
+            if exc.respond_to?(:uuid=)
+                return super if exc.uuid # Error page already outputted
+                exc.uuid = UUIDTools::UUID.random_create.to_s 
+            end
             format = self.class.output_format(:error) || :html
             unless exc.is_a?(Spider::Controller::Maintenance) || exc.is_a?(Spider::Controller::NotFound)
                 return super unless @executed_format == :html
@@ -555,6 +555,7 @@ module Spider; module ControllerMixins
                     path = Spider::Layout.named_layouts[path]
                 end
                 resource = Spider::Template.find_resource(path+'.layout', layout_path, self)
+                raise "Layout #{path} not found" unless resource && resource.path
                 layout = Spider::Layout.new(resource.path)
                 layout.definer_class = resource.definer
                 layout.asset_set = params[:assets] if params[:assets]

data/lib/spiderfw/controller/request.rb

@@ -21,10 +21,8 @@ module Spider
         
         
         def initialize(env)
-            Spider::Logger.debug("REQUEST:")
-            Spider::Logger.debug(env)
             @env = env
-            @locale = Locale.current[0]
+            @locale = Spider.locale
             @misc = {}
             @params = {}
             @action = ""

data/lib/spiderfw/http/adapters/mongrel.rb

@@ -24,7 +24,7 @@ module Spider; module HTTP
         
         
         def shutdown_server
-            @server.stop
+            @server.stop if @server
         end
         
         

data/lib/spiderfw/i18n/gettext.rb

@@ -12,6 +12,7 @@ module Spider
     
     module GetText
         
+        # Executes a block of code in the given text_domain
         def self.in_domain(domain, &block)
             prev_text_domain = FastGettext.text_domain
             FastGettext.text_domain = domain if FastGettext.translation_repositories.key?(domain)
@@ -19,6 +20,19 @@ module Spider
             FastGettext.text_domain = prev_text_domain
             v
         end
+
+        # Sets the current text_domain; return the previous domain
+        def self.set_domain(domain)
+            prev_text_domain = FastGettext.text_domain
+            FastGettext.text_domain = domain if FastGettext.translation_repositories.key?(domain)
+            prev_text_domain
+        end
+
+        # Sets the current text_domain; assumes the domain was already set before, so skips any
+        # check for domain validity
+        def self.restore_domain(domain)
+            FastGettext.text_domain = domain
+        end
         
     end
     

data/lib/spiderfw/i18n/shtml_parser.rb

@@ -21,13 +21,13 @@ module Spider; module I18n
                     str =~ Spider::TemplateBlocks::GettextRegexp
                     found = false
                     ary.each do |msg|
-                        if (msg[0] == $1)
+                        if (msg[0] == $2)
                             msg << "#{file}:#{cnt}"
                             found = true
                             break
                         end
                     end
-                    ary << [$1, "#{file}:#{cnt}"] unless found
+                    ary << [$2, "#{file}:#{cnt}"] unless found
                 end
             end
             f.close

data/lib/spiderfw/model/base_model.rb

@@ -1174,8 +1174,8 @@ module Spider; module Model
                 qs.autoload = true
                 qs.where(&proc)
             else
-                condition = Condition.and(params[0])
-                request = Request.new(params[1])
+                condition = params[0].is_a?(Condition) ? params[0] : Condition.and(params[0])
+                request = params[1].is_a?(Request) ? params[1] : Request.new(params[1])
                 query = Query.new(condition, request)
                 qs = QuerySet.new(self, query)
             end
@@ -1852,6 +1852,7 @@ module Spider; module Model
                 @_modified_elements[key] = true
                 el = self.class.elements[key.to_sym]
                 next unless el
+                next if el.attributes[:unmapped]
                 if el.integrated? && sub = self.get(el.integrated_from)
                     sub.set_modified(el.integrated_from_element)
                 end
@@ -1872,7 +1873,7 @@ module Spider; module Model
                 val.modified = false if val.is_a?(QuerySet)
             end
             self.class.elements_array.select{ |el| el.attributes[:integrated_model] && self.element_has_value?(el) }.each do |el|
-                self.get(el).reset_modified_elements(elements)
+                self.get(el).reset_modified_elements(*elements)
             end
 
             nil

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

@@ -90,43 +90,46 @@ module Spider; module Model; module Mappers
                 @model.each_element do |element|
                     next if !mapped?(element) || element.integrated?
                     next if save_mode == :update && !obj.element_modified?(element)
-                    if (save_mode == :insert)
+                    if save_mode == :insert
                         if element.attributes[:autoincrement] && !schema.attributes(element.name)[:autoincrement]
                             obj.set(element.name, @storage.sequence_next(schema.sequence(element.name)))
                         end
                     end
-                    if (!element.multiple?)
-                        next if (save_mode == :update && element.primary_key?)
-                        next if (element.model? && !schema.has_foreign_fields?(element.name))
-                        element_val = obj.get(element)
-                        # 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
-                                if (key.model?)
-                                    key_type = key.model.primary_keys[0].type
-                                    key_value = element_val ? element_val.get(key.name).get(key.model.primary_keys[0]) : nil
-                                else
-                                    key_type = key.model? ? key.model.primary_keys[0].type : key.type
-                                    key_value = element_val ? element_val.get(key.name) : nil
-                                end
-                                store_key = schema.foreign_key_field(element.name, key.name)
-                                next if store_key.is_a?(FieldExpression)
-                                values[store_key] = map_save_value(key_type, key_value, save_mode)
-                            end
-                        else
-                            store_key = schema.field(element.name)
-                            values[store_key] = map_save_value(element.type, element_val, save_mode)
-                        end
-                    end
+                    next if element.multiple?
+                    next if save_mode == :update && element.primary_key?
+                    next if element.model? && !schema.has_foreign_fields?(element.name)
+
+                    element_val = obj.get(element)
+                    prepare_save_value(element, element_val, save_mode, values)
                 end
             end
             return {
                 :values => values
             }
         end
+
+        def prepare_save_value(element, element_val, save_mode, values={})
+            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
+                    if (key.model?)
+                        key_type = key.model.primary_keys[0].type
+                        key_value = element_val ? element_val.get(key.name).get(key.model.primary_keys[0]) : nil
+                    else
+                        key_type = key.model? ? key.model.primary_keys[0].type : key.type
+                        key_value = element_val ? element_val.get(key.name) : nil
+                    end
+                    store_key = schema.foreign_key_field(element.name, key.name)
+                    next if store_key.is_a?(FieldExpression)
+                    values[store_key] = map_save_value(key_type, key_value, save_mode)
+                end
+            else
+                store_key = schema.field(element.name)
+                values[store_key] = map_save_value(element.type, element_val, save_mode)
+            end
+            values
+        end
         
         # Insert preprocessing
         def prepare_insert(obj) #:nodoc:
@@ -152,27 +155,29 @@ module Spider; module Model; module Mappers
         end
         
         # Updates according to a condition, storing the values, which must passed as a Hash.
+        # Condition may be nil.
         def bulk_update(values, condition)
             db_values = {}
             joins = []
             integrated = {}
-            condition = preprocess_condition(condition)
+            condition = preprocess_condition(condition) if condition
             values.each do |key, val|
                 element = @model.elements[key]
-                if (element.integrated?)
+                if element.integrated?
                     integrated[element.integrated_from] ||= {}
                     integrated[element.integrated_from][key] = val
                     next
                 end
                 next if !mapped?(element)
-                next if element.model? && val != nil
-                store_key = schema.field(element.name)
-                next unless store_key
-                if (val.is_a?(Spider::QueryFuncs::Expression))
+                next if element.multiple?
+                next if element.model? && !schema.has_foreign_fields?(element.name)
+                if val.is_a?(Spider::QueryFuncs::Expression)
                     joins += prepare_expression(val)
+                    store_key = schema.field(element.name)
+                    next unless store_key
                     db_values[store_key] = val
                 else
-                    db_values[store_key] = map_save_value(element.type, val, :update)
+                    prepare_save_value(element, val, :update, db_values)
                 end
             end
             integrated.each do |i_el, i_values|
@@ -181,11 +186,13 @@ module Spider; module Model; module Mappers
             end
             return if db_values.empty?
             save = {:table => schema.table, :values => db_values}
-            condition, c_joins = prepare_condition(condition)
-            joins += c_joins
-            save[:condition] = condition
+            if condition
+                condition, c_joins = prepare_condition(condition)
+                joins += c_joins
+                save[:condition] = condition
+            end
             save[:joins] = prepare_joins(joins)
-            sql, bind_vars = @storage.sql_update(save)
+            sql, bind_vars = @storage.sql_update(save, true)
             return @storage.execute(sql, *bind_vars)
         end
         
@@ -252,7 +259,11 @@ module Spider; module Model; module Mappers
             end
             model = obj_or_model.is_a?(Class) ? obj_or_model : obj_or_model.model
             data = {}
+            extra_data = {}
             request.keys.each do |element_name|
+                if element_name.is_a?(QueryFuncs::SelectFunction)
+                    extra_data[element_name.as] = result[element_name.as.to_s]
+                end
                 element = @model.elements[element_name]
                 result_value = nil
                 next if !element || element.integrated? || !have_references?(element)
@@ -282,6 +293,9 @@ module Spider; module Model; module Mappers
                 return nil
             end
             data.keys.each{ |el| obj.element_loaded(el) }
+            extra_data.each do |k, v|
+                obj[k] = v
+            end
             if (request.polymorphs)
                 request.polymorphs.each do |model, polym_request|
                     polym_result = {}
@@ -315,7 +329,9 @@ module Spider; module Model; module Mappers
         # Generates a select hash description based on the query.
         def prepare_select(query) #:nodoc:
             condition, joins = prepare_condition(query.condition)
-            elements = query.request.keys.select{ |k| mapped?(k) }
+            elements = query.request.keys.select{ |k| !k.is_a?(QueryFuncs::SelectFunction) && mapped?(k) }
+            select_functions = query.request.keys.select{ |k| k.is_a?(QueryFuncs::SelectFunction) }
+            
             keys = []
             primary_keys = []
             types = {}
@@ -331,6 +347,8 @@ module Spider; module Model; module Mappers
                 oj[:as] ||= "ORD#{cnt+=1}" if joins.select{ |j| j[:to] == oj[:to] }.length > 0
             end
             joins += order_joins if order_joins
+            group_by, group_by_joins = prepare_group_by(query)
+            joins += group_by_joins if group_by_joins
             seen_fields = {}
             model_pks = []
             @model.primary_keys.each do |pk|
@@ -363,15 +381,11 @@ module Spider; module Model; module Mappers
                         end
                     end
                     sub_request = query.request[element.name]
-                    # if (can_join?(element) && sub_request.is_a?(Request) && 
-                    #     sub_request.select{|k, v| !element.model.elements[k].primary_key?}.length > 0)
-                    #     sub_request = element.mapper.prepare_query_request(sub_request).reject{ |name, req| element.reverse == name }
-                    #     sub_select = element.mapper.prepare_select(Query.new(nil, sub_request))
-                    #     keys += sub_select[:keys]
-                    #     joins << get_join(element)
-                    # end
                 end
             end
+            select_functions.each do |f|
+                keys << prepare_queryfunc(f)
+            end
             if (query.request.polymorphs? || !query.condition.polymorphs.empty?)
                 only_conditions = {:conj => 'or', :values => []} if (query.request.only_polymorphs?)
                 polymorphs = (query.request.polymorphs.keys + query.condition.polymorphs).uniq
@@ -427,6 +441,7 @@ module Spider; module Model; module Mappers
                 :condition => condition,
                 :joins => joins,
                 :order => order,
+                :group_by => group_by,
                 :offset => query.offset,
                 :limit => query.limit
             }
@@ -580,9 +595,10 @@ module Spider; module Model; module Mappers
                     cond[:values] << [field, comp, v]
                     joins += field.joins
                     if is_having
-                        cond[:group_by_fields] += k.inner_elements.map{ |el_name, owner_func| 
-                            owner_func.mapper_fields[el_name.to_s]
-                        }
+                        k.inner_elements.each do |el_name, owner_func|
+                            next if owner_func.is_a?(QueryFuncs::AggregateFunction)
+                            cond[:group_by_fields] <<= owner_func.mapper_fields[el_name.to_s]
+                        end
                     end
                     next
                 end
@@ -600,6 +616,7 @@ module Spider; module Model; module Mappers
                         element_cond = {:conj => 'AND', :values => [], :is_having => is_having}
                         v.each_with_comparison do |el_k, el_v, el_comp|
                             field = model_schema.foreign_key_field(element.name, el_k)
+                            next if field.is_a?(FixedExpression)
                             el_comp ||= '='
                             op = el_comp
                             field_cond = [field, op,  map_condition_value(element.model.elements[el_k.to_sym].type, el_v)]
@@ -609,50 +626,56 @@ module Spider; module Model; module Mappers
                         cond[:values] << element_cond
                     else
                         if element.storage == model.mapper.storage
-                            join_type = join_info[element.name.to_s] ? :inner : :left
-                            sub_join = model.mapper.get_join(element, join_type)
-                            # FIXME! cleanup, and apply the check to joins acquired in other places, too (maybe pass the current joins to get_join)
-                            existent = joins.select{ |j| j[:to] == sub_join[:to] }
-                            j_cnt = nil
-                            had_join = false
-                            existent.each do |j|
-                                if sub_join[:to] == j[:to] && sub_join[:keys] == j[:keys] && sub_join[:conditions] == j[:conditions]
-                                    # if any condition allows a left join, then a left join should be used here as well
-                                    j[:type] = :left if sub_join[:type] == :left
-                                    sub_join = j
-                                    had_join = true
-                                    break
-                                else
-                                    j_cnt ||= 0; j_cnt += 1
-                                end
-                            end
-                            sub_join[:as] = "#{sub_join[:to]}#{j_cnt}" if j_cnt
-                            joins << sub_join unless had_join
                             
+                            needs_join = true
                             if v.nil? && comp == '='
                                 el_model_schema = model_schema
                                 element_cond = {:conj => 'AND', :values => [], :is_having => is_having}
                                 if model.mapper.have_references?(element.name)
                                     el_name = element.name
                                     el_model = element.model
+                                    needs_join = false
                                 elsif element.junction?
                                     el_model = element.type
                                     el_model_schema = element.model.mapper.schema 
                                     el_name = element.attributes[:junction_their_element]    
                                 else
-                                    el_model = element.type
-                                    el_model_schema = el_model.mapper.schema
+                                    el_model = @model
+                                    el_model_schema = element.type.mapper.schema
                                     el_name = element.reverse
                                 end
                                 el_model.primary_keys.each do |k|
                                     field = el_model_schema.foreign_key_field(el_name, k.name)
-                                    field_cond = [field, comp,  map_condition_value(element.model.elements[k.name].type, nil)]
+                                    next if field.is_a?(FixedExpression)
+                                    field_cond = [field, comp,  map_condition_value(el_model.elements[k.name].type, nil)]
                                     element_cond[:values] << field_cond
                                     element_cond[:is_having] = is_having
                                     cond[:group_by_fields] << field if is_having
                                 end
                                 cond[:values] << element_cond
-                            elsif v
+                            end
+                            if needs_join
+                                join_type = join_info[element.name.to_s] ? :inner : :left
+                                sub_join = model.mapper.get_join(element, join_type)
+                                # FIXME! cleanup, and apply the check to joins acquired in other places, too (maybe pass the current joins to get_join)
+                                existent = joins.select{ |j| j[:to] == sub_join[:to] }
+                                j_cnt = nil
+                                had_join = false
+                                existent.each do |j|
+                                    if sub_join[:to] == j[:to] && sub_join[:keys] == j[:keys] && sub_join[:conditions] == j[:conditions]
+                                        # if any condition allows a left join, then a left join should be used here as well
+                                        j[:type] = :left if sub_join[:type] == :left
+                                        sub_join = j
+                                        had_join = true
+                                        break
+                                    else
+                                        j_cnt ||= 0; j_cnt += 1
+                                    end
+                                end
+                                sub_join[:as] = "#{sub_join[:to]}#{j_cnt}" if j_cnt
+                                joins << sub_join unless had_join
+                            end
+                            if v
                                 sub_condition, sub_joins = element.mapper.prepare_condition(v, :table => sub_join[:as], 
                                     :joins => joins, :join_info => el_join_info, :is_having => is_having || nil)
                                 sub_condition[:table] = sub_join[:as] if sub_join[:as]
@@ -667,7 +690,7 @@ module Spider; module Model; module Mappers
                     end
                 elsif(model_schema.field(element.name))
                     field = model_schema.field(element.name)
-                    field = FieldInAliasedTable(field, options[:table]) if options[:table]
+                    field = FieldInAliasedTable.new(field, options[:table]) if options[:table]
                     op = comp ? comp : '='
                     if (v.is_a?(Spider::QueryFuncs::Expression))
                         v_joins = prepare_expression(v)
@@ -815,6 +838,7 @@ module Spider; module Model; module Mappers
                 owner_func.mapper_fields[el_name.to_s] = el_model.mapper.schema.field(el.name)
             end
             f = FieldFunction.new(storage.function(func), schema.table, joins)
+            f.as = func.as if func.is_a?(QueryFuncs::SelectFunction)
             f.aggregate = true if func.has_aggregates?
             return f
         end
@@ -850,7 +874,9 @@ module Spider; module Model; module Mappers
                     if el.model?
                         if el_model.mapper.have_references?(el) || el.model.storage != storage
                             el.model.primary_keys.each do |pk|
-                                fields << [el_model.mapper.schema.foreign_key_field(el.name, pk.name), direction]
+                                field = el_model.mapper.schema.foreign_key_field(el.name, pk.name)
+                                next if field.is_a?(FixedExpression)
+                                fields << [field, direction]
                             end
                         else
                             el.model.primary_keys.each do |pk|
@@ -868,6 +894,34 @@ module Spider; module Model; module Mappers
             return [fields, joins]
         end
 
+        def prepare_group_by(query)
+            return nil if !query.group_by_elements
+            joins = []
+            fields = []
+            query.group_by_elements.each do |gb|
+                el_model = @model
+                el_joins, el_model, el = get_deep_join(gb)
+                # FIXME: this is almost identical to prepare_order
+                if el.model?
+                    if el_model.mapper.have_references?(el) || el.model.storage != storage
+                        el.model.primary_keys.each do |pk|
+                            fields << el_model.mapper.schema.foreign_key_field(el.name, pk.name)
+                        end
+                    else
+                        el.model.primary_keys.each do |pk|
+                            fields << el.model.mapper.schema.field(pk.name)
+                        end
+                    end
+                else
+                    raise "Order on unmapped element #{el_model.name}.#{el.name}" unless el_model.mapper.mapped?(el)
+                    field = el_model.mapper.schema.field(el.name)
+                    fields << field
+                end
+                joins += el_joins
+            end
+            return [fields, joins]
+        end
+
         # Returns a type accepted by the storage for type.
         def map_type(type)
             st = type
@@ -1060,16 +1114,20 @@ module Spider; module Model; module Mappers
             end
         end
 
-        # Autogenerates schema. Returns a DbSchema.
-        def generate_schema(schema=nil)
-            had_schema = schema ? true : false
-            schema ||= DbSchema.new
+        def schema_table_name
             n = @model.name.sub('::Models', '')
             app = @model.app
             app_name = app.name if app
             short_prefix = app.short_prefix if app
             n.sub!(app_name, short_prefix) if short_prefix
-            schema.table ||= @model.attributes[:db_table] || @storage.table_name(n)
+            @storage.table_name(n)
+        end
+
+        # Autogenerates schema. Returns a DbSchema.
+        def generate_schema(schema=nil)
+            had_schema = schema ? true : false
+            schema ||= DbSchema.new
+            schema.table ||= @model.attributes[:db_table] || schema_table_name
             integrated_pks = []
             @model.each_element do |element|
                 if element.integrated?

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

@@ -604,7 +604,8 @@ module Spider; module Model
                         merged[merged_obj.object_id] = true
                     end
                     query.request.keys.each do |k, v|
-                        set.element_loaded(k) if have_references?(k)
+                         # k may be a SelectFunction
+                        set.element_loaded(k) if !k.is_a?(QueryFuncs::SelectFunction) && have_references?(k)
                     end
                     set.each_current do |obj|
                         next if merged[obj.object_id]
@@ -1054,7 +1055,10 @@ module Spider; module Model
             obj.class.elements_array.each do |el|
                 next unless obj.element_has_value?(el)
                 next unless el.model?
-                children << obj.get(el)
+                next unless obj.element_modified?(el)
+                val = obj.get(el)
+                next unless val.modified?
+                children << val
             end
             children
         end

data/lib/spiderfw/model/migrations/drop_element.rb

@@ -12,7 +12,7 @@ module Spider; module Migrations
             field = @options[:field_name]
             if !field
                 schema_field = @model.mapper.schema.field(@element)
-                field = schema_field.name
+                field = schema_field.name if schema_field
             end
             field ||= @model.mapper.storage.column_name(@element)
             desc = @model.mapper.storage.describe_table(@model.mapper.schema.table)