momomoto 0.1.14 → 0.1.15

data/Rakefile

@@ -35,12 +35,12 @@ end
 
 desc "create documentation for ri"
 task :doc do
-  sh "rdoc -r lib"
+  sh "rdoc -r lib -A momomoto_attribute=rw,momomoto_attribute_reader=r"
 end
 
 desc "create html documentation"
 task :html do
-  sh "rdoc --template jamis --main Momomoto::Table --inline-source --force-update --webcvs 'http://trac.c3d2.de/momomoto/browser/trunk/%s' lib"
+  sh "rdoc -A momomoto_attribute=rw,momomoto_attribute_reader=r --template jamis --main Momomoto::Table --inline-source --force-update --webcvs 'http://trac.c3d2.de/momomoto/browser/trunk/%s' lib"
 end
 
 desc "update html documentation on momomoto.rubyforge.org"

data/lib/momomoto/base.rb

@@ -2,6 +2,8 @@
 ## Momomoto is a database abstraction layer for PostgreSQL
 module Momomoto
 
+  @debug = false
+
   class << self
 
     # Getter and setter for debugging.
@@ -76,9 +78,60 @@ module Momomoto
 
     class << self
 
-      # Getter for logical operator. This is used in #compile_where.
-      # See Table#select for usage of logical operators.
-      attr_reader :logical_operator
+      def momomoto_attribute_reader( name )
+        singleton = self.instance_eval{class << self; self; end}
+        varname = "@#{name}"
+        # define getter method
+        singleton.send(:define_method, name) do | *values |
+          if not instance_variable_defined?( varname )
+            initialize
+          end
+          instance_variable_get( varname )
+        end
+      end
+
+      def momomoto_attribute( name )
+        singleton = self.instance_eval{class << self; self; end}
+        varname = "@#{name}"
+        settername = "#{name}="
+        # define getter method
+        singleton.send(:define_method, name) do | *values |
+          if values[0]
+            send( settername, values[0] )
+          else
+            if not instance_variable_defined?( varname )
+              initialize
+            end
+            instance_variable_get( varname )
+          end
+        end
+        # define setter method
+        singleton.send(:define_method, settername) do | value |
+          instance_variable_set( varname, value )
+        end
+      end
+
+      def initialize
+        return if initialized
+
+        @schema_name ||= construct_schema_name( self.name )
+        @logical_operator ||= 'AND'
+
+        self.initialized = true
+      end
+
+    end
+
+    # The schema name of the table this class operates on. Invokes
+    # #schema_name= if +schema_name+ is given as parameter. Returns
+    # +@schema_name+
+    momomoto_attribute :schema_name
+
+    # The logical operator is used in #compile_where and defines
+    # the top level logical relation for where clauses.
+    momomoto_attribute_reader :logical_operator
+
+    class << self
 
       # Set the default logical operator for constraints. AND and OR are
       # supported.
@@ -91,23 +144,7 @@ module Momomoto
         end
       end
 
-      # Set the schema name of the table this class operates on.
-      def schema_name=( schema_name )
-        @schema_name = schema_name
-      end
-
-      # Get the schema name of the table this class operates on. Invokes
-      # #schema_name= if +schema_name+ is given as parameter. Returns 
-      # +@schema_name+
-      def schema_name( schema_name  = nil )
-        return self.schema_name=( schema_name ) if schema_name
-        if not instance_variable_defined?( :@schema_name )
-          self.schema_name=( construct_schema_name( self.name ) )
-        end
-        @schema_name
-      end
-
-      protected
+     protected
 
       # Getter and setter used for marking tables as initialized.
       attr_accessor :initialized

data/lib/momomoto/database.rb

@@ -1,12 +1,5 @@
 
-begin
-  require 'rubygems'
-  gem 'ruby-postgres', '>= 0.7.1.2006.04.06'
-  require 'postgres'
-rescue LoadError
-  require 'postgres'
-end
-
+require 'postgres'
 require 'singleton'
 
 require 'momomoto/information_schema/columns'
@@ -140,6 +133,8 @@ module Momomoto
         end
       end
       p
+     rescue => e
+      raise Error, "Fetching procedure parameters for #{procedure_name} failed: #{e}"
     end
 
     # fetches the result set columns of a stored procedure

data/lib/momomoto/datatype/array.rb

@@ -0,0 +1,78 @@
+module Momomoto
+  module Datatype
+
+    # Represents the data type Array.
+    class Array < Base
+
+      # Escapes +input+ to be saved in database.
+      # Returns 'NULL' if +input+ is nil or empty. Otherwise escapes
+      # using Database#escape_string
+      def escape( input )
+        if input.nil?
+          "NULL"
+        elsif input.instance_of?( ::Array )
+          "ARRAY[" + input.map{|m| "'" + Database.escape_string(m) + "'"}.join(',') + "]"
+        else
+          "'" + Database.escape_string(m) + "'"
+        end
+      end
+
+      # Values are filtered by this function when being set. See the
+      # method in the appropriate derived data type class for allowed
+      # values.
+      def filter_get( value ) # :nodoc:
+        case value
+          when ::Array then value
+          when nil,"" then nil
+          when "{}" then []
+          when /^\{[^"]+(,[^"]+)*\}$/
+            m = v.match(/^\{()\}$/)
+            m[1].split(',')
+          when /^\{"[^"]+"(,"[^"]+")*\}$/
+            m = v.match(/^\{()\}$/)
+            m[1].split(',').map{|e| e.gsub(/^"(.*)"$/, "\\1")}
+          else
+            raise Error, "Error parsing array value"
+        end
+
+      end
+
+      # Values are filtered by this function when being set. See the
+      # method in the appropriate derived data type class for allowed
+      # values.
+      def filter_set( value ) # :nodoc:
+        value = [value] unless value.instance_of?( ::Array )
+        value
+      end
+
+      # Get the default value for this Datatype.
+      def default_operator
+        "@>"
+      end
+
+      # This method is used when compiling the where clause. No need
+      # for direct use.
+      def compile_rule( field_name, value ) # :nodoc:
+        case value
+          when ::Array then
+            raise Error, "empty or nil array conditions are not allowed for #{field_name}" if value.empty? or value.member?( nil )
+            field_name.to_s + ' @> ' + escape(filter_set(value))
+          else
+            super
+        end
+      end
+
+      # Additional operators for instances of Array.
+      # See Base#operator_sign
+      def self.operator_sign( op )
+        case op
+          when :contains then '@>'
+          when :contained then '<@'
+          else
+            super( op )
+        end
+      end
+
+    end
+  end
+end

data/lib/momomoto/datatype/base.rb

@@ -20,6 +20,11 @@ module Momomoto
         @default
       end
 
+      # Get the default value for this Datatype.
+      def default_operator
+        "="
+      end
+
       # Returns true if this column can be NULL otherwise false.
       def not_null?
         @not_null
@@ -64,7 +69,7 @@ module Momomoto
             field_name.to_s + ' IS NULL'
           when :NOT_NULL then
             field_name.to_s + ' IS NOT NULL'
-          when Array then
+          when ::Array then
             raise Error, "empty array conditions are not allowed for #{field_name}" if value.empty?
             raise Error, "nil values not allowed in compile_rule for #{field_name}" if value.member?( nil )
             field_name.to_s + ' IN (' + value.map{ | v | escape(filter_set(v)) }.join(',') + ')'
@@ -73,7 +78,7 @@ module Momomoto
             rules = []
             value.each do | op, v |
               raise Error, "nil values not allowed in compile_rule for #{field_name}" if v == nil
-              v = [v] if not v.kind_of?( Array )
+              v = [v] if not v.kind_of?( ::Array )
               if op == :eq # use IN if comparing for equality
                 rules << compile_rule( field_name, v )
               else
@@ -84,7 +89,7 @@ module Momomoto
             end
             rules.join( " AND " )
           else
-            field_name.to_s + ' = ' + escape(filter_set(value))
+            field_name.to_s + " #{default_operator} " + escape(filter_set(value))
         end
       end
 

data/lib/momomoto/datatype.rb

@@ -1,5 +1,6 @@
 
 require 'momomoto/datatype/base'
+require 'momomoto/datatype/array'
 require 'momomoto/datatype/boolean'
 require 'momomoto/datatype/integer'
 require 'momomoto/datatype/smallint'

data/lib/momomoto/procedure.rb

@@ -5,22 +5,26 @@ module Momomoto
   # It must not be used directly but you should inherit from this class.
   class Procedure < Base
 
+    # the procedure name of this class
+    momomoto_attribute :procedure_name
+
+    # the columns of the result set this procedure returns
+    # a hash with the field names as keys and the datatype as values
+    momomoto_attribute :columns
+
     class << self
 
-      def initialize_procedure # :nodoc:
+      def initialize # :nodoc:
+        return if initialized
+        super
 
         @procedure_name ||= construct_procedure_name( self.name )
-        @schema_name ||= construct_schema_name( self.name )
         @parameters ||= database.fetch_procedure_parameters( procedure_name )
         @columns ||= database.fetch_procedure_columns( procedure_name )
-        @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
-        self.initialized = true
-
       end
 
       # guesses the procedure name of the procedure this class works on
@@ -28,20 +32,6 @@ module Momomoto
         classname.split('::').last.downcase.gsub(/[^a-z_0-9]/, '')
       end
 
-      # sets the procedure name
-      def procedure_name=( procedure_name )
-        @procedure_name = procedure_name
-      end
-
-      # gets the procedure name
-      def procedure_name( procedure_name = nil )
-        return self.procedure_name=( procedure_name ) if procedure_name
-        if not instance_variable_defined?( :@procedure_name )
-          self.procedure_name = construct_procedure_name( self.name )
-        end
-        @procedure_name
-      end
-
       # gets the full name of the procedure including schema if set
       def full_name # :nodoc:
         "#{ schema_name ? schema_name + '.' : ''}#{procedure_name}"
@@ -58,24 +48,10 @@ module Momomoto
       # returns an array of hashes with the field names as keys and the datatype as values
       def parameters( *p )
         return self.send( :parameters=, *p ) if not p.empty?
-        initialize_procedure if not instance_variable_defined?( :@parameters )
+        initialize if not instance_variable_defined?( :@parameters )
         @parameters
       end
 
-      # sets the columns of the result set this procedure returns
-      # expects a hash with the field names as keys and the datatype as values
-      def columns=( columns )
-        @columns = columns
-      end
-
-      # gets the columns of the result set this procedure returns
-      # returns a hash with the field names as keys and the datatype as values
-      def columns( c = nil )
-        return self.columns=( c ) if c
-        initialize_procedure if not instance_variable_defined?( :@columns )
-        @columns
-      end
-
       def compile_parameter( params ) # :nodoc:
         args = []
         parameters.each do | parameter |
@@ -89,7 +65,6 @@ module Momomoto
 
       # executes the stored procedure
       def call( params = {}, conditions = {}, options = {} )
-        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

@@ -4,9 +4,6 @@ module Momomoto
   # Base class for all Rows.
   class Row
 
-    # undefining fields to avoid conflicts
-    undef :id,:type
-
     # Getter for the table this Row is using.
     def self.table
       @table

data/lib/momomoto/table.rb

@@ -5,63 +5,25 @@ module Momomoto
   # It must not be used directly but you should inherit from this class.
   class Table < Base
 
-    class << self
-
-      # set the default order for selects
-      def default_order=( order )
-        @default_order = order
-      end
-
-      # get the default order for selects
-      def default_order( order = nil )
-        return self.default_order=( order ) if order
-        @default_order
-      end
+    # controls the default order for selects
+    momomoto_attribute :default_order
 
-      # set the columns of the table this class operates on
-      def columns=( columns )
-        @columns = columns
-      end
+    # the columns of this table
+    momomoto_attribute :columns
 
-      # get the columns of the table this class operates on
-      def columns( columns = nil )
-        return self.columns=( columns ) if columns
-        if not instance_variable_defined?( :@columns )
-          initialize_table
-        end
-        @columns
-      end
+    # the table name of this table
+    momomoto_attribute :table_name
 
-      # set the table_name of the table this class operates on
-      def table_name=( table_name )
-        @table_name = table_name
-      end
+    # array containing the primary key fields of the table
+    momomoto_attribute :primary_keys
 
-      # get the table_name of the table this class operates on
-      def table_name( table_name = nil )
-        return self.table_name=( table_name ) if table_name
-        @table_name
-      end
+    class << self
 
       # get the full name of table including, if set, schema
       def full_name
         "#{ schema_name ? schema_name + '.' : ''}#{table_name}"
       end
 
-      # set the primary key fields of the table
-      def primary_keys=( keys )
-        @primary_keys = keys
-      end
-
-      # get the primary key fields of the table
-      def primary_keys( keys = nil )
-        return self.primary_keys=( keys ) if keys
-        if not instance_variable_defined?( :@primary_keys )
-          initialize_table
-        end
-        @primary_keys
-      end
-
       # Searches for records and returns an Array containing the records.
       # There are a bunch of different use cases as this method is the primary way
       # to access all rows in the database.
@@ -121,7 +83,7 @@ module Momomoto
       #   posts.first.title = "new title"
       #   posts.first.write
       def select( conditions = {}, options = {} )
-        initialize_table unless initialized
+        initialize unless initialized
         row_class = build_row_class( options )
         sql = compile_select( conditions, options )
         data = []
@@ -135,7 +97,7 @@ module Momomoto
       #
       # Searches for records and returns an array containing the records
       def select_outer_join( conditions = {}, options = {} )
-        initialize_table unless initialized
+        initialize 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+'"'}
@@ -166,7 +128,7 @@ module Momomoto
 
       # 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
+        initialize unless initialized
         new_row = const_get(:Row).new( [] )
         new_row.new_record = true
         # set default values
@@ -320,10 +282,11 @@ module Momomoto
       end
 
       # initializes a table class
-      def initialize_table
+      def initialize
+        return if initialized
+        super
 
         @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?
@@ -332,14 +295,10 @@ 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 )
         @row_cache = {}
 
-        self.initialized = true
-
       end
 
       # Builds the row class for this table when executing #select.
@@ -386,6 +345,10 @@ module Momomoto
         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]
+        if options[:distinct]
+          raise CriticalError, "condition key '#{options[:distinct]}' not a column in table '#{table_name}'" unless columns.keys.member?( options[:distinct])
+          sql = "SELECT DISTINCT ON(\"#{options[:distinct]}\") " + cols.keys.map{ | field | '"' + field.to_s + '"' }.join( "," ) + " FROM (#{sql}) AS t1" 
+        end
         sql
       end
 

data/test/test.sql

@@ -64,5 +64,7 @@ CREATE TABLE test_time_with_time_zone( id SERIAL, data TIME WITH TIME ZONE, PRIM
 CREATE TABLE test_time_without_time_zone( id SERIAL, data TIME WITHOUT TIME ZONE, PRIMARY KEY(id));
 CREATE TABLE test_timestamp_with_time_zone( id SERIAL, data TIMESTAMP WITH TIME ZONE, PRIMARY KEY(id));
 CREATE TABLE test_timestamp_without_time_zone( id SERIAL, data TIMESTAMP WITHOUT TIME ZONE, PRIMARY KEY(id));
+CREATE TABLE test_int_array( id SERIAL, data int[], PRIMARY KEY(id) );
+CREATE TABLE test_text_array( id SERIAL, data text[], PRIMARY KEY(id) );
 
 

data/test/test_array.rb

@@ -0,0 +1,18 @@
+
+class TestArray < Test::Unit::TestCase
+
+  def test_samples
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_int_array'
+    [["1","2","3"],nil].each do | value |
+      r = c.new( :data => value )
+      assert_equal( value, r.data )
+      r.write
+      r2 = c.select(:id=>r.id).first
+      assert_equal( value, r2.data )
+      r.delete
+    end
+  end
+
+end
+

data/test/test_base.rb

@@ -4,10 +4,11 @@ class TestBase < Test::Unit::TestCase
   def test_logical_operator
     t1 = Class.new( Momomoto::Table )
     t1.table_name = 'person'
-    t1.send( :initialize_table )
+    assert_equal( t1.logical_operator, 'AND' )
+    t1.send( :initialize )
     t2 = Class.new( Momomoto::Table )
     t2.table_name = 'person'
-    t2.send( :initialize_table )
+    t2.send( :initialize )
     assert_equal( "AND", t1.logical_operator )
     assert_equal( "AND", t2.logical_operator )
     t1.logical_operator = "OR"
@@ -25,7 +26,7 @@ class TestBase < Test::Unit::TestCase
   def test_compile_where
     t = Class.new( Momomoto::Table )
     t.table_name = 'person'
-    t.send( :initialize_table )
+    t.send( :initialize )
     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 )

data/test/test_procedure.rb

@@ -17,15 +17,17 @@ class TestProcedure < Test::Unit::TestCase
   end
 
   def test_procedure_name
-    self.class.const_set( :Proc1, Class.new( Momomoto::Procedure ) )
-    assert_equal( 'proc1', Proc1.procedure_name )
-    self.class.const_set( :Proc2, Class.new( Momomoto::Procedure ) )
-    assert_equal( 'proc2', Proc2.procedure_name )
-    Proc2.procedure_name( 'proc3' )
-    assert_equal( 'proc3', Proc2.procedure_name )
-    Proc2.procedure_name = 'proc4'
-    assert_equal( 'proc4', Proc2.procedure_name )
-    assert_equal( 'proc1', Proc1.procedure_name )
+    p1 = Class.new( Momomoto::Procedure )
+    p1.procedure_name = 'test_parameter_sql'
+    assert_equal( 'test_parameter_sql', p1.procedure_name )
+    p2 = Class.new( Momomoto::Procedure )
+    p2.procedure_name = 'test_parameter_sql_strict'
+    assert_equal( 'test_parameter_sql_strict', p2.procedure_name )
+    p2.procedure_name( 'proc3' )
+    assert_equal( 'proc3', p2.procedure_name )
+    p2.procedure_name = 'proc4'
+    assert_equal( 'proc4', p2.procedure_name )
+    assert_equal( 'test_parameter_sql', p1.procedure_name )
   end
 
   def test_columns_fetching

data/test/test_table.rb

@@ -64,6 +64,7 @@ class TestTable < Test::Unit::TestCase
 
   def test_schema_name_getter
     self.class.const_set( :S, Class.new( Momomoto::Table ) )
+    S.table_name = "test_text"
     assert_equal( 'public', S.schema_name )
     S.schema_name = "chunky"
     assert_equal( "chunky", S.schema_name )
@@ -99,10 +100,10 @@ class TestTable < Test::Unit::TestCase
 
   def test_full_name
     a = Class.new( Momomoto::Table )
-    a.table_name( 'abc' )
-    assert_equal( 'public.abc', a.full_name )
+    a.table_name( 'test_text' )
+    assert_equal( 'public.test_text', a.full_name )
     a.schema_name( 'def' )
-    assert_equal( 'def.abc', a.full_name )
+    assert_equal( 'def.test_text', a.full_name )
   end
 
   def test_custom_setter

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: momomoto
 version: !ruby/object:Gem::Version 
-  version: 0.1.14
-date: 2007-12-15 00:00:00 +01:00
+  version: 0.1.15
+date: 2008-01-13 00:00:00 +01:00
 summary: Momomoto is an object relational mapper for PostgreSQL.
 require_paths: 
 - lib
@@ -47,6 +47,7 @@ files:
 - lib/momomoto/information_schema/key_column_usage.rb
 - lib/momomoto/datatype/boolean.rb
 - lib/momomoto/datatype/date.rb
+- lib/momomoto/datatype/array.rb
 - lib/momomoto/datatype/smallint.rb
 - lib/momomoto/datatype/real.rb
 - lib/momomoto/datatype/text.rb
@@ -67,6 +68,7 @@ files:
 - sql/types.sql
 - sql/install.sql
 - test/test_procedure.rb
+- test/test_array.rb
 - test/test_boolean.rb
 - test/test_real.rb
 - test/test_smallint.rb
@@ -109,11 +111,11 @@ requirements:
 - PostgreSQL 8.1.x or greater
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: ruby-postgres
+  name: postgres
   version_requirement: 
   version_requirements: !ruby/object:Gem::Version::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.7.1.2006.04.06
+        version: 0.7.9.2007.12.12
     version: