drysql 0.2.1 → 0.2.2

data/lib/connection_adapters/oracle_adapter.rb

@@ -1,157 +1,138 @@
-module ActiveRecord
-
-  module ConnectionAdapters
-  
-    class OracleColumn < Column
-    
-      attr_accessor :primary_key, :default_spceified
-        
-      def initialize(name, default, sql_type = nil, null = true)
-        if !(default.nil? || default.blank?) then @default_specified = true end
-        super(name, default, sql_type, null)
-      end
-        
-    
-      def default_specified?
-        @default_specified
-      end
-      
-      # The only means that Oracle currently provides for auto-generating a column
-      # is to define a sequence and a trigger on insert that inserts sequence.nextval
-      # 
-      # As a result of this, there is no reliable way to determine whether a particular
-      # column is generated by the DB.
-      # 
-      # DrySQL currently makes the assumption that a column is auto-generated 
-      # if the column is of type integer and is the primary key for the table
-      # 
-      # Ideally a future release of Oracle will support declaring a default value 
-      # of sequence.nextval for a column, which will eliminate this problem.
-      def generated?
-        @type == :integer && @primary_key == true
-      end
-    
-    end
-  
-    class OracleConstraint < AbstractTableConstraint
-    
-      PRIMARY_KEY_TYPE = "P"
-      FOREIGN_KEY_TYPE = "R"
-      UNIQUE_KEY_TYPE = "U"
-      CHECK_CONSTRAINT_TYPE = "C"
-    
-      def initialize(constraint_name, constraint_type, table_name, column_name, 
-        referenced_constraint_name, referenced_table_name, referenced_column_name, delete_rule)
-        @constraint_name = constraint_name
-        @table_schema = table_schema
-        @table_name = table_name
-        @constraint_type = constraint_type
-        @column_name = Set.new [column_name]
-        @referenced_table_name = referenced_table_name
-        @referenced_column_name = referenced_column_name
-        @delete_rule = delete_rule
-      end
-      
-      def is_foreign_constraint?(table_name)
-        @table_name.upcase != table_name.upcase
-      end
-      
-      def is_member_of_composite?
-        @column_name.size > 1
-      end
-      
-      def primary_key?
-        constraint_type == PRIMARY_KEY_TYPE
-      end
-        
-      def foreign_key?
-        constraint_type == FOREIGN_KEY_TYPE
-      end
-        
-      def component_of_unique_key?
-        constraint_type == UNIQUE_KEY_TYPE
-      end
-    
-    end
-  
-    class OracleAdapter < AbstractAdapter
-    
-      alias :base_columns :columns
-      def columns(table_name, name = nil) #:nodoc:
-        columns = base_columns(table_name)
-        
-        # This is a hack. Once Oracle offers a better means of auto-generating IDs,
-        # this will be fixed
-        # FIXME must be fixed once composite primary keys are supported
-        sql = "select t1.column_name from all_cons_columns t1 inner join all_constraints t2 on \
-        (t1.owner = t2.owner AND t1.constraint_name = t2.constraint_name) where t1.table_name='#{table_name.upcase}' and t2.constraint_type='P'"
-        primary_key_column_name = select_one(sql, "Primary Key")['column_name']
-
-        columns.each do |column|
-          column.primary_key=(oracle_downcase(primary_key_column_name) == column.name)
-        end
-      end
-    
-      def constraints(table_name, name = nil)#:nodoc:
-        constraints = []    
-        upcase_table_name = table_name.upcase   
-        sql = "select UC.constraint_name, UC.constraint_type, UC.table_name, COL.column_name, \
-          REF.r_constraint_name as referenced_constraint_name, REF.constraint_name as foreign_constraint_name, \
-          REF.delete_rule as foreign_delete_rule, COLREF.table_name as foreign_table_name, COLREF.column_name as foreign_column_name from \
-          (select owner, constraint_name, constraint_type, table_name, r_owner, r_constraint_name \
-          from all_constraints where table_name='#{upcase_table_name}') UC inner join \
-          (select constraint_name, table_name, column_name from all_cons_columns where table_name='#{upcase_table_name}') COL on \
-          (COL.constraint_name = UC.constraint_name) left join all_constraints REF on \
-          (UC.constraint_name=REF.constraint_name OR UC.constraint_name=REF.r_constraint_name) left join all_cons_columns COLREF on \
-          (not COLREF.table_name='#{upcase_table_name}' AND (REF.constraint_name=COLREF.constraint_name OR REF.r_constraint_name=COLREF.constraint_name))"
-          
-        results = select_all(sql, name)     
-        constraint_name_hash = {}
-        results.each do |row| 
-          # The author(s) of the Oracle adapter chose to selectively downcase column names for
-          # "cleanliness" within our Rails code. I had to follow suit with constraint column & table names
-          # so that model objects could look up their data values using the generated column accessor methods
-          column_name = oracle_downcase(row['column_name'])
-          unless row['foreign_column_name'].nil? then row['foreign_column_name'] = oracle_downcase(row['foreign_column_name']) end
-          unless row['table_name'].nil? then row['table_name'] = oracle_downcase(row['table_name']) end
-          unless row['foreign_table_name'].nil? then row['foreign_table_name'] = oracle_downcase(row['foreign_table_name']) end
-          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 = OracleConstraint.new(constraint_name, row['constraint_type'], row['table_name'], 
-            column_name, row['referenced_constraint_name'], row['foreign_table_name'], 
-            row['foreign_column_name'], row['foreign_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(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 = OracleConstraint.new(foreign_constraint_name, OracleConstraint::FOREIGN_KEY_TYPE,
-              row['foreign_table_name'], row['foreign_column_name'], constraint_name,  
-              row['table_name'], row['column_name'], row['foreign_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
-
-         
-    end
-    
-  end
-  
+module ActiveRecord
+
+  module ConnectionAdapters
+  
+    class OracleColumn < Column
+    
+    	# The default initialize method must be overridden here in order to retrieve the
+    	# original default value. The standard Rails adapter nils out the default value
+    	# if it is not of a recognized type, so it then appears as if no default value 
+    	# was specified. DrySQL grabs the default value before it gets nil'd out
+      def initialize(name, default, sql_type = nil, null = true)
+        if !(default.nil? || default.blank?) then @default_specified = true end
+        super(name, default, sql_type, null)
+      end
+			
+	  def is_nullable?
+		@null || @default_specified
+	  end				
+    
+    end
+  
+    class OracleConstraint < AbstractTableConstraint
+    
+      PRIMARY_KEY_TYPE = "P"
+      FOREIGN_KEY_TYPE = "R"
+      UNIQUE_KEY_TYPE = "U"
+      CHECK_CONSTRAINT_TYPE = "C"
+    
+      def initialize(constraint_name, constraint_type, table_name, column_name, 
+        referenced_constraint_name, referenced_table_name, referenced_column_name, delete_rule)
+        @constraint_name = constraint_name
+        @table_schema = table_schema
+        @table_name = table_name
+        @constraint_type = constraint_type
+        @column_names = [column_name]
+        @referenced_table_name = referenced_table_name
+        @referenced_column_names = [ referenced_column_name ] if referenced_column_name
+        @delete_rule = delete_rule
+      end
+      
+      def is_foreign_constraint?(table_name)
+        @table_name.upcase != table_name.upcase
+      end
+      
+      def primary_key?
+        constraint_type == PRIMARY_KEY_TYPE
+      end
+        
+      def foreign_key?
+        constraint_type == FOREIGN_KEY_TYPE
+      end
+      
+      def unique_key?
+        constraint_type == UNIQUE_KEY_TYPE
+      end
+        
+    end
+  
+  
+    class OracleAdapter < AbstractAdapter
+    
+      def constraints(table_name, name = nil)#:nodoc:
+        constraints = []    
+        upcase_table_name = table_name.upcase   
+    	sql = %Q{
+    	  select UC.constraint_name, UC.constraint_type, UC.table_name, COL.column_name, 
+    	    REF.r_constraint_name as referenced_constraint_name, REF.constraint_name as foreign_constraint_name, 
+    	    REF.delete_rule as foreign_delete_rule, 
+    	    COLREF.table_name as foreign_table_name, 
+    	    COLREF.column_name as foreign_column_name 
+    	  from	(select owner, constraint_name, constraint_type, table_name, r_owner, r_constraint_name 
+    	    from all_constraints 
+    	    where table_name='#{upcase_table_name}') UC 
+    	  inner join (select constraint_name, table_name, column_name from all_cons_columns where table_name='#{upcase_table_name}') COL 
+    	    on (COL.constraint_name = UC.constraint_name) 
+    	  left join all_constraints REF 
+    	    on (UC.constraint_name=REF.constraint_name OR UC.constraint_name=REF.r_constraint_name) 
+    	  left join all_cons_columns COLREF 
+    	    on (not COLREF.table_name='#{upcase_table_name}' 
+    	    AND (REF.constraint_name=COLREF.constraint_name OR REF.r_constraint_name=COLREF.constraint_name)) 
+    	}
+          
+        results = select_all(sql, name)     
+        constraint_name_hash = {}
+        results.each do |row| 
+          # The author(s) of the Oracle adapter chose to selectively downcase column names for
+          # "cleanliness" within our Rails code. I had to follow suit with constraint column & table names
+          # so that model objects could look up their data values using the generated column accessor methods 
+          unless row['column_name'].nil? then row['column_name'] = oracle_downcase(row['column_name']) end
+          unless row['foreign_column_name'].nil? then row['foreign_column_name'] = oracle_downcase(row['foreign_column_name']) end
+          unless row['table_name'].nil? then row['table_name'] = oracle_downcase(row['table_name']) end
+          unless row['foreign_table_name'].nil? then row['foreign_table_name'] = oracle_downcase(row['foreign_table_name']) end
+          constraint_name = row['constraint_name']
+          foreign_constraint_name = row['foreign_constraint_name']
+          column_name = row['column_name']
+          
+          # Process constraints local to this table
+          if !(current_constraint = constraint_name_hash[constraint_name])
+            current_constraint = OracleConstraint.new(constraint_name, row['constraint_type'], row['table_name'], 
+            column_name, row['referenced_constraint_name'], row['foreign_table_name'], 
+            row['foreign_column_name'], row['foreign_delete_rule'])
+            constraints << current_constraint
+            constraint_name_hash[constraint_name] = current_constraint
+          # This key is a composite
+          else 
+            current_constraint.column_names << column_name unless current_constraint.column_names.include?(column_name)
+            referenced_column_name = row['foreign_column_name']
+            if referenced_column_name
+              current_constraint.referenced_column_names << referenced_column_name unless current_constraint.referenced_column_names.include?(referenced_column_name)
+            end
+          end
+          
+          # Process constraints that reference this table's local constraints
+          if foreign_constraint_name && foreign_constraint_name != constraint_name
+    	    if !(current_foreign_constraint = constraint_name_hash[foreign_constraint_name])
+              current_foreign_constraint = OracleConstraint.new(foreign_constraint_name, OracleConstraint::FOREIGN_KEY_TYPE,
+                row['foreign_table_name'], row['foreign_column_name'], constraint_name,  
+                row['table_name'], row['column_name'], row['foreign_delete_rule'])
+              constraints << current_foreign_constraint
+              constraint_name_hash[foreign_constraint_name] = current_foreign_constraint
+            # This key is a composite
+            else 
+              referenced_column_name = row['foreign_column_name']
+              if referenced_column_name
+                current_foreign_constraint.column_names << referenced_column_name unless current_foreign_constraint.column_names.include?(referenced_column_name)
+              end
+              current_foreign_constraint.referenced_column_names << column_name unless current_foreign_constraint.referenced_column_names.include?(column_name)
+            end
+          end   
+        end
+        constraints       
+      end
+         
+    end
+    
+  end
+  
 end

data/lib/connection_adapters/postgresql_adapter.rb

@@ -5,11 +5,9 @@ module ActiveRecord
     class PostgreSQLColumn < Column #:nodoc:
       attr_accessor :generated, :default_specified
       
-      alias :generated? :generated
-      
-      def default_specified?
-        @default_specified
-      end
+	  def is_nullable?
+	    @null || @default_specified || @generated
+	  end
     
     end
     
@@ -22,12 +20,12 @@ module ActiveRecord
         @table_catalog = table_catalog
         @table_schema = table_schema
         @table_name = table_name
-        @column_name = column_name
+        @column_names = [column_name]
         @constraint_name = constraint_name
         @constraint_type = constraint_type
         @referenced_constraint_name = referenced_constraint_name
         @referenced_table_name = referenced_table_name
-        @referenced_column_name = referenced_column_name
+        @referenced_column_names = [referenced_column_name] if referenced_column_name
         @update_rule = update_rule
         @delete_rule = delete_rule
       end
@@ -62,30 +60,43 @@ module ActiveRecord
       def constraints(table_name, name = nil)#:nodoc:
         constraints = []     
   
-        sql = "select t1.*, KCU.column_name, REF2.unique_constraint_name, KCU2.table_name as referenced_table_name, \
-          KCU2.column_name as referenced_column_name, REF2.delete_rule, REF2.update_rule from \
-          (select constraint_name, table_catalog, table_schema, table_name, constraint_type from \
-          information_schema.table_constraints where table_name='#{table_name.downcase}' or constraint_name in \
-            (select REF.constraint_name from information_schema.referential_constraints as REF 
-            where unique_constraint_name in (select constraint_name from information_schema.table_constraints 
-            where table_name='#{table_name.downcase}'))) as t1 inner join information_schema.key_column_usage as KCU on \
-            (t1.constraint_name=KCU.constraint_name) left join information_schema.referential_constraints as REF2 \
-            on (REF2.constraint_name=t1.constraint_name) left join information_schema.key_column_usage as KCU2 \
-            on (REF2.unique_constraint_name=KCU2.constraint_name)"
+        sql = %Q{
+          select t1.*, KCU.column_name, REF2.unique_constraint_name, KCU2.table_name as referenced_table_name, 
+            KCU2.column_name as referenced_column_name, REF2.delete_rule, REF2.update_rule 
+          from (select constraint_name, table_catalog, table_schema, table_name, constraint_type 
+            from information_schema.table_constraints 
+              where table_name='#{table_name.downcase}' 
+              or constraint_name in 
+                (select REF.constraint_name from information_schema.referential_constraints as REF 
+                where unique_constraint_name in 
+                  (select constraint_name from information_schema.table_constraints 
+                  where table_name='#{table_name.downcase}'))) as t1 
+          inner join information_schema.key_column_usage as KCU 
+            on (t1.constraint_name=KCU.constraint_name) 
+          left join information_schema.referential_constraints as REF2 
+            on (REF2.constraint_name=t1.constraint_name) 
+          left join information_schema.key_column_usage as KCU2 
+            on (REF2.unique_constraint_name=KCU2.constraint_name)
+        }
         
         results = query(sql, name)
         constraint_name_hash = {}
         results.each do |row| 
-          constraints << PostgreSQLConstraint.new(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10])
           comparable_constraint_name = row[0].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] > 1)
+          referenced_column_name = row[8]
+          column_name = row[5]
+          existing_constraint = constraint_name_hash[comparable_constraint_name]
+          if !existing_constraint
+            new_constraint = PostgreSQLConstraint.new(row[0], row[1], row[2], row[3], row[4], column_name, row[6], row[7], 
+              referenced_column_name, row[9], row[10])
+            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

data/lib/connection_adapters/sqlserver_adapter.rb

@@ -3,14 +3,12 @@ module ActiveRecord
   module ConnectionAdapters
   
     class SQLServerColumn < Column# :nodoc:
-      attr_reader :identity, :is_special
-      attr_accessor :default_specified
-      alias :generated? :identity
-      
-      def default_specified?
-        @default_specified
+    	
+      def is_nullable?
+    	@null || @default_specified || @identity
       end
       
+      
       # Borrowed verbatim from standard Rails sqlserver_adapter.
       # Had to re-implement a bit of functionality here to avoid
       # a dependency on SQLServerColumn.identity accessor
@@ -20,10 +18,6 @@ module ActiveRecord
       def initialize(name, default, sql_type = nil, identity = false, null = true) 
         if !(default.nil? || default.blank?) then @default_specified = true end
         super(name, default, sql_type, null)
-        @identity = identity
-        @is_special = sql_type =~ /text|ntext|image/i
-        # SQL Server only supports limits on *char and float types
-        @limit = nil unless @type == :float or @type == :string
       end
 
     end
@@ -34,75 +28,25 @@ module ActiveRecord
         referenced_constraint_name, referenced_table_name, referenced_column_name)
         @table_schema = table_schema
         @table_name = table_name
-        @column_name = Set.new [column_name]
+        @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
         @constraint_schema = constraint_schema
-        @referenced_constraint_name = referenced_constraint_name
+        @referenced_constraint_name = referenced_constraint_name 
         @constraint_name = constraint_name 
         @constraint_type = constraint_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 SQLServerAdapter < AbstractAdapter
 
-      # Borrowed verbatim from Rails sqlserver_adapter.
-      #     
-      # Since we can't create a dependency from ActiveRecord to DrySQL,
-      # we need to instantiate SQLServer columns in this class extension.
-      # 
-      # I'll be able to remove this code once the ActiveRecord gem is
-      # released with the new version of the sqlserver_adapter that defines
-      # the SQLServerColumn class
-      def columns(table_name, name = nil)
-        return [] if table_name.blank?
-        table_name = table_name.to_s if table_name.is_a?(Symbol)
-        table_name = table_name.split('.')[-1] unless table_name.nil?
-        sql = %Q{
-          SELECT 
-            cols.COLUMN_NAME as ColName,  
-            cols.COLUMN_DEFAULT as DefaultValue,
-            cols.NUMERIC_SCALE as numeric_scale,
-            cols.NUMERIC_PRECISION as numeric_precision, 
-            cols.DATA_TYPE as ColType, 
-            cols.IS_NULLABLE As IsNullable,  
-            COL_LENGTH(cols.TABLE_NAME, cols.COLUMN_NAME) as Length,  
-            COLUMNPROPERTY(OBJECT_ID(cols.TABLE_NAME), cols.COLUMN_NAME, 'IsIdentity') as IsIdentity,  
-            cols.NUMERIC_SCALE as Scale 
-          FROM INFORMATION_SCHEMA.COLUMNS cols 
-          WHERE cols.TABLE_NAME = '#{table_name}'   
-        }
-        # Comment out if you want to have the Columns select statment logged.
-        # Personally, I think it adds unnecessary bloat to the log. 
-        # If you do comment it out, make sure to un-comment the "result" line that follows
-        result = log(sql, name) { @connection.select_all(sql) }
-        #result = @connection.select_all(sql)
-        columns = []
-        result.each do |field|
-          default = field[:DefaultValue].to_s.gsub!(/[()\']/,"") =~ /null/ ? nil : field[:DefaultValue]
-          if field[:ColType] =~ /numeric|decimal/i
-            type = "#{field[:ColType]}(#{field[:numeric_precision]},#{field[:numeric_scale]})"
-          else
-            type = "#{field[:ColType]}(#{field[:Length]})"
-          end
-          is_identity = field[:IsIdentity] == 1
-          is_nullable = field[:IsNullable] == 'YES'
-          columns << SQLServerColumn.new(field[:ColName], default, type, is_identity, is_nullable)
-        end
-        columns
-      end
-      
-          
       # SQL Server allows you to duplicate table names & constraint names in a single database,
       # provided that each constraint belongs to a different schema.
       # 
@@ -114,60 +58,112 @@ module ActiveRecord
       # in the database connection properties and have information_schema queries select only
       # rows from the desired schema. Until this is implemented, do not duplicate table names
       # or constraint names inside any DB.
-      # 
-      # Constraints Query Optimization:
-      # -------------------------------
-      #  - The current query seems to be optimal for the strategy of retrieving local table constraints
-      #    as well as foreign keys into the current table in a single query
-      #  - Since 4 tables need to be joined to return information about FKs into the current table
-      #    the strategy is to join maximally reduced subsets of each table (i.e. rather than
-      #    join the entire table, select minimum number of columns necessary and the minimum number of
-      #    rows necessary from each table and then join the results)
-      #  - Due to the layout of the information_schema views, the database will always need to scan every
-      #    row in REFERENTIAL_CONSTRAINTS in order to stitch together table constraints and the FKs from
-      #    other tables that reference these table constraints, which means that performance is inversely
-      #    related to the number of FKs defined in the schema. Deleting unnecessary tables & FKs, and keeping
-      #    logically separate groups of tables in separate schemas will improve performance
       def constraints(table_name, name = nil)#:nodoc:
         constraints = [] 
-        sql = "select TC.constraint_schema, TC.constraint_name, TC.table_name, TC.constraint_type, CCU.column_name, \
-	      REF.constraint_name as foreign_constraint_name, REF.unique_constraint_name as referenced_constraint_name, REF.update_rule, \
-	      REF.delete_rule, CCUREF.table_name as foreign_table_name, CCUREF.column_name as foreign_column_name from \
-	      ((select * from information_schema.table_constraints where table_name='#{table_name}') as TC \
-	      inner join (select column_name, constraint_name from information_schema.constraint_column_usage where table_name='#{table_name}') \
-	      as CCU on (TC.constraint_name=CCU.constraint_name) left outer join information_schema.referential_constraints REF on \
-	      (TC.constraint_name=REF.unique_constraint_name or TC.constraint_name=REF.constraint_name) \
-	      left join information_schema.constraint_column_usage AS CCUREF on (NOT CCUREF.table_name='#{table_name}' AND \
-	      (REF.unique_constraint_name=CCUREF.constraint_name or REF.constraint_name=CCUREF.constraint_name)))"
+        
+        # May 15/2007 - Constraints query re-written by Clifford Heath
+	    sql = %Q{
+		-- Get fields of all unique indexes:
+		SELECT	user_name(o.uid) as constraint_schema,
+			i.name AS constraint_name,
+			o.name AS table_name,
+			CASE (SELECT p.xtype FROM sysconstraints t, sysobjects p
+				    WHERE t.id = o.id
+				      AND t.constid = p.id
+				      AND i.name = p.name
+			    )
+			    WHEN 'PK' THEN 'PRIMARY KEY'
+			    WHEN 'UQ' THEN 'UNIQUE' -- unique constraint
+			    ELSE 'UNIQUE'		-- unique index
+			END AS constraint_type,
+			c.name AS column_name,
+			NULL AS foreign_constraint_name,
+			NULL AS referenced_constraint_name,
+			NULL AS update_rule,
+			NULL AS delete_rule,
+			NULL AS foreign_table_name,
+			NULL AS foreign_column_name
+		FROM	sysobjects AS o,
+			sysindexes AS i,
+			sysindexkeys AS k,
+			syscolumns AS c
+		WHERE	('#{table_name}' = ''	-- All tables
+			OR '#{table_name}' = o.name)
+		  AND	o.type = 'U'		-- Tables
+		  AND	o.status >= 0		-- exclude system tables
+		  AND	o.id = i.id		-- indexes for this table
+		  AND	o.id = k.id		-- indexkeys for table
+		  AND	i.indid = k.indid	-- indexkey for index
+		  AND	k.colid = c.colid	-- indexkey for column
+		  AND	o.id = c.id		-- column for table
+		  AND	(i.status&2) <> 0	-- unique
+		  AND	i.indid NOT IN (0, 255)	-- not base table or text
+		-- ORDER BY o.name, i.indid, k.keyno	-- Can't do this with UNION
+
+		UNION ALL   -- Don't bother with distinct union!
+
+		-- Get field pairs of all FK constraints to and from this table
+		SELECT	user_name(foreign_key.uid) AS constraint_schema,
+			foreign_key.name AS constraint_name,
+			from_table.name AS table_name,
+			'FOREIGN KEY' AS constraint_type,
+			from_column.name AS column_name,
+			foreign_key.name AS foreign_constraint_name,
+			i.name AS referenced_constraint_name,
+			CASE WHEN (ObjectProperty(f.constid, 'CnstIsUpdateCascade')=1)
+			    THEN 'CASCADE'
+			    ELSE 'NO ACTION'
+			END AS update_rule,
+			CASE WHEN (ObjectProperty(f.constid, 'CnstIsDeleteCascade')=1)
+			    THEN 'CASCADE'
+			    ELSE 'NO ACTION'
+			END AS delete_rule,
+			to_table.name AS foreign_table_name,
+			to_column.name AS foreign_column_name
+		FROM    sysobjects AS from_table,
+			sysforeignkeys AS f,
+			sysobjects AS to_table,
+			sysobjects AS foreign_key,
+			syscolumns AS from_column,
+			syscolumns AS to_column,
+			sysreferences AS r,
+			sysindexes AS i
+		WHERE   ('#{table_name}' = ''		-- FK's for all tables
+			OR from_table.name = '#{table_name}'
+			OR to_table.name = '#{table_name}')
+		  AND	from_table.type = 'U'   	-- All user tables
+		  AND   from_table.status >= 0
+		  AND   from_table.id = f.fkeyid        -- All fk's from the table
+		  AND   f.constid = foreign_key.id      -- Get the sysobject from fk
+		  AND   f.rkeyid = to_table.id  	-- Get referenced table
+		  AND   f.fkey = from_column.colid      -- Get source table's column
+		  AND   from_column.id = from_table.id
+		  AND   f.rkey = to_column.colid        -- And referenced's table's col
+		  AND   to_column.id = to_table.id
+		  AND	foreign_key.id = r.constid
+		  AND	r.rkeyid = i.id
+		  AND	r.rkeyindid = i.indid
+	    }
 
         results = select_all(sql, name)
         constraint_name_hash = {}
         results.each do |row| 
           constraint_name = row['constraint_name']
           foreign_constraint_name = row['foreign_constraint_name']
-
+          column_name = row['column_name']
           # Process constraints local to this table
-          if !constraint_name_hash.has_key?(constraint_name)
-            current_constraint = SQLServerConstraint.new(row['constraint_schema'], row['table_name'], row['column_name'], constraint_name, 
+          if !(current_constraint = constraint_name_hash[constraint_name])
+            current_constraint = SQLServerConstraint.new(row['constraint_schema'], row['table_name'], column_name, constraint_name, 
             row['constraint_type'], row['referenced_constraint_name'], row['foreign_table_name'], row['foreign_column_name'] )
             constraints << current_constraint
-            constraint_name_hash[constraint_name] = 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? then 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 = SQLServerConstraint.new(row['constraint_schema'], row['foreign_table_name'], row['foreign_column_name'],
-              foreign_constraint_name, SQLServerConstraint::FOREIGN_KEY_TYPE, constraint_name, row['table_name'], row['column_name'] )
-              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'])
+            current_constraint.column_names << column_name unless current_constraint.column_names.include?(column_name)
+            referenced_column_name = row['foreign_column_name']
+            if referenced_column_name
+              current_constraint.referenced_column_names << referenced_column_name unless current_constraint.referenced_column_names.include?(referenced_column_name)
+            end
           end
         end
         constraints