rubeus 0.0.7-java → 0.0.8-java

data/lib/rubeus/jdbc/meta_element.rb

@@ -0,0 +1,58 @@
+module Rubeus::Jdbc
+  class MetaElement
+    attr_reader :meta_data, :jdbc_info, :options
+    def initialize(meta_data, attrs, options = nil)
+      @meta_data = meta_data
+      @jdbc_info = attrs.dup
+      attrs.each do |attr, value|
+        m = "#{attr.downcase}="
+        self.send(m, value) if respond_to?(m)
+      end
+      @options = options ? options.dup : {}
+    end
+    
+    def pretty_print_instance_variables
+      self.instance_variables.sort.map{|v| v.to_sym} - [:@meta_data, :@jdbc_info, :@table]
+    end
+    
+  end
+  
+  module FullyQualifiedNamed
+    FQN_ATTRS = [:table_cat, :table_schem, :table_name]
+    FQN_ATTR_STRS = FQN_ATTRS.map{|attr| attr.to_s.upcase}
+    
+    attr_accessor *FQN_ATTRS
+    
+    def fully_qualified_name
+      [table_cat, table_schem, table_name]
+    end
+    alias_method :fqn, :fully_qualified_name
+    
+    def same_fqn?(element)
+      if element.is_a?(Hash)
+        FQN_ATTR_STRS.all?{|attr|
+          jdbc_info[attr] == element[attr]
+        }
+      elsif element.is_a?(Array)
+        fully_qualified_name == element
+      elsif element.respond_to?(:fully_qualified_name)
+        fully_qualified_name == element.fully_qualified_name
+      else
+        raise ArgumentError, "Unsupported Object #{element.inspect}. Must be a Hash or a object which have 'fully_qualified_name' method."
+      end
+    end
+  end
+
+  class TableElement < MetaElement
+    attr_reader :table
+
+    def initialize(meta_data, table, *args, &block)
+      super(meta_data, *args, &block)
+      @table = table
+    end
+    
+    def pretty_print_instance_variables
+      super - [:@table]
+    end
+  end
+end

data/lib/rubeus/jdbc/primary_key.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+require 'rubeus/jdbc/meta_element'
+module Rubeus::Jdbc
+  class PrimaryKey < TableElement
+    include FullyQualifiedNamed
+    
+    # 1. TABLE_CAT String => テーブルカタログ (null の可能性がある)
+    # 2. TABLE_SCHEM String => テーブルスキーマ (null の可能性がある)
+    # 3. TABLE_NAME String => テーブル名
+    # 4. COLUMN_NAME String => 列名
+    # 5. KEY_SEQ short => 主キー中の連番
+    # 6. PK_NAME String => 主キー名 (null の可能性がある)
+    # 
+    # see also:
+    # http://java.sun.com/j2se/1.5.0/ja/docs/ja/api/java/sql/DatabaseMetaData.html#getPrimaryKeys(java.lang.String,%20java.lang.String,%20java.lang.String)
+    
+    attr_accessor :column_name, :key_seq, :pk_name
+
+    alias_method :seq, :key_seq
+    
+    def name
+      column_name.send(options[:name_case] || :to_s)
+    end
+  end
+end

data/lib/rubeus/jdbc/result_set_column.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+module Rubeus::Jdbc
+  # ResultSetMetaDataから生成されます
+  class ResultSetColumn
+    ATTRIBUTES = [
+      :column_index       , # 
+      :catalog_name       , # String  # 指定された列のテーブルのカタログ名を取得します。
+      :column_class_name  , # String  # Java クラスの完全指定された名前を返します。
+      :column_display_size, # int     # 指定された列の通常の最大幅を文字数で示します。
+      :column_label       , # String  # 印刷や表示に使用する、指定された列の推奨タイトルを取得します。
+      :column_name        , # String  # 指定された列の名前を取得します。
+      :column_type        , # int     # 指定された列の SQL 型を取得します。
+      :column_type_name   , # String  # 指定された列のデータベース固有の型名を取得します。
+      :precision          , # int     # 指定された列の 10 進桁数を取得します。
+      :scale              , # int     # 指定された列の小数点以下の桁数を取得します。
+      :schema_name        , # String  # 指定された列のテーブルのスキーマを取得します。
+      :table_name         , # String  # 指定された列のテーブル名を取得します。
+      :auto_increment     , # boolean # 指定された列が自動的に番号付けされて読み取り専用として扱われるかどうかを示します。
+      :case_sensitive     , # boolean # 列の大文字と小文字が区別されるかどうかを示します。
+      :currency           , # boolean # 指定された列がキャッシュの値かどうかを示します。
+      :definitely_writable, # boolean # 指定された列の書き込みが必ず成功するかどうかを示します。
+      :is_nullable        , # int     # 指定された列に NULL をセットできるかどうかを示します。
+      :read_only          , # boolean # 指定された列が絶対的に書き込み可能でないかどうかを示します。
+      :searchable         , # boolean # 指定された列を where 節で使用できるかどうかを示します。
+      :signed             , # boolean # 指定された列の値が符号付き数値かどうかを示します。
+      :writable             # boolean # 指定された列への書き込みを成功させることができるかどうかを示します。
+    ]
+    attr_reader(*ATTRIBUTES)
+
+    alias_method :index       , :column_index
+    alias_method :class_name  , :column_class_name
+    alias_method :display_size, :column_display_size
+    alias_method :label       , :column_label
+    alias_method :name        , :column_name
+    alias_method :type_name   , :column_type_name
+    
+    alias_method :auto_increment?     , :auto_increment
+    alias_method :case_sensitive?     , :case_sensitive
+    alias_method :currency?           , :currency
+    alias_method :definitely_writable?, :definitely_writable
+    # alias_method :nullable?
+    alias_method :read_only?          , :read_only
+    alias_method :searchable?         , :searchable
+    alias_method :signed?             , :signed
+    alias_method :writable?           , :writable
+    
+    def initialize(index, attributes = {})
+      @index = index
+      attributes.each do |key, value|
+        instance_variable_set("@#{key.to_s}", value)
+      end
+    end
+  end
+end

data/lib/rubeus/jdbc/table.rb

@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+require 'rubeus/jdbc/meta_element'
+require "rubeus/jdbc/column"
+require "rubeus/jdbc/index"
+require "rubeus/jdbc/primary_key"
+require "rubeus/jdbc/foreign_key"
+module Rubeus::Jdbc
+  class Table < MetaElement
+    include FullyQualifiedNamed
+    
+    #  1. TABLE_CAT       String => テーブルカタログ (null の可能性がある)
+    #  2. TABLE_SCHEM     String => テーブルスキーマ (null の可能性がある)
+    #  3. TABLE_NAME      String => テーブル名
+    #  4. TABLE_TYPE      String => テーブルの型。典型的な型は、"TABLE"、"VIEW"、"SYSTEM TABLE"、"GLOBAL TEMPORARY"、"LOCAL TEMPORARY"、"ALIAS"、"SYNONYM" である
+    #  5. REMARKS         String => テーブルに関する説明
+    #  6. TYPE_CAT        String => の型のカタログ (null の可能性がある)
+    #  7. TYPE_SCHEM      String => の型のスキーマ (null の可能性がある)
+    #  8. TYPE_NAME       String => の型名 (null の可能性がある)
+    #  9. SELF_REFERENCING_COL_NAME String => 型付きテーブルの指定された「識別子」列の名前 (null の可能性がある)
+    # 10. REF_GENERATION  String => SELF_REFERENCING_COL_NAME の値の作成方法を指定する。値は、"SYSTEM"、"USER"、"DERIVED" (null の可能性がある) 
+    # 
+    # see also:
+    # http://java.sun.com/javase/ja/6/docs/ja/api/java/sql/DatabaseMetaData.html#getTables(java.lang.String,%20java.lang.String,%20java.lang.String,%20java.lang.String[])
+    # 
+    attr_accessor :table_type,
+    :remarks, :type_cat, :type_schem, :type_name, 
+    :self_referencing_col_name, :ref_generation
+    
+    attr_accessor :pluralize_table_name
+    attr_accessor :columns
+    
+    def name
+      self.table_name.send(options[:name_case] || :to_s)
+    end
+    
+    def [](column_name)
+      column_name = column_name.to_s.upcase
+      columns.detect{|col|col.column_name.upcase == column_name}
+    end
+
+    def primary_keys
+      unless @primary_keys
+        pkeys = meta_data.getPrimaryKeys(table_cat, table_schem, table_name).map{|r| r.to_hash}
+        @primary_keys = Rubeus::Util::NameAccessArray.new(
+          *pkeys.
+          select{|hash|self.same_fqn?(hash)}.
+          sort{|a,b| a['KEY_SEQ'] <=> b['KEY_SEQ']}.
+          map{|hash| Rubeus::Jdbc::PrimaryKey.new(meta_data, self, hash, options)})
+      end
+      @primary_keys
+    end
+    alias_method :pks, :primary_keys
+
+    def primary_key_names
+      primary_keys.map{|pk| pk.name}
+    end
+    alias_method :pk_names, :primary_key_names
+
+    def primary_key_columns
+      @primary_key_columns ||= 
+        Rubeus::Util::NameAccessArray.new(*primary_keys.map{|pk| self.columns[pk.name]})
+    end
+    alias_method :pk_columns, :primary_key_columns
+    
+    def self.singular_access_if_possible(method_name, plural_method)
+      define_method(method_name) do
+        values = self.send(plural_method)
+        (values.nil? || values.empty?) ? nil :
+          (values.length == 1) ? values.first : values
+      end
+    end
+    
+    singular_access_if_possible(:pk, :pks)
+    singular_access_if_possible(:pk_name, :pk_names)
+    singular_access_if_possible(:pk_column, :pk_columns)
+    singular_access_if_possible(:primary_key, :primary_keys)
+    singular_access_if_possible(:primary_key_name, :primary_key_names)
+    singular_access_if_possible(:primary_key_column, :primary_key_columns)
+    
+    def indexes
+      unless @indexes
+        @indexes = Rubeus::Util::NameAccessArray.new
+        index_infos = meta_data.getIndexInfo(table_cat, table_schem, table_name, false, true).map{|r| r.to_hash}
+        index_hash = {}
+        index_infos.each do |index_info|
+          index_uniq_key = Rubeus::Jdbc::Index::RECORD_UNIQUE_ATTRS.
+            map{|attr| attr.to_s}.map{|attr| attr.upcase}.map{|key| index_info[key]}
+          unless index_hash[index_uniq_key]
+            attrs = Rubeus::Jdbc::Index::ATTR_NAMES.map{|attr| attr.to_s}.
+              inject({}){|dest, name| dest[name.downcase] = index_info[name.upcase]; dest}
+            index = Rubeus::Jdbc::Index.new(meta_data, self, attrs, options)
+            @indexes << index
+            index_hash[index_uniq_key] = index
+          end
+        end
+        index_infos.each do |index_info|
+          index_uniq_key = Rubeus::Jdbc::Index::RECORD_UNIQUE_ATTRS.
+            map{|attr| attr.to_s}.map{|attr| attr.upcase}.map{|key| index_info[key]}
+          index = index_hash[index_uniq_key]
+          attrs = Rubeus::Jdbc::Index::Key::ATTR_NAMES.map{|attr| attr.to_s}.
+            inject({}){|dest, name| dest[name.downcase] = index_info[name.upcase]; dest}
+          index.keys << Rubeus::Jdbc::Index::Key.new(meta_data, index, attrs, options)
+        end
+      end
+      @indexes
+    end
+    
+    IMPORTED_KEY_UNIQUE_ATTRS = %w(PKTABLE_CAT PKTABLE_SCHEM PKTABLE_NAME FK_NAME)
+    
+    def imported_keys
+      unless @imported_keys
+        @imported_keys = Rubeus::Util::NameAccessArray.new
+        imported_key_hash = {}
+        imported_keys = meta_data.getImportedKeys(table_cat, table_schem, table_name).map{|r| r.to_hash}
+        imported_keys.each do |imported_key|
+          unique_key = IMPORTED_KEY_UNIQUE_ATTRS.map{|attr| imported_key[attr]}
+          unless imported_key_hash[unique_key]
+            attrs = Rubeus::Jdbc::ForeignKey::ATTR_NAMES.map{|attr| attr.to_s}.
+              inject({}){|dest, name| dest[name.downcase] = imported_key[name.upcase]; dest}
+            foreign_key = Rubeus::Jdbc::ForeignKey.new(meta_data, self, attrs, options)
+            foreign_key.fktable = self
+            foreign_key.pktable = meta_data.table_object(imported_key['PKTABLE_NAME'],
+              :catalog => imported_key['PKTABLE_CAT'], :schema => imported_key['PKTABLE_SCHEM'])
+            @imported_keys << foreign_key
+            imported_key_hash[unique_key] = foreign_key
+          end
+        end
+        imported_keys.each do |imported_key|
+          unique_key = IMPORTED_KEY_UNIQUE_ATTRS.map{|attr| imported_key[attr]}
+          foreign_key = imported_key_hash[unique_key]
+          foreign_key.fkcolumn_names ||= []
+          foreign_key.pkcolumn_names ||= []
+          foreign_key.fkcolumn_names << imported_key['FKCOLUMN_NAME'].send(options[:name_case] || :to_s)
+          foreign_key.pkcolumn_names << imported_key['PKCOLUMN_NAME'].send(options[:name_case] || :to_s)
+        end
+      end
+      @imported_keys
+    end
+    
+    EXPORTED_KEY_UNIQUE_ATTRS = %w(FKTABLE_CAT FKTABLE_SCHEM FKTABLE_NAME PK_NAME)
+    
+    def exported_keys
+      unless @exported_keys
+        @exported_keys = Rubeus::Util::NameAccessArray.new
+        exported_key_hash = {}
+        exported_keys = meta_data.getExportedKeys(table_cat, table_schem, table_name).map{|r| r.to_hash}
+        exported_keys.each do |exported_key|
+          unique_key = EXPORTED_KEY_UNIQUE_ATTRS.map{|attr| exported_key[attr]}
+          unless exported_key_hash[unique_key]
+            attrs = Rubeus::Jdbc::ForeignKey::ATTR_NAMES.map{|attr| attr.to_s}.
+              inject({}){|dest, name| dest[name.downcase] = exported_key[name.upcase]; dest}
+            foreign_key = Rubeus::Jdbc::ForeignKey.new(meta_data, self, attrs, options)
+            foreign_key.fktable = meta_data.table_object(exported_key['FKTABLE_NAME'],
+              :catalog => exported_key['FKTABLE_CAT'], :schema => exported_key['FKTABLE_SCHEM'])
+            foreign_key.pktable = self
+            @exported_keys << foreign_key
+            exported_key_hash[unique_key] = foreign_key
+          end
+        end
+        exported_keys.each do |exported_key|
+          unique_key = EXPORTED_KEY_UNIQUE_ATTRS.map{|attr| exported_key[attr]}
+          foreign_key = exported_key_hash[unique_key]
+          foreign_key.fkcolumn_names ||= []
+          foreign_key.pkcolumn_names ||= []
+          foreign_key.fkcolumn_names << exported_key['FKCOLUMN_NAME'].send(options[:name_case] || :to_s)
+          foreign_key.pkcolumn_names << exported_key['PKCOLUMN_NAME'].send(options[:name_case] || :to_s)
+        end
+      end
+      @exported_keys
+    end
+    
+    
+    
+    def rails_table_name
+      unless @rails_table_name
+        @rails_table_name = table_name.downcase
+        @rails_table_name = @rails_table_name.pluralize if pluralize_table_name
+      end
+      @rails_table_name
+    end
+    
+    def rails_table_name=(value)
+      @rails_table_name = value
+    end
+    attr_accessor :rails_options
+    
+    def define_rails_model(mod)
+      class_name = "Rails#{rails_table_name.classify}"
+      class_def =  "class #{class_name} < ActiveRecord::Base\n"
+      class_def << "  set_table_name('#{rails_table_name}')\n"
+      class_def << "end"
+      mod.module_eval(class_def)
+      mod.const_get(class_name)
+    end
+    
+    def define_jdbc_model(mod)
+      class_name = "Jdbc#{table_name.classify}"
+      class_def =  "class #{class_name} < ActiveRecord::Base\n"
+      class_def << "  set_table_name('#{table_name}')\n"
+      class_def << "  establish_connection('#{meta_data.source_db}')\n"
+      class_def << "end"
+      mod.module_eval(class_def)
+      mod.const_get(class_name)
+    end
+    
+  end
+end

data/lib/rubeus/util.rb

@@ -0,0 +1,5 @@
+module Rubeus
+  module Util
+    autoload :NameAccessArray, 'rubeus/util/name_access_array'
+  end
+end

data/lib/rubeus/util/name_access_array.rb

@@ -0,0 +1,34 @@
+module Rubeus::Util
+  class NameAccessArray < Array
+    def initialize(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options = { 
+        :name_attr => :name,
+        :detect_with => :to_s
+      }.update(options)
+      @name_attr = options[:name_attr]
+      @detect_with = options[:detect_with]
+      args.each{|arg| push(arg)}
+    end
+    
+    def by_name(name)
+      return nil unless name
+      detect_name = name.send(@detect_with)
+      detect do |item| 
+        next unless item
+        ite_name = item.send(@name_attr)
+        next unless ite_name
+        ite_name.send(@detect_with) == detect_name
+      end
+    end
+    
+    def [](*args)
+      if args.length == 1
+        if (args.first.is_a?(Symbol) || args.first.is_a?(String))
+          return by_name(args.first)
+        end
+      end
+      return super
+    end
+  end
+end

data/test/rubeus/extensions/java/sql/test_connection.rb

@@ -1,12 +1,14 @@
 require 'test/unit'
 require 'rubygems'
 require 'rubeus'
+require 'test/rubeus/extensions/java/sql/test_sql_helper'
 
 # Test for connetion.rb
 class TestConnection < Test::Unit::TestCase
-  # setup method
+  include TestSqlHelper
+  
   def setup
-    @con = Rubeus::Jdbc::DriverManager.connect("jdbc:derby:test_db;create = true", "", "")
+    setup_connection
   end
 
   def test_statement
@@ -17,17 +19,8 @@ class TestConnection < Test::Unit::TestCase
   end
 
   def test_query
-    # Drop test table
-    begin
-      @con.statement do |stmt|
-        stmt.execute_update("DROP TABLE TEST")
-      end
-    rescue
-      # table test is already exist
-    end
-
     @con.statement do |stmt|
-      stmt.execute_update("CREATE TABLE TEST (ID INT, NAME CHAR(10))")
+      create_table_after_drop("CREATE TABLE TEST (ID INT, NAME CHAR(10))", stmt)
       stmt.execute_update("INSERT INTO TEST VALUES(1, 'row1')")
       stmt.execute_update("INSERT INTO TEST VALUES(2, 'row2')")
     end
@@ -37,14 +30,13 @@ class TestConnection < Test::Unit::TestCase
       rs.each_hash do |rsNext|
         assert_equal(i, rsNext["ID"])
         assert_equal("row#{i}      ", rsNext["NAME"])
-
         i += 1
       end
     end
   end
 
   def teardown
-    @con.close
+    teardown_connection
   end
 end
 

data/test/rubeus/extensions/java/sql/test_database_meta_data.rb

@@ -0,0 +1,257 @@
+require 'test/unit'
+require 'rubygems'
+require 'rubeus'
+require 'test/rubeus/extensions/java/sql/test_sql_helper'
+
+# Test for lib/rubeus/extensions/java/sql/database_meta_data.rb
+class TestDatabaseMetaData < Test::Unit::TestCase
+  include TestSqlHelper
+
+  def setup
+    setup_connection
+    @con.statement do |stmt|
+      drop_table_if_exist("TEST", stmt)
+      # DDL from http://db.apache.org/derby/docs/dev/ja_JP/ref/rrefsqlj13590.html
+      # Index from http://db.apache.org/derby/docs/dev/ja_JP/ref/rrefsqlj20937.html
+      create_table_after_drop(<<-"EOS", stmt)
+        CREATE TABLE FLIGHTS(
+          FLIGHT_ID CHAR(6) NOT NULL ,
+          SEGMENT_NUMBER INTEGER NOT NULL ,
+          ORIG_AIRPORT CHAR(3),
+          DEPART_TIME TIME,
+          DEST_AIRPORT CHAR(3),
+          ARRIVE_TIME TIME,
+          MEAL CHAR(1) CONSTRAINT MEAL_CONSTRAINT 
+          CHECK (MEAL IN ('B', 'L', 'D', 'S')),
+          PRIMARY KEY (FLIGHT_ID, SEGMENT_NUMBER)
+          );
+        CREATE TABLE FLTAVAIL(
+          FLIGHT_ID CHAR(6) NOT NULL, 
+          SEGMENT_NUMBER INT NOT NULL, 
+          FLIGHT_DATE DATE NOT NULL, 
+          ECONOMY_SEATS_TAKEN INT,
+          BUSINESS_SEATS_TAKEN INT,
+          FIRSTCLASS_SEATS_TAKEN INT, 
+          CONSTRAINT FLTAVAIL_PK PRIMARY KEY (FLIGHT_ID, SEGMENT_NUMBER), 
+          CONSTRAINT FLTS_FK
+          FOREIGN KEY (FLIGHT_ID, SEGMENT_NUMBER)
+          REFERENCES Flights (FLIGHT_ID, SEGMENT_NUMBER)
+          );
+      EOS
+      stmt.execute_update('CREATE INDEX IDX_FLIGHT_01 ON Flights(orig_airport)')
+      stmt.execute_update('CREATE INDEX IDX_FLIGHT_02 ON Flights(orig_airport, DEPART_TIME desc)')
+      stmt.execute_update('CREATE INDEX IDX_FLIGHT_03 ON Flights(DEST_AIRPORT, ARRIVE_TIME desc)')
+      create_table_after_drop(<<-"EOS", stmt)
+        CREATE TABLE CITIES(
+          ID INT NOT NULL CONSTRAINT CITIES_PK PRIMARY KEY,
+          CITY_NAME VARCHAR(50)
+          );
+        CREATE TABLE METROPOLITAN(
+          HOTEL_ID INT NOT NULL CONSTRAINT HOTELS_PK PRIMARY KEY,
+          HOTEL_NAME VARCHAR(40) NOT NULL,
+          CITY_ID INT CONSTRAINT METRO_FK REFERENCES CITIES
+          );
+      EOS
+      stmt.execute_update('CREATE UNIQUE INDEX IDX_CITIES_01 ON CITIES(CITY_NAME)')
+      stmt.execute_update('CREATE UNIQUE INDEX IDX_METROPOLITAN_01 ON METROPOLITAN(CITY_ID, HOTEL_NAME)')
+      create_table_after_drop(<<-"EOS", stmt)
+        CREATE TABLE TEST1(
+          ID INT NOT NULL,
+          NAME VARCHAR(60)
+          );
+      EOS
+    end
+  end
+  
+  def teardown
+    teardown_connection
+  end
+
+  def test_table_objects
+    tables = @con.meta_data.tables(:schema => "APP", :name_case => :downcase)
+    assert_equal 5, tables.length
+    assert_equal ['cities', 'flights', 'fltavail', 'metropolitan', 'test1'], tables.map{|t|t.name}.sort
+    assert_not_nil tables['flights']
+    assert_not_nil tables['fltavail']
+    assert_not_nil tables['cities']
+    assert_not_nil tables['metropolitan']
+    assert_not_nil tables['test1']
+  rescue => e
+    puts e.to_s
+    puts e.backtrace.join("\n  ")
+     raise e
+  end
+  
+  def assert_column(table, name, type, size, nullable)
+    column = table.columns[name]
+    assert_not_nil column, "column '#{name}' not found"
+    assert_equal(java.sql.Types.const_get(type.to_s.upcase), column.data_type, 
+      "column '#{name}' type expected #{java.sql.Types.const_get(type.to_s.upcase).inspect} but #{column.data_type.inspect}")
+    assert_equal(size, column.size, 
+      "column '#{name}' size expected #{size.inspect} but #{column.size.inspect}")
+    assert_equal(nullable, column.nullable?, 
+      "column '#{name}' nullable expected #{nullable.inspect} but #{column.nullable?.inspect}")
+    assert_equal(nullable ? 
+      java.sql.DatabaseMetaData.columnNullable : 
+      java.sql.DatabaseMetaData.columnNoNulls, column.nullable)
+    assert_equal column, table[name]
+  end
+  
+  def test_table_object_columns
+    tables = @con.meta_data.tables(:schema => "APP", :name_case => :downcase)
+    #
+    assert_not_nil flights = tables['flights']
+    assert_equal 7, flights.columns.length
+    assert_column(flights, 'flight_id', :char, 6, false)
+    assert_column(flights, 'segment_number', :integer, 10, false)
+    assert_column(flights, 'orig_airport', :char, 3, true)
+    assert_column(flights, 'depart_time', :time, 8, true)
+    assert_column(flights, 'dest_airport', :char, 3, true)
+    assert_column(flights, 'arrive_time', :time, 8, true)
+    assert_column(flights, 'meal', :char, 1, true)
+    #
+    assert_not_nil fltavail = tables['fltavail']
+    assert_equal 6, fltavail.columns.length
+    assert_column(fltavail, 'flight_id', :char, 6, false)
+    assert_column(fltavail, 'segment_number', :integer, 10, false)
+    assert_column(fltavail, 'flight_date', :date, 10, false)
+    assert_column(fltavail, 'economy_seats_taken', :integer, 10, true)
+    assert_column(fltavail, 'business_seats_taken', :integer, 10, true)
+    assert_column(fltavail, 'firstclass_seats_taken', :integer, 10, true)
+    #
+    assert_not_nil ctiies = tables['cities']
+    assert_equal 2, ctiies.columns.length
+    assert_column(ctiies, 'id', :integer, 10, false)
+    assert_column(ctiies, 'city_name', :varchar, 50, true)
+    #
+    assert_not_nil metropolitan = tables['metropolitan']
+    assert_equal 3, metropolitan.columns.length
+    assert_column(metropolitan, 'hotel_id', :integer, 10, false)
+    assert_column(metropolitan, 'hotel_name', :varchar, 40, false)
+    assert_column(metropolitan, 'city_id', :integer, 10, true)
+    #
+    assert_not_nil test1 = tables['test1']
+    assert_equal 2, test1.columns.length
+    assert_column(test1, 'id', :integer, 10, false)
+    assert_column(test1, 'name', :varchar, 60, true)
+  rescue => e
+    puts e.to_s
+    puts e.backtrace.join("\n  ")
+    raise e
+  end
+  
+  def assert_pk(table, names)
+    assert_equal names.length, table.primary_keys.length
+    assert_equal names, table.pks.map{|k| k.name}
+    assert_equal names, table.primary_keys.map{|k| k.name}
+    assert_equal names, table.pk_names
+    assert_equal names, table.primary_key_names
+    names.each_with_index do |name, index|
+      assert_equal name, table.primary_keys[name].name
+      assert_equal index + 1, table.primary_keys[name].seq
+      assert_equal table.columns[name], table.primary_key_columns[name]
+      assert_equal table.columns[name], table.pk_columns[name]
+    end
+    case names.length
+    when 0
+      assert_equal nil, table.pk
+      assert_equal nil, table.primary_key
+      assert_equal nil, table.pk_name
+      assert_equal nil, table.primary_key_name
+      assert_equal nil, table.pk_column
+      assert_equal nil, table.primary_key_column
+    when 1
+      assert_equal table.pks.first, table.pk
+      assert_equal table.pks.first, table.primary_key
+      assert_equal table.pk_names.first, table.pk_name
+      assert_equal table.pk_names.first, table.primary_key_name
+      assert_equal table.pk_columns.first, table.pk_column
+      assert_equal table.pk_columns.first, table.primary_key_column
+    else
+      assert_equal table.pks, table.pk
+      assert_equal table.pks, table.primary_key
+      assert_equal table.pk_names, table.pk_name
+      assert_equal table.pk_names, table.primary_key_name
+      assert_equal table.pk_columns, table.pk_column
+      assert_equal table.pk_columns, table.primary_key_column
+    end
+    table.columns.each do |column|
+      if table.pk_names.include?(column.name)
+        assert_equal true, column.primary_key?, "#{table.name}.#{column.name} shoud be one of pk"
+        assert_equal true, column.pk?, "#{table.name}.#{column.name} shoud be one of pk"
+      else
+        assert_equal false, column.primary_key?, "#{table.name}.#{column.name} shoud not be one of pk"
+        assert_equal false, column.pk?, "#{table.name}.#{column.name} shoud not be one of pk"
+      end
+    end
+  end
+  
+  def test_table_objects_pk
+    tables = @con.meta_data.tables(:schema => "APP", :name_case => :downcase)
+    assert_pk(tables['flights'], %w(flight_id segment_number))
+    assert_pk(tables['fltavail'], %w(flight_id segment_number))
+    assert_pk(tables['cities'], %w(id))
+    assert_pk(tables['metropolitan'], %w(hotel_id))
+    assert_pk(tables['test1'], [])
+  end
+  
+  def assert_index(table, index_name, key_names, asc_descs)
+    assert_equal key_names, table.indexes[index_name].keys.map{|k| k.name}
+    assert_equal asc_descs, table.indexes[index_name].keys.map{|k| k.asc?}
+  end
+  
+  def test_table_objects_index
+    tables = @con.meta_data.tables(:schema => "APP", :name_case => :downcase)
+    # assert_equal %w(idx_flight_01 idx_flight_02 idx_flight_03), tables['flights'].indexes.map{|idx| idx.name}
+    # assert_equal 3, tables['flights'].indexes.length
+    assert_index(tables['flights'], 'idx_flight_01', %w(orig_airport), [true])
+    assert_index(tables['flights'], 'idx_flight_02', %w(orig_airport depart_time), [true, false])
+    assert_index(tables['flights'], 'idx_flight_03', %w(dest_airport arrive_time), [true, false])
+    # assert_equal 0, tables['fltavail'].indexes.length
+    
+    # assert_equal 1, tables['cities'].indexes.length
+    assert_index(tables['cities'], 'idx_cities_01', %w(city_name), [true])
+    # assert_equal 1, tables['metropolitan'].indexes.length
+    assert_index(tables['metropolitan'], 'idx_metropolitan_01', %w(city_id hotel_name), [true, true])
+
+    # assert_equal 0, tables['test1'].indexes.length
+  end
+  
+  def assert_fk(fk_name, pktable, pkcolumn_names, fktable, fkcolumn_names)
+    imported_key = fktable.imported_keys[fk_name]
+    exported_key = pktable.exported_keys[fk_name]
+    assert_equal fk_name, imported_key.name
+    assert_equal fk_name, exported_key.name
+    
+    assert_equal pktable.name, imported_key.pktable.name
+    assert_equal fktable.name, imported_key.fktable.name
+    assert_equal pktable.name, exported_key.pktable.name
+    assert_equal fktable.name, exported_key.fktable.name
+    
+    assert_equal pkcolumn_names.length, imported_key.length
+    assert_equal fkcolumn_names.length, exported_key.length
+    assert_equal imported_key.length, exported_key.length
+
+    pkcolumn_names.each_with_index do |column_name, index|
+      [imported_key, exported_key].each do |key|
+        assert_equal pkcolumn_names[index], key.pkcolumn_names[index]
+        assert_equal pkcolumn_names[index], key.pkcolumns[index].name
+        assert_equal pktable, key.pkcolumns[index].table
+        assert_equal fkcolumn_names[index], key.fkcolumn_names[index]
+        assert_equal fkcolumn_names[index], key.fkcolumns[index].name
+        assert_equal fktable, key.fkcolumns[index].table
+      end
+    end
+  end
+  
+  def test_table_objects_imported_keys_and_exported_keys
+    tables = @con.meta_data.tables(:schema => "APP", :name_case => :downcase)
+    assert_fk('flts_fk', 
+      tables['flights'], %w(flight_id segment_number),
+      tables['fltavail'], %w(flight_id segment_number))
+    assert_fk('metro_fk', 
+      tables['cities'], %w(id),
+      tables['metropolitan'], %w(city_id))
+  end
+  
+end