momomoto 0.1.2 → 0.1.3

data/lib/momomoto/base.rb

@@ -31,17 +31,20 @@ module Momomoto
   class Nothing_found < Error; end
 
 
-  ## Momomoto base class for Table, Procedure and Join
+  ## Momomoto base class for Table and Procedure
   class Base
 
     class << self
 
-      # guesses the schema name of the table this class works on
-      def construct_schema_name( classname ) # :nodoc:
-        # Uncomment these lines to derive the schema from the enclosing namespace of the class
-        #schema = classname.split('::')[-2]
-        #schema ? schema.downcase.gsub(/[^a-z_0-9]/, '') : nil
-        'public'
+      attr_reader :logical_operator
+
+      # set the default logical operator for constraints
+      def logical_operator=( value )
+        @logical_operator = case value
+          when /and/i then "AND"
+          when /or/i then "OR"
+          else raise Momomoto::Error, "Unsupported logical operator"
+        end
       end
 
       # set the schema name of the table this class operates on
@@ -58,13 +61,25 @@ module Momomoto
         @schema_name
       end
 
+      protected
+
+      attr_accessor :initialized
+
+      # guesses the schema name of the table this class works on
+      def construct_schema_name( classname )
+        # Uncomment these lines to derive the schema from the enclosing namespace of the class
+        #schema = classname.split('::')[-2]
+        #schema ? schema.downcase.gsub(/[^a-z_0-9]/, '') : nil
+        'public'
+      end
+
       # get the database connection
       def database # :nodoc:
         Momomoto::Database.instance
       end
 
       # compiles the where-clause of the query
-      def compile_where( conditions ) # :nodoc:
+      def compile_where( conditions )
         conditions = {} if not conditions
         where = ''
         conditions.each do | key , value |
@@ -90,7 +105,7 @@ module Momomoto
       end
 
       # compiles the sql statement defining the table order
-      def compile_order( order ) # :nodoc:
+      def compile_order( order )
         order = default_order if not order
         order = [ order ] if not order.kind_of?( Array )
         order = order.map do | field |
@@ -106,12 +121,12 @@ module Momomoto
       end
 
       # append where string
-      def where_append( where, append ) # :nodoc:
-        ( where.empty? ? ' WHERE ' : where + ' AND ' ) + append
+      def where_append( where, append )
+        ( where.empty? ? ' WHERE ' : where + ' ' + logical_operator + ' ' ) + append
       end
 
       # construct the Row class for the table
-      def initialize_row( row, table ) # :nodoc:
+      def initialize_row( row, table )
 
         const_set( :Methods, Module.new ) if not const_defined?( :Methods )
         const_set( :StandardMethods, Module.new ) if not const_defined?( :StandardMethods )
@@ -120,9 +135,9 @@ module Momomoto
           raise CriticalError, "Row is not inherited from Momomoto::Row"
         end
 
-        row.instance_eval do class_variable_set( :@@table, table ) end
+        row.instance_eval do instance_variable_set( :@table, table ) end
 
-        define_row_accessors( table )
+        define_row_accessors( const_get( :StandardMethods ), table )
 
         row.instance_eval do
           include table.const_get( :StandardMethods )
@@ -133,8 +148,7 @@ module Momomoto
 
       # defines row setter and getter in the module StandardMethods which
       # is later included in the Row class 
-      def define_row_accessors( table ) #:nodoc:
-        method_module = const_get( :StandardMethods )
+      def define_row_accessors( method_module, table, columns = self.columns )
         columns.each_with_index do | ( field_name, data_type ), index |
           method_module.instance_eval do
             # define getter for row class

data/lib/momomoto/procedure.rb

@@ -18,7 +18,7 @@ module Momomoto
         initialize_row( const_get( :Row ), self )
 
         # mark class as initialized
-        class_variable_set( :@@initialized, true)
+        self.initialized = true
 
       end
 
@@ -84,7 +84,7 @@ module Momomoto
 
       # execute the stored procedure
       def call( params = {}, conditions = {}, options = {} )
-        initialize_procedure unless class_variables.member?('@@initialized')
+        initialize_procedure unless initialized
         sql = "SELECT #{columns.keys.join(',')} FROM "
         sql += "#{full_name}(#{compile_parameter(params)})"
         sql += compile_where( conditions )

data/lib/momomoto/row.rb

@@ -7,15 +7,19 @@ module Momomoto
     undef :id,:type
 
     def self.table
-      class_variable_get( :@@table )
+      @table
     end
 
     def []( fieldname )
-      send( fieldname )
+      get_column( fieldname )
     end
 
     def []=( fieldname, value )
-      send( fieldname.to_s + '=', value )
+      set_column( fieldname, value )
+    end
+
+    def ==( other )
+      @data == other.instance_variable_get( :@data )
     end
 
     def dirty?
@@ -87,3 +91,4 @@ module Momomoto
   end
 
 end
+

data/lib/momomoto/table.rb

@@ -12,7 +12,7 @@ module Momomoto
         @default_order = order
       end
 
-      # get the columns of the table this class operates on
+      # get the default order for selects
       def default_order( order = nil )
         return self.default_order=( order ) if order
         @default_order
@@ -53,11 +53,13 @@ module Momomoto
         @column_order = @columns.keys
         @default_order ||= nil
 
+        @logical_operator ||= "AND"
+
         const_set( :Row, Class.new( Momomoto::Row ) ) if not const_defined?( :Row )
         initialize_row( const_get( :Row ), self )
 
         # mark class as initialized
-        class_variable_set( :@@initialized, true)
+        self.initialized = true
 
       end
 
@@ -96,25 +98,47 @@ module Momomoto
         @primary_keys
       end
 
-      ## Searches for records and returns an array containing the records
-      def select( conditions = {}, options = {} )
-        initialize_table unless class_variables.member?('@@initialized')
-        sql = "SELECT " + columns.keys.map{ | field | '"' + field.to_s + '"' }.join( "," ) + " FROM "
+      # compile the select clause
+      def compile_select( conditions, options ) # :nodoc:
+        if options[:columns] 
+          cols = {}
+          options[:columns].each do | name | cols[name] = columns[name] end
+        else
+          cols = columns
+        end
+        sql = "SELECT " + cols.keys.map{ | field | '"' + field.to_s + '"' }.join( "," ) + " FROM "
         sql += full_name
         sql += compile_where( conditions )
         sql += compile_order( options[:order] ) if options[:order] || default_order
         sql += compile_limit( options[:limit] ) if options[:limit]
         sql += compile_offset( options[:offset] ) if options[:offset]
+        sql
+      end
+
+      # Searches for records and returns an array containing the records
+      def select( conditions = {}, options = {} )
+        initialize_table unless initialized
+        if options[:columns]
+          row_class = Class.new( Momomoto::Row )
+          cols = {}
+          columns.each do | key, value |
+            cols[key] = value if options[:columns].member?( key )
+          end
+          define_row_accessors( row_class, self, cols )
+        else
+          row_class = const_get(:Row)
+        end
+        sql = compile_select( conditions, options )
         data = []
         database.execute( sql ).each do | row |
-          data << const_get(:Row).new( row )
+          data << row_class.new( row )
         end
         data
       end
 
-      ## Searches for records and returns an array containing the records
-      def select_with_join( conditions = {}, options = {} )
-        initialize_table unless class_variables.member?('@@initialized')
+      # Searches for records and returns an array containing the records
+      def select_outer_join( conditions = {}, options = {} )
+        initialize_table unless initialized
         join_table = options[:join]
         fields = columns.keys.map{|field| full_name+'."'+field.to_s+'"'}
         fields += join_table.columns.keys.map{|field| join_table.full_name+'."'+field.to_s+'"'}
@@ -126,24 +150,31 @@ module Momomoto
         sql += compile_order( options[:order] ) if options[:order]
         sql += compile_limit( options[:limit] ) if options[:limit]
         sql += compile_offset( options[:offset] ) if options[:offset]
-        data = []
+        data = {}
         database.execute( sql ).each do | row |
-          new_row = const_get(:Row).new( row[0, columns.keys.length] )
-          join_row = join_table.const_get(:Row).new( row[columns.keys.length,join_table.columns.keys.length] )
+          new_row = row[0, columns.keys.length]
+          data[new_row] ||= []
+          join_row = row[columns.keys.length,join_table.columns.keys.length]
+          data[new_row] << join_table.const_get(:Row).new( join_row ) if join_row.nitems > 0
+        end
+        result = []
+        data.each do | new_row, join_row |
+          new_row = const_get(:Row).new( new_row )
           new_row.instance_variable_set(:@join, join_row)
           new_row.send( :instance_eval ) { class << self; self; end }.send(:define_method, join_table.table_name ) do join_row end
-          data << new_row
+          result << new_row
         end
-        data
+        result
       end
 
-      def join_columns( join_table )
+      # returns the columns to be used for joining
+      def join_columns( join_table ) # :nodoc:
         join_table.primary_keys.select{|f| columns.key?(f)}
       end
 
-      ## constructor for a record in this table accepts a hash with presets for the fields of the record
+      # constructor for a record in this table accepts a hash with presets for the fields of the record
       def new( fields = {} )
-        initialize_table unless class_variables.member?('@@initialized')
+        initialize_table unless initialized
         new_row = const_get(:Row).new( [] )
         new_row.new_record = true
         # set default values
@@ -167,10 +198,10 @@ module Momomoto
         new_row
       end
 
-      ## Tries to find a specific record and creates a new one if it does not find it
-      #  raises an exception if multiple records are found
-      #  You can pass a block which has to deliver the respective values for the
-      #  primary key fields
+      # Tries to find a specific record and creates a new one if it does not find it.
+      # Raises an exception if multiple records are found.
+      # You can pass a block which has to deliver the respective values for the
+      # primary key fields
       def select_or_new( conditions = {}, options = {} )
         begin
           if block_given?
@@ -192,8 +223,8 @@ module Momomoto
         end
       end
 
-      ## Select a single row from the database, raises an exception if more or zero
-      #  rows are found
+      # Select a single row from the database, raises an exception if more or zero
+      # rows are found
       def select_single( conditions = {}, options = {} )
         data = select( conditions, options )
         case data.length
@@ -209,7 +240,7 @@ module Momomoto
         if row.new_record?
           insert( row )
         else
-#          return false unless row.dirty?
+          return false unless row.dirty?
           update( row )
         end
         row.dirty = false

data/test/test_base.rb

@@ -1,16 +1,34 @@
 
 class TestBase < Test::Unit::TestCase
 
+  def test_logical_operator
+    t1 = Class.new( Momomoto::Table )
+    t1.table_name = 'person'
+    t1.initialize_table
+    t2 = Class.new( Momomoto::Table )
+    t2.table_name = 'person'
+    t2.initialize_table
+    assert_equal( "AND", t1.logical_operator )
+    assert_equal( "AND", t2.logical_operator )
+    t1.logical_operator = "OR"
+    assert_equal( "OR", t1.logical_operator )
+    assert_equal( "AND", t2.logical_operator )
+    t1.logical_operator = "or"
+    assert_equal( "OR", t1.logical_operator )
+    assert_equal( " WHERE first_name = E'a' OR person_id = '1'" , t1.instance_eval do compile_where(:person_id=>'1',:first_name=>'a') end )
+    assert_equal( " WHERE first_name = E'a' AND person_id = '1'" , t2.instance_eval do compile_where(:person_id=>'1',:first_name=>'a') end )
+  end
+
   def test_compile_where
     t = Class.new( Momomoto::Table )
     t.table_name = 'person'
-    t.columns
-    assert_equal( " WHERE person_id = '1'" , t.compile_where( :person_id => '1' ) )
-    assert_equal( " WHERE person_id IN ('1')" , t.compile_where( :person_id => ['1'] ) )
-    assert_equal( " WHERE person_id IN ('1','2')" , t.compile_where( :person_id => ['1',2] ) )
-    assert_equal( " WHERE first_name = E'1'" , t.compile_where( :first_name => '1' ) )
-    assert_equal( " WHERE first_name = E'chu''nky'" , t.compile_where( :first_name => "chu'nky" ) )
-    assert_equal( " WHERE first_name IN (E'chu''nky',E'bac''n')" , t.compile_where( :first_name => ["chu'nky","bac'n"] ) )
+    t.initialize_table
+      assert_equal( " WHERE person_id = '1'" , t.instance_eval do compile_where( :person_id => '1' ) end )
+      assert_equal( " WHERE person_id IN ('1')" , t.instance_eval do compile_where( :person_id => ['1'] ) end )
+      assert_equal( " WHERE person_id IN ('1','2')" , t.instance_eval do compile_where( :person_id => ['1',2] ) end )
+      assert_equal( " WHERE first_name = E'1'" , t.instance_eval do compile_where( :first_name => '1' ) end )
+      assert_equal( " WHERE first_name = E'chu''nky'" , t.instance_eval do compile_where( :first_name => "chu'nky" ) end )
+      assert_equal( " WHERE first_name IN (E'chu''nky',E'bac''n')" , t.instance_eval do compile_where( :first_name => ["chu'nky","bac'n"] ) end )
   end
 
 end

data/test/test_table.rb

@@ -131,6 +131,15 @@ class TestTable < Test::Unit::TestCase
     end
   end
 
+  def test_select_columns
+    p = Person.select({},{:columns=>[:person_id,:first_name],:limit=>1})[0]
+    assert( p.respond_to?( :person_id ))
+    assert( p.respond_to?( :first_name ))
+    assert_raise( NoMethodError ) do
+      p.nick_name
+    end
+  end
+
   def test_select
     r = Person.select( nil, {:limit => 3})
     assert_equal( 3, r.length )

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: momomoto
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
-date: 2007-08-13 00:00:00 +02:00
+  version: 0.1.3
+date: 2007-08-17 00:00:00 +02:00
 summary: Momomoto is an object relational mapper for PostgreSQL.
 require_paths: 
 - lib