drysql 0.2.1 → 0.2.2

data/lib/dependencies.rb

@@ -17,13 +17,17 @@ class Module #:nodoc:
         class #{class_id} < ActiveRecord::Base   
         end
       end_class_def
-      if ActiveRecord::Base.table_exists?(class_id)
-        eval(class_def, TOPLEVEL_BINDING)     
-        ActiveRecord::Base.logger.info("DRYSQL >> GENERATED CLASS: #{class_id} < ActiveRecord::Base")     
-      else 
-        ActiveRecord::Base.logger.error("DRYSQL >> No matching table could be found for class: #{class_id}")
-        raise NameError     
-      end      
+      begin
+        if ActiveRecord::Base.table_exists?(class_id)
+          eval(class_def, TOPLEVEL_BINDING)     
+          ActiveRecord::Base.logger.info("DRYSQL >> GENERATED CLASS: #{class_id} < ActiveRecord::Base")     
+        else 
+          ActiveRecord::Base.logger.error("DRYSQL >> No matching table could be found for class: #{class_id}")
+          raise NameError     
+        end  
+      rescue ActiveRecord::ConnectionNotEstablished
+	    throw "Unable to search for matching table for class #{class_id}: no database connection has been established"
+      end    
     end
     const_get(class_id)
   end

data/lib/drysql.rb

@@ -8,8 +8,8 @@ require 'connection_adapters/mysql_adapter'
 require 'connection_adapters/postgresql_adapter'
 require 'connection_adapters/sqlserver_adapter'
 require 'connection_adapters/oracle_adapter'
-if defined?(ActiveRecord::ConnectionAdapters::IBM_DB2Adapter)
-  require 'connection_adapters/ibm_db2_adapter' 
+if defined?(ActiveRecord::ConnectionAdapters::IBM_DBAdapter)
+  require 'connection_adapters/ibm_db_adapter' 
 end
 require 'connection_adapters/abstract/schema_definitions'
 require 'associations'

data/lib/validations.rb

@@ -73,27 +73,32 @@ module ActiveRecord
       #     I believe there is value in validating our PK, FK, and counter columns
       def generate_validations
         unless @validations 
-            columns.each do |column|
-            
-            if !(column.null || column.default_specified? || column.generated?)
-              self.validates_nullability_of column.name
-              logger.info("DRYSQL >> GENERATED VALIDATION: #{self.name} validates_nullability_of #{column.name}")
+          columns.each do |column|
+			# Columns are considered nullable if any of the following are true:
+			#
+			# 1) Column does not have a NOT NULL constraint
+			# 2) Column has a default value specified
+			# 3) Column is generated 
+			#    (DrySQL makes the assumption that if a column is a PK and of type integer, then it is generated)
+			if !(column.is_nullable? || (column.name.upcase == self.primary_key.upcase && column.type == :integer))
+            	self.validates_nullability_of column.name
+             	logger.info("DRYSQL >> GENERATED VALIDATION: #{self.name} validates_nullability_of :#{column.name}")
             end
             
-            if column.type == :integer   
-              self.validates_numericality_of column.name, :allow_nil => true, :only_integer => true
-              logger.info("DRYSQL >> GENERATED VALIDATION: #{self.name} validates_numericality_of #{column.name}, :allow_nil=>true, :only_integer=>true")
-            elsif column.number?
-              self.validates_numericality_of column.name, :allow_nil => true
-              logger.info("DRYSQL >> GENERATED VALIDATION: #{self.name} validates_numericality_of #{column.name}, :allow_nil=>true")
-            elsif column.text? && column.limit
-              self.validates_length_of column.name, :allow_nil => true, :maximum => column.limit
-              logger.info("DRYSQL >> GENERATED VALIDATION: #{self.name} validates_length_of #{column.name}, :allow_nil=>true, :maximum=>#{column.limit}")
-            elsif column.type == :boolean
-              self.validates_inclusion_of column.name, :in => [true, false], :allow_nil =>true, :message => ActiveRecord::Errors.default_error_messages[:inclusion]
-              logger.info("DRYSQL >> GENERATED VALIDATION: #{self.name} validates_inclusion_of #{column.name}, :in=>[true, false], \
-                :allow_nil=>true, :message=>ActiveRecord::Errors.default_error_messages[:inclusion]")
-            end
+	        if column.type == :integer   
+	          self.validates_numericality_of column.name, :allow_nil => true, :only_integer => true
+	          logger.info("DRYSQL >> GENERATED VALIDATION: #{self.name} validates_numericality_of :#{column.name}, :allow_nil=>true, :only_integer=>true")
+	        elsif column.number?
+	          self.validates_numericality_of column.name, :allow_nil => true
+	          logger.info("DRYSQL >> GENERATED VALIDATION: #{self.name} validates_numericality_of :#{column.name}, :allow_nil=>true")
+	        elsif column.text? && column.limit
+	          self.validates_length_of column.name, :allow_nil => true, :maximum => column.limit
+	          logger.info("DRYSQL >> GENERATED VALIDATION: #{self.name} validates_length_of :#{column.name}, :allow_nil=>true, :maximum=>#{column.limit}")
+	        elsif column.type == :boolean
+	          self.validates_inclusion_of column.name, :in => [true, false], :allow_nil =>true, :message => ActiveRecord::Errors.default_error_messages[:inclusion]
+	          logger.info("DRYSQL >> GENERATED VALIDATION: #{self.name} validates_inclusion_of :#{column.name}, :in=>[true, false], \
+	            :allow_nil=>true, :message=>ActiveRecord::Errors.default_error_messages[:inclusion]")
+	        end
           end         
         end
         @validations=true

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: drysql
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
-date: 2007-02-08 00:00:00 -05:00
+  version: 0.2.2
+date: 2007-11-04 00:00:00 -05:00
 summary: Dynamic, Reflective, Invisible Object-Relational Mapping for Ruby
 require_paths: 
 - lib
@@ -28,18 +28,18 @@ cert_chain:
 authors: 
 - Bryan Evans
 files: 
-- lib/associations.rb
-- lib/base.rb
+- lib/validations.rb
 - lib/dependencies.rb
+- lib/associations.rb
 - lib/drysql.rb
-- lib/validations.rb
+- lib/base.rb
 - lib/helpers/string.rb
-- lib/connection_adapters/abstract_adapter.rb
-- lib/connection_adapters/ibm_db2_adapter.rb
+- lib/connection_adapters/postgresql_adapter.rb
 - lib/connection_adapters/mysql_adapter.rb
 - lib/connection_adapters/oracle_adapter.rb
-- lib/connection_adapters/postgresql_adapter.rb
 - lib/connection_adapters/sqlserver_adapter.rb
+- lib/connection_adapters/abstract_adapter.rb
+- lib/connection_adapters/ibm_db_adapter.rb
 - lib/connection_adapters/abstract/schema_definitions.rb
 - README
 test_files: []
@@ -62,5 +62,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.14.4
+        version: 1.15.1
     version: 

data/lib/connection_adapters/ibm_db2_adapter.rb

@@ -1,432 +0,0 @@
-# Most of this code is borrowed from IBM's rails adapter,
-# which is authored by Antonio Cangiano
-# 
-# I have made modifications to the IBM adapter code to support DB2 iSeries
-# as well as to add features for DrySQL on DB2 LUW
-
-module ActiveRecord
-
-  # These extensions in ActiveRecord::Base are for iSeries support
-  class Base
-  
-    class << self
-    
-      alias_method :ibm_find_one, :find_one     
-      # Finds a record based on the +id+ value. The column associated with the primary key 
-      # can be of a numeric type however DB2 doesn't allow quoted numeric values (e.g WHERE id = '10'). 
-      # Therefore this overrides the default method to check for the column type,
-      # and leaves the value in the query unquoted in cases of numeric columns
-      def find_one(id, options)
-        # If the adapter in use is the IBM DB2 Adapter
-        if connection.kind_of?(ConnectionAdapters::IBM_DB2Adapter)
-          if !connection.iseries then return ibm_find_one(id, options) end
-          
-          conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
-          # Retrieves the sql type of the column associated to the primary key
-          cstmt = connection.execute("SELECT coltype FROM SYSCOLUMNS WHERE \
-          table_name ='#{table_name.upcase}' AND column_name ='#{primary_key.upcase}'")
-          DB2::fetch_row(cstmt)
-          primary_key_type = DB2::result(cstmt, 0)
-            
-          # Frees the results set associated with the statement
-          DB2::free_result(cstmt)
-            
-          # If the column is a numeric type
-          if primary_key_type =~ /int|double|real|decimal|numeric/i
-            # Assign the unquoted id value to san_id
-            san_id = sanitize_numeric(id)
-          else
-            # The column is not numeric, so +sanitize+ it
-            san_id = sanitize(id)
-          end 
-            
-          # Adds the options based on the san_id value
-          options.update :conditions => "#{table_name}.#{primary_key} = #{san_id}#{conditions}"
-            
-          if result = find_initial(options)
-              result
-          else
-              raise RecordNotFound, "Couldn't find #{name} with ID=#{id}#{conditions}"
-            end
-        else
-          # You're not using the IBM DB2 Adapter therefore the default method is recalled
-          default_find_one(id, options)      
-        end
-      end      
-
-        
-      alias_method :ibm_find_some, :find_some
-      # Finds a record based on a list of +ids+. The primary key column type could be numeric,
-      # and DB2 doesn't allow quoted numeric values. Therefore this version of the method 
-      # checks for the data type and if it's a numeric type the value in the query is unquoted.
-      # If the column datatype is not numeric, the value is properly quoted/sanitized
-      def find_some(ids, options)
-        # If the adapter in use is the IBM DB2 Adapter
-        if connection.kind_of?(ConnectionAdapters::IBM_DB2Adapter)
-          if !connection.iseries then return ibm_find_some(ids, options) end
-          
-          conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
-          # Retrieves the sql type of the column associated to the primary key
-          cstmt = connection.execute("SELECT typename FROM SYSCOLUMNS WHERE \
-          table_name ='#{table_name.upcase}' AND column_name ='#{primary_key.upcase}'")
-          DB2::fetch_row(cstmt)
-          primary_key_type = DB2::result(cstmt, 0)
-          
-          # Frees the results set associated with the statement
-          DB2::free_result(cstmt)
-          
-          # If the column is a numeric type
-          if primary_key_type =~ /int|double|real|decimal|numeric/i
-            # Generates a comma separated list of ids
-            ids_list   = ids.map {|id| sanitize_numeric(id) }.join(',')
-          else
-            # Generates a comma separated list of quoted/sanitized ids
-            ids_list   = ids.map { |id| sanitize(id) }.join(',')
-          end 
-          
-          # Adds the options to the query, based on the generated +ids_list+
-          options.update :conditions => "#{table_name}.#{primary_key} IN (#{ids_list})#{conditions}" 
-          
-          result = find_every(options)
-  
-          if result.size == ids.size
-            result
-          else
-            raise RecordNotFound, "Couldn't find all #{name.pluralize} with IDs (#{ids_list})#{conditions}"
-          end
-        else
-          # You're not using the IBM DB2 Adapter therefore the default method is recalled
-          default_find_some(ids, options)
-        end
-      end
-    end  # class << self
-  end  # class Base
-
-
-  module ConnectionAdapters
-  
-    class IBM_DB2Column < Column
-      attr_accessor :generated, :default_specified
-      
-      def initialize(name, default, generated, sql_type = nil, null = true)
-        @name, @type, @null = name, simplified_type(sql_type), null
-        @text  = [:string, :text, :binary].include? @type
-        @sql_type = sql_type
-        # have to do this one separately because type_cast depends on #type
-        if !(default.nil? || default.blank?) then @default_specified = true end
-        @default = type_cast(default)
-        # Extracts the limit if it's a :string or :text type
-        @limit   = extract_limit(sql_type) if !sql_type.nil? && @text
-        @primary = nil
-        @number  = [:float, :integer].include? @type
-        @generated = generated
-      end
-    
-      def default_specified?
-        @default_specified
-      end
-      
-      def generated?
-        !(generated.nil? || generated.blank?)
-      end   
-    end
-    
-
-    class IBM_DB2Constraint < AbstractTableConstraint
-       
-      attr_reader :update_rule, :delete_rule, :referenced_constraint_name
-      
-      ISERIES_PRIMARY_KEY_TYPE = "P"
-      ISERIES_FOREIGN_KEY_TYPE = "F"
-      ISERIES_UNIQUE_KEY_TYPE = "U"
-      ISERIES_CHECK_CONSTRAINT_TYPE = "C"
-    
-      def initialize(constraint_schema, constraint_name, constraint_type, table_name, column_name,
-        referenced_constraint_name, referenced_table_name, referenced_column_name, delete_rule)
-        @constraint_schema = constraint_schema
-        @constraint_name = constraint_name
-        @table_name = table_name
-        @constraint_type = constraint_type
-        if !column_name.nil? then @column_name = Set.new [column_name.downcase] end
-        @referenced_table_name = referenced_table_name
-        @referenced_constraint_name = referenced_constraint_name
-        @delete_rule = delete_rule
-        if !referenced_column_name.nil? then @referenced_column_name = referenced_column_name.downcase end
-      end
-      
-      def primary_key?
-        constraint_type == PRIMARY_KEY_TYPE || constraint_type == ISERIES_PRIMARY_KEY_TYPE
-      end
-        
-      def foreign_key?
-        constraint_type == FOREIGN_KEY_TYPE || constraint_type == ISERIES_FOREIGN_KEY_TYPE
-      end
-        
-      def component_of_unique_key?
-        constraint_type == UNIQUE_KEY_TYPE || constraint_type == ISERIES_UNIQUE_KEY_TYPE
-      end
-      
-      def is_member_of_composite?
-        @column_name.size > 1
-      end
-      
-      def is_foreign_constraint?(table_name)
-        @table_name.upcase != table_name.upcase
-      end
-    
-    end
-    
-    
-    class IBM_DB2Adapter < AbstractAdapter
-      attr_reader :iseries
-    
-      alias :base_initialize :initialize
-	  def initialize(connection, logger, config)
-	    if (config[:platform] == "iseries")
-	       @iseries = true
-	       logger.info("DRYSQL >> iSeries platform detected")
-	    end
-	    base_initialize(connection, logger, config)
-	  end
-	  
-    
-      alias :base_columns :columns
-      # Returns an array of Column objects for the table specified by +table_name+
-      # This method re-definition is valid only for iSeries
-      def columns(table_name, name = nil)
-        # to_s required because it may be a symbol.
-        table_name = table_name.to_s.upcase
-        # Checks if a blank table name has been given. 
-        # If so it returns an empty array
-        return [] if table_name.strip.empty?
-        # +columns+ will contain the resulting array
-        columns = []
-        if @iseries
-          sql = "SELECT column_name, dftvalue as column_default, coltype as type, length, nulls, generated FROM SYSCOLUMNS WHERE TBNAME = '#{table_name}' AND DBNAME = '#{@schema.upcase}' ORDER BY colno"
-        else
-          sql = "SELECT colname as column_name, default as column_default, typename as type, length, nulls, generated FROM SYSCAT.COLUMNS WHERE TABNAME = '#{table_name}' AND TABSCHEMA = '#{@schema.upcase}' ORDER BY colno"
-        end
-        # Statement required to access all the columns information
-        stmt = execute(sql, name)
-          # Fetches all the columns and assigns them to col.
-          # +col+ is an hash with keys/value pairs for a column
-          while col = DB2::fetch_assoc(stmt)
-              column_name = col["column_name"].downcase
-              # Assigns the column default value.
-              column_default_value = col["column_default"]
-              # If there is no default value, it assigns NIL
-              column_default_value = nil if (column_default_value && column_default_value.upcase == 'NULL')
-              # Removes single quotes from the default value
-              column_default_value.gsub!(/^'(.*)'$/, '\1') unless column_default_value.nil?
-              # Assigns the column type
-              column_type = col["type"].downcase
-              # Assigns the field length (size) for the column
-              column_length = col["length"]
-              # The initializer of the class Column, requires the +column_length+ to be declared between brackets after
-              # the datatype(e.g VARCHAR(50)) for :string and :text types. If it's a "for bit data" field it does a subsitution in place, if not
-              # it appends the (column_length) string on the supported data types
-              unless column_length.nil? || column_length == '' || column_type.sub!(/ \(\) for bit data/i,"(#{column_length}) FOR BIT DATA") || !column_type =~ /char|lob|graphic/i
-                column_type << "(#{column_length})"
-              end
-              # col["NULLABLE"] is 1 if the field is nullable, 0 if not.
-              column_nullable = col["nulls"] == 'Y' ? true : false
-              generated = col["generated"]
-              # Pushes into the array the *IBM_DB2Column* object, created by passing to the initializer
-              # +column_name+, +default_value+, +column_type+ and +column_nullable+.
-              columns << IBM_DB2Column.new(column_name, column_default_value, generated, column_type, column_nullable)
-          end
-        # Returns the columns array
-        columns
-      end
-      
-      alias :base_indexes :indexes
-      # Returns an array of indexes for the given table, skipping the primary key.
-      # The current implementation accesses SYSINDEXES and QSYS2.SYSKEYS.
-      # This method is valid only for iSeries
-      def indexes(table_name, name = nil)
-        if !@iseries then return base_indexes(table_name, name) end
-        
-        # to_s required because +table_name+ may be a symbol.
-        table_name = table_name.to_s
-        # Checks if a blank table name has been given. 
-        # If so it returns an empty array of columns.
-        return [] if table_name.strip.empty?
-        # +indexes+ will contain the resulting array
-        indexes = []
-        # Query used to retrieve all the indexes from the given table
-        sql = "select * from ((SELECT index_name, is_unique FROM SYSINDEXES WHERE table_name = '#{table_name.upcase}' AND table_schema = '#{@schema.upcase}') \
-          as IND inner join (select index_name, column_name from QSYS2.SYSKEYS where index_schema='#{@schema.upcase}') as KEYS on (IND.index_name=KEYS.index_name))"
-        stmt = execute(sql, name)
-        klass = instance_eval(ActiveRecord::Base.class_name(table_name))
-        primary_key = klass.primary_key
-        index_hash = {}
-        # Fetches all the records available
-        while table_index = DB2::fetch_assoc(stmt)
-          # Gets the lowercased index name
-          index_name = table_index["index_name"].downcase
-          # Is the index a primary key?
-          unless index_name.upcase == primary_key.upcase
-            # Is the index unique?
-            index_unique = table_index["is_unique"] == 'U'
-            if index_hash[index_name].nil?
-              index_hash[index_name] = [index_unique, [column_name]]
-            else
-              index_hash[index_name][1] << column_name
-            end
-          end
-        end
-        # Creates IndexDefinition objects and adds them to the indexes array
-        index_hash.keys.each do |key|
-          current_index = index_hash[key]
-          indexes << IndexDefinition.new(table_name, key, current_index[0], current_index[1])
-        end
-                
-        # Returns the indexes array
-        return indexes      
-        # Ensures to free the resources associated with the statement     
-        ensure
-          DB2::free_result(stmt) if stmt
-      end
-    
-    
-      # DrySQL queries the current schema's System Catalog Views, which contain metadata
-      # only for those constraints that are defined in the current schema.
-      # 
-      # If you have inter-schema referential constraints, and I'm not sure why you would or whether
-      # DB2 even supports this, DrySQL will not detect them and will raise an error.
-      def constraints(table_name, name = nil)#:nodoc:
-        constraints = []  
-        if @iseries
-          return iseries_constraints(table_name, name)
-        else
-          sql = "select CST.tabschema, CST.constname, CST.tabname, CST.type, COL.colname, \
-            REF.constname as foreign_constraint_name, REF.tabname as foreign_table_name, \
-            REF.refkeyname, REF.reftabname, REF.deleterule, REF.fk_colnames as foreign_columns, \
-            REF.pk_colnames as referenced_columns from \
-            ((select * from SYSCAT.TABCONST where tabname='#{table_name}') as CST \
-            inner join (select colname, constname from SYSCAT.KEYCOLUSE where tabname='#{table_name}') \
-            as COL on (CST.constname=COL.constname)) left outer join SYSCAT.REFERENCES REF on \
-            (CST.constname=REF.refkeyname or CST.constname=REF.constname)"
-        end       
-        results = execute(sql, name)
-        constraint_name_hash = {}
-          
-        # Note that column names in constraint objects are downcased in order to
-        # be comparable with the column names produced by IBM_DB2Adapter.columns  
-        while row = DB2::fetch_assoc(results)
-          constraint_name = row['constname']
-          foreign_constraint_name = row['foreign_constraint_name']
-
-          # Process constraints local to this table
-          if !constraint_name_hash.has_key?(constraint_name)
-            current_constraint = IBM_DB2Constraint.new(row['tabschema'], constraint_name, row['type'], 
-              row['tabname'], row['colname'], row['refkeyname'], row['reftabname'], 
-              row['referenced_columns'], row['deleterule'])
-            constraints << current_constraint
-            constraint_name_hash[constraint_name] = current_constraint
-          # This key is a composite
-          else
-            current_constraint = constraint_name_hash[constraint_name]
-            # Unique Keys are currently the only type of composite keys supported
-            if current_constraint.component_of_unique_key? 
-              current_constraint.column_name.add(row['colname']) 
-            end
-          end
-          
-          # Process constraints that reference this table's local constraints
-          if !foreign_constraint_name.nil? && !constraint_name_hash.has_key?(foreign_constraint_name)
-            current_foreign_constraint = IBM_DB2Constraint.new(row['tabschema'], foreign_constraint_name, IBM_DB2Constraint::FOREIGN_KEY_TYPE,
-              row['foreign_table_name'], row['foreign_columns'], constraint_name, row['tabname'], row['colname'],
-              row['deleterule'])
-              constraints << current_foreign_constraint
-              constraint_name_hash[foreign_constraint_name] = current_foreign_constraint
-          # Composite FKs are currently not supported 
-          # else
-          #  constraint_name_hash[foreign_constraint_name].column_name.add(row['foreign_column_name'])
-          end        
-        end
-        constraints
-      end
-      
-      # This method retrieves constraint information from the iSeries
-      # information schema views, which DB2 generates automatically
-      # for a schema when it (the schema) is created.
-      # 
-      # Note that the old-style iSeries "libraries" that some people consider to
-      # by synonymous with "schemas" do not get the benefit of the information
-      # schema views (or journaling, for that matter). DrySQL will not
-      # play nicely with iSeries libraries unless you create the information
-      # schema views.
-      def iseries_constraints(table_name, name = nil)#:nodoc:
-        constraints = []  
-        sql = "select CST.constraint_schema, CST.constraint_name, CST.table_name, CST.constraint_type, COL.column_name, \
-          REF.constraint_name as foreign_constraint_name, REF.unique_constraint_name as referenced_constraint_name, \
-          REF.delete_rule, COLREF.table_name as foreign_table_name, COLREF.column_name as foreign_column_name from \
-          ((select * from SYSCST where table_name='#{table_name}') as CST \
-	      inner join (select column_name, constraint_name from SYSCSTCOL where table_name='#{table_name}') \
-	      as COL on (CST.constraint_name=COL.constraint_name) left outer join SYSREFCST REF on \
-	      (CST.constraint_name=REF.unique_constraint_name or CST.constraint_name=REF.constraint_name) \
-	      left join SYSCSTCOL AS COLREF on (NOT COLREF.table_name='#{table_name}' AND \
-	      (REF.unique_constraint_name=COLREF.constraint_name or REF.constraint_name=COLREF.constraint_name)))"     
-        results = execute(sql, name)
-        constraint_name_hash = {}
-          
-        # Note that column names in constraint objects are downcased in order to
-        # be comparable with the column names produced by IBM_DB2Adapter.columns  
-        while row = DB2::fetch_assoc(results)
-          constraint_name = row['constraint_name']
-          foreign_constraint_name = row['foreign_constraint_name']
-
-          # Process constraints local to this table
-          if !constraint_name_hash.has_key?(constraint_name)
-            current_constraint = IBM_DB2Constraint.new(row['constraint_schema'], constraint_name, row['constraint_type'], 
-              row['table_name'], row['column_name'], row['referenced_constraint_name'], row['foreign_table_name'], 
-              row['foreign_column_name'], row['delete_rule'])
-            constraints << current_constraint
-            constraint_name_hash[constraint_name] = current_constraint
-          # This key is a composite
-          else
-            current_constraint = constraint_name_hash[constraint_name]
-            # Unique Keys are currently the only type of composite keys supported
-            if current_constraint.component_of_unique_key? 
-              current_constraint.column_name.add(row['column_name']) 
-            end
-          end
-          
-          # Process constraints that reference this table's local constraints
-          if !foreign_constraint_name.nil? && !constraint_name_hash.has_key?(foreign_constraint_name)
-            current_foreign_constraint = IBM_DB2Constraint.new(row['constraint_schema'], constraint_name, IBM_DB2Constraint::FOREIGN_KEY_TYPE,
-              row['foreign_table_name'], row['foreign_column_name'], foreign_constraint_name, row['table_name'], row['column_name'],
-              row['delete_rule'])
-              constraints << current_foreign_constraint
-              constraint_name_hash[foreign_constraint_name] = current_foreign_constraint
-          # Composite FKs are currently not supported 
-          # else
-          #  constraint_name_hash[foreign_constraint_name].column_name.add(row['foreign_column_name'])
-          end        
-        end
-        constraints
-      end
-      
-      
-      alias :base_last_generated_id :last_generated_id
-      # Private methods that returns the last automatically generated ID
-      # on the given +@connection+. This method is required by the +insert+ method
-      # This method is valid only for iSeries
-      def last_generated_id
-        if !@iseries then return base_last_generated_id end
-        
-        # Queries the db to obtain the last ID that was automatically generated
-        stmt = execute("SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1")
-        # Fetches the only record available (containing the last id)
-        DB2::fetch_row(stmt)
-        # Retrieves and returns the result of the query with the last id.
-        DB2::result(stmt,0)
-      end
-      private :last_generated_id
-        
-    end
-
-  end
-  
-end