Rubernate 0.1.0

data/lib/rubernate/queries.rb

@@ -0,0 +1,444 @@
+# Contains users methods for building queries
+module Rubernate
+module Queries
+  # Log instance for Queries
+  Log = Log4r::Logger.new self.name
+
+  # Re-Expr express prefix that starts all queries on RQL.
+  RQL_PREFIX_REGEXP = /^\s*Select\s+:/
+  
+  # Contains operations definitions
+  module Operations
+    # Declares +And+ sql clause.
+    def And expr1, expr2
+      @factory.bin_op expr1, expr2, 'and'
+    end
+    
+    # Declares +Or+ sql clause.
+    def Or expr1, expr2
+      @factory.bin_op expr1, expr2, 'or', true
+    end
+    
+    # Declares +=+ sql clause.
+    def Eq expr1, expr2
+      @factory.bin_op expr1, expr2, '='
+    end
+    
+    # Declares +Not+ sql clause.
+    def Not expr
+      @factory.un_op expr, 'not', true      
+    end
+    
+    # Declares +is null+ sql clause
+    def IsNil expr
+      @factory.bin_op expr, @factory.expr(nil), 'is'
+    end
+    
+    # Declares +is not null+ sql clause    
+    def IsNotNil expr
+      @factory.bin_op expr, @factory.expr(nil), 'is not'
+    end 
+    
+    # Declares +in+ sql clause
+    def In expr, list
+      @factory.bin_op expr, @factory.list(list), 'in'
+    end
+  end
+
+  # Factory method, creates queries based on Generic factory. 
+  def self.query q_text=nil, &q_block
+    if block_given?
+      @@generic_factory.query(&q_block)
+    else
+      @@generic_factory.query q_text
+    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.
+  # Following example changes implementation of BinOpConst
+  #
+  # :call-seq:
+  #   f = Factory.new
+  #   f.bin_op = MyBinOpImpl
+  #   f.bin_op expr1, expr2, '='  -> instance of MyBinOpImpl properly initialized
+  # 
+  # New implementations of elements MUST accept factory as it's first parameter.
+  class Factory
+    # 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
+    end
+    def query query=nil, &block
+      @query.new self, query, &block
+    end
+    private
+      # Defines factory method that will instantiate element instance 
+      # and pass +self+ as element factory.
+      def self.def_factory name
+        module_eval %{
+          attr_writer :#{name}
+          def #{name} *params
+            @#{name}.new self, *params
+          end
+        }
+      end
+      # The following factory methdos are available.
+      for p in %w{expr un_op bin_op field key_ref list r_param r_object}
+        def_factory p
+      end
+  end
+
+  # Contains classes for standart ANSY SQL.
+  module Generic
+    # 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  
+    
+    # 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
+      end
+      
+      def markers
+        @expr.markers
+      end
+      
+      def to_sql
+        if @braces
+          "#{@op} (#{@expr.to_sql})"
+        else
+          "#{@op} #{@expr.to_sql}"
+        end
+      end
+    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  
+    
+    # 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, :name
+      
+      # Init Param accepts table and name of param
+      def initialize factory, r_object, name
+        @factory, @r_object, @name, @r_params = factory, r_object, name, [self]
+      end
+      
+      # Returns full param table name with object tables prefix 
+      def to_sql
+        @r_object.to_sql + @name
+      end
+      
+      # Fields accessors.
+      def pk   () f_expr 'object_pk'; end
+      def int  () f_expr 'int_value'; end
+      def str  () f_expr 'str_value'; end
+      def time () f_expr 'dat_value'; end
+      def date () f_expr 'dat_value'; end # TODO: make proper convertation
+      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
+      
+      # 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
+      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
+      
+      # 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
+    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
+        @exprs.inject([]){|result, expr| result.concat expr.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
+        eval_query 
+        sql = "select #{@main.to_sql}.* from #{tables_sql}"
+        sql+= "\n\twhere #{where_sql}"
+        sql+= "\n\torder by #{order_by_sql}" unless @order.empty?
+        dbg_query sql
+        sql
+      end
+  
+      private
+        # Prints debug message
+        def dbg_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.
+        def eval_query
+          return if @evaluated
+          if @query.is_a? Proc
+            instance_eval(&@query)
+          else
+            instance_eval @query
+          end
+          @evaluated = true
+        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_objects.collect{|r_object| 'r_objects ' + r_object.to_sql}.join(', ') + 
+            r_params.collect{|r_param| 
+                  "\n\tleft outer join r_params " + r_param.to_sql + 
+                  ' on (' + r_param.r_object.to_sql + '.object_pk = ' + r_param.to_sql + '.object_pk)'
+          }.join()
+        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
+end

data/lib/rubernate/runtime.rb

@@ -0,0 +1,215 @@
+module Rubernate
+  # Base class for all "Runtime+ implementations.
+  # Most of these methods should be overriden by subclasses.
+  class Runtime
+    include Callbacks::Runtime
+
+    # Log for Runtime events
+    Log = Log4r::Logger.new self.name
+
+    def initialize
+      @pool = {} # Contains objects loaded during the session
+      @factory = Queries::Factory.new
+    end
+    
+    # Finds object by primary key,
+    #    raises ObjectNotFoundException if object is not found
+    def find_by_pk pk, load = false
+      result = @pool[pk]
+      unless result
+        result = load_by_pk pk
+        unless result
+          Log.debug {"Find by pk: #{pk} - NOT found"}
+          raise ObjectNotFoundException.new(pk) unless result
+        end
+        @pool[pk] = result
+      end
+      load_by_pk pk if load
+      Log.debug {"Find by pk: #{pk} - found"}
+      result
+    end
+    
+    # Finds objects by query. Returns ordered list of objects.
+    # If +params+ if Array the query will be treated as native sql
+    #   and won't be processed.
+    def find_by_query query, params={} #TODO: improve working with paramters
+      flush_modified
+      params = case params
+        when Hash: params
+        when Array: params
+        else [params]
+      end
+      if query =~ Queries::RQL_PREFIX_REGEXP
+        objs = load_by_query(*native_sql(query, params))
+      else
+        objs = load_by_query query, params.collect{|p| native_param p}
+      end
+      Log.debug {"Find by query: <<#{query}>>, params: <<#{params}>>,- #{objs.size} objects found,"}
+      objs
+      rescue Exception => e
+        Log.error "Find by query: <<#{query}>>, params: <<#{params}>>, failed: #{e}"
+        raise
+    end
+    
+    # Attaches object to session. Causes error if object with equal
+    # primary key already loaded in session.
+    def attach object
+      raise "Can't attach object: #{object.primary_key}" if @pool.has_key? object.primary_key
+      object.peer = Peer.new unless object.peer
+      create object
+      @pool[object.primary_key] = object
+      Log.debug {"Attach #{object.class.name}: #{object.primary_key} to session"}
+      object.on_create
+    end
+    
+    # Removes object 
+    def remove object
+      object.on_remove
+      @pool.delete object.primary_key 
+      Log.debug {"Remove object: #{object.primary_key}"}
+      delete object
+      def object.primary_key
+        raise "object #{@primary_key} has already been deleted"
+      end
+      rescue Exception => ex
+        Log.error "Object remove fails due to error #{ex}"
+        raise
+    end
+
+    # Begins session
+    def begin
+      Log.debug {"Begin session #{self}"}
+      on_begin      
+    end
+    
+    # Persist all changes and Commit transction.
+    def commit
+      before_commit # callback 
+      flush_modified
+      close
+      after_commit # callback
+      Log.debug {"Commit session  #{self}"}
+      rescue Exception => ex 
+        rollback ex
+        raise
+    end
+    
+    # Discard all changes and Rollback transaction.
+    def rollback ex='not specified'
+      on_rollback # callback
+      Log.warn {"Rollback session #{self} due to error: #{ex}"}
+      failed
+      rescue Exception => e
+        Log.error "Rolling back session: #{self} failed: #{e}"
+        raise
+    end
+
+    # Flushes modified objects. Invokes on_store callback before storing.
+    def flush_modified      
+      objects = modified
+      before_flush modified # callback
+      return if objects.empty?
+      Log.debug {"Flush #{objects.size} modified objects"}
+      objects.each {|object| object.on_save}
+      save objects
+      after_flush # callback
+    end
+
+    private     
+      # Creates new object instance or returns pooled one
+      def instantiate pk, klass, peer = nil
+        object = @pool[pk]
+        if object and object.class != klass
+          raise "invalid class #{klass} of object pk: #{pk}: #{object.class}"
+        end
+        unless object
+          object, object.primary_key = klass.allocate, pk
+          @pool[pk] = object
+        end
+        object.peer = peer
+        object
+      end
+          
+      # Returns modified objects.
+      def modified
+        @pool.values.find_all {|object| object.peer and object.dirty?}
+      end
+      
+      # Callback functions invoked when session successfully closed
+      # Should be overriden by subclasses to perform implement closing logic
+      def close
+      end
+      
+      # Callback functions invoked when session fails
+      # Should be overriden by subclasses to cleanup resources
+      def failed
+      end
+      
+      # The following methods must be overriden by subclasses.
+      # Loads object by primary key
+      def load_by_pk pk
+        raise "method MUST be overiden in subclass"
+      end
+      
+      # Loads objects by query
+      def load_by_query query, params=[]
+        raise "method MUST be overiden in subclass"
+      end
+      
+      # Saves object or object if parameter is array
+      def save object
+        raise "method MUST be overiden in subclass"
+      end
+      
+      # Creates object. Paramter can be class of object.
+      # Implementation should sets dirty flag to +true+ or +false+.
+      # Returns primary_key.
+      def create object
+        raise "method MUST be overiden in subclass"
+      end
+      
+      # Deletes object
+      def delete object
+        raise "method MUST be overiden in subclass"
+      end
+
+      def post_load object
+        for value in object.peer.values
+          value.compact! if value.is_a? Array
+        end      
+        object.peer.dirty = false
+        object.on_load
+      end
+      
+      def native_sql query, params
+        query = @factory.query(query)
+        [query.to_sql, query.params(params).map!{|p| native_param p}]
+      end
+      
+      def native_param p
+        case p
+          when Rubernate::Entity: p.primary_key
+          when Class: p.name
+          else p
+        end
+      end
+      
+      # TODO: continue from here!!!
+      class FakeEntity
+        persistent
+        def method_not_defined
+          raise 'object #{primary_key} has undefined class'
+        end
+      end
+       
+      @@classes = {}
+      # Returns class with specified name or throw error if there is on one.
+      def class_by_name name
+        klass = @@classes[name]
+        return klass if klass
+        klass =  Module.find_class name
+        @@classes[name] = klass if klass
+        klass
+      end
+  end
+end