ramen 0.4.0

data/lib/ramen/engine/sql2005.rb

@@ -0,0 +1,377 @@
+#--
+# Copyright (c) 2007 Gregory N. Houston
+# See ramen.rb for license information.
+#++
+
+module Ramen
+  # Responsible for returning T-SQL statements for various Sql Server 2005 queries.
+  #
+  # Links: readme.txt[link:files/readme_txt.html]; source[link:rcov/lib-ramen-sql2005_rb.html]
+  #
+  module Sql2005
+    include Ramen::Engine
+    
+    class Sql
+      # returns the query for all schemas and their meta-data.
+      #
+      # the query must include schema_name.
+      def Sql.schemas
+<<SQL
+select 
+  sys.schemas.schema_id, 
+  sys.schemas.name as schema_name
+from sys.schemas 
+SQL
+      end
+
+      # returns the query for all tables and their meta-data.
+      #
+      # the query must include the table_schema and table_name.
+      def Sql.tables
+<<SQL
+select 
+  sys.tables.schema_id,
+  sys.schemas.name as table_schema,
+  sys.tables.object_id as table_id,
+  sys.tables.name as table_name,
+  sys.tables.principal_id,
+  sys.tables.parent_object_id,
+  sys.tables.type as table_type,
+  sys.tables.type_desc,
+  sys.tables.create_date,
+  sys.tables.modify_date,
+  sys.tables.is_ms_shipped,
+  sys.tables.is_published,
+  sys.tables.is_schema_published,
+  sys.tables.lob_data_space_id,
+  sys.tables.filestream_data_space_id,
+  sys.tables.max_column_id_used,
+  sys.tables.lock_on_bulk_load,
+  sys.tables.uses_ansi_nulls,
+  sys.tables.is_replicated,
+  sys.tables.has_replication_filter,
+  sys.tables.is_merge_published,
+  sys.tables.is_sync_tran_subscribed,
+  sys.tables.has_unchecked_assembly_data,
+  sys.tables.text_in_row_limit,
+  sys.tables.large_value_types_out_of_row
+from sys.tables
+  inner join sys.schemas on sys.tables.schema_id = sys.schemas.schema_id
+SQL
+      end
+
+      # selects all tables, via a different query.  used for testing only.
+      # 
+      # returns table_schema (e.g. schema_name) and table_name for every table.
+      def Sql.list_tables
+<<SQL
+select 
+  sys.schemas.name as table_schema,
+  sys.tables.name as table_name
+from sys.tables
+  inner join sys.schemas on sys.tables.schema_id = sys.schemas.schema_id
+SQL
+      end
+
+      # returns the query for all columns and their meta-data.
+      #
+      # the query must include the table_schema, table_name and column_name.
+      def Sql.columns
+<<SQL
+select
+  sys.schemas.schema_id as schema_id,
+  sys.schemas.name as table_schema,
+  sys.columns.object_id as table_id,
+  sys.tables.name as table_name,
+  sys.columns.name as column_name,
+  sys.columns.column_id,
+  sys_type.name as system_type_name,
+  user_type.name as user_type_name,
+  sys.columns.max_length,
+  sys.columns.precision,
+  sys.columns.scale,
+  sys.columns.collation_name,
+  sys.columns.is_nullable,
+  sys.columns.is_ansi_padded,
+  sys.columns.is_rowguidcol,
+  sys.columns.is_identity,
+  sys.columns.is_computed,
+  sys.columns.is_filestream,
+  sys.columns.is_replicated,
+  sys.columns.is_non_sql_subscribed,
+  sys.columns.is_merge_published,
+  sys.columns.is_dts_replicated,
+  sys.columns.is_xml_document,
+  sys.columns.xml_collection_id,
+  sys.columns.default_object_id,
+  sys.columns.rule_object_id
+from sys.columns
+inner join sys.tables on 
+  sys.columns.object_id = sys.tables.object_id 
+inner join sys.schemas on
+  sys.tables.schema_id = sys.schemas.schema_id
+inner join sys.types sys_type on
+  sys.columns.system_type_id = sys_type.user_type_id
+inner join sys.types user_type on
+  sys.columns.user_type_id = user_type.user_type_id
+SQL
+      end
+
+      # returns the query for all foreign keys and their meta-data.
+      #
+      # the query must include the table_schema, table_name and foreign_key_name.
+      def Sql.foreign_keys
+<<SQL
+select
+  sys.foreign_keys.schema_id,
+  sys.schemas.name as table_schema,
+  sys.foreign_keys.parent_object_id as table_id,
+  sys.tables.name as table_name,
+  sys.foreign_keys.object_id as foreign_key_id,
+  sys.foreign_keys.name as foreign_key_name,
+  sys.foreign_keys.principal_id,
+  sys.foreign_keys.type as key_type,
+  sys.foreign_keys.type_desc,
+  sys.foreign_keys.create_date,
+  sys.foreign_keys.modify_date,
+  sys.foreign_keys.is_ms_shipped,
+  sys.foreign_keys.is_published,
+  sys.foreign_keys.is_schema_published,
+  sys.foreign_keys.referenced_object_id,
+  sys.foreign_keys.key_index_id,
+  sys.foreign_keys.is_disabled,
+  sys.foreign_keys.is_not_for_replication,
+  sys.foreign_keys.is_not_trusted,
+  sys.foreign_keys.delete_referential_action,
+  sys.foreign_keys.delete_referential_action_desc,
+  sys.foreign_keys.update_referential_action,
+  sys.foreign_keys.update_referential_action_desc,
+  sys.foreign_keys.is_system_named
+from sys.foreign_keys
+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
+SQL
+      end
+
+      # returns the query for all foreign key columns and their meta-data.
+      #
+      # the query must include foreign_key_name, table_schema, table_name, 
+      # column_name, referenced_table_schema, referenced_table_name,
+      # referenced_column_name.
+      def Sql.foreign_key_columns
+<<SQL
+select 
+  sys.schemas.schema_id,
+  sys.schemas.name as table_schema,
+  sys.foreign_key_columns.parent_object_id as table_id,
+  sys.tables.name as table_name,
+  sys.foreign_key_columns.constraint_object_id as foreign_key_id,
+  sys.foreign_keys.name as foreign_key_name,
+  parent_columns.name as column_name,
+  parent_column_id as column_id,
+  referenced_schema.name as referenced_table_schema,
+  referenced_table.name as referenced_table_name,
+  referenced_columns.name as referenced_column_name,
+  referenced_column_id,
+  referenced_columns.is_nullable
+from sys.foreign_key_columns 
+inner join sys.tables on 
+  sys.foreign_key_columns.parent_object_id = sys.tables.object_id 
+inner join sys.schemas on
+  sys.tables.schema_id = sys.schemas.schema_id
+inner join sys.foreign_keys on
+  sys.foreign_key_columns.constraint_object_id = sys.foreign_keys.object_id 
+inner join sys.columns parent_columns on
+  sys.foreign_key_columns.parent_object_id = parent_columns.object_id
+  and sys.foreign_key_columns.parent_column_id = parent_columns.column_id
+inner join sys.tables referenced_table on
+  sys.foreign_key_columns.referenced_object_id = referenced_table.object_id
+inner join sys.columns referenced_columns on
+  referenced_table.object_id = referenced_columns.object_id
+  and referenced_column_id = referenced_columns.column_id
+inner join sys.schemas referenced_schema on
+  referenced_table.schema_id = referenced_schema.schema_id
+SQL
+      end
+
+      # returns the query for all primary keys and their meta-data.
+      #
+      # the query must include the table_schema, table_name and
+      # primary_key_name.
+      def Sql.primary_keys
+<<SQL
+select
+  sys.schemas.schema_id,
+  sys.schemas.name as table_schema,
+  sys.indexes.object_id as table_id,
+  sys.tables.name as table_name,
+  sys.indexes.index_id as primary_key_id,
+  sys.indexes.name as primary_key_name,
+  sys.indexes.type as index_type,
+  sys.indexes.type_desc,
+  sys.indexes.is_unique,
+  sys.indexes.data_space_id,
+  sys.indexes.ignore_dup_key,
+  sys.indexes.is_primary_key,
+  sys.indexes.is_unique_constraint,
+  sys.indexes.fill_factor,
+  sys.indexes.is_padded,
+  sys.indexes.is_disabled,
+  sys.indexes.is_hypothetical,
+  sys.indexes.allow_row_locks,
+  sys.indexes.allow_page_locks	
+from sys.indexes
+inner join sys.tables on 
+  sys.indexes.object_id = sys.tables.object_id
+inner join sys.schemas on
+  sys.tables.schema_id = sys.schemas.schema_id
+where sys.indexes.is_primary_key = 1
+SQL
+      end
+
+      # returns the query for all primary key columns and their meta-data.
+      #
+      # the query must include the table_schema, table_name, 
+      # primary_key_name, column_name and referenced_column_name.
+      def Sql.primary_key_columns
+<<SQL
+select
+  sys.schemas.schema_id,
+  sys.schemas.name as table_schema,
+  sys.index_columns.object_id as table_id,
+  sys.tables.name as table_name,
+  sys.index_columns.index_id as primary_key_id,
+  sys.indexes.name as primary_key_name,
+  sys.index_columns.column_id,
+  sys.columns.name as column_name,
+  sys.index_columns.index_column_id as primary_key_column_id,
+  sys.index_columns.key_ordinal,
+  sys.index_columns.partition_ordinal,
+  sys.index_columns.is_descending_key,
+  sys.index_columns.is_included_column
+from sys.index_columns
+inner join sys.tables 
+  on sys.index_columns.object_id = sys.tables.object_id
+inner join sys.schemas 
+  on sys.tables.schema_id = sys.schemas.schema_id
+inner join sys.indexes 
+  on sys.index_columns.index_id = sys.indexes.index_id
+  and sys.indexes.object_id = sys.tables.object_id
+inner join sys.columns 
+  on sys.indexes.object_id = sys.columns.object_id 
+  and sys.index_columns.column_id = sys.columns.column_id
+where sys.indexes.is_primary_key = 1
+SQL
+      end
+
+      # returns the query for all indexes (except primary keys) and their meta-data.
+      #
+      # the query must include the schema_id, table_id, 
+      # index_id and index_name.
+      def Sql.indexes
+<<SQL
+select
+  sys.schemas.schema_id,
+  sys.schemas.name as table_schema,
+  sys.indexes.object_id as table_id,
+  sys.tables.name as table_name,
+  sys.indexes.index_id,
+  sys.indexes.name as index_name,
+  sys.indexes.type as index_type,
+  sys.indexes.type_desc,
+  sys.indexes.is_unique,
+  sys.indexes.data_space_id,
+  sys.indexes.ignore_dup_key,
+  sys.indexes.is_primary_key,
+  sys.indexes.is_unique_constraint,
+  sys.indexes.fill_factor,
+  sys.indexes.is_padded,
+  sys.indexes.is_disabled,
+  sys.indexes.is_hypothetical,
+  sys.indexes.allow_row_locks,
+  sys.indexes.allow_page_locks	
+from sys.indexes
+inner join sys.tables on 
+  sys.indexes.object_id = sys.tables.object_id
+inner join sys.schemas on
+  sys.tables.schema_id = sys.schemas.schema_id
+where sys.indexes.is_primary_key = 0
+SQL
+      end
+
+      # returns the query for all index columns and their meta-data.
+      #
+      # the query must include the schema_id, table_id, 
+      # index_id, column_name, column_id.
+      def Sql.index_columns
+<<SQL
+select
+  sys.schemas.schema_id,
+  sys.schemas.name as table_schema,
+  sys.index_columns.object_id as table_id,
+  sys.tables.name as table_name,
+  sys.index_columns.index_id,
+  sys.indexes.name as index_name,
+  sys.index_columns.column_id,
+  sys.columns.name as column_name,
+  sys.index_columns.index_column_id,
+  sys.index_columns.key_ordinal,
+  sys.index_columns.partition_ordinal,
+  sys.index_columns.is_descending_key,
+  sys.index_columns.is_included_column
+from sys.index_columns
+inner join sys.tables 
+  on sys.index_columns.object_id = sys.tables.object_id
+inner join sys.schemas 
+  on sys.tables.schema_id = sys.schemas.schema_id
+inner join sys.indexes 
+  on sys.index_columns.index_id = sys.indexes.index_id
+  and sys.indexes.object_id = sys.tables.object_id
+inner join sys.columns 
+  on sys.indexes.object_id = sys.columns.object_id 
+  and sys.index_columns.column_id = sys.columns.column_id
+where sys.indexes.is_primary_key = 0
+SQL
+      end
+
+      # returns the query for all key constraints and their meta-data.
+      #
+      # the query must include the schema_id, table_id, 
+      # key_id, key_name, and index_id.
+=begin      
+      def Sql.key_constraints
+<<SQL
+select 
+  sys.key_constraints.schema_id,
+  sys.schemas.name as table_schema,
+  sys.key_constraints.parent_object_id as table_id,
+  sys.tables.name as table_name,
+  sys.key_constraints.object_id as key_id,
+  sys.key_constraints.name as key_name,
+  sys.key_constraints.type as key_type,
+  sys.key_constraints.type_desc,
+  sys.key_constraints.create_date,
+  sys.key_constraints.modify_date,
+  sys.key_constraints.is_ms_shipped,
+  sys.key_constraints.is_published,
+  sys.key_constraints.is_schema_published,
+  sys.key_constraints.unique_index_id,
+  sys.key_constraints.unique_index_id as index_id, -- alias
+  sys.indexes.name as index_name,
+  sys.key_constraints.is_system_named
+from sys.key_constraints
+inner join sys.tables on 
+  sys.key_constraints.parent_object_id = sys.tables.object_id
+inner join sys.schemas on 
+  sys.tables.schema_id = sys.schemas.schema_id
+inner join sys.indexes on
+  sys.key_constraints.parent_object_id = sys.indexes.object_id
+  and sys.key_constraints.unique_index_id = sys.indexes.index_id
+SQL
+      end
+=end      
+    end
+  end
+end

data/lib/ramen/home.rb

@@ -0,0 +1,162 @@
+#--
+# Copyright (c) 2007 Gregory N. Houston
+# See ramen.rb for license information.
+#++
+
+module Ramen
+
+  # Home - noun.  Synonyms: Environment, Context
+  #
+  # Home contains the environmental stuff that
+  # is shared or used by many parts of Ramen.
+  #
+  # home.sql = module with details for database engine used.  see Sql2005 for an example.
+  #
+  # home.log = logger
+  #
+  # Home also contains common database
+  # access functions.  (in the future, these
+  # might move a a data access layer.)
+  #
+  # Links: readme.txt[link:files/readme_txt.html]; source[link:rcov/lib-ramen-home_rb.html]
+  #
+  class Home
+    attr_reader :log, :sql
+    
+    # :section: External Methods
+    # The following methods are intended for use by Ramen's clients.
+    
+    # Home.new( configuration ) #=> instance of Home
+    #
+    #   database = Database.new( Home.new( :sql => Sql2005 ), DBI.connection(...) )
+    #
+    # Ramen.create is a short-cut for the statement above. e.g.
+    #
+    #   database = Ramen.create( :connection => DBI.connect(...), :sql = Sql2005.new )
+    #
+    # Note that Home.new doesn't accepts a :connection, only Ramen#create.  The
+    # connection is not stored, it is only used during the call to Ramen#create.
+    #
+    # The configuration hash can include the following options:
+    #
+    # :logger     => a logger, see DefaultLogger for an example;
+    # default = DefaultLogger
+    #
+    # :sql        => class which provides the sql statments;
+    # default = Sql2005
+    #
+    # An alternative way to specify the configuration is to override
+    # the methods which create the defaults: new_logger, new_sql.  For example:
+    # 
+    #   module Ramen
+    #     class Home
+    #       def new_logger
+    #         get_logger_from_configuration_file()
+    #       end
+    #     end
+    #   end
+    #
+    def initialize( configuration = {} )
+      @log = configuration[:logger] || new_logger
+      @sql = configuration[:sql] || new_sql
+    end
+    
+    # :section: Internal Helper Methods
+    # The following are helper methods for Ramen's internal use.  They
+    # are not intended for clients of Ramen to use.
+    
+=begin
+THE FOLLOWING IS NOT USED, BUT I'M KEEPING THIS CODE SINCE IT IS LIKELY TO
+BE USED IN THE FUTURE.
+    def select_one( stmt, *args )
+      @log.debug "stmt=\"#{stmt}\", args=#{args.inspect}"
+      begin
+        @dbi.select_one( stmt, *args )
+      rescue 
+        @log.error "--------ERROR------------"
+        @log.error "stmt=\"#{stmt}\", args=#{args.inspect}"
+        @log.error $!
+        raise
+      end
+    end
+=end
+
+    # select( connection, sql_statement, args ) #=> rows, columns
+    #
+    #   rows, columns = select( connection, 'select * from some_table' )
+    #   
+    # helper methods to run a sql statement and return
+    # the resulting data along with the column names.
+    #
+    # this wraps dbi.execute with some logging, and other common steps.
+    def select( connection, stmt, *args )
+      @log.debug "stmt=\"#{stmt}\", args=#{args.inspect}"
+      begin
+        query = connection.execute( stmt, *args )
+        rows = query.fetch_all
+        cols = query.column_names
+        return rows, cols
+      ensure
+        query.finish unless query.nil?
+      end
+    end
+    
+    # execute( connection, sql_statement, args ) { |row| ... } 
+    #
+    #   execute( connection, 'select * from some_table' ) do |row|
+    #     puts row
+    #   end
+    #
+    # helper methods to run a sql statement and call
+    # a block for each row
+    #
+    # this wraps dbi.execute with some logging, and other common steps.
+    def execute( connection, stmt, *args )
+     @log.debug "stmt=\"#{stmt}\", args=#{args.inspect}"
+     begin
+       query = connection.execute( stmt, *args )
+       query.fetch do |row|
+         yield row
+       end
+     rescue 
+        @log.error "--------ERROR------------"
+        @log.error "stmt=\"#{stmt}\", args=#{args.inspect}"
+        @log.error $!
+        raise
+     ensure
+      query.finish unless query.nil?
+     end
+    end
+    
+    # :section: Internal Factory Methods
+    # The following are methods for Ramen's internal use.  They
+    # are not intended for clients of Ramen to call.  Clients may
+    # redefine these methods to change their behavior.
+    
+    # new_logger() #=> logger
+    #
+    # factory method, called by Home.new to get the default logger.
+    #
+    # returns an instance of DefaultLogger.
+    #
+    # To change the logger, either provide a logger (Log4Ruby will work) 
+    # when calling Home.new( :logger=> log ), or redefine this method.
+    def new_logger
+      DefaultLogger.new
+    end
+    
+    # new_sql #=> sql
+    #
+    # factory method, called by Home.new to get the default
+    # sql catalog.
+    #
+    # returns an instance of Sql2005 by default.
+    #
+    # To support different database engines, either provide a sql catalog
+    # when calling Home.new( :sql => sql_for_my_database ), or redefine this
+    # method.
+    def new_sql
+      Sql2005
+    end
+  end
+end

data/lib/ramen/metadata/column.rb

@@ -0,0 +1,38 @@
+#--
+# Copyright (c) 2007 Gregory N. Houston
+# See ramen.rb for license information.
+#++
+
+module Ramen::Metadata
+  # Column contains meta-data about columns within a Table.  The attributes are
+  # database engine specific.  Only column_name and column_id are required by
+  # Ramen.
+  # See RowDataGateway for more information.
+  #
+  # See Database for a description of how Column fits in the Ramen collection
+  # hierarchy.
+  #
+  # Links: readme.txt[link:files/readme_txt.html]; source[link:rcov/lib-ramen-column_rb.html]
+  #
+  class Column < Ramen::RowDataGateway
+    # :section: External Methods
+    # The following methods are intended for use by Ramen's clients.
+
+    # Comparison, returns -1,0,+1, compares column_name
+    def <=> other
+      Ramen::RowDataGateway.compare( column_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.
+    
+    # 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.table_schema ].table[ self.table_name ].add_column( self )
+    end
+  end
+end

data/lib/ramen/metadata/database.rb

@@ -0,0 +1,137 @@
+#--
+# Copyright (c) 2007 Gregory N. Houston
+# See ramen.rb for license information.
+#++
+
+module Ramen::Metadata
+  # Database is the top of a tree of collections and classes that
+  # contain the reflected information about the schema.
+  #
+  # Database is synonymous with Catalog on some database engines.
+  # 
+  # link:doc_resources/MetaData_Class_Diagram.png
+  #
+  # 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
+  # reference the appropriate Column.  Index contains IndexColumn objects; which
+  # reference the appropriate Column.  KeyConstraint objects refernece their
+  # Index.
+  #
+  # For more details see: http://ramen.rubyforge.org or readme.txt[link:files/readme_txt.html]
+  # 
+  # usage:
+  #   db = Ramen.create( configuration ) # a short-cut for Database.new
+  #   schema = db.schema['HumanResources']
+  #
+  # Links: readme.txt[link:files/readme_txt.html]; source[link:rcov/lib-ramen-database_rb.html]
+  #
+  class Database
+    # :section: External Methods
+    # The following methods are intended for use by Ramen's clients.
+    
+    # Database.new( connection, home ) #=> instance of Database
+    #
+    #  db = Database.new( DBI.connect(...), Home.new( :sql => Sql2005.new ) )
+    #
+    # Creates a database and loads all the objects (Schema, Table, Column, etc).
+    # To get the best performance for typical usage, Database.new will load
+    # all objects. Loading all objects during Database.new
+    # makes the fewest queries to the database server.
+    #
+    # Ramen does not hold on to the connection.  After this method returns, it
+    # is safe to close the connection or use it for other queries.  
+    #
+    # see Home.new for configuration options.
+    #
+    # Ramen.create in an alternative method to calling Database.new
+    def initialize( connection, home )
+      @home = home
+      load_all_objects( connection )
+    end
+
+    # schema() #=> RamenHash reference
+    #
+    # This attribute provides access to a RamenHash of all Schema in the
+    # Database.  The hash is indexed by schema_name and schema_id.
+    #
+    # usage:
+    #   require 'lib/ramen'
+    #   db = Ramen.create( configuration )
+    #   db.schema['Sales']  #=> #<Schema schema_name='Sales', schema_id='1234567' ...>
+    #   db.schema[1234567]  #=> #<Schema schema_name='Sales', schema_id='1234567' ...>
+    #
+    def schema
+      @schemas
+    end
+    
+    # inspect() #=> string
+    #
+    # Returns a nice and brief output of the database and it's schema.  This
+    # was redefined since the default inspect would typically output many
+    # pages of details.
+    #
+    # Each schema is listed by id:name.
+    #
+    # usage:
+    #   db = Ramen.create()
+    #   db.inspect  #=> "#<Ramen::Database:0x2da0668 schema=[1:dbo, 2:guest,..."
+    #
+    def inspect
+      children = []
+      @schemas.each_by_id do |id,schema|
+        children << (id.to_s+':'+schema.schema_name)
+      end
+      to_s[0..-2]+' schema=['+children.join(', ')+']>'
+    end
+    
+    # :section: Internal Methods
+    # The following methods are for Ramen's internal use.  They
+    # are not intended for clients of Ramen to use.
+    
+    # add_schema( obj ) #=> obj
+    #
+    # Adds the given schema to this database.  Throws a RamenError if the obj
+    # is not a Schema.
+    def add_schema( obj )
+      @schemas.add( obj )
+    end
+    
+    # list_tables() #=> Array of Array containing table_name, table_id, 
+    # schema_name, schema_id
+    #
+    # Intended for use by testing.  This lists all tables in the database using
+    # a call which is different than the one used to load_all_objects.
+    def list_tables( connection )
+      result = Array.new
+      @home.execute( connection, @home.sql::Sql.list_tables ) do |row|
+        result << [row['table_schema'], row['table_name']]
+      end
+      result
+    end
+
+    private
+    def load_all_objects( connection )
+      @schemas = Ramen::RamenHash.new( Schema )
+      sql = @home.sql::Sql
+      engine = @home.sql
+      load( engine::Schema, sql.schemas, connection )
+      load( engine::Table, sql.tables, connection )
+      load( engine::Column, sql.columns, connection )
+      load( engine::ForeignKey, sql.foreign_keys, connection )
+      load( engine::ForeignKeyColumn, sql.foreign_key_columns, connection )
+      load( engine::Index, sql.indexes, connection )
+      load( engine::IndexColumn, sql.index_columns, connection )
+      load( engine::PrimaryKey, sql.primary_keys, connection )
+      load( engine::PrimaryKeyColumn, sql.primary_key_columns, connection )
+      #load( engine::KeyConstraint, sql.key_constraints, connection )
+    end
+    
+    def load( clazz, sql, connection )
+      data, columns = @home.select( connection, sql )
+      clazz.add_attributes( columns )
+      data.each { |record| clazz.new(record, self).add_to(self) }
+    end
+  end
+end