activerecord 1.0.0

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,131 @@
+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:
+      symbolize_strings_in_hash(config)
+      host     = config[:host]
+      port     = config[:port]
+      socket   = config[:socket]
+      username = config[:username] || "root"
+      password = config[:password]
+
+      if config.has_key?(:database)
+        database = config[:database]
+      else
+        raise ArgumentError, "No database specified. Missing argument: database."
+      end
+
+      ConnectionAdapters::MysqlAdapter.new(
+        Mysql::real_connect(host, username, password, database, port, socket), logger
+      )
+    end
+  end
+
+  module ConnectionAdapters
+    class MysqlAdapter < 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 columns(table_name, name = nil)
+        sql = "SHOW FIELDS FROM #{table_name}"
+        result = nil
+        log(sql, name, @connection) { |connection| result = connection.query(sql) }
+
+        columns = []
+        result.each { |field| columns << Column.new(field[0], field[4], field[1]) }
+        columns
+      end
+
+      def insert(sql, name = nil, pk = nil, id_value = nil)
+        execute(sql, name = nil)
+        return id_value || @connection.insert_id
+      end
+
+      def execute(sql, name = nil)
+        log(sql, name, @connection) { |connection| connection.query(sql) }
+      end
+
+      alias_method :update, :execute
+      alias_method :delete, :execute
+      
+      def begin_db_transaction
+        begin
+          execute "BEGIN"
+        rescue Exception
+          # Transactions aren't supported
+        end
+      end
+      
+      def commit_db_transaction
+        begin
+          execute "COMMIT"
+        rescue Exception
+          # Transactions aren't supported
+        end
+      end
+      
+      def rollback_db_transaction
+        begin
+          execute "ROLLBACK"
+        rescue Exception
+          # Transactions aren't supported
+        end
+      end
+
+      def quote_column_name(name)
+        return "`#{name}`"
+      end
+      
+      def structure_dump
+        select_all("SHOW TABLES").inject("") do |structure, table|
+          structure += select_one("SHOW CREATE TABLE #{table.to_a.first.last}")["Create Table"] + ";\n\n"
+        end
+      end
+      
+      def recreate_database(name)
+        drop_database(name)
+        create_database(name)
+      end
+      
+      def drop_database(name)
+        execute "DROP DATABASE IF EXISTS #{name}"
+      end
+      
+      def create_database(name)
+        execute "CREATE DATABASE #{name}"
+      end
+      
+      private
+        def select(sql, name = nil)
+          result = nil
+          log(sql, name, @connection) { |connection| connection.query_with_result = true; result = connection.query(sql) }
+          rows = []
+          all_fields_initialized = result.fetch_fields.inject({}) { |all_fields, f| all_fields[f.name] = nil; all_fields }
+          result.each_hash { |row| rows << all_fields_initialized.dup.update(row) }
+          rows
+        end
+    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

@@ -0,0 +1,177 @@
+
+# postgresql_adaptor.rb
+# author: Luke Holden <lholden@cablelan.net>
+# notes: Currently this adaptor does not pass the test_zero_date_fields
+#        and test_zero_datetime_fields unit tests in the BasicsTest test
+#        group.
+#
+#        This is due to the fact that, in postgresql you can not have a
+#        totally zero timestamp. Instead null/nil should be used to 
+#        represent no value.
+#
+
+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
+        )
+      end
+    end
+
+    module ConnectionAdapters
+      class PostgreSQLAdapter < 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 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 execute(sql, name = nil)
+          log(sql, name, @connection) { |connection| connection.query(sql) }
+        end
+
+        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 quote_column_name(name)
+          return "\"#{name}\""
+        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
+            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]
+          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
+
+            size = field_length.nil? ? "" : "(#{field_length})"
+
+            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
+    end
+  end
+rescue LoadError
+  # PostgreSQL driver is not availible
+end

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -0,0 +1,107 @@
+# sqlite_adapter.rb
+# author:   Luke Holden <lholden@cablelan.net>
+
+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
+
+        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
+
+        ConnectionAdapters::SQLiteAdapter.new(db, logger)
+      end
+    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 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 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
+
+        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
+
+        private
+          def select(sql, name = nil)
+            results = nil
+            log(sql, name, @connection) { |connection| results = connection.execute(sql) }
+
+            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
+            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
+  end
+rescue LoadError
+  retry if require('rubygems') rescue LoadError
+  # SQLite driver is not availible
+end

data/lib/active_record/deprecated_associations.rb

@@ -0,0 +1,70 @@
+module ActiveRecord
+  module Associations # :nodoc:
+    module ClassMethods
+      def deprecated_collection_count_method(collection_name)# :nodoc:
+        module_eval <<-"end_eval", __FILE__, __LINE__
+          def #{collection_name}_count(force_reload = false)
+            #{collection_name}.reload if force_reload
+            #{collection_name}.size
+          end
+        end_eval
+      end
+      
+      def deprecated_add_association_relation(association_name)# :nodoc:
+        module_eval <<-"end_eval", __FILE__, __LINE__
+          def add_#{association_name}(*items)
+            #{association_name}.concat(items)
+          end
+        end_eval
+      end
+    
+       def deprecated_remove_association_relation(association_name)# :nodoc:
+        module_eval <<-"end_eval", __FILE__, __LINE__
+          def remove_#{association_name}(items)
+            #{association_name}.delete(items)
+          end
+        end_eval
+      end
+    
+      def deprecated_has_collection_method(collection_name)# :nodoc:
+        module_eval <<-"end_eval", __FILE__, __LINE__
+          def has_#{collection_name}?(force_reload = false)
+            !#{collection_name}(force_reload).empty?
+          end
+        end_eval
+      end
+      
+      def deprecated_find_in_collection_method(collection_name)# :nodoc:
+        module_eval <<-"end_eval", __FILE__, __LINE__
+          def find_in_#{collection_name}(association_id)
+            #{collection_name}.find(association_id)
+          end
+        end_eval
+      end
+      
+      def deprecated_find_all_in_collection_method(collection_name)# :nodoc:
+        module_eval <<-"end_eval", __FILE__, __LINE__
+          def find_all_in_#{collection_name}(runtime_conditions = nil, orderings = nil, limit = nil, joins = nil)
+            #{collection_name}.find_all(runtime_conditions, orderings, limit, joins)
+          end
+        end_eval
+      end
+    
+      def deprecated_create_method(collection_name)# :nodoc:
+        module_eval <<-"end_eval", __FILE__, __LINE__
+          def create_in_#{collection_name}(attributes = {})
+            #{collection_name}.create(attributes)
+          end
+        end_eval
+      end
+    
+      def deprecated_build_method(collection_name)# :nodoc:
+          module_eval <<-"end_eval", __FILE__, __LINE__
+            def build_to_#{collection_name}(attributes = {})
+              #{collection_name}.build(attributes)
+            end
+          end_eval
+        end
+    end
+  end
+end