momomoto 0.1.0 → 0.1.1

data/lib/momomoto/base.rb

@@ -114,30 +114,43 @@ module Momomoto
       # construct the Row class for the table
       def initialize_row( row, table ) # :nodoc:
 
+        const_set( :Methods, Module.new ) if not const_defined?( :Methods )
+        const_set( :StandardMethods, Module.new ) if not const_defined?( :StandardMethods )
+
         if not row.ancestors.member?( Momomoto::Row )
           raise CriticalError, "Row is not inherited from Momomoto::Row"
         end
 
         row.instance_eval do class_variable_set( :@@table, table ) end
 
+        define_row_accessors( table )
+
+        row.instance_eval do
+          include table.const_get( :StandardMethods )
+          include table.const_get( :Methods )
+        end
+
+      end
+
+      # 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 )
         columns.each_with_index do | ( field_name, data_type ), index |
-          row.instance_eval do
+          method_module.instance_eval do
             # define getter for row class
-            if not public_method_defined?( field_name )
-              if data_type.respond_to?( :filter_get )
-                define_method( field_name ) do
-                  data_type.filter_get( instance_variable_get(:@data)[index] )
-                end
-              else
-                define_method( field_name ) do
-                  instance_variable_get(:@data)[index]
-                end
+            if data_type.respond_to?( :filter_get )
+              define_method( field_name ) do
+                data_type.filter_get( instance_variable_get(:@data)[index] )
+              end
+            else
+              define_method( field_name ) do
+                instance_variable_get(:@data)[index]
               end
             end
 
             # define setter for row class
-            setter_name = "#{field_name}="
-            define_method( setter_name ) do | value |
+            define_method( "#{field_name}=" ) do | value |
               if not new_record? and table.primary_keys.member?( field_name )
                 raise Error, "Setting primary keys(#{field_name}) is only allowed for new records"
               end
@@ -151,7 +164,6 @@ module Momomoto
 
           end
         end
-
       end
 
     end

data/lib/momomoto/database.rb

@@ -1,7 +1,8 @@
 
 begin
   require 'rubygems'
-  require_gem 'ruby-postgres', '>= 0.7.1.2006.04.06'
+  gem 'ruby-postgres', '>= 0.7.1.2006.04.06'
+  require 'postgres'
 rescue LoadError
   require 'postgres'
 end
@@ -63,7 +64,7 @@ module Momomoto
     def disconnect
       @connection.close
       @connection = nil
-      @transaction_active = true
+      @transaction_active = false
     end
 
     # execute a query
@@ -71,6 +72,12 @@ module Momomoto
       puts sql if Momomoto.debug
       @connection.query( sql )
      rescue => e
+      if @connection.status == PGconn::CONNECTION_BAD
+        begin
+          connect
+        rescue
+        end
+      end
       raise CriticalError, "#{e}: #{sql}"
     end
 

data/lib/momomoto/datatype/bytea.rb

@@ -4,7 +4,7 @@ module Momomoto
     class Bytea < Base
 
       def escape( input )
-        input.nil? ? "NULL" : "'" + Database.escape_bytea( input ) + "'"
+        input.nil? ? "NULL" : "E'" + Database.escape_bytea( input ) + "'"
       end
 
     end

data/lib/momomoto/datatype/text.rb

@@ -6,7 +6,7 @@ module Momomoto
         if input.nil? || input.empty?
           "NULL"
         else
-          "'" + Database.escape_string( input.to_s ) + "'"
+          "E'" + Database.escape_string( input.to_s ) + "'"
         end
       end
 

data/lib/momomoto/row.rb

@@ -50,6 +50,7 @@ module Momomoto
       self.class.table.delete( self )
     end
 
+    # convert row to hash
     def to_hash
       hash = {}
       self.class.table.columns.keys.each do | key |
@@ -58,6 +59,31 @@ module Momomoto
       hash
     end
 
+    # generic setter for column values
+    def set_column( column, value )
+      table = self.class.table
+      if not new_record? and table.primary_keys.member?( column.to_sym )
+        raise Error, "Setting primary keys(#{column}) is only allowed for new records"
+      end
+      value = table.columns[column.to_sym].filter_set( value )
+      index = table.column_order.index( column.to_sym )
+      if @data[index] != value
+        @dirty = true
+        @data[index] = value
+      end
+    end
+
+    # generic getter for column values
+    def get_column( column )
+      table = self.class.table
+      index = table.column_order.index( column.to_sym )
+      if table.columns[column.to_sym].respond_to?( :filter_get )
+        table.columns[column.to_sym].filter_get( @data[index] )
+      else
+        @data[index]
+      end
+    end
+
   end
 
 end

data/lib/momomoto/table.rb

@@ -9,18 +9,31 @@ module Momomoto
 
       # set the default order for selects
       def default_order=( order )
-        @default_order = order
+        class_variable_set( :@@default_order, order )
       end
 
-      # get/set the default order for selects
+      # get the columns of the table this class operates on
       def default_order( order = nil )
         return self.default_order=( order ) if order
-        @default_order
+        begin
+          class_variable_get( :@@default_order )
+        rescue NameError
+          class_variable_set( :@@default_order, nil )
+        end
       end
 
       # set the columns of the table this class operates on
       def columns=( columns )
         class_variable_set( :@@columns, columns)
+        # we store the order separate because it's quite important 
+        # that it's constant otherwise get_colum and set_column 
+        # on the row class might stop working 
+        class_variable_set( :@@column_order, columns.keys )
+      end
+
+      # get the columns of this table
+      def column_order
+        class_variable_get( :@@column_order )
       end
 
       # get the columns of the table this class operates on
@@ -117,6 +130,35 @@ module Momomoto
         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')
+        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+'"'}
+
+        sql = "SELECT " + fields.join( "," ) + " FROM "
+        sql += full_name
+        sql += " LEFT OUTER JOIN " + join_table.full_name + " USING(#{join_columns(join_table).join(',')})"
+        sql += compile_where( conditions )
+        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 = []
+        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.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
+        end
+        data
+      end
+
+      def join_columns( join_table )
+        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 class_variables.member?('@@initialized')

data/test/test.sql

@@ -0,0 +1,68 @@
+
+CREATE TABLE conference (
+    conference_id SERIAL,
+    acronym TEXT NOT NULL UNIQUE,
+    title TEXT NOT NULL,
+    subtitle TEXT,
+    description TEXT,
+    start_date DATE NOT NULL,
+    timeslot_duration INTERVAL NOT NULL DEFAULT '0:30:00',
+    default_timeslots INTEGER NOT NULL DEFAULT 1,
+    max_timeslots_per_event INTEGER NOT NULL DEFAULT 10,
+    day_change TIME WITHOUT TIME ZONE NOT NULL DEFAULT '0:00:00',
+    feedback_enabled BOOL NOT NULL DEFAULT FALSE,
+    submission_enabled BOOL NOT NULL DEFAULT FALSE,
+    visitor_enabled BOOL NOT NULL DEFAULT FALSE,
+    reconfirmation_enabled BOOL NOT NULL DEFAULT FALSE,
+    PRIMARY KEY(conference_id)
+);
+
+CREATE TABLE person (
+    person_id SERIAL,
+    first_name TEXT,
+    last_name TEXT,
+    nick_name TEXT,
+    PRIMARY KEY(person_id)
+);
+
+INSERT INTO person(nick_name) VALUES ('blossom');
+INSERT INTO person(nick_name) VALUES ('buttercup');
+INSERT INTO person(nick_name) VALUES ('bubbles');
+INSERT INTO person(nick_name) VALUES ('mojojojo');
+
+CREATE TABLE event (
+    event_id SERIAL,
+    title TEXT,
+    subtitle TEXT,
+    PRIMARY KEY(event_id)
+);
+
+CREATE TABLE event_person (
+    event_id INTEGER,
+    person_id INTEGER,
+    description TEXT,
+    FOREIGN KEY(event_id) REFERENCES event(event_id),
+    FOREIGN KEY(person_id) REFERENCES person(person_id),
+    PRIMARY KEY(event_id, person_id, description)
+);
+
+CREATE TABLE test_bigint( id SERIAL, data BIGINT, PRIMARY KEY(id));
+CREATE TABLE test_boolean( id SERIAL, data BOOLEAN, PRIMARY KEY(id));
+CREATE TABLE test_bytea( id SERIAL, data BYTEA, PRIMARY KEY(id));
+CREATE TABLE test_character( id SERIAL, data CHARACTER(1000), PRIMARY KEY(id));
+CREATE TABLE test_character_varying( id SERIAL, data VARCHAR(1000), PRIMARY KEY(id));
+CREATE TABLE test_date( id SERIAL, data DATE, PRIMARY KEY(id));
+CREATE TABLE test_inet( id SERIAL, data INET, PRIMARY KEY(id));
+CREATE TABLE test_integer( id SERIAL, data INTEGER, PRIMARY KEY(id));
+CREATE TABLE test_interval( id SERIAL, data INTERVAL, PRIMARY KEY(id));
+CREATE TABLE test_nodefault ( id INTEGER, data TEXT, PRIMARY KEY(id));
+CREATE TABLE test_numeric( id SERIAL, data NUMERIC, PRIMARY KEY(id));
+CREATE TABLE test_real( id SERIAL, data REAL, PRIMARY KEY(id));
+CREATE TABLE test_smallint( id SERIAL, data SMALLINT, PRIMARY KEY(id));
+CREATE TABLE test_text( id SERIAL, data TEXT, PRIMARY KEY(id));
+CREATE TABLE test_time_with_time_zone( id SERIAL, data TIME WITH TIME ZONE, PRIMARY KEY(id));
+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));
+
+

data/test/test_base.rb

@@ -8,9 +8,9 @@ class TestBase < Test::Unit::TestCase
     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 = '1'" , t.compile_where( :first_name => '1' ) )
-    assert_equal( " WHERE first_name = 'chu''nky'" , t.compile_where( :first_name => "chu'nky" ) )
-    assert_equal( " WHERE first_name IN ('chu''nky','bac''n')" , t.compile_where( :first_name => ["chu'nky","bac'n"] ) )
+    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"] ) )
   end
 
 end

data/test/test_functions.sql

@@ -0,0 +1,25 @@
+
+CREATE OR REPLACE FUNCTION test_parameter_sql( param1 INTEGER ) RETURNS INTEGER AS $$
+  SELECT $1;
+$$ LANGUAGE sql;
+
+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_set_returning( person_id INTEGER ) RETURNS SETOF person AS $$
+  DECLARE
+    result RECORD;
+  BEGIN
+    FOR result IN
+      SELECT person.* FROM person WHERE person.person_id <> person_id
+      LOOP
+        RETURN NEXT result;
+      END LOOP;
+    RETURN;
+  END;
+$$ LANGUAGE plpgsql;
+

data/test/test_information_schema.rb

@@ -17,10 +17,8 @@ class TestInformationSchema < Test::Unit::TestCase
 
   # test for working information_schema.table_constraints class
   def test_information_schema_table_constraints
-    a = Momomoto::Information_schema::Table_constraints.select(:table_schema => 'pg_catalog', :table_name => 'pg_class')
-    assert_equal( 0, a.length )
     a = Momomoto::Information_schema::Table_constraints.select(:table_schema => 'public')
-    assert_operator( 0, :<, a.length )
+    assert( a.length > 0 )
   end
 
 end

data/test/test_table.rb

@@ -2,18 +2,32 @@
 class TestTable < Test::Unit::TestCase
 
   class Person < Momomoto::Table
-    def self.person_id=( row , newvalue )
-      newvalue
-    end
-
-    def self.nick_name=( row, newvalue )
-      row.first_name + newvalue
+    module Methods
+      def nick_name=( newvalue )
+        set_column(:nick_name, get_column(:first_name) + newvalue )
+      end
     end
   end
 
   class Conference < Momomoto::Table
   end
 
+  def test_default_order_getter
+    c1 = Class.new( Momomoto::Table )
+    c1.default_order = [:a,:b]
+    assert_equal( [:a,:b], c1.default_order )
+  end
+
+  def test_default_order_setter
+    c1 = Class.new( Momomoto::Table )
+    c1.default_order = :a
+    assert_equal( :a, c1.default_order )
+    c1.default_order = :b
+    assert_equal( :b, c1.default_order )
+    c1.default_order( :c )
+    assert_equal( :c, c1.default_order )
+  end
+
   def test_columns_getter
     c1 = Class.new( Momomoto::Table )
     c1.columns =  {:a=>Momomoto::Datatype::Text}
@@ -109,6 +123,14 @@ class TestTable < Test::Unit::TestCase
     assert_equal( true, sven.new_record? )
   end
 
+  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 
+      Person.select( {}, {:limit => 1, :order => :person_id,:offset=>'bacon'})
+    end
+  end
+
   def test_select
     r = Person.select( nil, {:limit => 3})
     assert_equal( 3, r.length )

metadata

@@ -3,7 +3,7 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: momomoto
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 date: 2007-08-13 00:00:00 +02:00
 summary: Momomoto is an object relational mapper for PostgreSQL.
 require_paths: 
@@ -90,6 +90,8 @@ files:
 - test/test_datatype.rb
 - test/test_bigint.rb
 - test/test_date.rb
+- test/test_functions.sql
+- test/test.sql
 - LICENSE
 - Rakefile
 test_files: []
@@ -103,7 +105,7 @@ executables: []
 extensions: []
 
 requirements: 
-- PostgreSQL 8.1.4 or greater
+- PostgreSQL 8.1.x or greater
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: ruby-postgres