activerecord 1.6.0 → 1.7.0

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -24,21 +24,37 @@ module ActiveRecord
       username = config[:username].to_s
       password = config[:password].to_s
 
+      schema_order = config[:schema_order]
+
       if config.has_key?(:database)
         database = config[:database]
       else
         raise ArgumentError, "No database specified. Missing argument: database."
       end
 
-      ConnectionAdapters::PostgreSQLAdapter.new(
+      pga = ConnectionAdapters::PostgreSQLAdapter.new(
         PGconn.connect(host, port, "", "", database, username, password), logger
       )
+
+      pga.execute("SET search_path TO #{schema_order}") if schema_order
+
+      pga
     end
   end
 
   module ConnectionAdapters
-
-    class PostgreSQLAdapter < AbstractAdapter # :nodoc:
+    # The PostgreSQL adapter works both with the C-based (http://www.postgresql.jp/interfaces/ruby/) and the Ruby-base
+    # (available both as gem and from http://rubyforge.org/frs/?group_id=234&release_id=1145) drivers.
+    #
+    # Options:
+    #
+    # * <tt>:host</tt> -- Defaults to localhost
+    # * <tt>:port</tt> -- Defaults to 5432
+    # * <tt>:username</tt> -- Defaults to nothing
+    # * <tt>:password</tt> -- Defaults to nothing
+    # * <tt>:database</tt> -- The name of the database. No default, must be provided.
+    # * <tt>:schema_order</tt> -- An optional schema order string that is using in a SET search_path TO <schema_order> call on connection.
+    class PostgreSQLAdapter < AbstractAdapter
       def select_all(sql, name = nil)
         select(sql, name)
       end
@@ -89,6 +105,10 @@ module ActiveRecord
         return "\"#{name}\""
       end
 
+      def adapter_name()
+        'PostgreSQL'
+      end
+
       private
         def last_insert_id(table, column = "id")
           sequence_name = "#{table}_#{column || 'id'}_seq"

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -59,9 +59,8 @@ module ActiveRecord
     end
   end
 
-  module ConnectionAdapters
-    
-    class SQLiteColumn < Column
+  module ConnectionAdapters #:nodoc:
+    class SQLiteColumn < Column #:nodoc:
       def string_to_binary(value)
         value.gsub(/(\0|\%)/) do
           case $1
@@ -81,7 +80,13 @@ module ActiveRecord
       end
     end
 
-    class SQLiteAdapter < AbstractAdapter # :nodoc:
+    # The SQLite adapter works with both the 2.x and 3.x series of SQLite with the sqlite-ruby drivers (available both as gems and
+    # from http://rubyforge.org/projects/sqlite-ruby/).
+    #
+    # Options:
+    #
+    # * <tt>:dbfile</tt> -- Path to the database file.
+    class SQLiteAdapter < AbstractAdapter
       def execute(sql, name = nil)
         log(sql, name) { @connection.execute(sql) }
       end
@@ -141,6 +146,10 @@ module ActiveRecord
         return "'#{name}'"
       end
 
+      def adapter_name()
+        'SQLite'
+      end
+
       protected
         def table_structure(table_name)
           execute "PRAGMA table_info(#{table_name})"

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -5,30 +5,12 @@ require 'active_record/connection_adapters/abstract_adapter'
 # Author: Joey Gibson <joey@joeygibson.com>
 # Date:   10/14/2004
 #
-# REQUIREMENTS:
-#
-# This adapter will ONLY work on Windows systems, since it relies on Win32OLE, which,
-# to my knowledge, is only available on Window.
-#
-# It relies on the ADO support in the DBI module. If you are using the
-# one-click installer of Ruby, then you already have DBI installed, but
-# the ADO module is *NOT* installed. You will need to get the latest
-# source distribution of Ruby-DBI from http://ruby-dbi.sourceforge.net/
-# unzip it, and copy the file src/lib/dbd_ado/ADO.rb to
-# X:/Ruby/lib/ruby/site_ruby/1.8/DBD/ADO/ADO.rb (you will need to create
-# the ADO directory). Once you've installed that file, you are ready to go.
-#
-# This module uses the ADO-style DSNs for connection. For example:
-# "DBI:ADO:Provider=SQLOLEDB;Data Source=(local);Initial Catalog=test;User Id=sa;Password=password;"
-# with User Id replaced with your proper login, and Password with your
-# password.
-#
 # I have tested this code on a WindowsXP Pro SP1 system,
 # ruby 1.8.2 (2004-07-29) [i386-mswin32], SQL Server 2000.
 #
 module ActiveRecord
   class Base
-    def self.sqlserver_connection(config)
+    def self.sqlserver_connection(config) #:nodoc:
       require_library_or_gem 'dbi' unless self.class.const_defined?(:DBI)
       
       symbolize_strings_in_hash(config)
@@ -52,58 +34,128 @@ module ActiveRecord
 
   module ConnectionAdapters
     class ColumnWithIdentity < Column# :nodoc:
-      attr_reader :identity
+      attr_reader :identity, :scale
 
-      def initialize(name, default, sql_type = nil, is_identity = false)
+      def initialize(name, default, sql_type = nil, is_identity = false, scale_value = 0)
         super(name, default, sql_type)
 
+        @scale = scale_value
         @identity = is_identity
+      end 
+
+      def binary_to_string(value)
+        value
+      end 
+
+      def string_to_binary(value)
+        value
+      end 
+
+      def simplified_type(field_type)
+        case field_type
+          when /int/i
+            :integer
+          when /float|double|decimal|numeric/i
+            if @scale == 0
+              :integer
+            else  
+              :float
+              nil
+            end  
+          when /datetime/i
+            :datetime
+          when /timestamp/i
+            :timestamp
+          when /time/i
+            :time
+          when /date/i
+            :date
+          when /clob|text|ntext/i
+            :text
+          when /blob|binary|image/i
+            :binary
+          when /char|string/i
+            :string
+          when /boolean|bit/i
+            :boolean
+        end
       end
-    end
 
-    class SQLServerAdapter < AbstractAdapter # :nodoc:
-      def quote_column_name(name)
-        "[#{name}]"
+      def string_to_time(string)
+        return string if string.is_a?(Time)
+        time_array = ParseDate.parsedate(string, true)
+        time_array.each_index do |i|
+          case i
+            when 0
+              time_array[i] = time_array[i].nil? ? "2000" : time_array[i].to_s
+            when 1
+              time_array[i] = time_array[i].nil? ? "Jan" : time_array[i].to_s
+            when 2
+              time_array[i] = time_array[i].nil? ? "1" : time_array[i].to_s
+            when 3
+              time_array[i] = time_array[i].nil? ? "0" : time_array[i].to_s
+            when 4
+              time_array[i] = time_array[i].nil? ? "0" : time_array[i].to_s
+            when 5
+              time_array[i] = time_array[i].nil? ? "0" : time_array[i].to_s
+          end
+        end
+        # treat 0000-00-00 00:00:00 as nil
+        Time.send(Base.default_timezone, *time_array) rescue nil
       end
 
+    end
+
+    # This adapter will ONLY work on Windows systems, since it relies on Win32OLE, which,
+    # to my knowledge, is only available on Window.
+    #
+    # It relies on the ADO support in the DBI module. If you are using the
+    # one-click installer of Ruby, then you already have DBI installed, but
+    # the ADO module is *NOT* installed. You will need to get the latest
+    # source distribution of Ruby-DBI from http://ruby-dbi.sourceforge.net/
+    # unzip it, and copy the file <tt>src/lib/dbd_ado/ADO.rb</tt> to
+    # <tt>X:/Ruby/lib/ruby/site_ruby/1.8/DBD/ADO/ADO.rb</tt> (you will need to create
+    # the ADO directory). Once you've installed that file, you are ready to go.
+    #
+    # Options:
+    #
+    # * <tt>:host</tt> -- Defaults to localhost
+    # * <tt>:username</tt> -- Defaults to sa
+    # * <tt>:password</tt> -- Defaults to nothing
+    # * <tt>:database</tt> -- The name of the database. No default, must be provided.
+    class SQLServerAdapter < AbstractAdapter
       def select_all(sql, name = nil)
+        add_limit!(sql, nil)
         select(sql, name)
       end
 
       def select_one(sql, name = nil)
+        add_limit!(sql, nil)
         result = select(sql, name)
         result.nil? ? nil : result.first
       end
 
       def columns(table_name, name = nil)
         sql = <<EOL
-SELECT s.name AS TableName, c.id AS ColId, c.name AS ColName, t.name AS ColType, c.length AS Length,
-c.AutoVal AS IsIdentity,
-c.cdefault AS DefaultId, com.text AS DefaultValue
-FROM syscolumns AS c
-JOIN systypes AS t ON (c.xtype = t.xtype AND c.usertype = t.usertype)
-JOIN sysobjects AS s ON (c.id = s.id)
-LEFT OUTER JOIN syscomments AS com ON (c.cdefault = com.id)
-WHERE s.name = '#{table_name}'
+SELECT 
+COLUMN_NAME as ColName,
+COLUMN_DEFAULT as DefaultValue,
+DATA_TYPE as ColType,
+COL_LENGTH('#{table_name}', COLUMN_NAME) as Length,
+COLUMNPROPERTY(OBJECT_ID('#{table_name}'), COLUMN_NAME, 'IsIdentity') as IsIdentity,
+NUMERIC_SCALE as Scale
+FROM INFORMATION_SCHEMA.columns
+WHERE TABLE_NAME = '#{table_name}'
 EOL
-        columns = []
-
-        log(sql, name, @connection) do |conn|
-          conn.select_all(sql) do |row|
-            default_value = row[:DefaultValue]
 
-            if default_value =~ /null/i
-              default_value = nil
-            else
-              default_value =~ /\(([^)]+)\)/
-              default_value = $1
-            end
-
-            col = ColumnWithIdentity.new(row[:ColName], default_value, "#{row[:ColType]}(#{row[:Length]})", row[:IsIdentity] != nil)
-
-            columns << col
-          end
-        end
+        result = nil
+        # Uncomment if you want to have the Columns select statment logged.
+        # Personnally, I think it adds unneccessary SQL statement bloat to the log. 
+        # If you do uncomment, make sure to comment the "result" line that follows
+        log(sql, name, @connection) { |conn| result = conn.select_all(sql) }
+        #result = @connection.select_all(sql)
+        columns = []
+        result.each { |field| columns << ColumnWithIdentity.new(field[:ColName], field[:DefaultValue].to_s.gsub!(/[()\']/,"") =~ /null/ ? nil : field[:DefaultValue], "#{field[:ColType]}(#{field[:Length]})", field[:IsIdentity] == 1 ? true : false, field[:Scale]) }
 
         columns
       end
@@ -144,16 +196,6 @@ EOL
         end
       end
 
-      def execute(sql, name = nil)
-        if sql =~ /^INSERT/i
-          insert(sql, name)
-        else
-          log(sql, name, @connection) do |conn|
-            conn.execute(sql)
-          end
-        end
-      end
-
       def update(sql, name = nil)
         execute(sql, name)
         affected_rows(name)
@@ -185,6 +227,47 @@ EOL
         end
       end
 
+      def quote(value, column = nil)
+        case value
+          when String                
+            if column && column.type == :binary
+              "'#{quote_string(column.string_to_binary(value))}'"
+            else
+              "'#{quote_string(value)}'"
+            end
+          when NilClass              then "NULL"
+          when TrueClass             then (column && column.type == :boolean ? "'t'" : "1")
+          when FalseClass            then (column && column.type == :boolean ? "'f'" : "0")
+          when Float, Fixnum, Bignum then value.to_s
+          when Date                  then "'#{value.to_s}'" 
+          when Time, DateTime        then "'#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
+          else                            "'#{quote_string(value.to_yaml)}'"
+        end
+      end
+
+      def quote_string(s)
+        s.gsub(/\'/, "''")
+      end
+
+      def quote_column_name(name)
+        "[#{name}]"
+      end
+
+      def add_limit!(sql, limit)
+        if sql =~ /LIMIT/i
+          limit = sql.slice!(/LIMIT.*/).gsub(/LIMIT.(.*)$/, '\1')
+        end
+        if !limit.nil?
+          limit_amount = limit.to_s.include?("OFFSET") ? get_offset_amount(limit) : Array.new([limit])
+          order_by = sql.include?("ORDER BY") ? get_order_by(sql.sub(/.*ORDER\sBY./, "")) : nil
+          if limit_amount.size == 2
+            sql.gsub!(/SELECT/i, "SELECT * FROM ( SELECT TOP #{limit_amount[0]} * FROM ( SELECT TOP #{limit_amount[1]}")<<" ) AS tmp1 ORDER BY #{order_by[1]} ) AS tmp2 ORDER BY #{order_by[0]}"
+          else
+            sql.gsub!(/SELECT/i, "SELECT TOP #{limit_amount[0]}")
+          end
+        end
+      end
+
       def recreate_database(name)
         drop_database(name)
         create_database(name)
@@ -198,14 +281,18 @@ EOL
         execute "CREATE DATABASE #{name}"
       end
 
-      def add_limit!(sql, limit)
-        limit_amount = limit.to_s.include?("OFFSET") ? get_offset_amount(limit) : Array.new([limit])
-        order_by = sql.include?("ORDER BY") ? get_order_by(sql.sub(/.*ORDER\sBY./, "")) : nil
-        if limit_amount.size == 2
-          sql.gsub!(/SELECT/i, "SELECT * FROM ( SELECT TOP #{limit_amount[0]} * FROM ( SELECT TOP #{limit_amount[1]}")<<" ) AS tmp1 ORDER BY #{order_by[1]} ) AS tmp2 ORDER BY #{order_by[0]}"
+      def execute(sql, name = nil)
+        if sql =~ /^INSERT/i
+          insert(sql, name)
         else
-          sql.gsub!(/SELECT/i, "SELECT TOP #{limit_amount[0]}")
-        end     
+          log(sql, name, @connection) do |conn|
+            conn.execute(sql)
+          end
+        end
+      end
+
+      def adapter_name()
+        'SqlServer'
       end
 
       private
@@ -266,6 +353,10 @@ EOL
           return sql =~ /[\(\.\,]\s*#{col}/
         end
 
+        def query_contains_text_column(sql, col)
+          
+        end
+
         def get_order_by(sql)
           return sql, sql.gsub(/\s*DESC\s*/, "").gsub(/\s*ASC\s*/, " DESC")
         end

data/lib/active_record/deprecated_associations.rb

@@ -66,7 +66,7 @@ module ActiveRecord
         end_eval
       end
 
-      def deprecated_association_comparison_method(association_name, association_class_name)
+      def deprecated_association_comparison_method(association_name, association_class_name) # :nodoc:
         module_eval <<-"end_eval", __FILE__, __LINE__
           def #{association_name}?(comparison_object, force_reload = false)
             if comparison_object.kind_of?(#{association_class_name})
@@ -78,7 +78,7 @@ module ActiveRecord
         end_eval
       end
         
-      def deprecated_has_association_method(association_name)
+      def deprecated_has_association_method(association_name) # :nodoc:
         module_eval <<-"end_eval", __FILE__, __LINE__
           def has_#{association_name}?(force_reload = false)
             !#{association_name}(force_reload).nil?
@@ -86,7 +86,7 @@ module ActiveRecord
         end_eval
       end
       
-      def deprecated_build_method(method_prefix, collection_name, collection_class_name, class_primary_key_name)
+      def deprecated_build_method(method_prefix, collection_name, collection_class_name, class_primary_key_name)# :nodoc:
         module_eval <<-"end_eval", __FILE__, __LINE__
           def #{method_prefix + collection_name}(attributes = {})
             association = #{collection_class_name}.new
@@ -96,7 +96,7 @@ module ActiveRecord
         end_eval
       end
 
-      def deprecated_create_method(method_prefix, collection_name, collection_class_name, class_primary_key_name)
+      def deprecated_create_method(method_prefix, collection_name, collection_class_name, class_primary_key_name)# :nodoc:
         module_eval <<-"end_eval", __FILE__, __LINE__
           def #{method_prefix + collection_name}(attributes = nil)
             #{collection_class_name}.create((attributes || {}).merge({ "#{class_primary_key_name}" => id}))

data/lib/active_record/fixtures.rb

@@ -1,8 +1,8 @@
 require 'erb'
 require 'yaml'
 require 'csv'
-require 'active_record/support/class_inheritable_attributes'
-require 'active_record/support/inflector'
+require 'active_support/class_inheritable_attributes'
+require 'active_support/inflector'
 
 # Fixtures are a way of organizing data that you want to test against; in short, sample data. They come in 3 flavours:
 #
@@ -39,7 +39,7 @@ require 'active_record/support/inflector'
 # Fixtures can also be kept in the Comma Separated Value format. Akin to YAML fixtures, CSV fixtures are stored
 # in a single file, but, instead end with the .csv file extension (Rails example: "<your-rails-app>/test/fixtures/web_sites.csv")
 #
-# The format of this tye of fixture file is much more compact than the others, but also a little harder to read by us
+# The format of this type of fixture file is much more compact than the others, but also a little harder to read by us
 # humans.  The first line of the CSV file is a comma-separated list of field names.  The rest of the file is then comprised
 # of the actual data (1 per line).  Here's an example:
 #
@@ -146,7 +146,11 @@ class Fixtures < Hash
   def self.instantiate_fixtures(object, fixtures_directory, *table_names)
     [ create_fixtures(fixtures_directory, *table_names) ].flatten.each_with_index do |fixtures, idx|
       object.instance_variable_set "@#{table_names[idx]}", fixtures
-      fixtures.each { |name, fixture| object.instance_variable_set "@#{name}", fixture.find }
+      fixtures.each do |name, fixture|
+        if model = fixture.find
+          object.instance_variable_set "@#{name}", model
+        end
+      end
     end
   end
 
@@ -294,7 +298,10 @@ class Fixture #:nodoc:
   end
 
   def find
-    Object.const_get(@class_name).find(self[Object.const_get(@class_name).primary_key])
+    if Object.const_defined?(@class_name)
+      klass = Object.const_get(@class_name)
+      klass.find(self[klass.primary_key])
+    end
   end
 
   private