drysql 0.2.1 → 0.2.2

data/lib/associations.rb

@@ -21,8 +21,7 @@ module ActiveRecord
         logger.info("DRYSQL >> Cleared cached schema for: #{self}")
       end
       
-
-      
+     
       private
       
         # A belongs_to association exists from class A to class B if A contains a foreign key into B
@@ -30,8 +29,8 @@ module ActiveRecord
           foreign_keys = table_constraints.select {|constraint| constraint.foreign_key?}
           foreign_keys.each do |foreign_key| 
             belongs_to_class_name = association_class_name_from_table_name(class_name(foreign_key.referenced_table_name))
-            self.send(:belongs_to, :"#{belongs_to_class_name}", :foreign_key=>foreign_key.column_name.to_a[0])
-            logger.info("DRYSQL >> GENERATED ASSOCIATION: #{self.name} belongs_to :#{belongs_to_class_name}, :foreign_key=>#{foreign_key.column_name.to_a[0]}")
+            self.send(:belongs_to, :"#{belongs_to_class_name}", :foreign_key=>foreign_key.column_names[0])
+            logger.info("DRYSQL >> GENERATED ASSOCIATION: #{self.name} belongs_to :#{belongs_to_class_name}, :foreign_key=>#{foreign_key.column_names[0]}")
           end
         end
         
@@ -41,12 +40,12 @@ module ActiveRecord
           foreign_constraints.each do |foreign_constraint|
             if foreign_constraint_column_is_unique?(foreign_constraint)
               has_one_class_name = association_class_name_from_table_name(class_name(foreign_constraint.table_name))
-              self.send(:has_one, :"#{has_one_class_name}", :foreign_key=>foreign_constraint.column_name.to_a[0])
-              logger.info("DRYSQL >> GENERATED ASSOCIATION: #{self.name} has_one :#{has_one_class_name}, :foreign_key=>#{foreign_constraint.column_name.to_a[0]}")
+              self.send(:has_one, :"#{has_one_class_name}", :foreign_key=>foreign_constraint.column_names[0])
+              logger.info("DRYSQL >> GENERATED ASSOCIATION: #{self.name} has_one :#{has_one_class_name}, :foreign_key=>#{foreign_constraint.column_names[0]}")
             else
               has_many_class_name = association_class_name_from_table_name(class_name(foreign_constraint.table_name)).pluralize
-              self.send(:has_many, :"#{has_many_class_name}", :foreign_key=>foreign_constraint.column_name.to_a[0])
-              logger.info("DRYSQL >> GENERATED ASSOCIATION: #{self.name} has_many :#{has_many_class_name}, :foreign_key=>#{foreign_constraint.column_name.to_a[0]}")
+              self.send(:has_many, :"#{has_many_class_name}", :foreign_key=>foreign_constraint.column_names[0])
+              logger.info("DRYSQL >> GENERATED ASSOCIATION: #{self.name} has_many :#{has_many_class_name}, :foreign_key=>#{foreign_constraint.column_names[0]}")
             end
           end
         end
@@ -56,8 +55,8 @@ module ActiveRecord
           klass = instance_eval(class_name)
           # FIXME Is there a more efficient way of doing this?
           # The uniqueness check requires that all constraints for each table that references the current table must be retrieved
-          constraints_on_given_column = klass.table_constraints.select {|current| current.column_name.include?(constraint.column_name.to_a[0])}
-          constraints_on_given_column.any? {|current| current.unique_key?}
+          unique_constraints = klass.table_constraints.select {|current| current.unique_key?}
+          unique_constraints.any? {|current| current.column_names.size == constraint.column_names.size && current.column_names.all? {|col| constraint.column_names.include?(col)}}
         end
         
         # Identifying has_many :through associations:
@@ -78,12 +77,21 @@ module ActiveRecord
           has_many_associations.each do |association|
             # FIXME the singularization is a hack. We should be able to figure the exact class name without relying
             #            on naming conventions
-            foreign_class = instance_eval(association[0].to_s.camelize.singularize)            
-            eligible_foreign_keys = foreign_class.table_constraints.select {|c| c.foreign_key? && c.referenced_table_name.upcase != table_name.upcase}
-            eligible_foreign_keys.select {|key| !is_associated_with(association_class_name_from_table_name(key.referenced_table_name))}.each do |fk|
-              has_many_class_name = association_class_name_from_table_name(class_name(fk.referenced_table_name)).pluralize
-              self.send(:has_many, :"#{has_many_class_name}", :through=>association[0])
-              logger.info("DRYSQL >> GENERATED ASSOCIATION: #{self.name} has_many :#{has_many_class_name}, :through=>:#{association[0]}")             
+            foreign_class = instance_eval(association[0].to_s.camelize.singularize)          
+            eligible_foreign_keys = foreign_class.constraints.select {|c| c.foreign_key? && c.referenced_table_name.upcase != table_name.upcase && c.table_name.upcase != table_name.upcase}
+			eligible_foreign_keys.each do |key| 
+			  if foreign_class.table_name == key.table_name
+			    # outgoing FK
+			    association_table_name = key.referenced_table_name
+			  else
+			    #incoming FK
+			    association_table_name = key.table_name
+			  end
+			  if !is_associated_with(association_class_name_from_table_name(association_table_name))
+			    has_many_class_name = association_class_name_from_table_name(class_name(association_table_name)).pluralize
+                self.send(:has_many, :"#{has_many_class_name}", :through=>association[0])
+				logger.info("DRYSQL >> GENERATED ASSOCIATION: #{self.name} has_many :#{has_many_class_name}, :through=>:#{association[0]}")
+			  end             
             end
           end
         end

data/lib/base.rb

@@ -30,6 +30,11 @@ module ActiveRecord
       def logger
         @@logger
       end
+			
+	  def set_drysql_log_output(file)
+	    @@logger = Logger.new(file)
+		@@logger.level = Logger::INFO
+	  end
   
       # Save table name keys as all UPPERCASE to simplify lookup
       alias :base_set_table_name :set_table_name
@@ -51,7 +56,7 @@ module ActiveRecord
         if primary.nil?
           logger.error("DRYSQL >> No primary key defined for table #{table_name}") 
         else 
-          primary_name = primary.column_name.to_a[0]
+          primary_name = primary.column_names[0]
           set_primary_key(primary_name)
           logger.info("DRYSQL >> Identified PRIMARY KEY for #{self}: #{primary_name}")
         end
@@ -110,7 +115,7 @@ module ActiveRecord
         @constraints = nil
         @columns = nil
         primary = table_constraints.detect {|constraint| constraint.primary_key?}
-        primary_name = primary.column_name
+        primary_name = primary.column_names[0]
         set_primary_key(primary_name)
         logger.info("DRYSQL >> Reset PRIMARY KEY for #{self}: #{primary_name}")
       end
@@ -139,17 +144,16 @@ module ActiveRecord
           end
         end
       end
-     
-      
-      private
+           
       
-        def constraints
-          unless @constraints
-            @constraints = connection.constraints(table_name, "#{name} Constraints")
-          end
-          @constraints 
+      def constraints
+        unless @constraints
+          @constraints = connection.constraints(table_name, "#{name} Constraints")
         end
+        @constraints 
+      end
         
+	  private
         # FIXME MacroReflection needs an instance method has_many?
         # This logic does not belong in Base  
         def has_many_associations
@@ -167,13 +171,13 @@ module ActiveRecord
     public    
       alias :base_initialize :initialize
       def initialize(attributes = nil)
-        base_initialize
+        base_initialize(attributes)
         self.class.generate_associations
         self.class.generate_validations
       end
       
       def constraints
-        self.class.table_constraints
+        self.class.constraints
       end
       
     

data/lib/connection_adapters/abstract/schema_definitions.rb

@@ -3,17 +3,12 @@ module ActiveRecord
   
     class Column
     
-      def generated?
+		  # This method should return true if the DB will accept a null value for this column.
+			# Note that this does not equate to a NOT NULL constraint, as the DB will still
+			# accept null values for columns with NOT NULL constraints under certain conditions
+      def is_nullable?
         raise NotImplementedError, "Column subclass did not implement this method"
-      end
-      
-      # MySQL sinks the boat on this one.
-      # If no default is specified for a non-nullable column, then MySQL assigns an implicit default value.
-      # This makes it impossible to determine whether or not a default value has been specified for any 
-      # non-nullable column without parsing the SHOW CREATE TABLE output, which is non-standard.
-      def default_specified?
-        raise NotImplementedError, "Column subclass did not implement this method"
-      end        
+      end       
     
     end
     

data/lib/connection_adapters/abstract_adapter.rb

@@ -11,10 +11,10 @@ module ActiveRecord
       UNIQUE_KEY_TYPE = "UNIQUE"
       CHECK_CONSTRAINT_TYPE = "CHECK"
         
-      attr_reader :constraint_name, :constraint_type, :table_schema, :table_name, :column_name,
-        :referenced_table_name, :referenced_column_name
+      attr_reader :constraint_name, :constraint_type, :table_schema, :table_name, :referenced_table_name, 
+        :column_names,            # An array is used to preserve the order of the elements (A set will sort them alphabetically)
+        :referenced_column_names  # An array
         
-      attr_writer :member_of_composite
       
       def raise_subclass_responsibility_error
         raise NotImplementedError, "AbstractTableConstraint subclass #{self.class} did not implement this method"
@@ -30,17 +30,9 @@ module ActiveRecord
       def foreign_key?
         constraint_type == FOREIGN_KEY_TYPE
       end
-        
-      def component_of_unique_key?
-        constraint_type == UNIQUE_KEY_TYPE
-      end
       
       def unique_key?
-        component_of_unique_key? and !is_member_of_composite?
-      end
-      
-      def is_member_of_composite?
-        @member_of_composite ? @member_of_composite : false
+        constraint_type == UNIQUE_KEY_TYPE
       end
           
     end

data/lib/connection_adapters/ibm_db_adapter.rb

@@ -0,0 +1,216 @@
+module ActiveRecord
+
+  module ConnectionAdapters
+  
+    class IBM_DBColumn < Column
+    
+    	# This method will return true if the database will accept a null value for this column on insert/update.
+    	# Note that even though the column may have a NOT NULL constraint, the DB will accept a null value if
+    	# a default value is specified
+    	def is_nullable?
+    		@null || !default.nil?
+    	end
+			
+    end
+    
+
+    class IBM_DBConstraint < 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_names, delete_rule)
+        @constraint_schema = constraint_schema
+        @constraint_name = constraint_name
+        @table_name = table_name
+        @constraint_type = constraint_type
+        @column_names = column_name.to_a if column_name
+        @referenced_table_name = referenced_table_name
+        @referenced_constraint_name = referenced_constraint_name
+        @delete_rule = delete_rule
+        @referenced_column_names = referenced_column_names if referenced_column_names
+      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 unique_key?
+        constraint_type == UNIQUE_KEY_TYPE || constraint_type == ISERIES_UNIQUE_KEY_TYPE
+      end	  
+        
+      def is_foreign_constraint?(table_name)
+        @table_name.upcase != table_name.upcase
+      end
+    
+    end
+		
+		
+	class IBM_DB2_LUW < IBM_DB2
+			
+		def constraints(table_name, name = nil) #:nodoc
+ 			constraints = []  
+			upcase_table_name = table_name.upcase	
+			sql = %Q{
+				select CST.tabschema, CST.constname, LOWER(CST.tabname) as tabname, CST.type, 
+					LOWER(COL.colname) as colname, REF.constname as foreign_constraint_name, 
+					LOWER(REF.tabname) as foreign_table_name, REF.refkeyname, 
+					LOWER(REF.reftabname) as reftabname, REF.deleterule, 
+					REF.fk_colnames as foreign_columns, REF.pk_colnames as referenced_columns 
+				from 
+					((select * from SYSCAT.TABCONST where tabname='#{upcase_table_name}') as CST 
+				inner join 
+					(select colname, constname from SYSCAT.KEYCOLUSE 
+					where tabname='#{upcase_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)
+				}				
+             
+        	results = IBM_DB::exec(@adapter.connection, sql)
+        	constraint_name_hash = {}
+          
+        	# Note that column names in constraint objects are downcased in order to
+        	# be comparable with the column names produced by IBM_DBAdapter.columns  
+        	while row = IBM_DB::fetch_assoc(results)
+	          	constraint_name = row['constname']
+	          	foreign_constraint_name = row['foreign_constraint_name']
+				column_name = row['colname']
+				table_name = row['tabname']
+				referenced_columns = row['referenced_columns'].downcase.split if row['referenced_columns']
+				foreign_columns = row['foreign_columns'].downcase.split if row['foreign_columns']
+	
+				# Process constraints local to this table
+	          	if !constraint_name_hash.has_key?(constraint_name)
+	            	current_constraint = IBM_DBConstraint.new(row['tabschema'], constraint_name, row['type'], 
+	            		table_name, column_name, row['refkeyname'], row['reftabname'], 
+	              		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]
+					current_constraint.column_names << column_name unless current_constraint.column_names.include?(column_name)
+					referenced_columns.each do |column|
+						current_constraint.referenced_column_names << column unless current_constraint.referenced_column_names.include?(column)
+					end
+	          	end
+	          
+	          	# Process constraints that reference this table's local constraints
+				if foreign_constraint_name
+		          	if !constraint_name_hash.has_key?(foreign_constraint_name)
+		            	current_foreign_constraint = IBM_DBConstraint.new(row['tabschema'], foreign_constraint_name, 
+		            		IBM_DBConstraint::FOREIGN_KEY_TYPE,  row['foreign_table_name'], foreign_columns, 
+							constraint_name, table_name, column_name, row['deleterule'])
+		              	constraints << current_foreign_constraint
+		              	constraint_name_hash[foreign_constraint_name] = current_foreign_constraint
+		          	# Composite FK 
+		          	else
+		          		current_foreign_constraint = constraint_name_hash[foreign_constraint_name]
+						foreign_columns.each do |fc|
+							current_foreign_constraint.column_names << fc unless current_foreign_constraint.column_names.include?(fc)
+						end
+						referenced_columns.each do |rc|
+							current_foreign_constraint.referenced_column_names << rc unless current_foreign_constraint.referenced_column_names.include?(rc)	
+		          		end
+					end  
+				end      
+        	end
+        	constraints
+      	end
+			
+	end
+		
+		
+	class IBM_DB2_I5 < IBM_DB2
+ 
+ 		def constraints(table_name, name = nil)#:nodoc:
+        	constraints = []  
+			upcase_table_name = table_name.upcase
+        	sql = %Q{
+        		select CST.constraint_schema, CST.constraint_name, LOWER(CST.table_name) as table_name, CST.constraint_type, 
+					LOWER(COL.column_name) as column_name, REF.constraint_name as foreign_constraint_name, REF.unique_constraint_name as referenced_constraint_name, 
+          			REF.delete_rule, LOWER(COLREF.table_name) as foreign_table_name, LOWER(COLREF.column_name) as foreign_column_name 
+				from 
+          			((select * from SYSCST where table_name='#{upcase_table_name}') as CST 
+	      			inner join (select column_name, constraint_name from SYSCSTCOL where table_name='#{upcase_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='#{upcase_table_name}' 
+						AND (REF.unique_constraint_name=COLREF.constraint_name or REF.constraint_name=COLREF.constraint_name)))
+				}     
+        	results = IBM_DB::exec(@adapter.connection, sql)
+        	constraint_name_hash = {}
+          
+        	# Note that column names in constraint objects are downcased in order to
+        	# be comparable with the column names produced by IBM_DBAdapter.columns  
+        	while row = IBM_DB::fetch_assoc(results)
+          		constraint_name = row['constraint_name']
+          		foreign_constraint_name = row['foreign_constraint_name']
+				column_name = row['column_name']
+				table_name = row['table_name']
+				foreign_column = row['foreign_column_name']				
+
+          		# Process constraints local to this table
+          		if !constraint_name_hash.has_key?(constraint_name)
+            		current_constraint = IBM_DBConstraint.new(row['constraint_schema'], constraint_name, row['constraint_type'], 
+              		table_name, column_name, row['referenced_constraint_name'], row['foreign_table_name'], 
+              		foreign_column.to_a, 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]
+					current_constraint.column_names << column_name unless current_constraint.column_names.include?(column_name)
+					current_constraint.referenced_column_names << foreign_column unless current_constraint.referenced_column_names.include?(foreign_column)
+          		end
+          
+          		# Process constraints that reference this table's local constraints
+          		if foreign_constraint_name && foreign_constraint_name != constraint_name
+          			if !constraint_name_hash.has_key?(foreign_constraint_name)
+            			current_foreign_constraint = IBM_DBConstraint.new(row['constraint_schema'], foreign_constraint_name, 
+            				IBM_DBConstraint::FOREIGN_KEY_TYPE, row['foreign_table_name'], foreign_column, 
+							constraint_name, table_name, column_name.to_a, row['delete_rule'])
+              			constraints << current_foreign_constraint
+              			constraint_name_hash[foreign_constraint_name] = current_foreign_constraint	
+          			# Composite FKs
+          			else					
+						current_foreign_constraint = constraint_name_hash[foreign_constraint_name]
+						current_foreign_constraint.column_names << foreign_column unless current_foreign_constraint.column_names.include?(foreign_column)
+						current_foreign_constraint.referenced_column_names << column_name unless current_foreign_constraint.referenced_column_names.include?(column_name)	
+          			end  
+				end      
+        	end
+        	constraints
+      	end
+			
+		end
+    
+    class IBM_DBAdapter < AbstractAdapter
+    
+      # 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:
+      	@servertype.constraints(table_name, name)
+      end
+              
+    end
+
+  end
+  
+end

data/lib/connection_adapters/mysql_adapter.rb

@@ -3,31 +3,21 @@ module ActiveRecord
   module ConnectionAdapters
   
     class MysqlColumn < Column #:nodoc:
-      attr_reader :extra
       
-      @@auto_increment = "auto_increment"
+      AUTO_INCREMENT = "auto_increment"
       
       # Capture the value of the "EXTRA" column in the column metadata table.
       # This can be used to generate validations
       alias :base_initialize :initialize
       def initialize(name, default, sql_type = nil, null = true, extra = nil)
+      	if !(default.nil? || default.blank?) then @default_specified = true end
         base_initialize(name, default, sql_type, null)
         @extra = extra
       end
-      
-      def generated?
-        @extra == @@auto_increment
-      end
-      
-      # Until MySQL properly handles default values, I assume that a default value of NULL or empty
-      # string means that a default value has not been specified for the column.
-      # 
-      # We really only care about this when the column is NOT NULL, in which case it should be safe
-      # to assume that no one would define the column as NOT NULL and then explicitly set the empty string
-      # as the default value. ...Right? 
-      def default_specified?
-        !(default.nil? || default.blank?)
-      end
+			
+	  def is_nullable?
+		@null || @default_specified	|| @extra == AUTO_INCREMENT
+	  end
       
     end
   
@@ -41,10 +31,14 @@ module ActiveRecord
         @constraint_name = constraint_name
         @table_schema = table_schema
         @table_name = table_name
-        @constraint_type = constraint_type
-        @column_name = column_name
+		if constraint_type.nil? && table_name != referenced_table_name 
+		  @constraint_type = FOREIGN_KEY_TYPE
+		else
+          @constraint_type = constraint_type
+		end
+        @column_names = [column_name]
         @referenced_table_name = referenced_table_name
-        @referenced_column_name = referenced_column_name
+        @referenced_column_names = [referenced_column_name] if referenced_column_name
       end
       
       def is_foreign_constraint?(table_name)
@@ -79,29 +73,37 @@ module ActiveRecord
     
       # Retrieve each DB constraint from the information_schema database that is either a constraint on
       # table_name or references table_name (eg. FK into table_name) 
-      # 
-      # Save a boolean value on each constraint indicating whether it is part of a composite constraint or not.
-      # This allows us to encapsulate is_composite? logic on the constraint object itself, rather than 
-      # depending on access to the complete set of constraints for the table at a later time
       def constraints(table_name, name = nil)#:nodoc:
         constraints = []
-        sql = "select KCU.constraint_name, KCU.table_schema, KCU.table_name, KCU.column_name, TC.constraint_type, KCU.referenced_table_name, KCU.referenced_column_name from \
-          ((select constraint_name, constraint_type, table_name from information_schema.table_constraints where table_schema='#{schema}' and table_name='#{table_name}') as TC right join \
-          (select * from information_schema.key_column_usage where table_schema='#{schema}' and (table_name='#{table_name}' or referenced_table_name='#{table_name}')) as KCU on \
-          (TC.constraint_name=KCU.constraint_name AND TC.table_name=KCU.table_name))"
+        sql = %Q{
+          select KCU.constraint_name, KCU.table_schema, KCU.table_name, KCU.column_name, TC.constraint_type, 
+            KCU.referenced_table_name, KCU.referenced_column_name 
+          from ((select constraint_name, constraint_type, table_name 
+            from information_schema.table_constraints 
+              where table_schema='#{schema}' and table_name='#{table_name}') as TC 
+          right join (select * 
+            from information_schema.key_column_usage 
+            where table_schema='#{schema}' 
+            and (table_name='#{table_name}' or referenced_table_name='#{table_name}')) as KCU 
+          on (TC.constraint_name=KCU.constraint_name AND TC.table_name=KCU.table_name))}
         results = execute(sql, name)
+        
         constraint_name_hash = {}
         results.each do |row| 
-          constraints << MysqlConstraint.new(row[0], row[1], row[2], row[3], row[4], row[5], row[6])
           comparable_constraint_name = row[0].upcase + row[2].upcase
-          constraint_name_count = constraint_name_hash[comparable_constraint_name]
-          constraint_name_count ? 
-            constraint_name_hash[comparable_constraint_name] = constraint_name_count + 1 :
-            constraint_name_hash[comparable_constraint_name] = 1
-        end
-        
-        constraints.each do | constraint|
-          constraint.member_of_composite=(constraint_name_hash[constraint.constraint_name.upcase + constraint.table_name.upcase] > 1)
+          referenced_column_name = row[6]
+          column_name = row[3]
+          existing_constraint = constraint_name_hash[comparable_constraint_name]
+          if !existing_constraint
+            new_constraint = MysqlConstraint.new(row[0], row[1], row[2], row[3], row[4], row[5], row[6])
+            constraints << new_constraint
+            constraint_name_hash[comparable_constraint_name] = new_constraint
+          else
+            existing_constraint.column_names << column_name unless existing_constraint.column_names.include?(column_name)
+            if referenced_column_name
+              existing_constraint.referenced_column_names << referenced_column_name unless existing_constraint.referenced_column_names.include?(referenced_column_name)
+            end
+          end
         end
         constraints
       end