lore 0.4.8 → 0.9.2

data/lib/lore/query.rb

@@ -0,0 +1,71 @@
+
+module Lore
+
+  # Proxy class for Select queries. 
+  #
+  #   Model.select { |x| ... }    --> Select.new(Model, clause_parser)
+  #
+  class Select_Query < Array
+
+    attr_reader :model, :clause_parser
+
+    def initialize(model, what=nil, polymorphic=false, &block)
+      @model         = model
+      @strategy      = model.__select_strategy__
+      @what          = what
+      @polymorphic   = polymorphic
+      @clause_parser = yield(Clause_Parser.new(@model))
+    end
+
+    def to_sql
+      @strategy.select_query(@what, @clause_parser, @polymorphic)[:query]
+    end
+    alias sql to_sql
+
+    def perform
+      @strategy.select_cached(@what, @clause_parser, @polymorphic)
+    end
+    alias to_a perform
+    alias exec perform
+    alias result perform
+
+    def first
+      perform.first
+    end
+    def last
+      perform.last
+    end
+    def each(&block)
+      perform.each(&block)
+    end
+    def each_with_index(&block)
+      perform.each_with_index(&block)
+    end
+
+    def union(other)
+      @clause_parser.union(other)
+      return self
+    end
+
+    def +(other)
+      perform + other.to_a
+    end
+
+    # Any undefined method is interpreted as 
+    # kicker call. 
+    def method_missing(meth, *args)
+      perform.__send__(meth, *args)
+    end
+
+  end
+
+  class Delete_Query
+  end
+
+  class Update_Query
+  end
+
+  class Insert_Query
+  end
+
+end

data/lib/lore/query_shortcuts.rb

@@ -36,6 +36,11 @@ module Lore
     end
     alias where with
 
+    def or(condition)
+      @condition = ((@condition) | condition)
+      return self
+    end
+
     # Adds HAVING statement to query. Examples: 
     # 
     #   User.all.having(User.user_id.in( Admin.all(:user_id) ))
@@ -60,7 +65,7 @@ module Lore
     #   -> Highest car_id as integer, e.g. 14223
     #
     def method_missing(method, attribute_name)
-      @what = method.to_s << '(' << attribute_name.to_s << ') AS "value"'
+      @what = "#{method.to_s}(#{attribute_name.to_s}) "
       return self
     end
 
@@ -69,6 +74,7 @@ module Lore
   class Refined_Select < Refined_Query
 
     def initialize(accessor, statements={})
+      @polymorphic = false
       super(accessor, statements)
     end
 
@@ -103,6 +109,7 @@ module Lore
       entities.first
     end
 
+
     # When requesting a single value, #to_i can be used to 
     # retreive the result as string instead of calling #entity:
     # 
@@ -167,6 +174,13 @@ module Lore
       return self
     end
 
+    # Execute as polymorphic query, joining all concrete base models 
+    # of this polymorhpic model. 
+    def polymorphic
+      @polymorphic = true
+      return self
+    end
+
     # Handy wrapper for 
     #   <request>.entities.each { |e| ... }
     def each(&block)
@@ -221,16 +235,29 @@ module Lore
     #
     def entities
       if @what.nil? then
-        result = @accessor.select { |entity|
-          entity.where(@condition)
-          entity.limit(@limit, @offset) unless @limit.nil?
-          @order_by.each { |o|  
-            entity.order_by(o[0], o[1]) 
-          }
-          entity.group_by(@group_by) unless @group_by.nil?
-          entity.having(@having) unless @having.nil?
-          entity
-        }
+        if @polymorphic then
+          result = @accessor.polymorphic_select { |entity|
+            entity.where(@condition)
+            entity.limit(@limit, @offset) unless @limit.nil?
+            @order_by.each { |o|  
+              entity.order_by(o[0], o[1]) 
+            }
+            entity.group_by(@group_by) unless @group_by.nil?
+            entity.having(@having) unless @having.nil?
+            entity
+          }.to_a
+        else
+          result = @accessor.select { |entity|
+            entity.where(@condition)
+            entity.limit(@limit, @offset) unless @limit.nil?
+            @order_by.each { |o|  
+              entity.order_by(o[0], o[1]) 
+            }
+            entity.group_by(@group_by) unless @group_by.nil?
+            entity.having(@having) unless @having.nil?
+            entity
+          }.to_a
+        end
       else
         result = Array.new
         @accessor.select_values(@what) { |entity|
@@ -247,6 +274,8 @@ module Lore
             result << row.values['value'] 
           elsif row.kind_of? String then
             result << row
+          else 
+            result = row
           end
         }
       end
@@ -254,6 +283,9 @@ module Lore
       return result
     end
     alias perform entities
+    alias to_a entities
+    alias result entities
+    alias value entity
 
   end # class
 

data/lib/lore/strategies/table_delete.rb

@@ -0,0 +1,115 @@
+
+require('lore/bits')
+
+module Lore
+
+  class Table_Delete
+
+    @logger = Lore.logger
+
+    public
+
+    def initialize(accessor)
+      @accessor = accessor
+    end
+    
+    private
+    
+    def self.atomic_delete_query(table_name, primary_keys, value_keys)
+    # {{{
+      query_string = 'DELETE FROM '+table_name+' WHERE '
+      
+      field_counter=0
+      primary_keys.each { |field|
+        
+        query_string << "#{field} ='" 
+        value = value_keys[field].to_s
+        if value == '' then 
+          value = value_keys["#{table_name}.#{internal_attribute_name}"].to_s
+        end
+
+        query_string << "#{value}' "
+        if field_counter < primary_keys.length-1
+          query_string += 'AND '
+        end
+        field_counter += 1
+      }
+      query_string << '; '
+        
+      query_string
+      
+    end # }}}
+    
+    public 
+
+    def block_delete(&block)
+    # {{{
+      query_string = "DELETE FROM #{@accessor.table_name} "
+      
+      if block_given? then
+        yield_obj = Lore::Clause_Parser.new(@accessor.table_name)
+        clause = yield *yield_obj
+      end
+      
+      query_string += clause.where_part
+      
+      Lore::Context.enter(@accessor.get_context) if @accessor.get_context
+      begin
+        Lore::Connection.perform(query_string)
+      ensure
+        Lore::Context.leave if @accessor.get_context
+      end
+    end # }}}
+    
+    def self.delete_query(table_name, 
+                          is_a_hierarchy, 
+                          primary_keys, 
+                          value_keys, 
+                          query_string='')
+    # {{{
+      query_string += atomic_delete_query(table_name, 
+                                          primary_keys[table_name], 
+                                          value_keys
+                                          ).to_s
+      is_a_hierarchy.each_pair { |table, base_tables| 
+        
+        # pass base tables afterwards, recursively, as IS_A-based deletion has
+        # to be done top-down (derived tabled first): 
+        query_string = delete_query(table, 
+                                    base_tables, 
+                                   
+                                    primary_keys, 
+                                    value_keys, 
+                                   
+                                    query_string
+                                   ).to_s
+      }
+      return query_string
+    end # }}}
+    
+    public
+    
+    def perform_delete(value_keys)
+    # {{{
+      query_string = self.class.delete_query(@accessor.table_name, 
+                                             @accessor.__associations__.base_klasses_tree, 
+                                             @accessor.__associations__.primary_keys, 
+                                             value_keys)
+      
+      Lore::Context.enter(@accessor.get_context) if @accessor.get_context
+      begin
+        Lore::Connection.perform("BEGIN;\n#{query_string}\nCOMMIT;")
+      rescue ::Exception => excep
+        Lore::Connection.perform("ROLLBACK;")
+        raise excep
+      ensure
+        Lore::Context.leave if @accessor.get_context
+      end
+      @accessor.flush_entity_cache()
+      
+    end # }}}
+    
+  end # class
+
+end # module
+  

data/lib/lore/strategies/table_insert.rb

@@ -0,0 +1,146 @@
+
+module Lore
+
+  class Table_Insert
+        
+    public
+
+    def initialize(accessor)
+      @accessor        = accessor
+      @aggregates      = accessor.__associations__.aggregate_klasses
+      @is_a            = accessor.__associations__.base_klasses_tree
+      @foreign_keys    = accessor.__associations__.foreign_keys
+      @base_table      = accessor.table_name
+      @fields          = accessor.__attributes__.fields
+      @sequences       = accessor.__attributes__.sequences
+      @sequence_values = {}
+    end
+
+    def perform_insert(value_keys)
+    # {{{
+      @aggregates.keys.each { |table|
+        @is_a.delete(table)
+      }
+      
+      Context.enter(@accessor.get_context) if @accessor.get_context
+      Lore.logger.info { 'PERFORM INSERT on '+@accessor.to_s }
+
+      @sequence_values = load_sequence_values(@sequences)
+      
+      # Parse sequence_values into value_keys where entries match the exact table: 
+      # (thus, there is an explicit call like primary_key :this_field, :this_sequence)
+      @sequence_values.each_pair { |table, fields|
+        value_keys[table].update(@sequence_values[table])
+      }
+      # Parse sequence_values into value_keys where a table depends from a 
+      # sequence field by IS_A
+      value_keys 	 = update_sequence_values_deps(@base_table, 
+                                                 @is_a, 
+                                                 value_keys)
+      query_string = insert_query(@base_table, 
+                                  @is_a, 
+                                  value_keys)
+      
+      begin
+        Lore::Connection.perform("BEGIN;\n#{query_string}\nCOMMIT;")
+      rescue ::Exception => excep
+        Lore::Connection.perform("ROLLBACK;")
+        raise excep
+      ensure
+        Lore::Context.leave if @accessor.get_context
+      end
+      @accessor.flush_entity_cache()
+
+      # value_keys now are extended by sequence values: 
+      return value_keys
+    end # }}}
+
+    protected
+    
+    def load_sequence_values(sequences)
+    # {{{
+      sequence_values = Hash.new
+
+      sequences.each_pair { |table_name, field| 
+        field.each_pair { |field_name, sequence_name|
+          
+          pure_schema_name 	  = table_name.split('.')[0]
+          pure_table_name 	  = table_name.split('.')[1]
+          temp_sequence_name 	= "#{sequence_name}_temp"
+          
+          sequence_query_string = "SELECT nextval('#{pure_schema_name}.#{sequence_name}'::text) as #{temp_sequence_name}; "
+          sequence_value_result = Lore::Connection.perform(sequence_query_string)
+          
+          sequence_values[table_name] = Hash.new if sequence_values[table_name] == nil
+          sequence_values[table_name][field_name.to_sym] = sequence_value_result.get_field_value(0, temp_sequence_name)
+        }
+      }
+      
+      return sequence_values
+    end # }}}
+    
+    def atomic_insert_query(table_name, value_keys)
+    # {{{ 
+      query_string = "\nINSERT INTO #{table_name} "
+      
+      value_string = String.new
+      field_string = String.new
+      key_counter = 0
+      value_keys.each_pair { |field, value|
+        
+        field_string << "#{field}"
+        value_string << "'#{value}'"
+        if key_counter < value_keys.length-1
+          field_string += ', '
+          value_string += ', '
+        end
+        key_counter += 1
+      }
+      query_string += "(#{field_string}) \n VALUES (#{value_string}); "
+      return query_string
+    end # }}}
+    
+    def insert_query(table_name, 
+                     is_a, 
+                     value_keys, 
+                     query_string='')
+    # {{{
+      is_a.each_pair { |table, base_tables| 
+        
+        # pass base tables first, recursively, as IS_A-based creation has
+        # to be done bottom-up:
+        query_string << insert_query(table, base_tables, value_keys).to_s
+      }
+      # finally, add query string for this table: 
+      if(value_keys[table_name] != nil)
+        query_string << atomic_insert_query(table_name, value_keys[table_name]).to_s
+      else 
+        Lore.logger.debug { "No initial attribute for IS_A related table #{table_name} given. " } 
+      end
+      query_string
+    end # }}}
+    
+    def update_sequence_values_deps(table, is_a, value_keys)
+    # {{{
+      is_a.each_pair { |base_table, next_base_tables| 
+        # extend each value_key with primary keys of its base table: 
+        if @sequence_values.has_key?(base_table) then
+          # For sequenced foreign keys, only one attribute is allowed! 
+          own_fkey = @foreign_keys[table][base_table].first.first
+          if own_fkey
+          then
+            foreign_pkey = @foreign_keys[table][base_table].at(1).first
+            seq_val = @sequence_values[base_table][foreign_pkey]
+            value_keys[table][own_fkey] = seq_val
+          end
+        end
+        value_keys = update_sequence_values_deps(base_table, 
+                                                 next_base_tables, 
+                                                 value_keys)
+      }
+      return value_keys
+    end # }}}
+    
+  end # class
+
+end # module

data/lib/lore/strategies/table_select.rb

@@ -0,0 +1,299 @@
+
+require('lore/cache/cached_entities')
+require('lore/clause')
+
+module Lore
+
+  class Table_Select 
+
+    @@logger = Lore.logger
+    
+    public
+
+    def initialize(accessor)
+      @accessor = accessor
+    end
+
+    # Extracted, recursive method for building the JOIN-part of 
+    # a SELECT query. 
+    def self.build_joined_query(accessor, 
+                                join_type='JOIN', 
+                                query_string='', 
+                                joined_tables=[])
+    # {{{
+      associations     = accessor.__associations__
+      top_table        = accessor.table_name
+      is_a_hierarchy   = associations.joins()
+      own_primary_keys = associations.primary_keys()
+      own_foreign_keys = associations.foreign_keys()
+      joined_models    = associations.joined_models
+
+      # predefine
+      own_p_keys       = Hash.new
+      foreign_p_keys   = Hash.new
+      on_string        = String.new
+      field_counter    = 0
+
+      is_a_hierarchy.each_pair { |foreign_table, foreign_base_tables|
+        # Ensure no table is joined twice
+        if !(joined_tables.include?(foreign_table)) then
+          # [ [ a_id_f, a_id ], [ b_id_f, b_id ] ]
+          mapping = own_foreign_keys[top_table][foreign_table]
+          own_f_keys     = mapping.at(0)
+          foreign_p_keys = mapping.at(1)
+
+          if own_f_keys then
+            joined_tables << foreign_table
+            query_string  << "\n #{join_type} #{foreign_table} ON ("
+            on_string      = ''
+            foreign_p_keys.uniq.each_with_index { |foreign_field, field_counter|
+              # base.table.foreign_field = this.table.own_field
+              on_string    << "#{foreign_table}.#{foreign_field} = #{top_table}.#{own_f_keys[field_counter]}"
+              query_string << ", " if field_counter > 0
+              query_string << on_string
+            } 
+            query_string << ')'
+          end
+            
+          # sub-joins of joined table: 
+          query_string = build_joined_query(joined_models[foreign_table].first, 
+                                            join_type, 
+                                            query_string, 
+                                            joined_tables)
+        end
+      }
+      return query_string
+    end # }}}
+
+    protected
+
+    def build_select_query(value_keys)
+    # {{{
+      raise ::Exception.new("This method is deprecated. ")
+
+      query_string = "SELECT * FROM #{base_table} #{self.class.build_joined_query(@accessor)} WHERE "
+      query_string << "\n WHERE "
+    
+      operator = '='
+      field    = String.new
+      value_keys[0].each_pair { |field, value|
+      # Filtering values is not necessary when feeded with 
+      # Lore::Attributes instance
+        field = field.to_s
+        if value.instance_of? Hash then
+          value.each_pair { |attrib_name, attrib_value|
+            query_string << "#{field}.#{attrib_name} #{operator} '#{attrib_value.to_s.lore_escape}' AND "
+          }
+        else
+          query_string << "#{base_table}." if field.split('.')[2].nil?
+          query_string << "#{field} #{operator} '#{value.to_s.lore_escape}' AND "
+        end
+      }
+      # remove trailing AND: 
+      query_string.chomp!(' AND ')
+      
+      return query_string
+    end # }}}
+
+    def plan_select_query(what, &block)
+    # {{{
+      auto_plan = Lore::Plan.new(clause, select_query(what, &block), @accessor)
+    end # }}}
+   
+    public 
+
+    def select_query(what=nil, clause_parser=nil, polymorphic=false, &block)
+    # {{{
+      # Example: 
+      # select(Car.name) -> SELECT max(id)
+      if what.instance_of? Clause then
+        what = what.to_s 
+      end
+      
+      if(what.nil? || what == '*' || what == '') then
+        query_as_part = '*'
+      else 
+        query_as_part = what.to_s      
+      end
+
+      if block_given? then
+        yield_obj  = Clause_Parser.new(@accessor)
+        clause_parser = yield *yield_obj
+      end
+      
+      query_string = 'SELECT '
+      
+      query_parts = clause_parser.parts
+      query_parts[:what] = query_as_part
+      query_parts[:from] = "FROM #{@accessor.table_name}"
+      # Add JOIN part for system defined type (user defined 
+      # joins will be set in Clause_Parser object in later 
+      # yield): 
+      if polymorphic && @accessor.is_polymorphic? then
+        query_parts[:all_joins] = self.class.build_polymorphic_joined_query(@accessor) << query_parts[:join]
+      else
+        query_parts[:all_joins] = self.class.build_joined_query(@accessor) << query_parts[:join]
+      end
+      query_string << [ :what, :from, :all_joins, :where, 
+                        :group_by, :having, :filter, 
+                        :order_by, :limit, :offset ].map { |part|
+        query_parts[part]
+      }.join(' ')
+
+      # Attaching UNION selects: 
+      if clause_parser.unions then
+        clause_parser.unions.each { |select_query_obj|
+          query_string << "\nUNION\n"
+          union_sql = select_query_obj.sql
+          query_string << union_sql
+        }
+      end
+
+      return { :query => query_string, :joined_models => clause_parser.parts[:joined] }
+    end # }}}
+    
+    def self.build_polymorphic_joined_query(accessor)
+    # {{{
+      # Generates full outer join on all concrete submodels of this 
+      # (abstract) polymorphic model. 
+      
+      # Correct query for this is: 
+      # select * from asset 
+      # ----  BEGIN IMPLICIT JOINS
+      # -- full outer join on concrete model's base table
+      # full outer join document_asset on (asset.asset_id = document_asset.asset_id) 
+      #   -- left join on concrete model's implicitly joined tables
+      #   left join document_asset_info on (document_asset_info.document_asset_id = document_asset.id)
+      # -- full outer join on next concrete base table
+      # full outer join media_asset on (asset.asset_id = media_asset.asset_id) 
+      #   -- left join on concrete model's implicitly joined tables
+      #   left join media_asset_info on (media_asset_info.media_asset_id = media_asset.id)
+      # ----  END IMPLICIT JOINS
+      # ----  BEGIN EXPLICIT JOINS
+      # join Asset_Comments using (asset_id)
+      # ----  END EXPLICIT JOINS
+      # where ...
+      # order by model;
+      concrete_models = accessor.__associations__.concrete_models
+      own_table_name  = accessor.table_name
+      implicit_joins  = build_joined_query(accessor) 
+      own_pkeys       = accessor.__associations__.primary_keys[own_table_name]
+      concrete_models.each { |concrete_model|
+        join_constraints = []
+        concrete_model.__associations__.foreign_keys[concrete_model.table_name][own_table_name].first.each_with_index { |fkey,index|
+          join_constraints << "#{own_table_name}.#{own_pkeys[index]} = #{concrete_model.table_name}.#{fkey}"
+        }
+        implicit_joins << "\nFULL OUTER JOIN #{concrete_model.table_name} ON (#{join_constraints.join(' AND ')}) "
+        # Attach the concrete model's own implicit joins (is_a and aggregates), 
+        # but don't join polymorphic base table (own_table_name) again: 
+        implicit_joins << build_joined_query(concrete_model, '  LEFT JOIN', '', [own_table_name]) 
+      }
+      implicit_joins
+    end # }}}
+
+    def select(what, polymorphic=false, &block)
+    # {{{
+      query_string = select_query(what, nil, polymorphic, &block)
+      return perform_select(query_string[:query])
+    end # }}}
+
+    def select_cached(what, clause_parser=nil, polymorphic=false, &block)
+    # {{{
+      joined_models = []
+      query_string  = nil
+      query         = nil
+      if clause_parser.nil? && block_given? then
+        query         = select_query(what, nil, polymorphic, &block)
+        query_string  = query[:query]
+        joined_models = query[:joined_models]
+      elsif !block_given? && clause_parser then
+        query         = select_query(what, clause_parser, polymorphic)
+        query_string  = query[:query]
+        joined_models = query[:joined_models]
+      else
+        query_string  = what.to_s
+      end
+      what = false if what.empty?
+
+      result = Array.new
+      if Lore.cache_enabled? && 
+         @accessor.entity_cache && 
+         @accessor.entity_cache.include?(@accessor, query) then
+        result = @accessor.entity_cache.read(@accessor, query)
+        result = [] if result.to_s == ''
+      else
+        Context.enter(@accessor.get_context) if @accessor.get_context
+        begin 
+          result = Lore::Connection.perform(query_string).get_rows()
+          if polymorphic && !what && @accessor.is_polymorphic? then
+            result.map! { |row|
+              Lore.logger.debug { "Polymorphic select returned: #{row.inspect}" }
+              row = @accessor.new_polymorphic(row, joined_models)
+            }
+          else
+            result.map! { |row|
+              row = (@accessor.new(row, joined_models))
+            }
+          end
+        rescue PGError => pge
+          raise pge
+        ensure
+          Context.leave if @accessor.get_context
+        end
+        if Lore.cache_enabled? && @accessor.entity_cache then
+          @accessor.entity_cache.create(@accessor, query, result)
+        end
+      end
+      return result
+    end # }}}
+
+    def prepare(plan_name, args, &block)
+    # {{{
+      args_string = ''
+      args.map { |a| a = Lore::TYPE_NAMES[a] } 
+      if args.to_s != '' && args.length > 0 then args_string = "(#{args.join(',')})" end
+      query_string = "PREPARE #{@accessor.table_name.gsub('.','_')}__#{plan_name.to_s}#{args_string} AS " << select_query(&block)[:query]
+      begin
+        Context.enter(@accessor.get_context) if @accessor.get_context
+        result = Lore::Connection.perform(query_string)
+      rescue ::Exception => excep
+        @@logger.debug("Exception when preparing #{plan_name.to_s}: #{excep.message}")
+      ensure
+        Context.leave if @accessor.get_context
+      end
+    end # }}}
+
+    def select_prepared(plan_name, *args)
+    # {{{
+      args_string = ''
+      if args.to_s != '' && args.length > 0 then args_string = "(#{args.join(',')})" end
+      query_string = "EXECUTE #{plan_name.to_s} #{args_string}; "
+      return select_cached(query_string)
+    end # }}}
+
+    def deallocate(plan_name)
+    # {{{
+      begin
+        query_string = "DEALLOCATE #{@accessor.table_name.gsub('.','_')}__#{plan_name.to_s}; "
+        result = Lore::Connection.perform(query_string)
+      rescue ::Exception => excep
+      end
+    end # }}}
+
+    private
+
+    def perform_select(query_string)
+    # {{{
+      Context.enter(@accessor.get_context) if @accessor.get_context
+      begin 
+        return Lore::Connection.perform(query_string)
+      rescue PGError => pge
+        raise pge
+      ensure
+        Context.leave if @accessor.get_context
+      end
+   end # }}}
+
+  end # class
+
+end # module