ramen 0.4.0 → 0.4.1

data/lib/ramen/engine/mysql.rb

@@ -183,15 +183,29 @@ SQL
 
       # returns the query for all foreign keys and their meta-data.
       #
-      # the query must include the table_schema, table_name, and foreign_key_name.
+      # the query must include the table_schema, table_name, foreign_key_name,
+      # referenced_table_schema, referenced_table_name.
+      # 
+      # note:   the clause "not kcu.referenced_table_schema is null" is necessary
+      # on mysql to distinguish foreign keys from unique keys in kcu when
+      # there exists both a foreign key and unique key with the same name.  see
+      # http://www.xcdsql.org/MySQL/information_schema/5.1/MySQL_5_1_INFORMATION_SCHEMA.html
       def Sql.foreign_keys
 <<SQL
 select
-  constraint_schema as table_schema,
-  table_name,
-  constraint_name as foreign_key_name
+  tc.constraint_schema as table_schema,
+  tc.table_name,
+  tc.constraint_name as foreign_key_name,
+  kcu.referenced_table_schema,
+  kcu.referenced_table_name
 from information_schema.table_constraints tc
+inner join information_schema.key_column_usage kcu
+  on  tc.constraint_schema = kcu.constraint_schema
+  and tc.table_name        = kcu.table_name
+  and tc.constraint_name   = kcu.constraint_name
 where tc.constraint_type = 'FOREIGN KEY'
+  and not kcu.referenced_table_schema is null
+group by table_schema,table_name,foreign_key_name,referenced_table_schema,referenced_table_name
 SQL
       end
 
@@ -200,6 +214,11 @@ SQL
       # the query must include foreign_key_name, table_schema, table_name, 
       # column_name, referenced_table_schema, referenced_table_name,
       # referenced_column_name.
+      #
+      # note:   the clause "not kcu.referenced_table_schema is null" is necessary
+      # on mysql to distinguish foreign keys from unique keys in kcu when
+      # there exists both a foreign key and unique key with the same name.  see
+      # http://www.xcdsql.org/MySQL/information_schema/5.1/MySQL_5_1_INFORMATION_SCHEMA.html
       def Sql.foreign_key_columns
 <<SQL
 select
@@ -218,6 +237,35 @@ inner join information_schema.key_column_usage kcu
   and tc.table_name        = kcu.table_name
   and tc.constraint_name   = kcu.constraint_name
 where tc.constraint_type = 'FOREIGN KEY'
+  and not kcu.referenced_table_schema is null        
+SQL
+      end
+      
+      # returns the query for all DML triggers.
+      #
+      # ther query must include trigger_schema, trigger_name,
+      # event_object_schema, event_object_table.
+      def Sql.triggers
+<<SQL      
+select
+  trigger_schema,
+  trigger_name,
+  event_object_schema,
+  event_object_table,
+  event_manipulation,
+  action_order,
+  action_condition,
+  -- skipping due to size: action_statement,
+  action_orientation,
+  action_timing,
+  action_reference_old_table,
+  action_reference_new_table,
+  action_reference_old_row,
+  action_reference_new_row,
+  created,
+  sql_mode,
+  definer
+from information_schema.triggers
 SQL
       end
     end

data/lib/ramen/engine/sql2005.rb

@@ -119,7 +119,8 @@ SQL
 
       # returns the query for all foreign keys and their meta-data.
       #
-      # the query must include the table_schema, table_name and foreign_key_name.
+      # the query must include the table_schema, table_name, foreign_key_name,
+      # referenced_table_schema, referenced_table_name.
       def Sql.foreign_keys
 <<SQL
 select
@@ -138,6 +139,8 @@ select
   sys.foreign_keys.is_published,
   sys.foreign_keys.is_schema_published,
   sys.foreign_keys.referenced_object_id,
+  referenced_schema.name as referenced_table_schema,
+  referenced_table.name as referenced_table_name,
   sys.foreign_keys.key_index_id,
   sys.foreign_keys.is_disabled,
   sys.foreign_keys.is_not_for_replication,
@@ -152,6 +155,10 @@ inner join sys.tables on
   sys.foreign_keys.parent_object_id = sys.tables.object_id 
 inner join sys.schemas on
   sys.tables.schema_id = sys.schemas.schema_id
+inner join sys.tables referenced_table on
+  sys.foreign_keys.referenced_object_id = referenced_table.object_id
+inner join sys.schemas referenced_schema on
+  referenced_table.schema_id = referenced_schema.schema_id
 SQL
       end
 
@@ -336,6 +343,40 @@ where sys.indexes.is_primary_key = 0
 SQL
       end
 
+      # returns the query for all DML triggers.
+      #
+      # ther query must include trigger_schema, trigger_name,
+      # event_object_schema, event_object_table.
+      def Sql.triggers
+<<SQL      
+select 
+  sys.schemas.name as trigger_schema,
+  t.name as trigger_name,
+  sys.schemas.name as event_object_schema,
+  sys.tables.name as event_object_table,
+  t.object_id,
+  t.parent_class,
+  t.parent_class_desc,
+  t.parent_id,
+  t.type,
+  t.type_desc,
+  t.create_date,
+  t.modify_date,
+  t.is_ms_shipped,
+  t.is_disabled,
+  t.is_not_for_replication,
+  t.is_instead_of_trigger,
+  te.type as event_type,
+  te.type_desc as event_type_desc,
+  te.is_first as event_is_first,
+  te.is_last as event_is_last
+from sys.triggers t
+inner join sys.trigger_events te on t.object_id = te.object_id
+inner join sys.tables on t.parent_id = sys.tables.object_id -- inner join will avoid ddl triggers
+inner join sys.schemas on sys.tables.schema_id = sys.schemas.schema_id
+SQL
+      end
+      
       # returns the query for all key constraints and their meta-data.
       #
       # the query must include the schema_id, table_id, 

data/lib/ramen/metadata/database.rb

@@ -14,10 +14,9 @@ module Ramen::Metadata
   # Database contains many Schema objects, which are accessable through the
   # schema attribute. Schema contains many Table objects, which are accessable
   # through Schema#table. Table contains many Column, ForeignKey, Index and
-  # KeyConstraint objects.  ForeignKey contains ForeignKeyColumn objects; which
+  # Trigger objects.  ForeignKey contains ForeignKeyColumn objects; which
   # reference the appropriate Column.  Index contains IndexColumn objects; which
-  # reference the appropriate Column.  KeyConstraint objects refernece their
-  # Index.
+  # reference the appropriate Column.
   #
   # For more details see: http://ramen.rubyforge.org or readme.txt[link:files/readme_txt.html]
   # 
@@ -125,6 +124,7 @@ module Ramen::Metadata
       load( engine::IndexColumn, sql.index_columns, connection )
       load( engine::PrimaryKey, sql.primary_keys, connection )
       load( engine::PrimaryKeyColumn, sql.primary_key_columns, connection )
+      load( engine::Trigger, sql.triggers, connection )
       #load( engine::KeyConstraint, sql.key_constraints, connection )
     end
     

data/lib/ramen/metadata/foreign_key.rb

@@ -50,6 +50,8 @@ module Ramen::Metadata
     def initialize( record, database )
       super( record, database )
       @columns = Ramen::RamenHash.new( ForeignKeyColumn, 'column' )
+      @table = database.schema[ self.table_schema ].table[ self.table_name ]
+      @referenced_table = database.schema[ self.referenced_table_schema ].table[ self.referenced_table_name]
     end
     
     # add_to( database )
@@ -57,7 +59,8 @@ module Ramen::Metadata
     # Add self to the given database.  (Choosing Message; Double Dispatch pattern)
     # (Kent Beck. Smalltalk Best Practices Patterns. Perntice Hall PTR, Upper Saddle River, NJ 1997)
     def add_to( database )
-      database.schema[ self.table_schema ].table[ self.table_name ].add_foreign_key( self )
+      @table.add_foreign_key( self )
+      @referenced_table.add_belongs_to( self )
     end
     
     # add_column( obj ) #=> obj
@@ -67,5 +70,19 @@ module Ramen::Metadata
     def add_column( obj )
       @columns.add( obj )
     end
+    
+    # referenced_table #=> Table
+    #
+    # Returns the table to which the foreign key references.
+    def referenced_table
+      @referenced_table
+    end
+    
+    # table #=> Table
+    #
+    # Returns the table which contains this foreign key.
+    def table
+      @table
+    end
   end
 end

data/lib/ramen/metadata/table.rb

@@ -4,7 +4,7 @@
 #++
 
 module Ramen::Metadata
-  # Table contains collections of Column, ForeignKey, Index, KeyConstraint, and
+  # Table contains collections of Column, ForeignKey, Index, Trigger, and
   # PrimaryKey objects.  Attributes available for Table are database engine specific.  
   # Ramen only requires the attributes table_name and table_id.  See
   # RowDataGateway for more information.
@@ -42,6 +42,8 @@ module Ramen::Metadata
     # foreign_key() #=> RamenHash reference
     # 
     # fk() #=> RamenHash reference
+    # 
+    # has() #=> RamenHash reference
     #
     # This attribute provides access to a RamenHash of all ForeignKey objects
     # in the Table.  The hash is indexed by foreign_key_id and foreign_key_name.
@@ -53,10 +55,39 @@ module Ramen::Metadata
     #   table = schema.table['Products']
     #   fk = table.fk['FK_PRODUCTS_ORDERS'] #=> #<ForeignKey...>
     #
+    # The methods #has and #belongs_to barrow their names from ActiveRecord.  In
+    # ActiveRecord these terms are used to express relations between tables or
+    # model objects.  In Ramen, #has and #belongs_to don't refer to the other Table
+    # directly, instead they provide access to the ForeignKeys that form the
+    # relationship.  Use ForeignKey#table and ForeignKey#referenced_table to
+    # access the other Table.    
     def foreign_key
       @foreign_keys
     end
     alias fk foreign_key
+    alias has foreign_key
+    
+    # belongs_to() #=> RamenHash reference
+    # 
+    # This attribute provides access to a RamenHash of all ForeignKey objects
+    # where referenced_table is this Table.
+    #
+    # usage:
+    #   require 'lib/ramen'
+    #   db = Ramen.create( configuration )
+    #   schema = db.schema['Sales']
+    #   table = schema.table['Orders']
+    #   table.belongs_to['FK_PRODUCTS_ORDERS'] #=> #<ForeignKey...>
+    #
+    # The methods #has and #belongs_to get their names from ActiveRecord.  In
+    # ActiveRecord these terms are used to express relations between tables or
+    # model objects.  In Ramen, #has and #belongs_to don't refer to the other Table
+    # directly, instead they provide access to the ForeignKeys that form the
+    # relationship.  Use ForeignKey#table and ForeignKey#referenced_table to
+    # access the other Table.    
+    def belongs_to
+      @belongs_to
+    end
     
     # index() #=> RamenHash reference
     #
@@ -96,6 +127,21 @@ module Ramen::Metadata
     alias key key_constraint
 =end
     
+    # trigger() #=> RamenHash reference
+    #
+    # This attribute provides access to a RamenHash of all Trigger objects
+    # in the Table.  The hash is indexed by trigger_name.
+    #
+    # usage:
+    #   require 'ramen'
+    #   db = Ramen.create( configuration )
+    #   schema = db.schema['Sales']
+    #   table = schema.table['Products']
+    #   trigger = table.trigger['Products_Insert_Trigger'] #=> #<Trigger...>
+    def trigger
+      @triggers
+    end
+    
     # primary_key() #=> PrimaryKey reference
     # 
     # pk() #=> PrimaryKey reference
@@ -145,8 +191,10 @@ module Ramen::Metadata
       super( record, database )
       @columns         = Ramen::RamenHash.new( Column )
       @foreign_keys    = Ramen::RamenHash.new( ForeignKey )
+      @belongs_to      = Ramen::RamenHash.new( ForeignKey )
       @indexes         = Ramen::RamenHash.new( Index )
       @key_constraints = Ramen::RamenHash.new( KeyConstraint, 'key' )
+      @triggers        = Ramen::RamenHash.new( Trigger )
       @primary_key     = nil
     end
     
@@ -158,6 +206,14 @@ module Ramen::Metadata
       database.schema[ self.table_schema ].add_table( self )
     end
 
+    # add_belongs_to( obj ) #=> obj
+    # 
+    # Adds the foreign_key to this table as a belongs_to relationship.  Throws
+    # a RamenError if the obj is not a foreign_key
+    def add_belongs_to( foreign_key )
+      @belongs_to.add( foreign_key )
+    end
+    
     # add_column( obj ) #=> obj
     #
     # Adds the column to this table.  Throws a RamenError if the obj
@@ -192,6 +248,14 @@ module Ramen::Metadata
     end
 =end
     
+    # add_trigger( obj ) #=> obj
+    #
+    # Adds the trigger to this table.  Throws a RamenError if the obj is not
+    # a Trigger.
+    def add_trigger( obj )
+      @triggers.add( obj )
+    end
+    
     # set_primary_key( obj ) #=> obj
     #
     # Sets the primary key for this table.

data/lib/ramen/metadata/trigger.rb

@@ -0,0 +1,46 @@
+#--
+# Copyright (c) 2007 Gregory N. Houston
+# See ramen.rb for license information.
+#++
+module Ramen::Metadata
+
+  # Trigger contains meta-data about data manipulation triggers (insert, update,
+  # delete). The attributes are database engine specific.  Only trigger_name
+  # trigger_schema, event_object_schema, event_object_table are required by Ramen.
+  # See RowDataGateway for more information.
+  #
+  # See Database for a description of how Trigger fits in the Ramen collection
+  # hierarchy.  For simplicity, Triggers are accessable in Ramen via their
+  # event_object_schema, event_object_name; that is, they are stored in the
+  # Table#trigger collection.
+  #
+  # Links: readme.txt[link:files/readme_txt.html]; source[link:rcov/lib-ramen-trigger_rb.html]
+  #
+  class Trigger < Ramen::RowDataGateway
+    # :section: External Methods
+    # The following methods are intended for use by Ramen's clients.
+
+    # Comparison, returns -1,0,+1, compares trigger_name
+    #
+    # TODO improve the comparison to ensure uniqueness
+    def <=> other
+      Ramen::RowDataGateway.compare( trigger_name, other )
+    end
+    
+    # :section: Internal Methods
+    # The following methods are for Ramen's internal use.  They
+    # are not intended for clients of Ramen to use.
+    
+    def initialize( record, database )
+      super( record, database )
+    end
+    
+    # add_to( database )
+    #
+    # Add self to the given database.  (Choosing Message; Double Dispatch pattern)
+    # (Kent Beck. Smalltalk Best Practices Patterns. Perntice Hall PTR, Upper Saddle River, NJ 1997)
+    def add_to( database )
+      database.schema[ self.event_object_schema ].table[ self.event_object_table ].add_trigger( self )
+    end
+  end
+end

data/lib/ramen/version.rb

@@ -10,7 +10,7 @@ module Ramen
   module Version
     MAJOR = 0
     MINOR = 4
-    REVISION = 0
+    REVISION = 1
     STRING = [MAJOR, MINOR, REVISION].join('.')
   end
 end

data/lib/ramen.rb

@@ -48,6 +48,7 @@ require 'ramen/metadata/primary_key'
 require 'ramen/metadata/primary_key_column'
 require 'ramen/metadata/schema'
 require 'ramen/metadata/table'
+require 'ramen/metadata/trigger'
 
 require 'ramen/engine/engine'
 require 'ramen/engine/sql2005'

data/readme.txt

@@ -7,10 +7,33 @@ _data_ _dictionary_, _system_ _catalog_, or _INFORMATION_ _SCHEMA_.
 
 Version:: 0.4.0 SQL Server 2005 and MySQL 5.0.
 
-It is easy to support additional database engines.  All that is needed are 
-the SQL statements to query the metadata, and maybe a few tweaks to the
-unit tests.  Please contact the author if you want help getting Ramen to
-support another database.
+What can you do with Ramen?
+* Build a tool for generating test data (see Noodle on Rubyforge)
+* Refect the structure of your database in Ruby.
+* Check your database for design problems.
+* Dynamically generate code from the database's structure.   (Similar to
+  ActiveRecord which generates the Model based on table structure.
+
+How is Ramen different than ActiveRecord?
+* ActiveRecord is for getting your data into and out of the database.  Ramen is
+  for getting meta-data about your database design.  For example, ActiveRecord can
+  get the Employee Name and Address from an Employees Table and Addresses Table (Data).
+  Ramen can tell you the database contains an Employees Table with a Name column
+  and a Foreign Key to an Address table which contains an Address column (Meta-data).
+
+* ActiveRecord normalizes the data types to a few common types which will work
+  on many database engines.  For example ActiveRecord doesn't support TIMESTAMP
+  which is a type in SQL Server 2005, but isn't available on other databases.
+  Ramen doesn't normalize the meta-data.  Instead it provides the information
+  in as much detail as possible, even when this creates variation between
+  databases.  (Ramen is also planning on adding a Normalization layer for
+  situations where a common interface is desired.)
+
+Can Ramen support my database engine?
+* Ramen 0.4.0 works with SQL Server 2005 and MySQL 5.0.  It is easy to support
+  additional database engines.  All that is needed are the SQL statements to query
+  the metadata, and maybe a few tweaks to the unit tests.  Please contact the
+  author if you want help getting Ramen to support another database.
 
 == Links:
 

data/test/mysql_create_test_db.sql

@@ -1,4 +1,4 @@
-DROP DATABASE IF EXISTS RamenTestSchema;
+DROP DATABASE IF EXISTS RamenTestSchema;
 DROP DATABASE IF EXISTS RamenTestSchema2;
 
 CREATE DATABASE RamenTestSchema;
@@ -45,3 +45,38 @@ ALTER TABLE RamenTestSchema.Bug1
 # Note, MySQL cant have a foreign key that spans schemas (databases).
 #       Some databases dont have this restriction.
 */
+CREATE TABLE RamenTestSchema.MultiColumnPK (
+  PK1 INTEGER UNSIGNED NOT NULL,
+  PK2 INTEGER UNSIGNED NOT NULL,
+  PRIMARY KEY (PK1, PK2)
+);
+
+CREATE TABLE RamenTestSchema.MultiColumnFK (
+  PK VARCHAR(16) NOT NULL,
+  FK1 INTEGER UNSIGNED NOT NULL,
+  FK2 INTEGER UNSIGNED NOT NULL,
+  PRIMARY KEY (PK)
+);
+ALTER TABLE RamenTestSchema.MultiColumnFK
+  ADD CONSTRAINT FK_MultiColumnFK_MultiColumnPK
+  FOREIGN KEY FK_MultiColumnFK_MultiColumnPK (FK1, FK2)
+    REFERENCES MultiColumnPK (PK1, PK2)
+    ON DELETE RESTRICT
+    ON UPDATE RESTRICT;
+
+CREATE TABLE RamenTestSchema.TriggerTable (
+  PK INTEGER UNSIGNED NOT NULL,
+  PRIMARY KEY (PK)
+);
+CREATE TRIGGER RamenTestSchema.TriggerTable_ITrig AFTER INSERT ON RamenTestSchema.TriggerTable
+  FOR EACH ROW BEGIN
+    -- do nothing
+  END;
+CREATE TRIGGER RamenTestSchema.TriggerTable_UTrig AFTER UPDATE ON RamenTestSchema.TriggerTable
+  FOR EACH ROW BEGIN
+    -- do nothing
+  END;
+CREATE TRIGGER RamenTestSchema.TriggerTable_DTrig AFTER DELETE ON RamenTestSchema.TriggerTable
+  FOR EACH ROW BEGIN
+    -- do nothing
+  END;

data/test/sql2005_create_test_db.sql

@@ -9,7 +9,13 @@ USE MASTER
 GO
 
 IF  EXISTS (SELECT name FROM sys.databases WHERE name = N'RamenTest')
-DROP DATABASE RamenTest
+ALTER DATABASE [RamenTest] SET  SINGLE_USER WITH ROLLBACK IMMEDIATE
+GO
+IF  EXISTS (SELECT name FROM sys.databases WHERE name = N'RamenTest')
+ALTER DATABASE [RamenTest] SET  SINGLE_USER 
+GO
+IF  EXISTS (SELECT name FROM sys.databases WHERE name = N'RamenTest')
+DROP DATABASE [RamenTest]
 GO
 
 CREATE DATABASE RamenTest
@@ -28,6 +34,11 @@ CREATE SCHEMA RamenTestSchema
         CONSTRAINT PK_Employee_EmployeeID PRIMARY KEY CLUSTERED (EmployeeID ASC))
     CREATE TABLE EmployeeAddress (EmployeeID int, AddressID int
         CONSTRAINT PK_EmployeeAddress_EmployeeID_AddressID PRIMARY KEY CLUSTERED (EmployeeID ASC, AddressID ASC))
+    CREATE TABLE MultiColumnPK (PK1 int, PK2 int
+		CONSTRAINT PK_MultiColumnPK PRIMARY KEY CLUSTERED(PK1 ASC, PK2 ASC))
+    CREATE TABLE MultiColumnFK (PK nvarchar(16), FK1 int, FK2 int
+		CONSTRAINT PK_MultiColumnFK PRIMARY KEY CLUSTERED(PK ASC))
+    CREATE TABLE TriggerTable (PK int)
 GO
 
 CREATE UNIQUE NONCLUSTERED INDEX IX_Employee_LoginID ON RamenTestSchema.Employee (LoginID ASC)
@@ -36,10 +47,21 @@ ALTER TABLE RamenTestSchema.Employee ADD CONSTRAINT FK_Employee_Employee_Manager
 ALTER TABLE RamenTestSchema.Employee CHECK CONSTRAINT FK_Employee_Employee_ManagerID
 ALTER TABLE RamenTestSchema.EmployeeAddress ADD CONSTRAINT FK_EmployeeAddress_Employee FOREIGN KEY(EmployeeID) REFERENCES RamenTestSchema.Employee (EmployeeID)
 ALTER TABLE RamenTestSchema.EmployeeAddress CHECK CONSTRAINT FK_EmployeeAddress_Employee
+ALTER TABLE RamenTestSchema.MultiColumnFK ADD CONSTRAINT FK_MultiColumnFK_MultiColumnPK FOREIGN KEY(FK1, FK2) REFERENCES RamenTestSchema.MultiColumnPK (PK1, PK2)
+ALTER TABLE RamenTestSchema.MultiColumnFK CHECK CONSTRAINT FK_MultiColumnFK_MultiColumnPK
+GO 
+
+CREATE TRIGGER RamenTestSchema.TriggerTable_ITrig ON TriggerTable FOR INSERT AS SELECT * FROM INSERTED
+GO
+CREATE TRIGGER RamenTestSchema.TriggerTable_UTrig ON TriggerTable FOR UPDATE AS SELECT * FROM INSERTED
+GO
+CREATE TRIGGER RamenTestSchema.TriggerTable_DTrig ON TriggerTable FOR DELETE AS SELECT * FROM DELETED
+GO
+CREATE TRIGGER RamenTestSchema.TriggerTable_IUTrig ON TriggerTable FOR INSERT, UPDATE AS SELECT * FROM INSERTED
 GO
 
 ALTER TABLE RamenTestSchema2.Bug1 ADD CONSTRAINT FK_Bug1_Employee FOREIGN KEY(PkID) REFERENCES RamenTestSchema.Employee (EmployeeID)
 GO
 
---CREATE SCHEMA Person
---GO
+USE MASTER
+GO

data/test/test_ramen.rb

@@ -10,6 +10,7 @@ require 'dbi'
 require 'yaml'
 require 'test/helper.rb'
 require 'test/test_bugs'
+require 'pp'
 
 # not a very good test suite, but even so it has proved invaluable when
 # making changes to ensure everything is still working.
@@ -133,6 +134,17 @@ class Test_Ramen < Test::Unit::TestCase
     assert_equal( 'employeeid', table.pk.column['EmployeeID'].column_name.downcase )
   end
   
+  def t_trigger_access( key, db )
+    @name = "test_trigger_access_#{key}"
+    table = db.schema['RamenTestSchema'].table['TriggerTable']
+    begin
+      trigger = table.trigger['TriggerTable_ITrig']
+    rescue RamenError
+      trigger = table.trigger['triggertable_itrig'] # TODO make RamenHash case-insensitive
+    end
+    assert_equal( 'ramentestschema', trigger.trigger_schema.downcase)
+  end
+  
   def t2_all( key, db, conn )
     @name = "test_all_#{key}"
     db.list_tables(conn).each do |record|
@@ -218,7 +230,16 @@ class Test_Ramen < Test::Unit::TestCase
     unless address.pk.primary_key_name == 'PRIMARY' and employee.pk.primary_key_name == 'PRIMARY' then # mysql
       compare_helper address.pk, employee.pk
     end
-    compare_helper address.pk.column['AddressID'], employee.pk.column['EmployeeID'] 
+    compare_helper address.pk.column['AddressID'], employee.pk.column['EmployeeID']
+    begin
+      trigger1 = db.schema['RamenTestSchema'].table['TriggerTable'].trigger['TriggerTable_DTrig']
+      trigger2 = db.schema['RamenTestSchema'].table['TriggerTable'].trigger['TriggerTable_UTrig']
+    rescue RamenError
+      # TODO make RamenHash case-insensitive
+      trigger1 = db.schema['RamenTestSchema'].table['TriggerTable'].trigger['triggertable_dtrig']
+      trigger2 = db.schema['RamenTestSchema'].table['TriggerTable'].trigger['triggertable_utrig']
+    end
+    compare_helper trigger1, trigger2
 #    compare_helper address.key['PK_EmployeeAddress_EmployeeID_AddressID'], employee.key['PK_Employee_EmployeeID']
   end
   
@@ -228,6 +249,42 @@ class Test_Ramen < Test::Unit::TestCase
     assert_equal(  1, b <=> a, "b <=> a; #{msg}")
     assert_equal(  0, a <=> a, "a <=> a; #{msg}")
   end
+
+  def t_fk_table( key, db )
+    @name = 'test_fk_table_#{key}'
+    table = db.schema['RamenTestSchema'].table['EmployeeAddress']
+    fk = table.fk['FK_EmployeeAddress_Employee']
+    assert_same( table, fk.table )
+  end
+  
+  def t_fk_referenced_table( key, db )
+    @name = 'test_fk_referenced_table_#{key}'
+    table = db.schema['RamenTestSchema'].table['EmployeeAddress']
+    fk = table.fk['FK_EmployeeAddress_Employee']
+    referenced_table = db.schema['RamenTestSchema'].table['Employee']
+    assert_same( referenced_table, fk.referenced_table )
+  end
+  
+  def t_fk_multicolumn( key, db )
+    @name = 'test_fk_multicolumn_#{key}'
+    table = db.schema['RamenTestSchema'].table['MultiColumnFK']
+    fk = table.fk['FK_MultiColumnFK_MultiColumnPK']
+    referenced_table = db.schema['RamenTestSchema'].table['MultiColumnPK']
+    assert_same( referenced_table, fk.referenced_table )
+    if fk.respond_to? :foreign_key_id
+      assert_equal( 4, fk.column.size )
+    else
+      assert_equal( 2, fk.column.size )
+      assert_equal( ['fk1', 'fk2'], fk.column.keys.sort )
+    end
+  end
+  
+  def t_belongs_to( key, db )
+    @name = "test_belongs_to_#{key}"
+    belongs_to = db.schema['RamenTestSchema'].table['Employee'].belongs_to['FK_EmployeeAddress_Employee']
+    fk = db.schema['RamenTestSchema'].table['EmployeeAddress'].fk['FK_EmployeeAddress_Employee']
+    assert_same( fk, belongs_to )
+  end
   
   self.instance_methods.each do |method_name|
     if method_name =~ /^t_/ then

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: ramen
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
-date: 2008-03-14 00:00:00 -05:00
+  version: 0.4.1
+date: 2008-04-28 00:00:00 -05:00
 summary: Ramen, database reflection library.  Easy access to the definition of schemas, tables, columns, indexes, and foreign keys.
 require_paths: 
 - lib
@@ -47,6 +47,7 @@ files:
 - lib/ramen/metadata/primary_key_column.rb
 - lib/ramen/metadata/schema.rb
 - lib/ramen/metadata/table.rb
+- lib/ramen/metadata/trigger.rb
 - lib/ramen/ramen_error.rb
 - lib/ramen/ramen_hash.rb
 - lib/ramen/ramen_module.rb
@@ -66,9 +67,7 @@ files:
 - test/test_ramen_hash.rb
 - test/test_ramen_module.rb
 - readme.txt
-- doc/doc_resources/MetaData_Class_Diagram.gif
 - doc/doc_resources/MetaData_Class_Diagram.png
-- doc/doc_resources/Thumbs.db
 test_files: 
 - test/config
 - test/config/config.yml