momomoto 0.1.12 → 0.1.13

data/lib/momomoto/base.rb

@@ -90,14 +90,16 @@ module Momomoto
         case conditions
           when Array then
             conditions.each do | value |
-              where << compile_expression( value, operator )
+              expr = compile_expression( value, operator )
+              where << expr if expr.length > 0
             end
           when Hash then
             conditions.each do | key , value |
               key = key.to_sym if key.kind_of?( String )
               case key
-                when :OR then where << "(" + compile_expression( value, "OR" ) + ")"
-                when :AND then where << "(" + compile_expression( value, "AND" ) + ")"
+                when :OR,:AND then
+                  expr = compile_expression( value, key.to_s )
+                  where << "(#{expr})" if expr.length > 0
                 else
                   raise CriticalError, "condition key '#{key}' not a column in table '#{table_name}'" unless columns.keys.member?( key )
                   where << columns[key].compile_rule( key, value )

data/lib/momomoto/procedure.rb

@@ -55,18 +55,21 @@ module Momomoto
       end
 
       # get the parameters this procedure accepts
+      # returns an array of hashes with the fieldnames as key and the datatype as value
       def parameters( *p )
         return self.send( :parameters=, *p ) if not p.empty?
         initialize_procedure if not instance_variable_defined?( :@parameters )
         @parameters
       end
 
-      # get the columns of the resultset this procedure returns
+      # set the columns of the resultset this procedure returns
+      # expects a hash with the fieldnames as key and the datatype as value
       def columns=( columns )
         @columns = columns
       end
 
       # get the columns of the resultset this procedure returns
+      # returns a hash with the fieldnames as key and the datatype as value
       def columns( c = nil )
         return self.columns=( c ) if c
         initialize_procedure if not instance_variable_defined?( :@columns )

data/lib/momomoto/table.rb

@@ -32,34 +32,6 @@ module Momomoto
         @columns
       end
 
-      def initialize_table # :nodoc:
-
-        @table_name ||= construct_table_name( self.name )
-        @schema_name ||= construct_schema_name( self.name )
-
-        @columns ||= database.fetch_table_columns( table_name(), schema_name() ) 
-        raise CriticalError, "No fields in table #{table_name}" if columns.keys.empty?
-
-        @primary_keys ||= database.fetch_primary_keys( table_name(), schema_name() )
-        @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 )
-        @row_cache = {}
-
-        # mark class as initialized
-        self.initialized = true
-
-      end
-
-      # guesses the table name of the table this class works on
-      def construct_table_name( classname ) # :nodoc:
-        classname.split('::').last.downcase.gsub(/[^a-z_0-9]/, '')
-      end
-
       # set the table_name of the table this class operates on
       def table_name=( table_name )
         @table_name = table_name
@@ -77,7 +49,7 @@ module Momomoto
       end
 
       # set the primary key fields of the table
-      def primary_keys=( keys ) # :nodoc:
+      def primary_keys=( keys )
         @primary_keys = keys
       end
 
@@ -90,23 +62,6 @@ module Momomoto
         @primary_keys
       end
 
-      # 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
@@ -119,25 +74,6 @@ module Momomoto
         data
       end
 
-      def build_row_class( options )
-        if options[:columns]
-          options[:columns] += primary_keys
-          options[:columns].uniq!
-          if not @row_cache[options[:columns]]
-            row_class = Class.new( Momomoto::Row )
-            cols = {}
-            columns.each do | key, value |
-              cols[key] = value if options[:columns].member?( key )
-            end
-            initialize_row( row_class, self, cols )
-            @row_cache[options[:columns]] = row_class
-          end
-          return @row_cache[options[:columns]]
-        else
-          return const_get(:Row)
-        end
-      end
-
       # Searches for records and returns an array containing the records
       def select_outer_join( conditions = {}, options = {} )
         initialize_table unless initialized
@@ -169,11 +105,6 @@ module Momomoto
         result
       end
 
-      # 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
       def new( fields = {} )
         initialize_table unless initialized
@@ -225,8 +156,9 @@ 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 Momomoto::Nothing_found if nothing was found, raises
+      # Momomoto::Too_many_records if more than one record was found.
       def select_single( conditions = {}, options = {} )
         data = select( conditions, options )
         case data.length
@@ -237,6 +169,7 @@ module Momomoto
       end
 
       # write row back to database
+      # this function is called by Momomoto::Row#write
       def write( row ) # :nodoc:
         if row.new_record?
           insert( row )
@@ -249,7 +182,8 @@ module Momomoto
       end
 
       # create an insert statement for a row
-      def insert( row ) # :nodoc:
+      # do not call insert directly use row.write or Table.write( row ) instead
+      def insert( row )
         fields, values = [], []
         columns.each do | field_name, datatype |
           # check for set primary key fields or fetch respective default values
@@ -272,7 +206,8 @@ module Momomoto
       end
 
       # create an update statement for a row
-      def update( row ) # :nodoc:
+      # do not call update directly use row.write or Table.write( row ) instead
+      def update( row )
         raise CriticalError, 'Updating is only allowed for tables with primary keys' if primary_keys.empty?
         setter, conditions = [], {}
         row.class.columns.each do | field_name, data_type |
@@ -287,7 +222,8 @@ module Momomoto
         database.execute( sql )
       end
 
-      def delete( row ) # :nodoc:
+      # delete _row_ from the database
+      def delete( row )
         raise CriticalError, 'Deleting is only allowed for tables with primary keys' if primary_keys.empty?
         raise Error, "this is a new record" if row.new_record?
         conditions = {}
@@ -300,6 +236,78 @@ module Momomoto
         database.execute( sql )
       end
 
+      protected
+
+      # guesses the table name of the table this class works on
+      def construct_table_name( classname )
+        classname.split('::').last.downcase.gsub(/[^a-z_0-9]/, '')
+      end
+
+      # initialie a table class
+      def initialize_table
+
+        @table_name ||= construct_table_name( self.name )
+        @schema_name ||= construct_schema_name( self.name )
+
+        @columns ||= database.fetch_table_columns( table_name(), schema_name() )
+        raise CriticalError, "No fields in table #{table_name}" if columns.keys.empty?
+
+        @primary_keys ||= database.fetch_primary_keys( table_name(), schema_name() )
+        @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 )
+        @row_cache = {}
+
+        self.initialized = true
+
+      end
+
+      # builds the row class for this table
+      def build_row_class( options )
+        if options[:columns]
+          options[:columns] += primary_keys
+          options[:columns].uniq!
+          if not @row_cache[options[:columns]]
+            row_class = Class.new( Momomoto::Row )
+            cols = {}
+            columns.each do | key, value |
+              cols[key] = value if options[:columns].member?( key )
+            end
+            initialize_row( row_class, self, cols )
+            @row_cache[options[:columns]] = row_class
+          end
+          return @row_cache[options[:columns]]
+        else
+          return const_get(:Row)
+        end
+      end
+
+      # compile the select clause
+      def compile_select( conditions, options )
+        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
+
+      # returns the columns to be used for joining
+      def join_columns( join_table ) # :nodoc:
+        join_table.primary_keys.select{|f| columns.key?(f)}
+      end
+
     end
 
   end

data/lib/timeinterval.rb

@@ -1,6 +1,7 @@
 
 require 'date'
 
+# the class is used in Momomoto to represent the SQL interval datatype
 class TimeInterval
 
   include Comparable
@@ -17,10 +18,14 @@ class TimeInterval
 
   end
 
+  # compare two TimeInterval instances
+  # the comparison is done by calling to_i on other
   def <=>( other )
     self.to_i <=> other.to_i
   end
 
+  # formats timeinterval according to the directives in the give format
+  # string
   def strftime( fmt = "%H:%M:%S" )
     fmt.gsub( /%(.)/ ) do | match |
       case match[1,1]
@@ -33,14 +38,17 @@ class TimeInterval
     end
   end
 
+  # returns the value of timeinterval as number of seconds
   def to_i
     @hour * 3600 + @min * 60 + @sec
   end
 
   alias_method :to_int, :to_i
 
+  # Returns a string representing timeinterval. Equivalent to calling
+  # Time#strftime with a format string of '%H:%M:%S'.
   def to_s
-    strftime
+    strftime( '%H:%M:%S' )
   end
 
   def initialize( d = {} )

data/sql/procedures.sql

@@ -4,6 +4,7 @@ DECLARE
   proc RECORD;
   typ RECORD;
   att RECORD;
+  i INTEGER;
   col momomoto.procedure_column%rowtype;
 BEGIN
   SELECT INTO proc * FROM pg_proc WHERE proname = procedure_name;
@@ -11,15 +12,42 @@ BEGIN
     SELECT INTO typ * FROM pg_type WHERE oid = proc.prorettype;
 
     IF typ.typtype = 'b' THEN
-      col.column_name = procedure_name;
-      SELECT INTO col.data_type format_type( proc.prorettype, NULL::integer );
-      RETURN NEXT col;
+      -- base type
+      IF proc.proallargtypes IS NULL THEN
+        -- we only got IN arguments
+        col.column_name = procedure_name;
+        SELECT INTO col.data_type format_type( proc.prorettype, NULL::integer );
+        RETURN NEXT col;
+      ELSE
+        -- we got a named out arguments
+        FOR i IN array_lower(proc.proallargtypes, 1) .. array_upper(proc.proallargtypes, 1)
+        LOOP
+          CONTINUE WHEN proc.proargmodes[ i ] = 'i';
+          IF COALESCE( proc.proargnames[ i ], '' ) = '' THEN
+            col.column_name = procedure_name;
+          ELSE
+            col.column_name = proc.proargnames[ i ];
+          END IF;
+          col.data_type = format_type( proc.proallargtypes[ i ], NULL );
+          RETURN NEXT col;
+        END LOOP;
+      END IF;
     ELSIF typ.typtype = 'c' THEN
+      -- composite type
       FOR col IN
         SELECT attname AS column_name, format_type(atttypid, NULL) FROM pg_attribute WHERE attrelid = typ.typrelid AND attnum > 0 ORDER BY attnum
       LOOP
         RETURN NEXT col;
       END LOOP;
+    ELSIF typ.typtype = 'p' THEN
+      -- pseudo type
+      FOR i IN array_lower(proc.proallargtypes, 1) .. array_upper(proc.proallargtypes, 1)
+      LOOP
+        CONTINUE WHEN proc.proargmodes[ i ] = 'i';
+        col.column_name = proc.proargnames[ i ];
+        col.data_type = format_type( proc.proallargtypes[ i ], NULL );
+        RETURN NEXT col;
+      END LOOP;
     ELSE
       RAISE EXCEPTION 'Not yet implemented';
     END IF;
@@ -34,17 +62,17 @@ DECLARE
   typ RECORD;
   col momomoto.procedure_parameter%rowtype;
   i INTEGER;
-  j INTEGER;
-  k INTEGER;
 BEGIN
-  SELECT INTO proc proargnames, proallargtypes, proargtypes FROM pg_proc WHERE proname = procedure_name;
+  SELECT INTO proc proargnames, proargtypes, proargmodes, proargtypes FROM pg_proc WHERE proname = procedure_name;
   IF FOUND THEN
-    j = array_lower(proc.proargtypes, 1);
-    k = array_upper(proc.proargtypes, 1);
-    FOR i IN j .. k
+    FOR i IN array_lower(proc.proargtypes, 1) .. array_upper(proc.proargtypes, 1)
     LOOP
-      col.parameter_name = proc.proargnames[ i + array_lower( proc.proargnames, 1 )];
-      col.data_type = format_type( proc.proargtypes[i], NULL );
+      IF COALESCE( proc.proargnames[ i + array_lower( proc.proargnames, 1 ) ], '' ) = '' THEN
+        col.parameter_name = procedure_name;
+      ELSE
+        col.parameter_name = proc.proargnames[ i + array_lower( proc.proargnames, 1 )];
+      END IF;
+      col.data_type = format_type( proc.proargtypes[ i ], NULL );
       RETURN NEXT col;
     END LOOP;
   END IF;

data/test/test_base.rb

@@ -4,10 +4,10 @@ class TestBase < Test::Unit::TestCase
   def test_logical_operator
     t1 = Class.new( Momomoto::Table )
     t1.table_name = 'person'
-    t1.initialize_table
+    t1.send( :initialize_table )
     t2 = Class.new( Momomoto::Table )
     t2.table_name = 'person'
-    t2.initialize_table
+    t2.send( :initialize_table )
     assert_equal( "AND", t1.logical_operator )
     assert_equal( "AND", t2.logical_operator )
     t1.logical_operator = "OR"
@@ -25,7 +25,7 @@ class TestBase < Test::Unit::TestCase
   def test_compile_where
     t = Class.new( Momomoto::Table )
     t.table_name = 'person'
-    t.initialize_table
+    t.send( :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 )
@@ -34,10 +34,13 @@ class TestBase < Test::Unit::TestCase
     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 )
     assert_equal( " WHERE (person_id = '1')" , t.instance_eval do compile_where( :OR => { :person_id => '1' } ) end )
     assert_equal( " WHERE (person_id = '1')" , t.instance_eval do compile_where( :AND => { :person_id => '1' } ) end )
-    assert_equal( " WHERE (person_id = '1' OR first_name = E's')" , t.instance_eval do compile_where( :OR => { :person_id => '1',:first_name=>'s' } ) end )
-    assert_equal( " WHERE (person_id = '1' AND first_name = E's')" , t.instance_eval do compile_where( :AND => { :person_id => '1',:first_name=>'s' } ) end )
+    assert( [" WHERE (person_id = '1' OR first_name = E's')"," WHERE (first_name = E's' OR person_id = '1')"].member?( t.instance_eval do compile_where( :OR => { :person_id => '1',:first_name=>'s' } ) end ) )
+    assert( [" WHERE (person_id = '1' AND first_name = E's')"," WHERE (first_name = E's' AND person_id = '1')"].member?( t.instance_eval do compile_where( :AND => { :person_id => '1',:first_name=>'s' } ) end ) )
     assert_equal( " WHERE (person_id = '1' AND person_id = '2')" , t.instance_eval do compile_where( :AND =>[{:person_id=>1},{:person_id=>2}] ) end )
     assert_equal( " WHERE (person_id = '1' OR person_id = '2')" , t.instance_eval do compile_where( :OR =>[{:person_id=>1},{:person_id=>2}] ) end )
+    assert_equal( "" , t.instance_eval do compile_where( :OR =>[] ) end )
+    assert_equal( "" , t.instance_eval do compile_where( :OR =>[{}] ) end )
+    assert_equal( "" , t.instance_eval do compile_where( :AND =>[{},{}] ) end )
   end
 
 end

data/test/test_functions.sql

@@ -8,14 +8,12 @@ CREATE OR REPLACE FUNCTION test_parameter_sql_strict( param1 INTEGER ) RETURNS I
 $$ LANGUAGE sql STRICT;
 
 CREATE OR REPLACE FUNCTION test_parameter_plpgsql( param1 INTEGER, param2 TEXT ) RETURNS INTEGER AS $$
-  DECLARE
   BEGIN
     RETURN param1;
   END;
 $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE FUNCTION test_parameter_plpgsql_strict( param1 INTEGER, param2 TEXT ) RETURNS INTEGER AS $$
-  DECLARE
   BEGIN
     RETURN param1;
   END;
@@ -34,3 +32,38 @@ CREATE OR REPLACE FUNCTION test_set_returning( person_id INTEGER ) RETURNS SETOF
   END;
 $$ LANGUAGE plpgsql;
 
+CREATE OR REPLACE FUNCTION test_parameter_inout_sql( IN param1 INTEGER, OUT ret1 INTEGER ) AS $$
+  SELECT $1;
+$$ LANGUAGE sql;
+
+CREATE OR REPLACE FUNCTION test_parameter_inout_plpgsql( IN param1 INTEGER, IN param2 TEXT, OUT ret1 INTEGER ) AS $$
+  BEGIN
+    ret1 := param1;
+    RETURN;
+  END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION test_set_returning_inout( IN param1 INTEGER, OUT ret1 INTEGER, OUT ret2 TEXT ) RETURNS SETOF RECORD AS $$
+  BEGIN
+    ret1 := param1;
+    ret2 := 'chunky';
+    RETURN NEXT;
+    ret2 := 'bacon';
+    RETURN NEXT;
+    RETURN;
+  END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION test_parameter_inout_unnamed( IN INTEGER, OUT INTEGER ) AS $$
+  SELECT $1;
+$$ LANGUAGE sql;
+
+CREATE OR REPLACE FUNCTION test_parameter_inout_unnamed2( IN param1 INTEGER, OUT INTEGER ) AS $$
+  SELECT $1;
+$$ LANGUAGE sql;
+
+CREATE OR REPLACE FUNCTION test_parameter_inout_unnamed3( IN INTEGER, OUT ret1 INTEGER ) AS $$
+  SELECT $1;
+$$ LANGUAGE sql;
+
+

data/test/test_procedure.rb

@@ -85,7 +85,68 @@ class TestProcedure < Test::Unit::TestCase
     assert_raise( Momomoto::Error ) { b.call }
     assert_raise( Momomoto::Error ) { b.call({:param1=>nil})}
     assert_nothing_raised { b.call({:param1=>1})}
+  end
+
+  def test_inout_sql
+    a = Class.new(Momomoto::Procedure)
+    a.procedure_name("test_parameter_inout_sql")
+    assert_equal( 1, a.columns.keys.length )
+    assert_instance_of( Momomoto::Datatype::Integer, a.columns[:ret1] )
+    assert_equal( 1, a.parameters.length )
+    assert_instance_of( Momomoto::Datatype::Integer, a.parameters.first[:param1] )
+  end
+
+  def test_inout_plpgsql
+    a = Class.new(Momomoto::Procedure)
+    a.procedure_name("test_parameter_inout_plpgsql")
+    assert_equal( 1, a.columns.keys.length )
+    assert_instance_of( Momomoto::Datatype::Integer, a.columns[:ret1] )
+    assert_equal( 2, a.parameters.length )
+    assert_instance_of( Momomoto::Datatype::Integer, a.parameters[0][:param1] )
+    assert_instance_of( Momomoto::Datatype::Text, a.parameters[1][:param2] )
+  end
 
+  def test_set_returning_inout
+    a = Class.new(Momomoto::Procedure)
+    a.procedure_name("test_set_returning_inout")
+    assert_equal( 2, a.columns.keys.length )
+    assert_instance_of( Momomoto::Datatype::Integer, a.columns[:ret1] )
+    assert_instance_of( Momomoto::Datatype::Text, a.columns[:ret2] )
+    assert_equal( 1, a.parameters.length )
+    assert_instance_of( Momomoto::Datatype::Integer, a.parameters[0][:param1] )
+  end
+
+  def test_parameter_inout_unnamed
+    a = Class.new(Momomoto::Procedure)
+    a.procedure_name("test_parameter_inout_unnamed")
+    assert_equal( 1, a.columns.keys.length )
+    assert_equal( :test_parameter_inout_unnamed, a.columns.keys.first )
+    assert_instance_of( Momomoto::Datatype::Integer, a.columns[:test_parameter_inout_unnamed] )
+    assert_equal( 1, a.parameters.length )
+    assert_equal( :test_parameter_inout_unnamed, a.parameters.first.keys.first )
+    assert_instance_of( Momomoto::Datatype::Integer, a.parameters[0][:test_parameter_inout_unnamed] )
+  end
+
+  def test_parameter_inout_unnamed2
+    a = Class.new(Momomoto::Procedure)
+    a.procedure_name("test_parameter_inout_unnamed2")
+    assert_equal( 1, a.columns.keys.length )
+    assert_equal( :test_parameter_inout_unnamed2, a.columns.keys.first )
+    assert_instance_of( Momomoto::Datatype::Integer, a.columns[:test_parameter_inout_unnamed2] )
+    assert_equal( 1, a.parameters.length )
+    assert_equal( :param1, a.parameters.first.keys.first )
+    assert_instance_of( Momomoto::Datatype::Integer, a.parameters[0][:param1] )
+  end
+
+  def test_parameter_inout_unnamed3
+    a = Class.new(Momomoto::Procedure)
+    a.procedure_name("test_parameter_inout_unnamed3")
+    assert_equal( 1, a.columns.keys.length )
+    assert_equal( :ret1, a.columns.keys.first )
+    assert_instance_of( Momomoto::Datatype::Integer, a.columns[:ret1] )
+    assert_equal( 1, a.parameters.length )
+    assert_equal( :test_parameter_inout_unnamed3, a.parameters.first.keys.first )
+    assert_instance_of( Momomoto::Datatype::Integer, a.parameters[0][:test_parameter_inout_unnamed3] )
   end
 
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: momomoto
 version: !ruby/object:Gem::Version 
-  version: 0.1.12
-date: 2007-11-17 00:00:00 +01:00
+  version: 0.1.13
+date: 2007-11-22 00:00:00 +01:00
 summary: Momomoto is an object relational mapper for PostgreSQL.
 require_paths: 
 - lib