activerecord 1.0.0 → 1.1.0

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -1,6 +1,29 @@
 require 'benchmark'
 require 'date'
 
+# Method that requires a library, ensuring that rubygems is loaded
+# This is used in the database adaptors to require DB drivers. Reasons:
+# (1) database drivers are the only third-party library that Rails depend upon
+# (2) they are often installed as gems
+def require_library_or_gem(library_name)
+  begin
+    require library_name
+  rescue LoadError => cannot_require
+    # 1. Requiring the module is unsuccessful, maybe it's a gem and nobody required rubygems yet. Try.
+    begin
+      require 'rubygems'
+    rescue LoadError => rubygems_not_installed
+      raise cannot_require
+    end
+    # 2. Rubygems is installed and loaded. Try to load the library again
+    begin 
+      require library_name
+    rescue LoadError => gem_not_installed
+      raise cannot_require
+    end
+  end
+end
+
 module ActiveRecord
   class Base
     class ConnectionSpecification #:nodoc:
@@ -9,7 +32,7 @@ module ActiveRecord
         @config, @adapter_method = config, adapter_method
       end
     end
-
+    
     # The class -> [adapter_method, config] map
     @@defined_connections = {}
 
@@ -251,6 +274,21 @@ module ActiveRecord
         return rt
       end
 
+      # Wrap a block in a transaction.  Returns result of block.
+      def transaction
+        begin
+          if block_given?
+            begin_db_transaction
+            result = yield
+            commit_db_transaction
+            result
+          end
+        rescue Exception => database_transaction_rollback
+          rollback_db_transaction
+          raise
+        end
+      end
+
       # Begins the transaction (and turns off auto-committing).
       def begin_db_transaction()    end
       
@@ -263,16 +301,20 @@ module ActiveRecord
 
       def quote(value, column = nil)
         case value
-          when String                      then "'#{value.gsub(/\\/,'\&\&').gsub(/'/, "''")}'" # ' (for ruby-mode)
+          when String                      then "'#{quote_string(value)}'" # ' (for ruby-mode)
           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, Date then "'#{value.to_s}'" 
           when Time, DateTime              then "'#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
-          else                                  "'#{value.to_yaml.gsub(/'/, "''")}'"
+          else                                  "'#{quote_string(value.to_yaml)}'"
         end
       end
 
+      def quote_string(s)
+        s.gsub(/\\/, '\&\&').gsub(/'/, "''") # ' (for ruby-mode)
+      end
+
       def quote_column_name(name)
         return name
       end
@@ -322,5 +364,6 @@ module ActiveRecord
           log_entry
         end
     end
+    
   end
 end

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -1,25 +1,29 @@
 require 'active_record/connection_adapters/abstract_adapter'
 require 'parsedate'
 
-begin
-  begin
-    # Only include the MySQL driver if one hasn't already been loaded
-    require 'mysql' unless self.class.const_defined?(:Mysql)
-  rescue LoadError
-    # Only use the supplied backup Ruby/MySQL driver if no driver is already in place
-    require 'active_record/vendor/mysql'
-  end
-
 module ActiveRecord
   class Base
     # Establishes a connection to the database that's used by all Active Record objects
     def self.mysql_connection(config) # :nodoc:
+      unless self.class.const_defined?(:Mysql)
+        begin
+          # Only include the MySQL driver if one hasn't already been loaded
+          require_library_or_gem 'mysql'
+        rescue LoadError => cannot_require_mysql
+          # Only use the supplied backup Ruby/MySQL driver if no driver is already in place
+          begin 
+            require 'active_record/vendor/mysql'
+          rescue LoadError
+            raise cannot_require_mysql
+          end
+        end
+      end
       symbolize_strings_in_hash(config)
       host     = config[:host]
       port     = config[:port]
       socket   = config[:socket]
-      username = config[:username] || "root"
-      password = config[:password]
+      username = config[:username] ? config[:username].to_s : 'root'
+      password = config[:password].to_s
 
       if config.has_key?(:database)
         database = config[:database]
@@ -125,7 +129,3 @@ module ActiveRecord
     end
   end
 end
-
-rescue LoadError
-  # MySQL is not available, so neither should the adapter be
-end

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -13,165 +13,158 @@
 require 'active_record/connection_adapters/abstract_adapter'
 require 'parsedate'
 
-begin
-  # Only include the PostgreSQL driver if one hasn't already been loaded
-  require 'postgres' unless self.class.const_defined?(:PGconn)
-
-  module ActiveRecord
-    class Base
-      # Establishes a connection to the database that's used by all Active Record objects
-      def self.postgresql_connection(config) # :nodoc:
-        symbolize_strings_in_hash(config)
-        host     = config[:host]
-        port     = config[:port]     || 5432 unless host.nil?
-        username = config[:username] || ""
-        password = config[:password] || ""
-        
-        if config.has_key?(:database)
-          database = config[:database]
-        else
-          raise ArgumentError, "No database specified. Missing argument: database."
-        end
-
-        ConnectionAdapters::PostgreSQLAdapter.new(
-          PGconn.connect(host, port, "", "", database, username, password), logger
-        )
+module ActiveRecord
+  class Base
+    # Establishes a connection to the database that's used by all Active Record objects
+    def self.postgresql_connection(config) # :nodoc:
+      require_library_or_gem 'postgres' unless self.class.const_defined?(:PGconn)
+      symbolize_strings_in_hash(config)
+      host     = config[:host]
+      port     = config[:port]     || 5432 unless host.nil?
+      username = config[:username].to_s
+      password = config[:password].to_s
+
+      if config.has_key?(:database)
+        database = config[:database]
+      else
+        raise ArgumentError, "No database specified. Missing argument: database."
       end
+
+      ConnectionAdapters::PostgreSQLAdapter.new(
+        PGconn.connect(host, port, "", "", database, username, password), logger
+      )
     end
+  end
 
-    module ConnectionAdapters
-      class PostgreSQLAdapter < AbstractAdapter # :nodoc:
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter # :nodoc:
+      def select_all(sql, name = nil)
+        select(sql, name)
+      end
 
-        def select_all(sql, name = nil)
-          select(sql, name)
-        end
+      def select_one(sql, name = nil)
+        result = select(sql, name)
+        result.nil? ? nil : result.first
+      end
 
-        def select_one(sql, name = nil)
-          result = select(sql, name)
-          result.nil? ? nil : result.first
+      def columns(table_name, name = nil)
+        table_structure(table_name).inject([]) do |columns, field|
+          columns << Column.new(field[0], field[2], field[1])
+          columns
         end
+      end
 
-        def columns(table_name, name = nil)
-          table_structure(table_name).inject([]) do |columns, field|
-            columns << Column.new(field[0], field[2], field[1])
-            columns
-          end
-        end
+      def insert(sql, name = nil, pk = nil, id_value = nil)
+        execute(sql, name = nil)
+        table = sql.split(" ", 4)[2]
+        return id_value || last_insert_id(table, pk)
+      end
 
-        def insert(sql, name = nil, pk = nil, id_value = nil)
-          execute(sql, name = nil)
-          table = sql.split(" ", 4)[2]
-          return id_value || last_insert_id(table, pk)
-        end
+      def execute(sql, name = nil)
+        log(sql, name, @connection) { |connection| connection.query(sql) }
+      end
 
-        def execute(sql, name = nil)
-          log(sql, name, @connection) { |connection| connection.query(sql) }
-        end
+      alias_method :update, :execute
+      alias_method :delete, :execute
 
-        alias_method :update, :execute
-        alias_method :delete, :execute
+      def begin_db_transaction()    execute "BEGIN" end
+      def commit_db_transaction()   execute "COMMIT" end
+      def rollback_db_transaction() execute "ROLLBACK" end
 
-        def begin_db_transaction()    execute "BEGIN" end
-        def commit_db_transaction()   execute "COMMIT" end
-        def rollback_db_transaction() execute "ROLLBACK" end
+      def quote_column_name(name)
+        return "\"#{name}\""
+      end
 
-        def quote_column_name(name)
-          return "\"#{name}\""
+      private
+        def last_insert_id(table, column = "id")
+          sequence_name = "#{table}_#{column || 'id'}_seq"
+          @connection.exec("SELECT currval('#{sequence_name}')")[0][0].to_i
         end
 
-        private
-          def last_insert_id(table, column = "id")
-            sequence_name = "#{table}_#{column || 'id'}_seq"
-            @connection.exec("SELECT currval('#{sequence_name}')")[0][0].to_i
-          end
-
-          def select(sql, name = nil)
-            res = nil
-            log(sql, name, @connection) { |connection| res = connection.exec(sql) }
-    
-            results = res.result           
-            rows = []
-            if results.length > 0
-              fields = res.fields
-              results.each do |row|
-                hashed_row = {}
-                row.each_index { |cel_index| hashed_row[fields[cel_index]] = row[cel_index] }
-                rows << hashed_row
-              end
+        def select(sql, name = nil)
+          res = nil
+          log(sql, name, @connection) { |connection| res = connection.exec(sql) }
+  
+          results = res.result           
+          rows = []
+          if results.length > 0
+            fields = res.fields
+            results.each do |row|
+              hashed_row = {}
+              row.each_index { |cel_index| hashed_row[fields[cel_index]] = row[cel_index] }
+              rows << hashed_row
             end
-            return rows
           end
+          return rows
+        end
 
-          def split_table_schema(table_name)
-            schema_split = table_name.split('.')
-            schema_name = "public"
-            if schema_split.length > 1
-              schema_name = schema_split.first.strip
-              table_name = schema_split.last.strip
-            end
-            return [schema_name, table_name]
+        def split_table_schema(table_name)
+          schema_split = table_name.split('.')
+          schema_name = "public"
+          if schema_split.length > 1
+            schema_name = schema_split.first.strip
+            table_name = schema_split.last.strip
           end
+          return [schema_name, table_name]
+        end
 
-          def table_structure(table_name)
-            database_name = @connection.db
-            schema_name, table_name = split_table_schema(table_name)
-            
-            # Grab a list of all the default values for the columns.
-            sql =  "SELECT column_name, column_default, character_maximum_length, data_type "
-            sql << "  FROM information_schema.columns "
-            sql << " WHERE table_catalog = '#{database_name}' "
-            sql << "   AND table_schema = '#{schema_name}' "
-            sql << "   AND table_name = '#{table_name}';"
-
-            column_defaults = nil
-            log(sql, nil, @connection) { |connection| column_defaults = connection.query(sql) }
-            column_defaults.collect do |row|
-                field   = row[0]
-                type    = type_as_string(row[3], row[2])
-                default = default_value(row[1])
-                length  = row[2]
-
-                [field, type, default, length]
-            end
+        def table_structure(table_name)
+          database_name = @connection.db
+          schema_name, table_name = split_table_schema(table_name)
+          
+          # Grab a list of all the default values for the columns.
+          sql =  "SELECT column_name, column_default, character_maximum_length, data_type "
+          sql << "  FROM information_schema.columns "
+          sql << " WHERE table_catalog = '#{database_name}' "
+          sql << "   AND table_schema = '#{schema_name}' "
+          sql << "   AND table_name = '#{table_name}';"
+
+          column_defaults = nil
+          log(sql, nil, @connection) { |connection| column_defaults = connection.query(sql) }
+          column_defaults.collect do |row|
+              field   = row[0]
+              type    = type_as_string(row[3], row[2])
+              default = default_value(row[1])
+              length  = row[2]
+
+              [field, type, default, length]
           end
+        end
 
-          def type_as_string(field_type, field_length)
-            type = case field_type
-              when 'numeric', 'real', 'money'      then 'float'
-              when 'character varying', 'interval' then 'string'
-	            when 'timestamp without time zone'   then 'datetime'
-              else field_type
-            end
+        def type_as_string(field_type, field_length)
+          type = case field_type
+            when 'numeric', 'real', 'money'      then 'float'
+            when 'character varying', 'interval' then 'string'
+            when 'timestamp without time zone'   then 'datetime'
+            else field_type
+          end
 
-            size = field_length.nil? ? "" : "(#{field_length})"
+          size = field_length.nil? ? "" : "(#{field_length})"
 
-            return type + size
-          end
+          return type + size
+        end
 
-          def default_value(value)
-            # Boolean types
-            return "t" if value =~ /true/i
-            return "f" if value =~ /false/i
-            
-            # Char/String type values
-            return $1 if value =~ /^'(.*)'::(bpchar|text|character varying)$/
-            
-            # Numeric values
-            return value if value =~ /^[0-9]+(\.[0-9]*)?/
-
-      	    # Date / Time magic values
-      	    return Time.now.to_s if value =~ /^\('now'::text\)::(date|timestamp)/
-
-      	    # Fixed dates / times
-      	    return $1 if value =~ /^'(.+)'::(date|timestamp)/
-            
-            # Anything else is blank, some user type, or some function
-            # and we can't know the value of that, so return nil.
-            return nil
-          end
-      end
+        def default_value(value)
+          # Boolean types
+          return "t" if value =~ /true/i
+          return "f" if value =~ /false/i
+          
+          # Char/String type values
+          return $1 if value =~ /^'(.*)'::(bpchar|text|character varying)$/
+          
+          # Numeric values
+          return value if value =~ /^[0-9]+(\.[0-9]*)?/
+
+          # Date / Time magic values
+          return Time.now.to_s if value =~ /^\('now'::text\)::(date|timestamp)/
+
+          # Fixed dates / times
+          return $1 if value =~ /^'(.+)'::(date|timestamp)/
+          
+          # Anything else is blank, some user type, or some function
+          # and we can't know the value of that, so return nil.
+          return nil
+        end
     end
   end
-rescue LoadError
-  # PostgreSQL driver is not availible
 end

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -3,105 +3,103 @@
 
 require 'active_record/connection_adapters/abstract_adapter'
 
-begin
-  require 'sqlite' unless self.class.const_defined?(:SQLite)
-
-  module ActiveRecord
-    class Base
-      # Establishes a connection to the database that's used by all Active Record objects
-      def self.sqlite_connection(config) # :nodoc:
-        symbolize_strings_in_hash(config)
-        unless config.has_key?(:dbfile)
-          raise ArgumentError, "No database file specified. Missing argument: dbfile"
-        end
+module ActiveRecord
+  class Base
+    # Establishes a connection to the database that's used by all Active Record objects
+    def self.sqlite_connection(config) # :nodoc:
+      require_library_or_gem('sqlite') unless self.class.const_defined?(:SQLite)
+      symbolize_strings_in_hash(config)
+      unless config.has_key?(:dbfile)
+        raise ArgumentError, "No database file specified. Missing argument: dbfile"
+      end
 
-        db = SQLite::Database.new(config[:dbfile], 0)
+      db = SQLite::Database.new(config[:dbfile], 0)
 
-        db.show_datatypes   = "ON" if !defined? SQLite::Version
-        db.results_as_hash  = true if defined? SQLite::Version
-        db.type_translation = false
+      db.show_datatypes   = "ON" if !defined? SQLite::Version
+      db.results_as_hash  = true if defined? SQLite::Version
+      db.type_translation = false
 
-        ConnectionAdapters::SQLiteAdapter.new(db, logger)
-      end
+      ConnectionAdapters::SQLiteAdapter.new(db, logger)
     end
+  end
 
-    module ConnectionAdapters
-      class SQLiteAdapter < AbstractAdapter # :nodoc:
-        def select_all(sql, name = nil)
-          select(sql, name)
-        end
+  module ConnectionAdapters
+    class SQLiteAdapter < AbstractAdapter # :nodoc:
+      def select_all(sql, name = nil)
+        select(sql, name)
+      end
 
-        def select_one(sql, name = nil)
-          result = select(sql, name)
-          result.nil? ? nil : result.first
-        end
+      def select_one(sql, name = nil)
+        result = select(sql, name)
+        result.nil? ? nil : result.first
+      end
 
-        def columns(table_name, name = nil)
-          table_structure(table_name).inject([]) do |columns, field| 
-            columns << Column.new(field['name'], field['dflt_value'], field['type'])
-            columns
-          end
+      def columns(table_name, name = nil)
+        table_structure(table_name).inject([]) do |columns, field| 
+          columns << Column.new(field['name'], field['dflt_value'], field['type'])
+          columns
         end
+      end
 
-        def insert(sql, name = nil, pk = nil, id_value = nil)
-          execute(sql, name = nil)
-          id_value || @connection.send( defined?( SQLite::Version ) ? :last_insert_row_id : :last_insert_rowid )
-        end
+      def insert(sql, name = nil, pk = nil, id_value = nil)
+        execute(sql, name = nil)
+        id_value || @connection.send( defined?( SQLite::Version ) ? :last_insert_row_id : :last_insert_rowid )
+      end
 
-        def execute(sql, name = nil)
-          log(sql, name, @connection) do |connection|
-            if defined?( SQLite::Version )
-              case sql
-                when "BEGIN" then connection.transaction
-                when "COMMIT" then connection.commit
-                when "ROLLBACK" then connection.rollback
-                else connection.execute(sql)
-              end
-            else
-              connection.execute( sql )
+      def execute(sql, name = nil)
+        log(sql, name, @connection) do |connection|
+          if defined?( SQLite::Version )
+            case sql
+              when "BEGIN" then connection.transaction
+              when "COMMIT" then connection.commit
+              when "ROLLBACK" then connection.rollback
+              else connection.execute(sql)
             end
+          else
+            connection.execute( sql )
           end
         end
+      end
 
-        alias_method :update, :execute
-        alias_method :delete, :execute
+      alias_method :update, :execute
+      alias_method :delete, :execute
 
-        def begin_db_transaction()    execute "BEGIN" end
-        def commit_db_transaction()   execute "COMMIT" end
-        def rollback_db_transaction() execute "ROLLBACK" end
+      def begin_db_transaction()    execute "BEGIN" end
+      def commit_db_transaction()   execute "COMMIT" end
+      def rollback_db_transaction() execute "ROLLBACK" end
 
-        def quote_column_name(name)
-          return "'#{name}'"
-        end
+      def quote_string(s)
+        SQLite::Database.quote(s)
+      end
+        
+      def quote_column_name(name)
+        return "'#{name}'"
+      end
 
-        private
-          def select(sql, name = nil)
-            results = nil
-            log(sql, name, @connection) { |connection| results = connection.execute(sql) }
+      private
+        def select(sql, name = nil)
+          results = nil
+          log(sql, name, @connection) { |connection| results = connection.execute(sql) }
 
-            rows = []
+          rows = []
 
-            results.each do |row|
-              hash_only_row = {}
-              row.each_key do |key|
-                hash_only_row[key.gsub(/\w\./, "")] = row[key] unless key.class == Fixnum
-              end
-              rows << hash_only_row
+          results.each do |row|
+            hash_only_row = {}
+            row.each_key do |key|
+              hash_only_row[key.sub(/\w+\./, "")] = row[key] unless key.class == Fixnum
             end
-
-            return rows
+            rows << hash_only_row
           end
 
-          def table_structure(table_name)
-            sql = "PRAGMA table_info(#{table_name});"
-            results = nil
-            log(sql, nil, @connection) { |connection| results = connection.execute(sql) }
-            return results
-          end
-      end
+          return rows
+        end
+
+        def table_structure(table_name)
+          sql = "PRAGMA table_info(#{table_name});"
+          results = nil
+          log(sql, nil, @connection) { |connection| results = connection.execute(sql) }
+          return results
+        end
     end
   end
-rescue LoadError
-  retry if require('rubygems') rescue LoadError
-  # SQLite driver is not availible
-end
+end