activerecord 1.11.1 → 1.12.1

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,24 +1,12 @@
-
-# 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'
 
 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)
+
+      config = config.symbolize_keys
       host     = config[:host]
       port     = config[:port]     || 5432 unless host.nil?
       username = config[:username].to_s
@@ -60,6 +48,10 @@ module ActiveRecord
     # * <tt>:encoding</tt> -- An optional client encoding that is using in a SET client_encoding TO <encoding> call on connection.
     # * <tt>:min_messages</tt> -- An optional client min messages that is using in a SET client_min_messages TO <min_messages> call on connection.
     class PostgreSQLAdapter < AbstractAdapter
+      def adapter_name
+        'PostgreSQL'
+      end
+
       def native_database_types
         {
           :primary_key => "serial primary key",
@@ -72,7 +64,7 @@ module ActiveRecord
           :time        => { :name => "timestamp" },
           :date        => { :name => "date" },
           :binary      => { :name => "bytea" },
-          :boolean     => { :name => "boolean"}
+          :boolean     => { :name => "boolean" }
         }
       end
       
@@ -80,99 +72,218 @@ module ActiveRecord
         true
       end      
       
-      def select_all(sql, name = nil)
-        select(sql, name)
+
+      # QUOTING ==================================================
+
+      def quote(value, column = nil)
+        if value.kind_of?(String) && column && column.type == :binary
+          "'#{escape_bytea(value)}'"
+        else
+          super
+        end
       end
 
-      def select_one(sql, name = nil)
-        result = select(sql, name)
-        result.nil? ? nil : result.first
+      def quote_column_name(name)
+        %("#{name}")
       end
 
-      def columns(table_name, name = nil)
-        column_definitions(table_name).collect do |name, type, default|
-          Column.new(name, default_value(default), translate_field_type(type))
-        end
+
+      # DATABASE STATEMENTS ======================================
+
+      def select_all(sql, name = nil) #:nodoc:
+        select(sql, name)
+      end
+
+      def select_one(sql, name = nil) #:nodoc:
+        result = select(sql, name)
+        result.first if result
       end
 
-      def insert(sql, name = nil, pk = nil, id_value = nil)
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
         execute(sql, name)
         table = sql.split(" ", 4)[2]
-        return id_value || last_insert_id(table, pk)
+        id_value || last_insert_id(table, sequence_name)
       end
 
-      def query(sql, name = nil)
+      def query(sql, name = nil) #:nodoc:
         log(sql, name) { @connection.query(sql) }
       end
 
-      def execute(sql, name = nil)
+      def execute(sql, name = nil) #:nodoc:
         log(sql, name) { @connection.exec(sql) }
       end
 
-      def update(sql, name = nil)
+      def update(sql, name = nil) #:nodoc:
         execute(sql, name).cmdtuples
       end
 
-      alias_method :delete, :update
+      alias_method :delete, :update #:nodoc:
 
-      def begin_db_transaction()    execute "BEGIN" end
-      def commit_db_transaction()   execute "COMMIT" end
-      def rollback_db_transaction() execute "ROLLBACK" end
 
-      def quote(value, column = nil)
-        if value.class == String && column && column.type == :binary
-          quote_bytea(value)
-        else
-          super
-        end
+      def begin_db_transaction #:nodoc:
+        execute "BEGIN"
       end
 
-      def quote_column_name(name)
-        %("#{name}")
+      def commit_db_transaction #:nodoc:
+        execute "COMMIT"
+      end
+      
+      def rollback_db_transaction #:nodoc:
+        execute "ROLLBACK"
       end
 
-      def adapter_name
-        'PostgreSQL'
+
+      # SCHEMA STATEMENTS ========================================
+
+      # Return the list of all tables in the schema search path.
+      def tables(name = nil) #:nodoc:
+        schemas = schema_search_path.split(/,/).map { |p| quote(p) }.join(',')
+        query(<<-SQL, name).map { |row| row[0] }
+          SELECT tablename
+            FROM pg_tables
+           WHERE schemaname IN (#{schemas})
+        SQL
+      end
+
+      def indexes(table_name, name = nil) #:nodoc:
+        result = query(<<-SQL, name)
+          SELECT i.relname, d.indisunique, a.attname
+            FROM pg_class t, pg_class i, pg_index d, pg_attribute a
+           WHERE i.relkind = 'i'
+             AND d.indexrelid = i.oid
+             AND d.indisprimary = 'f'
+             AND t.oid = d.indrelid
+             AND t.relname = '#{table_name}'
+             AND a.attrelid = t.oid
+             AND ( d.indkey[0]=a.attnum OR d.indkey[1]=a.attnum
+                OR d.indkey[2]=a.attnum OR d.indkey[3]=a.attnum
+                OR d.indkey[4]=a.attnum OR d.indkey[5]=a.attnum
+                OR d.indkey[6]=a.attnum OR d.indkey[7]=a.attnum
+                OR d.indkey[8]=a.attnum OR d.indkey[9]=a.attnum )
+          ORDER BY i.relname
+        SQL
+
+        current_index = nil
+        indexes = []
+
+        result.each do |row|
+          if current_index != row[0]
+            indexes << IndexDefinition.new(table_name, row[0], row[1] == "t", [])
+            current_index = row[0]
+          end
+
+          indexes.last.columns << row[2]
+        end
+
+        indexes
       end
 
+      def columns(table_name, name = nil) #:nodoc:
+        column_definitions(table_name).collect do |name, type, default, notnull|
+          Column.new(name, default_value(default), translate_field_type(type),
+            notnull == "f")
+        end
+      end
 
       # Set the schema search path to a string of comma-separated schema names.
       # Names beginning with $ are quoted (e.g. $user => '$user')
       # See http://www.postgresql.org/docs/8.0/interactive/ddl-schemas.html
-      def schema_search_path=(schema_csv)
+      def schema_search_path=(schema_csv) #:nodoc:
         if schema_csv
           execute "SET search_path TO #{schema_csv}"
           @schema_search_path = nil
         end
       end
 
-      def schema_search_path
+      def schema_search_path #:nodoc:
         @schema_search_path ||= query('SHOW search_path')[0][0]
       end
+
+      def default_sequence_name(table_name, pk = 'id')
+        "#{table_name}_#{pk}_seq"
+      end
+
+      # Set the sequence to the max value of the table's pk.
+      def reset_pk_sequence!(table)
+        pk, sequence = pk_and_sequence_for(table)
+        if pk and sequence
+          select_value <<-end_sql, 'Reset sequence'
+            SELECT setval('#{sequence}', (SELECT COALESCE(MAX(#{pk})+(SELECT increment_by FROM #{sequence}), (SELECT min_value FROM #{sequence})) FROM #{table}), false)
+          end_sql
+        end
+      end
+
+      # Find a table's primary key and sequence.
+      def pk_and_sequence_for(table)
+        execute(<<-end_sql, 'Find pk sequence')[0]
+          SELECT attr.attname, (name.nspname || '.' || seq.relname)
+          FROM pg_class      seq,
+               pg_attribute  attr,
+               pg_depend     dep,
+               pg_namespace  name,
+               pg_constraint cons
+          WHERE seq.oid           = dep.objid
+            AND seq.relnamespace  = name.oid
+            AND seq.relkind       = 'S'
+            AND attr.attrelid     = dep.refobjid
+            AND attr.attnum       = dep.refobjsubid
+            AND attr.attrelid     = cons.conrelid
+            AND attr.attnum       = cons.conkey[1]
+            AND cons.contype      = 'p'
+            AND dep.refobjid      = '#{table}'::regclass
+        end_sql
+      rescue
+        nil
+      end
+
+      
+      def rename_table(name, new_name)
+        execute "ALTER TABLE #{name} RENAME TO #{new_name}"
+      end
             
-      def change_column(table_name, column_name, type, options = {})
+      def add_column(table_name, column_name, type, options = {})
+        native_type = native_database_types[type]
+        sql_commands = ["ALTER TABLE #{table_name} ADD #{column_name} #{type_to_sql(type, options[:limit])}"]
+        if options[:default]
+          sql_commands << "ALTER TABLE #{table_name} ALTER #{column_name} SET DEFAULT '#{options[:default]}'"
+        end
+        if options[:null] == false
+          sql_commands << "ALTER TABLE #{table_name} ALTER #{column_name} SET NOT NULL"
+        end
+        sql_commands.each { |cmd| execute(cmd) }
+      end
+
+      def change_column(table_name, column_name, type, options = {}) #:nodoc:
         execute = "ALTER TABLE #{table_name} ALTER  #{column_name} TYPE #{type}"
         change_column_default(table_name, column_name, options[:default]) unless options[:default].nil?
       end      
 
-      def change_column_default(table_name, column_name, default)
+      def change_column_default(table_name, column_name, default) #:nodoc:
         execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DEFAULT '#{default}'"
       end
       
-      def rename_column(table_name, column_name, new_column_name)
+      def rename_column(table_name, column_name, new_column_name) #:nodoc:
         execute "ALTER TABLE #{table_name} RENAME COLUMN #{column_name} TO #{new_column_name}"
       end
 
-      def remove_index(table_name, column_name)
-        execute "DROP INDEX #{table_name}_#{column_name}_index"
+      def remove_index(table_name, options) #:nodoc:
+        if Hash === options
+          index_name = options[:name]
+        else
+          index_name = "#{table_name}_#{options}_index"
+        end
+
+        execute "DROP INDEX #{index_name}"
       end      
+
       
       private
         BYTEA_COLUMN_TYPE_OID = 17
 
-        def last_insert_id(table, column = "id")
-          sequence_name = "#{table}_#{column || 'id'}_seq"
-          @connection.exec("SELECT currval('#{sequence_name}')")[0][0].to_i
+        def last_insert_id(table, sequence_name)
+          if sequence_name
+            @connection.exec("SELECT currval('#{sequence_name}')")[0][0].to_i
+          end
         end
 
         def select(sql, name = nil)
@@ -196,18 +307,54 @@ module ActiveRecord
           return rows
         end
 
-        def quote_bytea(s)
-          "'#{escape_bytea(s)}'"
-        end
-
         def escape_bytea(s)
-          s.gsub(/\\/) { '\\\\\\\\' }.gsub(/[^\\]/) { |c| sprintf('\\\\%03o', c[0].to_i) } unless s.nil?
+          if PGconn.respond_to? :escape_bytea
+            self.class.send(:define_method, :escape_bytea) do |s|
+              PGconn.escape_bytea(s) if s
+            end
+          else
+            self.class.send(:define_method, :escape_bytea) do |s|
+              if s
+                result = ''
+                s.each_byte { |c| result << sprintf('\\\\%03o', c) }
+                result
+              end
+            end
+          end
+          escape_bytea(s)
         end
 
         def unescape_bytea(s)
-          s.gsub(/\\([0-9][0-9][0-9])/) { $1.oct.chr }.gsub(/\\\\/) { '\\' } unless s.nil?
+          if PGconn.respond_to? :unescape_bytea
+            self.class.send(:define_method, :unescape_bytea) do |s|
+              PGconn.unescape_bytea(s) if s
+            end
+          else
+            self.class.send(:define_method, :unescape_bytea) do |s|
+              if s
+                result = ''
+                i, max = 0, s.size
+                while i < max
+                  char = s[i]
+                  if char == ?\\
+                    if s[i+1] == ?\\
+                      char = ?\\
+                      i += 1
+                    else
+                      char = s[i+1..i+3].oct
+                      i += 3
+                    end
+                  end
+                  result << char
+                  i += 1
+                end
+                result
+              end
+            end
+          end
+          unescape_bytea(s)
         end
-
+        
         # Query a table's column names, default values, and types.
         #
         # The underlying query is roughly:
@@ -228,7 +375,7 @@ module ActiveRecord
         #  - ::regclass is a function that gives the id for a table name
         def column_definitions(table_name)
           query <<-end_sql
-            SELECT a.attname, format_type(a.atttypid, a.atttypmod), d.adsrc
+            SELECT a.attname, format_type(a.atttypid, a.atttypmod), d.adsrc, a.attnotnull
               FROM pg_attribute a LEFT JOIN pg_attrdef d
                 ON a.attrelid = d.adrelid AND a.attnum = d.adnum
              WHERE a.attrelid = '#{table_name}'::regclass
@@ -246,6 +393,8 @@ module ActiveRecord
             when /^timestamp/i    then 'datetime'
             when /^real|^money/i  then 'float'
             when /^interval/i     then 'string'
+            # geometric types (the line type is currently not implemented in postgresql)
+            when /^(?:point|lseg|box|"?path"?|polygon|circle)/i  then 'string' 
             when /^bytea/i        then 'binary'
             else field_type       # Pass through standard types.
           end
@@ -263,7 +412,7 @@ module ActiveRecord
           return value if value =~ /^[0-9]+(\.[0-9]*)?/
 
           # Date / Time magic values
-          return Time.now.to_s if value =~ /^\('now'::text\)::(date|timestamp)/
+          return Time.now.to_s if value =~ /^now\(\)|^\('now'::text\)::(date|timestamp)/i
 
           # Fixed dates / times
           return $1 if value =~ /^'(.+)'::(date|timestamp)/

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -1,6 +1,5 @@
-# sqlite_adapter.rb
-# author: Luke Holden <lholden@cablelan.net>
-# updated for SQLite3: Jamis Buck <jamis_buck@byu.edu>
+# Author: Luke Holden <lholden@cablelan.net>
+# Updated for SQLite3: Jamis Buck <jamis@37signals.com>
 
 require 'active_record/connection_adapters/abstract_adapter'
 
@@ -51,8 +50,10 @@ module ActiveRecord
             raise ArgumentError, "No database file specified. Missing argument: dbfile"
           end
 
-          # Allow database path relative to RAILS_ROOT.
-          if Object.const_defined?(:RAILS_ROOT)
+          # Allow database path relative to RAILS_ROOT, but only if
+          # the database path is not the special path that tells
+          # Sqlite build a database only in memory.
+          if Object.const_defined?(:RAILS_ROOT) && ':memory:' != config[:dbfile]
             config[:dbfile] = File.expand_path(config[:dbfile], RAILS_ROOT)
           end
         end
@@ -61,22 +62,24 @@ module ActiveRecord
 
   module ConnectionAdapters #:nodoc:
     class SQLiteColumn < Column #:nodoc:
-      def string_to_binary(value)
-        value.gsub(/(\0|\%)/) do
-          case $1
-            when "\0" then "%00"
-            when "%" then "%25"
-          end
-        end                
-      end
-      
-      def binary_to_string(value)
-        value.gsub(/(%00|%25)/) do
-          case $1
-            when "%00" then "\0"
-            when "%25" then "%"
-          end
-        end                
+      class <<  self
+        def string_to_binary(value)
+          value.gsub(/\0|\%/) do |b|
+            case b
+              when "\0" then "%00"
+              when "%"  then "%25"
+            end
+          end                
+        end
+        
+        def binary_to_string(value)
+          value.gsub(/%00|%25/) do |b|
+            case b
+              when "%00" then "\0"
+              when "%25" then "%"
+            end
+          end                
+        end
       end
     end
 
@@ -87,7 +90,15 @@ module ActiveRecord
     #
     # * <tt>:dbfile</tt> -- Path to the database file.
     class SQLiteAdapter < AbstractAdapter
-      def native_database_types
+      def adapter_name #:nodoc:
+        'SQLite'
+      end
+
+      def supports_migrations? #:nodoc:
+        true
+      end
+
+      def native_database_types #:nodoc:
         {
           :primary_key => "INTEGER PRIMARY KEY NOT NULL",
           :string      => { :name => "varchar", :limit => 255 },
@@ -99,32 +110,45 @@ module ActiveRecord
           :time        => { :name => "datetime" },
           :date        => { :name => "date" },
           :binary      => { :name => "blob" },
-          :boolean     => { :name => "integer" }
+          :boolean     => { :name => "boolean" }
         }
       end
 
-      def execute(sql, name = nil)
-        #log(sql, name, @connection) { |connection| connection.execute(sql) }
+
+      # QUOTING ==================================================
+
+      def quote_string(s) #:nodoc:
+        @connection.class.quote(s)
+      end
+
+      def quote_column_name(name) #:nodoc:
+        "'#{name}'"
+      end
+
+
+      # DATABASE STATEMENTS ======================================
+
+      def execute(sql, name = nil) #:nodoc:
         log(sql, name) { @connection.execute(sql) }
       end
 
-      def update(sql, name = nil)
+      def update(sql, name = nil) #:nodoc:
         execute(sql, name)
         @connection.changes
       end
 
-      def delete(sql, name = nil)
+      def delete(sql, name = nil) #:nodoc:
         sql += " WHERE 1=1" unless sql =~ /WHERE/i
         execute(sql, name)
         @connection.changes
       end
 
-      def insert(sql, name = nil, pk = nil, id_value = nil)
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
         execute(sql, name = nil)
         id_value || @connection.last_insert_row_id
       end
 
-      def select_all(sql, name = nil)
+      def select_all(sql, name = nil) #:nodoc:
         execute(sql, name).map do |row|
           record = {}
           row.each_key do |key|
@@ -136,43 +160,168 @@ module ActiveRecord
         end
       end
 
-      def select_one(sql, name = nil)
+      def select_one(sql, name = nil) #:nodoc:
         result = select_all(sql, name)
         result.nil? ? nil : result.first
       end
 
 
-      def begin_db_transaction()    @connection.transaction end
-      def commit_db_transaction()   @connection.commit      end
-      def rollback_db_transaction() @connection.rollback    end
+      def begin_db_transaction #:nodoc:
+        @connection.transaction
+      end
+      
+      def commit_db_transaction #:nodoc:
+        @connection.commit
+      end
+
+      def rollback_db_transaction #:nodoc:
+        @connection.rollback
+      end
+
 
+      # SCHEMA STATEMENTS ========================================
 
-      def tables
-        execute('.table').map { |table| Table.new(table) }
+      def tables(name = nil) #:nodoc:
+        execute("SELECT name FROM sqlite_master WHERE type = 'table'", name).map do |row|
+          row[0]
+        end
       end
 
-      def columns(table_name, name = nil)
+      def columns(table_name, name = nil) #:nodoc:
         table_structure(table_name).map { |field|
-          SQLiteColumn.new(field['name'], field['dflt_value'], field['type'])
+          SQLiteColumn.new(field['name'], field['dflt_value'], field['type'], field['notnull'] == "0")
         }
       end
 
-      def quote_string(s)
-        @connection.class.quote(s)
+      def indexes(table_name, name = nil) #:nodoc:
+        execute("PRAGMA index_list(#{table_name})", name).map do |row|
+          index = IndexDefinition.new(table_name, row['name'])
+          index.unique = row['unique'] != '0'
+          index.columns = execute("PRAGMA index_info('#{index.name}')").map { |col| col['name'] }
+          index
+        end
       end
 
-      def quote_column_name(name)
-        "'#{name}'"
+      def primary_key(table_name) #:nodoc:
+        column = table_structure(table_name).find {|field| field['pk'].to_i == 1}
+        column ? column['name'] : nil
       end
 
-      def adapter_name()
-        'SQLite'
+      def remove_index(table_name, options={}) #:nodoc:
+        if Hash === options
+          index_name = options[:name]
+        else
+          index_name = "#{table_name}_#{options}_index"
+        end
+
+        execute "DROP INDEX #{index_name}"
+      end
+      
+      def rename_table(name, new_name)
+        move_table(name, new_name)
       end
 
+      def add_column(table_name, column_name, type, options = {}) #:nodoc:
+        alter_table(table_name) do |definition|
+          definition.column(column_name, type, options)
+        end
+      end
+      
+      def remove_column(table_name, column_name) #:nodoc:
+        alter_table(table_name) do |definition|
+          definition.columns.delete(definition[column_name])
+        end
+      end
+      
+      def change_column_default(table_name, column_name, default) #:nodoc:
+        alter_table(table_name) do |definition|
+          definition[column_name].default = default
+        end
+      end
+
+      def change_column(table_name, column_name, type, options = {}) #:nodoc:
+        alter_table(table_name) do |definition|
+          definition[column_name].instance_eval do
+            self.type    = type
+            self.limit   = options[:limit] if options[:limit]
+            self.default = options[:default] if options[:default]
+          end
+        end
+      end
+
+      def rename_column(table_name, column_name, new_column_name) #:nodoc:
+        alter_table(table_name, :rename => {column_name => new_column_name})
+      end
+          
 
       protected
         def table_structure(table_name)
-          execute "PRAGMA table_info(#{table_name})"
+          returning structure = execute("PRAGMA table_info(#{table_name})") do
+            raise ActiveRecord::StatementInvalid if structure.empty?
+          end
+        end
+        
+        def alter_table(table_name, options = {}) #:nodoc:
+          altered_table_name = "altered_#{table_name}"
+          caller = lambda {|definition| yield definition if block_given?}
+
+          transaction do
+            move_table(table_name, altered_table_name, 
+              options.merge(:temporary => true))
+            move_table(altered_table_name, table_name, &caller)
+          end
+        end
+        
+        def move_table(from, to, options = {}, &block) #:nodoc:
+          copy_table(from, to, options, &block)
+          drop_table(from)
+        end
+        
+        def copy_table(from, to, options = {}) #:nodoc:
+          create_table(to, options) do |@definition|
+            columns(from).each do |column|
+              column_name = options[:rename][column.name] if 
+                options[:rename][column.name] if options[:rename]
+              
+              @definition.column(column_name || column.name, column.type, 
+                :limit => column.limit, :default => column.default,
+                :null => column.null)
+            end
+            @definition.primary_key(primary_key(from))
+            yield @definition if block_given?
+          end
+          
+          copy_table_indexes(from, to)
+          copy_table_contents(from, to, 
+            @definition.columns.map {|column| column.name}, 
+            options[:rename] || {})
+        end
+        
+        def copy_table_indexes(from, to) #:nodoc:
+          indexes(from).each do |index|
+            name = index.name
+            if to == "altered_#{from}"
+              name = "temp_#{name}"
+            elsif from == "altered_#{to}"
+              name = name[5..-1]
+            end
+
+            opts = { :name => name }
+            opts[:unique] = true if index.unique
+            add_index(to, index.columns, opts)
+          end
+        end
+        
+        def copy_table_contents(from, to, columns, rename = {}) #:nodoc:
+          column_mappings = Hash[*columns.map {|name| [name, name]}.flatten]
+          rename.inject(column_mappings) {|map, a| map[a.last] = a.first; map}
+          
+          @connection.execute "SELECT * FROM #{from}" do |row|
+            sql = "INSERT INTO #{to} VALUES ("
+            sql << columns.map {|col| quote row[column_mappings[col]]} * ', '
+            sql << ')'
+            @connection.execute sql
+          end
         end
     end