momomoto 0.1.19 → 0.2.0

data/lib/momomoto/database.rb

@@ -2,12 +2,7 @@
 require 'postgres'
 require 'singleton'
 
-require 'momomoto/information_schema/columns'
-require 'momomoto/information_schema/table_constraints'
-require 'momomoto/information_schema/key_column_usage'
-require 'momomoto/information_schema/routines'
-require 'momomoto/information_schema/fetch_procedure_columns'
-require 'momomoto/information_schema/fetch_procedure_parameters'
+require 'momomoto/information_schema'
 
 ## Momomoto is a database abstraction layer
 module Momomoto
@@ -109,6 +104,17 @@ module Momomoto
       pkeys
     end
 
+
+    # get table type from database
+    # should work with any SQL2003 compliant DBMS
+    def get_table_type( table_name, schema_name )
+      begin
+        Information_schema::Tables.select_single({:table_name=>table_name,:table_schema=>schema_name}).table_type
+      rescue => e
+        raise CriticalError, "Table #{table_name} does not exist. #{e.to_s}"
+      end
+    end
+
     # fetch column definitions from database
     # should work with any SQL2003 compliant DBMS
     def fetch_table_columns( table_name, schema_name = nil ) # :nodoc:

data/lib/momomoto/information_schema.rb

@@ -0,0 +1,20 @@
+
+module Momomoto::Information_schema 
+
+  def self.const_missing( table )
+    raise CriticalError, "Invalid name." unless table.to_s.downcase.match(/^[a-z0-9_]+$/)
+    begin
+      require "momomoto/information_schema/#{table.to_s.downcase}"
+      ::Momomoto::Information_schema::const_get( table )
+    rescue LoadError
+      klass = Class.new( ::Momomoto::Table )
+      klass.schema_name = "information_schema"
+      klass.table_type = "VIEW"
+      klass.primary_keys( [] )
+
+      ::Momomoto::Information_schema.const_set(table, klass)
+    end
+  end
+
+end
+

data/lib/momomoto/information_schema/columns.rb

@@ -12,6 +12,7 @@ module Momomoto
     class Columns < Momomoto::Table
       primary_keys( [] )
       schema_name( "information_schema" )
+      table_type( "VIEW" )
       columns( { :table_catalog             => Momomoto::Datatype::Text.new,
                  :table_schema              => Momomoto::Datatype::Text.new,
                  :table_name                => Momomoto::Datatype::Text.new,

data/lib/momomoto/table.rb

@@ -17,6 +17,9 @@ module Momomoto
     # array containing the primary key fields of the table
     momomoto_attribute :primary_keys
 
+    # the table type of this table
+    momomoto_attribute :table_type
+
     class << self
 
       # get the full name of table including, if set, schema
@@ -24,6 +27,16 @@ module Momomoto
         "#{ schema_name ? schema_name + '.' : ''}#{table_name}"
       end
 
+      # is this a base table
+      def base_table?
+        table_type == "BASE TABLE"
+      end
+
+      # is this a view
+      def view?
+        table_type == "VIEW"
+      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.
@@ -281,6 +294,15 @@ module Momomoto
         classname.split('::').last.downcase.gsub(/[^a-z_0-9]/, '')
       end
 
+      # get namespace of current class
+      def namespace
+        if self.name.split('::').length > 1
+          const_get( self.name.split('::')[0..-2].join('::') )
+        else
+          Object
+        end
+      end
+
       # initializes a table class
       def initialize
         return if initialized
@@ -289,8 +311,7 @@ module Momomoto
         @table_name ||= construct_table_name( self.name )
 
         @columns ||= database.fetch_table_columns( table_name(), schema_name() )
-        raise CriticalError, "No fields in table #{table_name}" if columns.keys.empty?
-
+        @table_type ||= database.get_table_type( table_name, schema_name )
         @primary_keys ||= database.fetch_primary_keys( table_name(), schema_name() )
         @column_order = @columns.keys
         @default_order ||= nil
@@ -299,6 +320,89 @@ module Momomoto
         initialize_row( const_get( :Row ), self )
         @row_cache = {}
 
+        # define helper methods for foreign key relations
+        if base_table?
+          
+          # find all columns that reference other tables and add helper methods for those keys
+          Information_schema::Table_constraints.select({:table_name=>table_name,:table_schema=>schema_name,:constraint_type=>'FOREIGN KEY'}).each do | fk |
+            referenced_columns = Information_schema::Constraint_column_usage.select({:constraint_name=>fk.constraint_name,:constraint_schema=>fk.constraint_schema})
+            raise CriticalError, "Foreign key constraint without referenced columns" if referenced_columns.length == 0
+            ref_table = referenced_columns[0].table_name
+            # check if there is already a method by that name defined on Row
+            if !const_get( :Row ).instance_methods.member?( ref_table )
+              begin
+                klass = namespace.const_get( ref_table.capitalize )
+              rescue
+                # if there is no such class yet we create one in the appropriate namespace
+                klass = Class.new( Momomoto::Table )
+                klass.table_name = ref_table
+                klass.schema_name = referenced_columns[0].table_schema
+                namespace.const_set( ref_table.capitalize, klass )
+              end
+              ref_columns = referenced_columns.map(&:column_name).map(&:to_sym)
+              fk_helper_single( ref_table, klass, ref_columns )
+            end
+          end
+
+          # find other tables that reference this table and add helper methods
+          if primary_keys.length == 1
+            Information_schema::Constraint_column_usage.select({:table_name=>table_name,:table_schema=>schema_name,:column_name=>primary_keys[0]}).each do | fk |
+              constraint = Information_schema::Table_constraints.select({:constraint_name=>fk.constraint_name,:constraint_schema=>fk.constraint_schema,:constraint_type=>'FOREIGN KEY'})[0]
+              # check if there is already a method by that name defined on Row
+              if constraint && !const_get( :Row ).instance_methods.member?( constraint.table_name )
+
+                begin
+                  klass = namespace.const_get( constraint.table_name.capitalize )
+                rescue
+                  # if there is no such class yet we create one in the appropriate namespace
+                  klass = Class.new( Momomoto::Table )
+                  klass.table_name = constraint.table_name
+                  klass.schema_name = constraint.table_schema
+                  namespace.const_set( constraint.table_name.capitalize, klass )
+                end
+                fk_helper_multiple( constraint.table_name, klass, primary_keys )
+              end
+            end
+          end
+
+        end
+
+      end
+
+      # Define a helper method +method_name+ for +table_class+ 
+      def fk_helper_single( method_name, table_class, ref_columns )
+        var_name = "@#{method_name}".to_sym
+        const_set(:Methods, Module.new) if not const_defined?(:Methods)
+        const_get(:Methods).send(:define_method, method_name) do
+          return instance_variable_get( var_name ) if instance_variable_defined?( var_name )
+          conditions = {}
+          ref_columns.each do | col | conditions[col] = get_column( col ) end
+          begin
+            value = table_class.select_single( conditions )
+          rescue Momomoto::Nothing_found
+            value = nil
+          end
+          instance_variable_set( var_name, value )
+        end
+      end
+
+      # Define a helper method +method_name+ for +table_class+ 
+      def fk_helper_multiple( method_name, table_class, ref_columns )
+        var_name = "@#{method_name}".to_sym
+        const_set(:Methods, Module.new) if not const_defined?(:Methods)
+        const_get(:Methods).send(:define_method, method_name) do | *args |
+          conditions = args[0] ||= {}
+          options = args[1] ||= {}
+          hash = args.hash
+          if instance_variable_defined?( var_name ) 
+            return instance_variable_get( var_name )[hash] if instance_variable_get( var_name )[hash]
+          else
+            instance_variable_set( var_name, Hash.new )
+          end
+          ref_columns.each do | col | conditions[col] = get_column( col ) end
+          value = table_class.select( conditions, options )
+          instance_variable_get( var_name )[hash] = value
+        end
       end
 
       # Builds the row class for this table when executing #select.

data/test/test.sql

@@ -67,4 +67,4 @@ CREATE TABLE test_timestamp_without_time_zone( id SERIAL, data TIMESTAMP WITHOUT
 CREATE TABLE test_int_array( id SERIAL, data int[], PRIMARY KEY(id) );
 CREATE TABLE test_text_array( id SERIAL, data text[], PRIMARY KEY(id) );
 
-
+CREATE VIEW view_person AS SELECT * FROM person;

data/test/test_database.rb

@@ -54,6 +54,21 @@ class TestDatabase < Test::Unit::TestCase
     assert_equal( 1, pk.length )
   end
 
+  def test_get_table_type
+    db = Momomoto::Database.instance
+    type = db.get_table_type( 'person', 'public' )
+    assert_equal( type, 'BASE TABLE' )
+    type = db.get_table_type( 'view_person', 'public' )
+    assert_equal( type, 'VIEW' )
+  end
+
+  def test_non_existant_table
+    db = Momomoto::Database.instance
+    assert_raise( Momomoto::CriticalError ) do
+      db.get_table_type( 'nonexistant_table', 'public' )
+    end
+  end
+
   def test_rollback
     db = Momomoto::Database.instance
     db.begin

data/test/test_table.rb

@@ -313,5 +313,85 @@ class TestTable < Test::Unit::TestCase
     assert_equal( true, r.dirty? )
   end
 
+  def test_table_type_getter_and_setter
+    c1 = Class.new( Momomoto::Table )
+    c1.table_name('person')
+    c1.table_type = 'BASE TABLE'
+    assert_equal( 'BASE TABLE', c1.table_type )
+    c1.table_type = 'VIEW'
+    assert_equal( 'VIEW', c1.table_type )
+  end
+
+  def test_table_type
+    a = Class.new( Momomoto::Table )
+    a.table_name('person')
+    assert_equal( "BASE TABLE", a.table_type )
+    assert_equal( true, a.base_table? )
+    assert_equal( false, a.view? )
+
+    b = Class.new( Momomoto::Table )
+    b.table_name('view_person')
+    assert_equal( "VIEW", b.table_type )
+    assert_equal( false, b.base_table? )
+    assert_equal( true, b.view? )
+  end
+
+  def test_non_existant_table
+    a = Class.new( Momomoto::Table )
+    a.table_name('nonexistant_table')
+    assert_raise( Momomoto::CriticalError ) do
+      a.new
+    end
+  end
+
+  def test_foreign_keys
+    c1 = Class.new( Momomoto::Table )
+    c1.table_name('event')
+    c1.columns
+    assert_equal( true, c1::Methods.instance_methods.include?("event_person"))
+    c2 = Class.new( Momomoto::Table )
+    c2.table_name('person')
+    c2.columns
+    assert_equal( true, c2::Methods.instance_methods.include?("event_person"))
+    c3 = Class.new( Momomoto::Table )
+    c3.table_name('event_person')
+    c3.columns
+    assert_equal( true, c3::Methods.instance_methods.include?("event"))
+    assert_equal( true, c3::Methods.instance_methods.include?("person"))
+    event = c1.new
+    event.title = 'foreign key test'
+    event.write
+    person = c2.new
+    person.first_name = 'frank'
+    person.write
+    event_person = c3.new
+    event_person.event_id = event.event_id
+    event_person.person_id = person.person_id
+    event_person.description = 'foreign key test'
+    event_person.write
+
+    assert_equal( event.event_id, event_person.event.event_id )
+    assert_equal( person.person_id, event_person.person.person_id )
+    assert_equal( 1, event.event_person.length )
+    assert_equal( event.event_id, event.event_person[0].event_id )
+    assert_equal( person.person_id, event.event_person[0].person_id )
+    assert_equal( 1, person.event_person.length )
+    assert_equal( event.event_id, person.event_person[0].event_id )
+    assert_equal( person.person_id, person.event_person[0].person_id )
+
+    # test caching
+    id = event.event_person.object_id
+    assert_equal( id, event.event_person.object_id )
+    id = event.event_person(:person_id=>7).object_id
+    assert_equal( id, event.event_person(:person_id=>7).object_id )
+    id = event_person.event.object_id
+    assert_equal( id, event_person.event.object_id )
+    
+
+    event_person.delete
+    event.delete
+    person.delete
+  end
+
 end
 

metadata

@@ -1,124 +1,130 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: momomoto
 version: !ruby/object:Gem::Version 
-  version: 0.1.19
-date: 2009-03-02 00:00:00 +01:00
-summary: Momomoto is an object relational mapper for PostgreSQL.
-require_paths: 
-- lib
-email: sven@c3d2.de
-homepage: http://pentabarf.org/Momomoto
-rubyforge_project: 
-description: Momomoto is an object relational mapper for PostgreSQL.
-autorequire: momomoto
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: 1.8.2
-  version: 
+  version: 0.2.0
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Sven Klemm
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-13 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: postgres
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.7.9.2008.01.09
+    version: 
+description: Momomoto is an object relational mapper for PostgreSQL.
+email: sven@c3d2.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
 files: 
-- lib/timeinterval.rb
 - lib/momomoto.rb
-- lib/momomoto/database.rb
 - lib/momomoto/momomoto.rb
-- lib/momomoto/row.rb
-- lib/momomoto/table.rb
-- lib/momomoto/procedure.rb
-- lib/momomoto/datatype.rb
-- lib/momomoto/base.rb
-- lib/momomoto/order.rb
-- lib/momomoto/information_schema/table_constraints.rb
-- lib/momomoto/information_schema/columns.rb
-- lib/momomoto/information_schema/fetch_procedure_parameters.rb
-- lib/momomoto/information_schema/fetch_procedure_columns.rb
-- lib/momomoto/information_schema/routines.rb
-- lib/momomoto/information_schema/key_column_usage.rb
-- lib/momomoto/datatype/boolean.rb
-- lib/momomoto/datatype/date.rb
+- lib/momomoto/datatype/character.rb
+- lib/momomoto/datatype/bytea.rb
+- lib/momomoto/datatype/array/text.rb
+- lib/momomoto/datatype/array/base.rb
+- lib/momomoto/datatype/array/integer.rb
+- lib/momomoto/datatype/interval.rb
 - lib/momomoto/datatype/array.rb
-- lib/momomoto/datatype/smallint.rb
 - lib/momomoto/datatype/real.rb
 - lib/momomoto/datatype/text.rb
-- lib/momomoto/datatype/interval.rb
-- lib/momomoto/datatype/character.rb
-- lib/momomoto/datatype/integer.rb
-- lib/momomoto/datatype/time_without_time_zone.rb
-- lib/momomoto/datatype/character_varying.rb
+- lib/momomoto/datatype/time_with_time_zone.rb
 - lib/momomoto/datatype/inet.rb
+- lib/momomoto/datatype/character_varying.rb
+- lib/momomoto/datatype/time_without_time_zone.rb
 - lib/momomoto/datatype/numeric.rb
-- lib/momomoto/datatype/bytea.rb
+- lib/momomoto/datatype/smallint.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/timestamp_with_time_zone.rb
+- lib/momomoto/datatype/date.rb
+- lib/momomoto/datatype/integer.rb
+- lib/momomoto/datatype/boolean.rb
 - lib/momomoto/datatype/bigint.rb
-- lib/momomoto/datatype/array/integer.rb
-- lib/momomoto/datatype/array/text.rb
-- lib/momomoto/datatype/array/base.rb
+- lib/momomoto/information_schema.rb
+- lib/momomoto/information_schema/fetch_procedure_columns.rb
+- lib/momomoto/information_schema/fetch_procedure_parameters.rb
+- lib/momomoto/information_schema/columns.rb
+- lib/momomoto/database.rb
+- lib/momomoto/datatype.rb
+- lib/momomoto/row.rb
+- lib/momomoto/table.rb
+- lib/momomoto/base.rb
+- lib/momomoto/order.rb
+- lib/momomoto/procedure.rb
+- lib/timeinterval.rb
 - sql/procedures.sql
-- sql/types.sql
 - sql/install.sql
-- test/test_procedure.rb
-- test/test_array.rb
-- test/test_boolean.rb
+- sql/types.sql
 - test/test_real.rb
-- test/test_smallint.rb
-- test/test_interval.rb
-- test/test_text.rb
-- test/test_table.rb
-- test/test_numeric.rb
+- test/test_time_with_time_zone.rb
 - test/test_inet.rb
-- test/test_time_without_time_zone.rb
-- test/test_character_varying.rb
-- test/test_character.rb
+- test/test_table.rb
 - test/test_integer.rb
+- test/test_information_schema.rb
+- test/test_timeinterval.rb
+- test/test_text.rb
 - test/test_datatype.rb
+- test/test_character.rb
+- test/test_boolean.rb
 - test/test_row.rb
+- test/test_date.rb
+- test/test_array.rb
+- test/test_bigint.rb
+- test/test_base.rb
 - test/test_timestamp_without_time_zone.rb
-- test/test_time_with_time_zone.rb
-- test/test_timeinterval.rb
+- test/test_interval.rb
 - test/test_database.rb
+- test/test_smallint.rb
+- test/test_procedure.rb
 - test/test_bytea.rb
-- test/test_information_schema.rb
-- test/test_base.rb
-- test/test_bigint.rb
+- test/test_character_varying.rb
 - test/test_timestamp_with_time_zone.rb
-- test/test_date.rb
+- test/test_time_without_time_zone.rb
+- test/test_numeric.rb
 - test/test_functions.sql
 - test/test.sql
-- LICENSE
 - Rakefile
-test_files: []
-
+- LICENSE
+has_rdoc: true
+homepage: http://pentabarf.org/Momomoto
+post_install_message: 
 rdoc_options: []
 
-extra_rdoc_files: []
-
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: 
 - PostgreSQL 8.1.x or greater
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: postgres
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.7.9.2008.01.09
-    version: 
+rubyforge_project: momomoto
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Momomoto is an object relational mapper for PostgreSQL.
+test_files: []
+

data/lib/momomoto/information_schema/key_column_usage.rb

@@ -1,14 +0,0 @@
-
-module Momomoto
-  module Information_schema
-
-    # internal use only
-    #
-    # Represents the corresponding view from Information Schema and is
-    # used for getting the column names of primary keys of a table.
-    class Key_column_usage < Momomoto::Table
-      schema_name( "information_schema" )
-    end
-  end
-end
-

data/lib/momomoto/information_schema/routines.rb

@@ -1,16 +0,0 @@
-
-module Momomoto
-
-  module Information_schema
-
-    # internal use only
-    #
-    # Represents the corresponding view from Information Schema and is
-    # used for getting all defined functions within a database.
-    class Routines < Momomoto::Table
-      schema_name( "information_schema" )
-    end
-
-  end
-
-end

data/lib/momomoto/information_schema/table_constraints.rb

@@ -1,14 +0,0 @@
-
-module Momomoto
-  module Information_schema
-
-    # internal use only
-    #
-    # Represents the corresponding view from Information Schema and is
-    # used when fetching primary keys.
-    class Table_constraints < Momomoto::Table
-      primary_keys( [] )
-      schema_name( "information_schema" )
-    end
-  end
-end