momomoto 0.1.15 → 0.1.16

data/lib/momomoto/base.rb

@@ -83,9 +83,7 @@ module Momomoto
         varname = "@#{name}"
         # define getter method
         singleton.send(:define_method, name) do | *values |
-          if not instance_variable_defined?( varname )
-            initialize
-          end
+          initialize if not initialized
           instance_variable_get( varname )
         end
       end
@@ -99,9 +97,7 @@ module Momomoto
           if values[0]
             send( settername, values[0] )
           else
-            if not instance_variable_defined?( varname )
-              initialize
-            end
+            initialize if not initialized
             instance_variable_get( varname )
           end
         end
@@ -147,7 +143,24 @@ module Momomoto
      protected
 
       # Getter and setter used for marking tables as initialized.
-      attr_accessor :initialized
+      attr_writer :initialized
+
+      # overwrite initialized with a normal reader once it has been initialized
+      # to get rid of ruby warnings about @initialized not being initialized
+      # this also works for ruby 1.8.5 where instance_variable_defined? is not
+      # available
+      def initialized
+        @initialized ||= false
+        instance_eval do
+          undef :initialized
+          class << self
+            class_eval do
+              attr_reader :initialized
+            end
+          end
+        end
+        @initialized
+      end
 
       # Guesses the schema name of the table this class works on.
       def construct_schema_name( classname )

data/lib/momomoto/database.rb

@@ -182,6 +182,26 @@ module Momomoto
       @transaction_active = false
     end
 
+    # quotes and escapes the given string +input+
+    def self.quote( input )
+      PGconn.quote( input )
+    end
+
+    # quotes and escapes the given string +input+
+    def self.quote_string( input )
+      "E" + PGconn.quote( input )
+    end
+
+    # escapes the given identifier +input+
+    def self.quote_ident( input )
+      PGconn.quote_ident( input.to_s )
+    end
+
+    # quotes and escapes the given string +input+
+    def self.quote_bytea( input )
+      "E'#{PGconn.escape_bytea(input)}'"
+    end
+
     # escapes the given string +input+
     def self.escape_string( input )
       PGconn.escape( input )

data/lib/momomoto/datatype/array.rb

@@ -1,76 +1,23 @@
+
+require 'momomoto/datatype/array/base'
+require 'momomoto/datatype/array/integer'
+require 'momomoto/datatype/array/text'
+
 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 )
+    class Array
+
+      # Creates a new instance of the special data type, setting +not_null+
+      # and +default+ according to the values from Information Schema.
+      def self.new( row = nil )
+        subtype = nil
+        if row.respond_to?( :udt_name ) && row.udt_name
+          subtype = row.udt_name.gsub(/^_/,"")
         end
+        subtype ||= 'text'
+        Momomoto::Datatype::Array.const_get(subtype.capitalize).new( row )
       end
 
     end

data/lib/momomoto/datatype/array/base.rb

@@ -0,0 +1,96 @@
+module Momomoto
+  module Datatype
+    class Array
+
+      # base datatype for array types
+      class Base < Momomoto::Datatype::Base
+
+        # Creates a new instance of the special data type, setting +not_null+
+        # and +default+ according to the values from Information Schema.
+        def initialize( row = nil )
+          @not_null = row.respond_to?(:is_nullable) && row.is_nullable == "NO" ? true : false
+          @default = row.respond_to?(:column_default) ? row.column_default : nil
+        end
+
+        # Escape and quote +input+ to be saved in database.
+        # Returns 'NULL' if +input+ is nil or empty. Otherwise uses
+        # Database#quote
+        def escape( input )
+          if input.nil?
+            "NULL"
+          elsif input.instance_of?( ::Array )
+            if input.empty?
+              "'{}'::#{array_type}[]"
+            else
+              "ARRAY[" + input.map{|m| Database.quote(m)}.join(',') + "]::#{array_type}[]"
+            end
+          else
+            Database.quote( input )
+          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 = value.match(/^\{(.*)\}$/)
+              values = []
+              m[1].gsub( /("[^"]+"|[^",]+)/ ) do | element |
+                if m = element.match(/^"(.*)"$/)
+                  values << m[1]
+                else
+                  values << element
+                end
+              end
+              values
+            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] if value && !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
+end

data/lib/momomoto/datatype/array/integer.rb

@@ -0,0 +1,27 @@
+module Momomoto
+  module Datatype
+    class Array
+
+      # datatype for text arrays
+      class Integer < Base
+
+        def array_type
+          "int"
+        end
+
+        def filter_get( value )
+          value = super( value )
+          if value.instance_of?( ::Array )
+            value = value.map{|v| Integer(v)}
+          end
+          value
+        end
+
+      end
+
+      Int4 = Integer
+
+    end
+  end
+end
+

data/lib/momomoto/datatype/array/text.rb

@@ -0,0 +1,16 @@
+module Momomoto
+  module Datatype
+    class Array
+
+      # datatype for text arrays
+      class Text < Base
+
+        def array_type
+          "text"
+        end
+
+      end
+    end
+  end
+end
+

data/lib/momomoto/datatype/base.rb

@@ -52,11 +52,11 @@ module Momomoto
       end
 
       # Escapes +input+ to be saved in database.
-      # If +input+ equals nil, NULL is returned, otherwise Database#escape_string
+      # If +input+ equals nil, NULL is returned, otherwise Database#quote
       # is called.
       # This method is overwritten to get data type-specific escaping rules.
       def escape( input )
-        input.nil? ? "NULL" : "'" + Database.escape_string( input.to_s ) + "'"
+        input.nil? ? "NULL" : Database.quote( input.to_s )
       end
 
       # This method is used when compiling the where clause. No need
@@ -70,6 +70,7 @@ module Momomoto
           when :NOT_NULL then
             field_name.to_s + ' IS NOT NULL'
           when ::Array then
+            return compile_rule( field_name, value[0] ) if value.length == 1
             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(',') + ')'

data/lib/momomoto/datatype/bytea.rb

@@ -5,10 +5,10 @@ module Momomoto
     # This class is used for Binary Data (Byte Array).
     class Bytea < Base
 
-      # Escapes +input+ using Database#escape_bytea or returns NULL if
+      # Escapes +input+ using Database#quote_bytea or returns NULL if
       # +input+ is nil.
       def escape( input )
-        input.nil? ? "NULL" : "E'" + Database.escape_bytea( input ) + "'"
+        input.nil? ? "NULL" : Database.quote_bytea( input )
       end
 
     end

data/lib/momomoto/datatype/date.rb

@@ -17,10 +17,10 @@ module Momomoto
           when String then ::Date.parse( value, '%Y-%m-%d' )
           else raise Error
         end
-       rescue => e 
+       rescue => e
         raise ConversionError, "parse Error in Date #{e}"
       end
-    
+
     end
   end
 end

data/lib/momomoto/datatype/inet.rb

@@ -12,7 +12,7 @@ module Momomoto
           else value
         end
       end
-    
+
     end
   end
 end

data/lib/momomoto/datatype/interval.rb

@@ -5,18 +5,18 @@ module Momomoto
     class Interval < Time_without_time_zone
 
       # Escapes +value+ before storing to database.
-      # +value+ can be either 
+      # +value+ can be either
       #   nil, resulting in 'NULL',
-      #   String, which is escaped using Database#escape_string,
+      #   String, which is escaped using Database#quote,
       #   or some Date-like format
       def escape( value )
         case value
           when nil then 'NULL'
-          when String then "'#{Database.escape_string(value)}'"
-          else "'#{Database.escape_string(value.strftime('%H:%M:%S'))}'"
+          when String then Database.quote(value)
+          else Database.quote(value.strftime('%H:%M:%S'))
         end
       end
-  
+
       # Values are filtered by this method when getting them from database.
       # Returns an instance of TimeInterval or nil if +value+ is nil or
       # empty.

data/lib/momomoto/datatype/real.rb

@@ -1,9 +1,9 @@
 module Momomoto
   module Datatype
-    
+
     # Represents the data type Real
     class Real < Numeric
-    
+
     end
   end
 end

data/lib/momomoto/datatype/smallint.rb

@@ -3,7 +3,7 @@ module Momomoto
 
     # Represents the data type Smallint
     class Smallint < Integer
-    
+
     end
   end
 end

data/lib/momomoto/datatype/text.rb

@@ -6,26 +6,26 @@ module Momomoto
 
       # Compares two values and returns true if equal or false otherwise.
       # It is used to check if a row field has been changed so that only
-      # changed fields are written to database. 
+      # changed fields are written to database.
       def equal( a, b )
         a.to_s == b.to_s
       end
 
       # Escapes +input+ to be saved in database.
       # Returns 'NULL' if +input+ is nil or empty. Otherwise escapes
-      # using Database#escape_string
+      # using Database#quote
       def escape( input )
         if input.nil? || input.to_s.empty?
           "NULL"
         else
-          "E'" + Database.escape_string( input.to_s ) + "'"
+          Database.quote_string( input.to_s )
         end
       end
 
       # Additional operators for instances of Text.
       # See Base#operator_sign
       #
-      #   # Selects all posts having "surveillance" in their content field 
+      #   # Selects all posts having "surveillance" in their content field
       #   # while ignoring case.
       #   Posts.select( :content => {:ilike => 'surveillance'} )
       def self.operator_sign( op )

data/lib/momomoto/datatype/time_without_time_zone.rb

@@ -9,7 +9,7 @@ module Momomoto
 
       # Compares two values and returns true if equal or false otherwise.
       # It is used to check if a row field has been changed so that only
-      # changed fields are written to database. 
+      # changed fields are written to database.
       # Escapes before comparing.
       def equal( a, b )
         escape(a) == escape(b)
@@ -20,8 +20,8 @@ module Momomoto
       def escape( value )
         case value
           when nil then 'NULL'
-          when String then "'#{Database.escape_string(value)}'"
-          else "'#{Database.escape_string(value.strftime('%H:%M:%S'))}'"
+          when String then Database.quote(value)
+          else Database.quote(value.strftime('%H:%M:%S'))
         end
       end
 

data/lib/momomoto/datatype/timestamp_without_time_zone.rb

@@ -11,8 +11,8 @@ module Momomoto
       def escape( value )
         case value
           when nil then 'NULL'
-          when String then "'#{Database.escape_string(value)}'"
-          else "'#{Database.escape_string(value.strftime('%Y-%m-%d %H:%M:%S'))}'"
+          when String then Database.quote(value)
+          else Database.quote(value.strftime('%Y-%m-%d %H:%M:%S'))
         end
       end
 

data/lib/momomoto/procedure.rb

@@ -29,7 +29,7 @@ module Momomoto
 
       # guesses the procedure name of the procedure this class works on
       def construct_procedure_name( classname ) # :nodoc:
-        classname.split('::').last.downcase.gsub(/[^a-z_0-9]/, '')
+        classname.to_s.split('::').last.downcase.gsub(/[^a-z_0-9]/, '')
       end
 
       # gets the full name of the procedure including schema if set
@@ -48,7 +48,7 @@ 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 if not instance_variable_defined?( :@parameters )
+        initialize if not initialized
         @parameters
       end
 

data/lib/momomoto/table.rb

@@ -339,16 +339,26 @@ module Momomoto
         else
           cols = columns
         end
-        sql = "SELECT " + cols.keys.map{ | field | '"' + field.to_s + '"' }.join( "," ) + " FROM "
+        sql = "SELECT " + cols.keys.map{ | field | Database.quote_ident( field ) }.join( "," ) + " FROM "
         sql += full_name
         sql += compile_where( conditions )
         sql += compile_order( options[:order] ) if options[:order] || default_order
+        sql = compile_distinct( sql, cols, options[:distinct] ) if options[:distinct]
         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" 
+        sql
+      end
+
+      def compile_distinct( inner_sql, cols, distinct )
+        distinct = [distinct] unless distinct.instance_of?( Array )
+        distinct.each do | field |
+          raise CriticalError, "condition key '#{field}' not a column in table '#{table_name}'" unless columns.keys.member?( field.to_sym )
         end
+        sql = "SELECT DISTINCT ON("
+        sql += distinct.map{|f| Database.quote_ident(f)}.join(',')
+        sql += ") "
+        sql += cols.keys.map{ | field | Database.quote_ident( field ) }.join(',')
+        sql += " FROM (#{inner_sql}) AS t1"
         sql
       end
 

data/test/test_array.rb

@@ -1,10 +1,10 @@
 
 class TestArray < Test::Unit::TestCase
 
-  def test_samples
+  def test_int_samples
     c = Class.new( Momomoto::Table )
     c.table_name = 'test_int_array'
-    [["1","2","3"],nil].each do | value |
+    [[1,2,3],nil,[],[1]].each do | value |
       r = c.new( :data => value )
       assert_equal( value, r.data )
       r.write
@@ -14,5 +14,38 @@ class TestArray < Test::Unit::TestCase
     end
   end
 
+  def test_text_samples
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_text_array'
+    [['chunky','bacon'],nil,[],['foo']].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
+
+  def test_escape
+    a = Momomoto::Datatype::Array.new
+    assert_equal( a.escape( '{1,2,3}' ), "'{1,2,3}'" )
+  end
+
+  def test_filter_get_text
+    a = Momomoto::Datatype::Array::Text.new
+    assert_equal( a.filter_get( '{1,2,3}' ), ['1','2','3'] )
+    assert_equal( a.filter_get( "{',bacon,chunky}" ), ["'","bacon","chunky"] )
+    assert_equal( a.filter_get( '{",",bacon,chunky}' ), [",","bacon","chunky"] )
+    assert_raise( Momomoto::Error ) do
+      a.filter_get( "{\"}")
+    end
+  end
+
+  def test_filter_get_integer
+    a = Momomoto::Datatype::Array::Integer.new
+    assert_equal( a.filter_get( '{1,2,3}' ), [1,2,3] )
+  end
+
 end
 

data/test/test_base.rb

@@ -28,7 +28,7 @@ class TestBase < Test::Unit::TestCase
     t.table_name = 'person'
     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 = '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 )

data/test/test_bytea.rb

@@ -24,10 +24,9 @@ class TestBytea < Test::Unit::TestCase
     assert_equal( data.length, r.data.length )
     assert_equal( data, r.data )
     r.write
-    r2 = c.select(:id=>r.id)
-    assert_equal( 1, r2.length )
-    assert_equal( data.length , r2[0].data.length )
-    assert_equal( data, r2[0].data )
+    r2 = c.select_single(:id=>r.id)
+    assert_equal( data.length , r2.data.length )
+    assert_equal( data, r2.data )
   end
 
 end

data/test/test_datatype.rb

@@ -39,13 +39,14 @@ class TestDatatype < Test::Unit::TestCase
     end
 
     define_method( "test_operator_sign_#{type_name}" ) do
-      assert_equal( '<=', type.operator_sign( :le ) )
-      assert_equal( '<', type.operator_sign( :lt ) )
-      assert_equal( '>=', type.operator_sign( :ge ) )
-      assert_equal( '>', type.operator_sign( :gt ) )
-      assert_equal( '=', type.operator_sign( :eq ) )
-      assert_equal( '<>', type.operator_sign( :ne ) )
-      assert_raise( Momomoto::CriticalError ) { type.operator_sign( :foo ) }
+      t = type.new
+      assert_equal( '<=', t.class.operator_sign( :le ) )
+      assert_equal( '<', t.class.operator_sign( :lt ) )
+      assert_equal( '>=', t.class.operator_sign( :ge ) )
+      assert_equal( '>', t.class.operator_sign( :gt ) )
+      assert_equal( '=', t.class.operator_sign( :eq ) )
+      assert_equal( '<>', t.class.operator_sign( :ne ) )
+      assert_raise( Momomoto::CriticalError ) { t.class.operator_sign( :foo ) }
     end
 
     define_method( "test_escape_#{type_name}" ) do

data/test/test_procedure.rb

@@ -39,20 +39,24 @@ class TestProcedure < Test::Unit::TestCase
 
   def test_columns
     p = Class.new( Momomoto::Procedure )
+    p.procedure_name("test_parameter_plpgsql")
     p2 = Class.new( Momomoto::Procedure )
-    p.columns = :chunky
-    p2.columns = :alice
-    assert_equal( :chunky, p.columns )
+    p2.procedure_name("test_parameter_plpgsql")
+    p.columns = { :chunky => :bacon }
+    p2.columns = { :bacon => :chunky }
+    assert_equal( {:chunky=>:bacon}, p.columns )
     p.columns = :bacon
     assert_equal( :bacon, p.columns )
-    p.columns( :chunky )
-    assert_equal( :chunky, p.columns )
-    assert_equal( :alice, p2.columns )
+    p.columns = { :chunky => :bacon }
+    assert_equal( {:chunky=>:bacon}, p.columns )
+    assert_equal( {:bacon=>:chunky}, p2.columns )
   end
 
   def test_parameters
     p = Class.new( Momomoto::Procedure )
+    p.procedure_name("test_parameter_plpgsql")
     p2 = Class.new( Momomoto::Procedure )
+    p2.procedure_name("test_parameter_plpgsql")
     p.parameters = { :chunky => :bacon }
     p2.parameters = { :bacon => :chunky }
     assert_equal( [{:chunky=>:bacon}], p.parameters )

data/test/test_table.rb

@@ -14,12 +14,14 @@ class TestTable < Test::Unit::TestCase
 
   def test_default_order_getter
     c1 = Class.new( Momomoto::Table )
+    c1.table_name('person')
     c1.default_order = [:a,:b]
     assert_equal( [:a,:b], c1.default_order )
   end
 
   def test_default_order_setter
     c1 = Class.new( Momomoto::Table )
+    c1.table_name('person')
     c1.default_order = :a
     assert_equal( :a, c1.default_order )
     c1.default_order = :b
@@ -30,12 +32,14 @@ class TestTable < Test::Unit::TestCase
 
   def test_columns_getter
     c1 = Class.new( Momomoto::Table )
+    c1.table_name('person')
     c1.columns =  {:a=>Momomoto::Datatype::Text}
     assert_equal( {:a=>Momomoto::Datatype::Text}, c1.columns )
   end
 
   def test_columns_setter
     c1 = Class.new( Momomoto::Table )
+    c1.table_name('person')
     c1.columns =  {:a=>Momomoto::Datatype::Text}
     assert_equal( {:a=>Momomoto::Datatype::Text}, c1.columns )
     c1.columns =  {:b=>Momomoto::Datatype::Text}
@@ -46,6 +50,7 @@ class TestTable < Test::Unit::TestCase
 
   def test_primary_key_getter
     a = Class.new( Momomoto::Table )
+    a.table_name('person')
     a.primary_keys( [:pk] )
     assert_equal( [:pk], a.primary_keys )
     p = Class.new( Momomoto::Table )
@@ -56,6 +61,7 @@ class TestTable < Test::Unit::TestCase
 
   def test_primary_key_setter
     a = Class.new( Momomoto::Table )
+    a.table_name('person')
     a.primary_keys( [:pk] )
     assert_equal( [:pk], a.primary_keys )
     a.primary_keys= [:pk2]
@@ -72,26 +78,28 @@ class TestTable < Test::Unit::TestCase
 
   def test_schema_name_setter
     a = Class.new( Momomoto::Table )
+    a.table_name("person")
     b = Class.new( Momomoto::Table )
-    a.schema_name = :chunky
-    b.schema_name = :bacon
-    assert_equal( :chunky, a.schema_name )
-    assert_equal( :bacon, b.schema_name )
+    b.table_name("person")
+    a.schema_name = :public
+    b.schema_name = :public
+    assert_equal( :public, a.schema_name )
+    assert_equal( :public, b.schema_name )
     a.schema_name( :ratbert )
     assert_equal( :ratbert, a.schema_name )
-    assert_equal( :bacon, b.schema_name )
+    assert_equal( :public, b.schema_name )
   end
 
   def test_table_name_getter
     t = Class.new( Momomoto::Table )
-    t.table_name = "chunky"
-    assert_equal( "chunky", t.table_name )
+    t.table_name = "person"
+    assert_equal( "person", t.table_name )
   end
 
   def test_table_name_setter
     t = Class.new( Momomoto::Table )
-    t.table_name = "chunky"
-    assert_equal( "chunky", t.table_name )
+    t.table_name = "person"
+    assert_equal( "person", t.table_name )
     t.table_name = "bacon"
     assert_equal( "bacon", t.table_name )
     t.table_name( "fox" )
@@ -127,7 +135,7 @@ class TestTable < Test::Unit::TestCase
   def test_offset
     p = Person.select( {}, {:limit => 1, :order => :person_id,:offset=>2})
     assert_operator( 2, :<, p[0].person_id )
-    assert_raise( Momomoto::Error ) do 
+    assert_raise( Momomoto::Error ) do
       Person.select( {}, {:limit => 1, :order => :person_id,:offset=>'bacon'})
     end
   end
@@ -145,8 +153,16 @@ class TestTable < Test::Unit::TestCase
     end
   end
 
+  def test_distinct
+    p = Person.select({},{:distinct=>[:first_name,:nick_name]})
+  end
+
   def test_write_columns
-    p = Person.select({},{:columns=>[:first_name],:limit=>1})[0]
+    t = Class.new( Momomoto::Table )
+    t.table_name( 'person' )
+    p = t.select({},{:columns=>[:first_name],:limit=>1})[0]
+    assert( p.class.columns.member?(:first_name))
+    assert( p.class.columns.member?(:person_id))
     p.first_name = 'test_write_columns'
     p.write
     p2 = Person.select_single(:person_id=>p.person_id)

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: momomoto
 version: !ruby/object:Gem::Version 
-  version: 0.1.15
-date: 2008-01-13 00:00:00 +01:00
+  version: 0.1.16
+date: 2008-01-21 00:00:00 +01:00
 summary: Momomoto is an object relational mapper for PostgreSQL.
 require_paths: 
 - lib
@@ -60,10 +60,13 @@ files:
 - lib/momomoto/datatype/numeric.rb
 - lib/momomoto/datatype/bytea.rb
 - lib/momomoto/datatype/timestamp_without_time_zone.rb
+- lib/momomoto/datatype/timestamp_with_time_zone.rb
 - lib/momomoto/datatype/time_with_time_zone.rb
 - lib/momomoto/datatype/base.rb
 - lib/momomoto/datatype/bigint.rb
-- lib/momomoto/datatype/timestamp_with_time_zone.rb
+- lib/momomoto/datatype/array/integer.rb
+- lib/momomoto/datatype/array/text.rb
+- lib/momomoto/datatype/array/base.rb
 - sql/procedures.sql
 - sql/types.sql
 - sql/install.sql
@@ -117,5 +120,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.7.9.2007.12.12
+        version: 0.7.9.2008.01.09
     version: