Rubernate 0.1.4 → 0.1.5

data/lib/rubernate/queries.rb

@@ -1,5 +1,8 @@
+require 'rubernate/impl/dbi_generic'
+
 # Contains users methods for building queries
 module Rubernate
+# This module contains classes and modules used for query building
 module Queries
   # Log instance for Queries
   Log = Rubernate::Log
@@ -9,12 +12,12 @@ module Queries
   
   # Contains operations definitions
   module Operations
-    # Declares And sql clause.
+    # Declares AND sql clause.
     def And expr1, expr2
       @factory.bin_op expr1, expr2, 'and'
     end
     
-    # Declares Or sql clause.
+    # Declares OR sql clause.
     def Or expr1, expr2
       @factory.bin_op expr1, expr2, 'or', true
     end
@@ -24,22 +27,22 @@ module Queries
       @factory.bin_op expr1, expr2, '='
     end
     
-    # Declares Not sql clause.
+    # Declares NOT sql clause.
     def Not expr
       @factory.un_op expr, 'not', true      
     end
     
-    # Declares is null sql clause
+    # Declares IS NULL sql clause
     def IsNil expr
       @factory.bin_op expr, @factory.expr(nil), 'is'
     end
     
-    # Declares is not null sql clause    
+    # Declares IS NOT NULL sql clause    
     def IsNotNil expr
       @factory.bin_op expr, @factory.expr(nil), 'is not'
     end 
     
-    # Declares in sql clause
+    # Declares IN sql clause
     def In expr, list
       @factory.bin_op expr, @factory.list(list), 'in'
     end
@@ -54,8 +57,8 @@ module Queries
     end
   end
   
-  # Defines query elements factory. By default it creates elements defined 
-  # in module Generic, but this befavior can be changed by seting of appropriate class.
+  # Defines query elements factory. By default it creates elements defined in module Queries.
+  # This behaviour can be changed to provide support for kinds of queries other then ANSI SQL.
   # Following example changes implementation of BinOpConst
   #
   # :call-seq:
@@ -68,15 +71,15 @@ module Queries
     attr_reader :cache # Queries cache. TODO: limit size!
     # Initalizes default implementations
     def initialize
-      @expr     = Generic::Expr
-      @un_op    = Generic::UnOpConstr
-      @bin_op   = Generic::BinOpConstr
-      @field    = Generic::FieldExpr 
-      @key_ref  = Generic::KeyRefExpr
-      @list     = Generic::ExprsList
-      @r_param  = Generic::RParam 
-      @r_object = Generic::RObject
-      @query    = Generic::Query
+      @expr     = Expr
+      @un_op    = UnOpConstr
+      @bin_op   = BinOpConstr
+      @field    = FieldExpr 
+      @key_ref  = KeyRefExpr
+      @list     = ExprsList
+      @r_param  = RParam 
+      @r_object = RObject
+      @query    = Query
       @cache    = {}
     end
     def query query=nil, &block
@@ -100,365 +103,364 @@ module Queries
   end
 
   # Contains classes for standart ANSY SQL.
-  module Generic
-    # Represent abstract expression
-    class Expr
-      include Operations
-      attr_reader :r_params, :markers
+  # Represent abstract expression
+  class Expr
+    include Operations
+    attr_reader :r_params, :markers
 
-      def initialize factory, value = nil
-        @factory, @value, @r_params, @markers = factory, value, [], []
-        @markers << @value if @value.is_a? Symbol
-      end
-      
-      # Generates SQL for expression
-      def to_sql
-        case @value
-          when Symbol:  '?'
-          when Integer: @value
-          when nil: 'null'
-          else "'#{@value.to_s}'"
-        end
-      end        
-      private
-        def fit_type expr
-          case expr
-            when RObject: expr.pk
-            when RParam: expr.ref
-            when Expr: expr
-            else @factory.expr expr
-          end
-        end
-        def self.def_bin_op ruby_op, sql_op
-          module_eval %{
-            def #{ruby_op} (other) @factory.bin_op self, other, '#{sql_op}'; end
-          }
-        end
-        for op in [['==', '='], ['=~', '<>'], '<', '>', '<=', '>=']
-          if op.is_a? Array
-            def_bin_op(*op)
-          else
-            def_bin_op op, op
-          end
-        end
-    end  
+    def initialize factory, value = nil
+      @factory, @value, @r_params, @markers = factory, value, [], []
+      @markers << @value if @value.is_a? Symbol
+    end
     
-    # Represents constraint for one columns.
-    class UnOpConstr < Expr
-      def initialize factory, expr, op, braces = false
-        @factory, @op, @braces = factory, op, braces
-        @expr = fit_type expr
-      end
-      
-      def r_params
-        @expr.r_params
+    # Generates SQL for expression
+    def to_sql
+      case @value
+        when Symbol:  '?'
+        when Integer: @value
+        when nil: 'null'
+        else "'#{@value.to_s}'"
+      end
+    end        
+    private
+      def fit_type expr
+        case expr
+          when RObject: expr.pk
+          when RParam: expr.name
+          when Expr: expr
+          else @factory.expr expr
+        end
       end
-      
-      def markers
-        @expr.markers
+      def self.def_bin_op ruby_op, sql_op
+        module_eval %{
+          def #{ruby_op} (other) @factory.bin_op self, other, '#{sql_op}'; end
+        }
       end
-      
-      def to_sql
-        if @braces
-          "#{@op} (#{@expr.to_sql})"
+      for op in [['==', '='], ['=~', '<>'], '<', '>', '<=', '>=']
+        if op.is_a? Array
+          def_bin_op(*op)
         else
-          "#{@op} #{@expr.to_sql}"
+          def_bin_op op, op
         end
       end
+  end  
+  
+  # Represents constraint for one columns.
+  class UnOpConstr < Expr
+    def initialize factory, expr, op, braces = false
+      @factory, @op, @braces = factory, op, braces
+      @expr = fit_type expr
     end
     
-    # Represent constraint that applied on two columns.
-    class BinOpConstr < Expr
-      def initialize factory, expr1, expr2, sign, braces = false
-        @factory, @sign, @braces = factory, sign, braces
-        @expr1, @expr2 = fit_type(expr1), fit_type(expr2)             
-      end
-      
-      # Returns r_params used in both expressions
-      def r_params    
-        @expr1.r_params + @expr2.r_params
-      end
-      
-      # Returns markers used in both expressions
-      def markers    
-        @expr1.markers + @expr2.markers
-      end
-      
-      # Generates SQL for constraint
-      def to_sql
-        if @braces
-          "(#{@expr1.to_sql} #{@sign} #{@expr2.to_sql})"
-        else
-          "#{@expr1.to_sql} #{@sign} #{@expr2.to_sql}"
-        end      
-      end
-    end  
+    def r_params
+      @expr.r_params
+    end
     
-    # Represent expression with table's field
-    class FieldExpr < Expr    
-      def initialize factory, table, field
-        @factory, @table, @field, @markers = factory, table, field, []
-        @r_params = table.is_a?(RParam) ? [table] : []
-      end
-      # Creates constraint that check if this field is nil
-      def is_nil      
-        IsNil self
-      end
-      # Creates constraint that check if this field is not nil
-      def is_not_nil
-        IsNotNil self
-      end
-      
-      def to_sql
-        @table.to_sql + '.' + @field
-      end
+    def markers
+      @expr.markers
     end
     
-    # Represent r_params for hashes and arrays constrained by key
-    class KeyRefExpr < BinOpConstr
-      def initialize factory, r_param, key_field, key_value
-        @factory, @r_param, @key_field, @key_value = factory, r_param, key_field, key_value
-        super factory, key_field, key_value, '='
-      end
-      def == expr
-        And self, Eq(@r_param.ref, expr)
+    def to_sql
+      if @braces
+        "#{@op} (#{@expr.to_sql})"
+      else
+        "#{@op} #{@expr.to_sql}"
       end
     end
+  end
   
-    # Reresents List of expressions
-    class ExprsList < Expr
-      def initialize factory, list
-        @factory, @exprs = factory, list.collect{|expr| Expr === expr ? expr : factory.expr(expr)}
-      end
-      def to_sql
-        '(' + @exprs.collect{|expr| expr.to_sql}.join(', ') + ')'
-      end
-      def markers
-        @exprs.inject([]) {|res, expr| res.concat expr.markers}
-      end
-      def r_params
-        @exprs.inject([]) {|res, expr| res.concat expr.r_params}
-      end
+  # Represent constraint that applied on two columns.
+  class BinOpConstr < Expr
+    def initialize factory, expr1, expr2, sign, braces = false
+      @factory, @sign, @braces = factory, sign, braces
+      @expr1, @expr2 = fit_type(expr1), fit_type(expr2)             
     end
     
-    # Represents r_params table
-    class RParam < Expr
-      include Rubernate::DBI
-      
-      attr_reader :r_object, :name
-      
-      # Init Param accepts table and name of param
-      def initialize factory, r_object, name
-        @factory, @r_object, @name = factory, r_object, name
-        @marker, @r_params = [], [self]
-      end
-      
-      # Returns full param table name with object tables prefix 
-      def to_sql
-        @r_object.to_sql + @name
+    # Returns r_params used in both expressions
+    def r_params    
+      @expr1.r_params + @expr2.r_params
+    end
+    
+    # Returns markers used in both expressions
+    def markers    
+      @expr1.markers + @expr2.markers
+    end
+    
+    # Generates SQL for constraint
+    def to_sql
+      if @braces
+        "(#{@expr1.to_sql} #{@sign} #{@expr2.to_sql})"
+      else
+        "#{@expr1.to_sql} #{@sign} #{@expr2.to_sql}"
+      end      
+    end
+  end  
+  
+  # Represent expression with table's field
+  class FieldExpr < Expr    
+    def initialize factory, table, field
+      @factory, @table, @field, @markers = factory, table, field, []
+      @r_params = table.is_a?(RParam) ? [table] : []
+    end
+    # Creates constraint that check if this field is nil
+    def is_nil      
+      IsNil self
+    end
+    # Creates constraint that check if this field is not nil
+    def is_not_nil
+      IsNotNil self
+    end
+    
+    def to_sql
+      @table.to_sql + '.' + @field
+    end
+  end
+  
+  # Represent r_params for hashes and arrays constrained by key
+  class KeyRefExpr < BinOpConstr
+    def initialize factory, r_param, key_field, key_value
+      @factory, @r_param, @key_field, @key_value = factory, r_param, key_field, key_value
+      super factory, key_field, key_value, '='
+    end
+    def == expr
+      And self, Eq(@r_param.ref, expr)
+    end
+  end
+
+  # Reresents List of expressions
+  class ExprsList < Expr
+    def initialize factory, list
+      @factory, @exprs = factory, list.collect{|expr| Expr === expr ? expr : factory.expr(expr)}
+    end
+    def to_sql
+      '(' + @exprs.collect{|expr| expr.to_sql}.join(', ') + ')'
+    end
+    def markers
+      @exprs.inject([]) {|res, expr| res.concat expr.markers}
+    end
+    def r_params
+      @exprs.inject([]) {|res, expr| res.concat expr.r_params}
+    end
+  end
+  
+  # Represents r_params table
+  class RParam < Expr
+    include Rubernate::DBI
+    
+    attr_reader :r_object, :p_name
+    
+    # Init Param accepts table and name of param
+    def initialize factory, r_object, p_name
+      @factory, @r_object, @p_name = factory, r_object, p_name
+      @markers, @r_params = [], [self]
+    end        
+    
+    # Returns full param table name with object tables prefix 
+    def to_sql
+      @r_object.to_sql + @p_name
+    end
+    
+    # Fields accessors.
+    def pk   () f_expr 'object_pk'; end
+    def int  () f_expr 'int_value'; end
+    def float() f_expr 'flt_value'; end
+    def str  () f_expr 'str_value'; end
+    def time () f_expr 'dat_value'; end
+    def date () f_expr 'dat_value'; end
+    def ref  () f_expr 'ref_value'; end
+    def flags() f_expr 'flags';     end
+    def name () f_expr 'name';      end
+    
+    # The following methods checks r_param.flags value. (r_param.flags)
+    def is_int () Eq flags, PARAM_FLAG_INT;    end
+    def is_str () Eq flags, PARAM_FLAG_STRING; end
+    def is_time() Eq flags, PARAM_FLAG_TIME;   end
+    def is_ref () Eq flags, PARAM_FLAG_REF;    end
+    
+    # Shortcut for Eq method
+    def == expr
+      expr.is_a?(RObject) ?
+        @factory.bin_op(ref, expr.pk, '=') :
+        @factory.bin_op(ref, expr, '=')
+    end
+    
+    # Shortcut for arrays and hashes
+    def [] key
+      case key
+        when Integer: key_ref int, key
+        when String:  key_ref str, key
+        when Time:    key_ref dat, key
+        when Symbol:  key_ref int, key
+        else raise "invalid key value #{key}"
       end
-      
-      # Fields accessors.
-      def pk   () f_expr 'object_pk'; end
-      def int  () f_expr 'int_value'; end
-      def float() f_expr 'flt_value'; end
-      def str  () f_expr 'str_value'; end
-      def time () f_expr 'dat_value'; end
-      def date () f_expr 'dat_value'; end
-      def ref  () f_expr 'ref_value'; end
-      def flags() f_expr 'flags';     end
-      
-      # The following methods checks r_param.flags value. (r_param.flags)
-      def is_int () Eq flags, PARAM_FLAG_INT;    end
-      def is_str () Eq flags, PARAM_FLAG_STRING; end
-      def is_time() Eq flags, PARAM_FLAG_TIME;   end
-      def is_ref () Eq flags, PARAM_FLAG_REF;    end
-      
-      # Shortcut for Eq method
-      def == expr
-        expr.is_a?(RObject) ?
-          @factory.bin_op(ref, expr.pk, '=') :
-          @factory.bin_op(ref, expr, '=')
+    end
+    private
+      # Creates FieldExpr witch field of this (r_param) table 
+      def f_expr field
+        @factory.field self, field
       end
-      
-      # Shortcut for arrays and hashes
-      def [] key
-        case key
-          when Integer: key_ref int, key
-          when String:  key_ref str, key
-          when Time:    key_ref dat, key
-          when Symbol:  key_ref int, key
-          else raise "invalid key value #{key}"
-        end
+      def key_ref key_field, key_value
+        @factory.key_ref self, key_field, key_value
       end
-      private
-        # Creates FieldExpr witch field of this (r_param) table 
-        def f_expr field
-          @factory.field self, field
-        end
-        def key_ref key_field, key_value
-          @factory.key_ref self, key_field, key_value
-        end
+  end
+  
+  # Represent r_objects table
+  class RObject < Expr 
+    # Init Table accepts query and name of table
+    def initialize factory, name
+      @factory, @to_sql, @r_params = factory, name.to_s + '_', {}
+      @pk, @klass = @factory.field(self, 'object_pk'), @factory.field(self, 'object_class')
     end
     
-    # Represent r_objects table
-    class RObject < Expr 
-      # Init Table accepts query and name of table
-      def initialize factory, name
-        @factory, @to_sql, @r_params = factory, name.to_s + '_', {}
-        @pk, @klass = @factory.field(self, 'object_pk'), @factory.field(self, 'object_class')
-      end
-      
-      # Fiends access expressions
-      attr_reader :pk, :klass, :to_sql     
+    # Fiends access expressions
+    attr_reader :pk, :klass, :to_sql     
 
-      # Creates subclasses constraint
-      def derived klass
-        if klass.subclasses and not klass.subclasses.empty?
-          In self.klass, [klass].concat(klass.subclasses)
-        else
-          Eq self.klass, klass
-        end
-      end        
-      
-      # Tracks missing methods and creates accessor for params.
-      def method_missing name, *params
-        return super if params.size != 0
-        def_param name
-      end
-      
-      private
-        # Defines accessor for new param. (joins r_param to r_objects)
-        def def_param name
-          instance_eval "def #{name}() @r_params[:#{name}]; end"
-          @r_params[name] = @factory.r_param self, name.to_s
-        end
+    # Creates subclasses constraint
+    def derived klass
+      if klass.subclasses and not klass.subclasses.empty?
+        In self.klass, [klass].concat(klass.subclasses)
+      else
+        Eq self.klass, klass
+      end
+    end        
+    
+    # Tracks missing methods and creates accessor for params.
+    def method_missing name, *params
+      return super if params.size != 0
+      def_param name
     end
     
-    # Represents context in which query building executes
-    # Holds constraints tables and so on.
-    class Query < Expr
-      include Operations
-      
-      # Accepts query as string or as block and executes it.
-      def initialize factory, query = nil, &block 
-        @factory, @r_objects, @exprs, @order, @query  = factory, {}, [], [], query
-        @query = block if block_given?        
+    private
+      # Defines accessor for new param. (joins r_param to r_objects)
+      def def_param name
+        instance_eval "def #{name}() @r_params[:#{name}]; end"
+        @r_params[name] = @factory.r_param self, name.to_s
       end
-      
-      # Next section contains methods available during query construction.
-      # Declares objects for selection. The first argument will be result object.   
-      def Select main, *tables
-        for t in [main, *tables].flatten
-          @r_objects[t] = @factory.r_object t.to_s
-          instance_eval "def #{t}() @r_objects[:#{t}]; end"
+  end
+  
+  # Represents context in which query building executes
+  # Holds constraints tables and so on.
+  class Query < Expr
+    include Operations
+    
+    # Accepts query as string or as block and executes it.
+    def initialize factory, query = nil, &block 
+      @factory, @r_objects, @exprs, @order, @query  = factory, {}, [], [], query
+      @query = block if block_given?        
+    end
+    
+    # Next section contains methods available during query construction.
+    # Declares objects for selection. The first argument will be result object.   
+    def Select main, *tables
+      for t in [main, *tables].flatten
+        @r_objects[t] = @factory.r_object t.to_s
+        instance_eval "def #{t}() @r_objects[:#{t}]; end"
+      end
+      @main = @r_objects[main]
+    end
+    
+    # Declares +Where+ clause.
+    def Where *exprs
+      @exprs = exprs
+    end
+    
+    # Declares +Order By+ clause.
+    def OrderBy expr, *exprs
+      @order << expr
+      @order.concat exprs
+    end    
+    
+    # Returns markers used in query in valid order.
+    def markers
+      to_sql
+      @markers
+    end
+    
+    # Arranges map: values {marker=>value} to ordered array of values 
+    # accroding to markers in query. 
+    def params values
+      markers.inject([]){|r, m| r << values[m]}
+    end
+    
+    # Generates SQL for entire query.
+    def to_sql
+      return @sql if @sql
+      if @query.is_a? String
+        @sql, @markers = @factory.cache[@query]       
+        unless @sql
+          @sql, @markers = eval_query
+          @factory.cache[@query] = [@sql, @markers]
         end
-        @main = @r_objects[main]
+      else
+        @sql, @markers = eval_query
       end
-      
-      # Declares +Where+ clause.
-      def Where *exprs
-        @exprs = exprs
+      @sql
+    end
+
+    private
+      # Prints debug message
+      def log_debug_query sql
+        return unless Log.debug?
+        query = @query.is_a?(Proc) ? 'query given as block' : @query
+        Log.debug "Translate: <<#{query}>> to sql: <<#{sql}>>"
       end
       
-      # Declares +Order By+ clause.
-      def OrderBy expr, *exprs
-        @order << expr
-        @order.concat exprs
-      end    
-      
-      # Returns markers used in query in valid order.
-      def markers
-        to_sql
-        @markers
+      # Evaluates query withing the object context. Returns sql, and array of markers: [sql, [m1,m2,..]]
+      def eval_query
+        if @query.is_a? Proc
+          instance_eval(&@query)
+        else
+          instance_eval @query
+        end
+        sql = "select #{@main.to_sql}.* from #{tables_sql}"
+        sql+= "\n\twhere #{where_sql}"
+        sql+= "\n\torder by #{order_by_sql}" unless @order.empty?
+        log_debug_query sql
+        [sql, @exprs.inject([]){|result, expr| result.concat expr.markers}]
+      end
+
+      # Generates where clause for each expression joined by and clause
+      def where_sql        
+        r_params.collect{|rp| rp.to_sql + '.name = \'' + rp.p_name + '\''}.concat(
+          @exprs.collect{|ex| ex.to_sql}).join(" and\n\t\t")
       end
       
-      # Arranges map: values {marker=>value} to ordered array of values 
-      # accroding to markers in query. 
-      def params values
-        markers.inject([]){|r, m| r << values[m]}
+      # Generates order by sql clause
+      def order_by_sql
+        @order.collect{|ord| ord.to_sql}.join(', ')
       end
       
-      # Generates SQL for entire query.
-      def to_sql
-        return @sql if @sql
-        if @query.is_a? String
-          @sql, @markers = @factory.cache[@query]       
-          unless @sql
-            @sql, @markers = eval_query
-            @factory.cache[@query] = [@sql, @markers]
+      # Generates left outer join for each r_params used in query
+      def tables_sql
+        r_joins = {}
+        r_objects.each{|r_o| r_joins[r_o.to_sql] ||= []} # Collect all r_objects used in query
+        r_params.each{|r_p| r_joins[r_p.r_object.to_sql] << r_p.to_sql} #Join all r_params to r_objects          
+                  
+        result = nil
+        for obj, params in r_joins
+          result = result ? result << ",\n\t\t" : ''
+          result << 'r_objects ' + obj
+          for param in params
+            result << " left outer join r_params #{param} on (#{obj}.object_pk = #{param}.object_pk)"
           end
-        else
-          @sql, @markers = eval_query
         end
-        @sql
+        result
+      end      
+      
+      # Retruns r_params used in query. List of RParam.
+      def r_params
+        res = @exprs.inject([]) {|res, exp| res.concat exp.r_params}
+        @order.inject(res) {|res, ord| res.concat ord.r_params}
+        res.uniq!
+        res
+      end
+      
+      # Retruns r_objects used in query. List of RObject.
+      def r_objects
+        res = (@r_objects.values + r_params.inject([]){|res, rp| res << rp.r_object})
+        res.uniq!
+        res
       end
-  
-      private
-        # Prints debug message
-        def log_debug_query sql
-          return unless Log.debug?
-          query = @query.is_a?(Proc) ? 'query given as block' : @query
-          Log.debug "Translate: <<#{query}>> to sql: <<#{sql}>>"
-        end
-        
-        # Evaluates query withing the object context. Returns sql, and array of markers: [sql, [m1,m2,..]]
-        def eval_query
-          if @query.is_a? Proc
-            instance_eval(&@query)
-          else
-            instance_eval @query
-          end
-          sql = "select #{@main.to_sql}.* from #{tables_sql}"
-          sql+= "\n\twhere #{where_sql}"
-          sql+= "\n\torder by #{order_by_sql}" unless @order.empty?
-          log_debug_query sql
-          [sql, @exprs.inject([]){|result, expr| result.concat expr.markers}]
-        end
-
-        # Generates where clause for each expression joined by and clause
-        def where_sql        
-          r_params.collect{|rp| rp.to_sql + '.name = \'' + rp.name + '\''}.concat(
-            @exprs.collect{|ex| ex.to_sql}).join(" and\n\t\t")
-        end
-        
-        # Generates order by sql clause
-        def order_by_sql
-          @order.collect{|ord| ord.to_sql}.join(', ')
-        end
-        
-        # Generates left outer join for each r_params used in query
-        def tables_sql
-          r_joins = {}
-          r_objects.each{|r_o| r_joins[r_o.to_sql] ||= []} # Collect all r_objects used in query
-          r_params.each{|r_p| r_joins[r_p.r_object.to_sql] << r_p.to_sql} #Join all r_params to r_objects          
-                    
-          result = nil
-          for obj, params in r_joins
-            result = result ? result << ",\n\t\t" : ''
-            result << 'r_objects ' + obj
-            for param in params
-              result << " left outer join r_params #{param} on (#{obj}.object_pk = #{param}.object_pk)"
-            end
-          end
-          result
-        end      
-        
-        # Retruns r_params used in query. List of RParam.
-        def r_params
-          res = @exprs.inject([]) {|res, exp| res.concat exp.r_params}
-          @order.inject(res) {|res, ord| res.concat ord.r_params}
-          res.uniq!
-          res
-        end
-        
-        # Retruns r_objects used in query. List of RObject.
-        def r_objects
-          res = (@r_objects.values + r_params.inject([]){|res, rp| res << rp.r_object})
-          res.uniq!
-          res
-        end
-    end
   end
   @@generic_factory = Factory.new  
 end