activerecord 1.13.2 → 1.14.0

data/lib/active_record/connection_adapters/abstract/quoting.rb

@@ -6,7 +6,7 @@ module ActiveRecord
       def quote(value, column = nil)
         case value
           when String
-            if column && column.type == :binary
+            if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
               "'#{quote_string(column.class.string_to_binary(value))}'" # ' (for ruby-mode)
             elsif column && [:integer, :float].include?(column.type) 
               value.to_s

data/lib/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -4,7 +4,7 @@ module ActiveRecord
   module ConnectionAdapters #:nodoc:
     # An abstract definition of a column in a table.
     class Column
-      attr_reader :name, :default, :type, :limit, :null
+      attr_reader :name, :default, :type, :limit, :null, :sql_type
       attr_accessor :primary
 
       # Instantiates a new column in the table.
@@ -15,6 +15,7 @@ module ActiveRecord
       # +null+ determines if this column allows +NULL+ values.
       def initialize(name, default, sql_type = nil, null = true)
         @name, @type, @null = name, simplified_type(sql_type), null
+        @sql_type = sql_type
         # have to do this one separately because type_cast depends on #type
         @default = type_cast(default)
         @limit   = extract_limit(sql_type) unless sql_type.nil?

data/lib/active_record/connection_adapters/abstract/schema_statements.rb

@@ -8,6 +8,16 @@ module ActiveRecord
         {}
       end
 
+      # This is the maximum length a table alias can be
+      def table_alias_length
+        255
+      end
+
+      # Truncates a table alias according to the limits of the current adapter.  
+      def table_alias_for(table_name)
+        table_name[0..table_alias_length-1].gsub(/\./, '_')
+      end
+
       # def tables(name = nil) end
 
       # Returns an array of indexes for the given table.
@@ -153,6 +163,13 @@ module ActiveRecord
       # The index will be named after the table and the first column names,
       # unless you pass +:name+ as an option.
       #
+      # When creating an index on multiple columns, the first column is used as a name
+      # for the index. For example, when you specify an index on two columns
+      # [+:first+, +:last+], the DBMS creates an index for both columns as well as an
+      # index for the first colum +:first+. Using just the first name for this index
+      # makes sense, because you will never have to create a singular index with this
+      # name.
+      #
       # ===== Examples
       # ====== Creating a simple index
       #  add_index(:suppliers, :name)
@@ -187,7 +204,10 @@ module ActiveRecord
       #   remove_index :accounts, :column => :branch_id
       # Remove the index named by_branch_party in the accounts table.
       #   remove_index :accounts, :name => :by_branch_party
-      
+      #
+      # You can remove an index on multiple columns by specifying the first column.
+      #   add_index :accounts, [:username, :password]
+      #   remove_index :accounts, :username
       def remove_index(table_name, options = {})
         execute "DROP INDEX #{index_name(table_name, options)} ON #{table_name}"
       end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -21,10 +21,11 @@ module ActiveRecord
     class AbstractAdapter
       include Quoting, DatabaseStatements, SchemaStatements
       @@row_even = true
-
+      
       def initialize(connection, logger = nil) #:nodoc:
         @connection, @logger = connection, logger
         @runtime = 0
+        @last_verification = 0
       end
 
       # Returns the human-readable name of the adapter.  Use mixed case - one
@@ -38,6 +39,12 @@ module ActiveRecord
       def supports_migrations?
         false
       end
+      
+      # Does this adapter support using DISTINCT within COUNT?  This is +true+
+      # for all adapters except sqlite.
+      def supports_count_distinct?
+        true
+      end
 
       # Should primary key values be selected from their corresponding
       # sequence before the insert statement?  If true, next_sequence_value
@@ -57,13 +64,35 @@ module ActiveRecord
 
       # Is this connection active and ready to perform queries?
       def active?
-        true
+        @active != false
       end
 
       # Close this connection and open a new one in its place.
       def reconnect!
+        @active = true
       end
 
+      # Close this connection
+      def disconnect!
+        @active = false
+      end
+
+      # Lazily verify this connection, calling +active?+ only if it hasn't
+      # been called for +timeout+ seconds.       
+      def verify!(timeout)
+        now = Time.now.to_i
+        if (now - @last_verification) > timeout
+          reconnect! unless active?
+          @last_verification = now
+        end
+      end
+      
+      # Provides access to the underlying database connection. Useful for
+      # when you need to call a proprietary method such as postgresql's lo_*
+      # methods
+      def raw_connection
+        @connection
+      end
 
       protected
         def log(sql, name)
@@ -83,6 +112,9 @@ module ActiveRecord
           end
         rescue Exception => e
           # Log message and raise exception.
+          # Set last_verfication to 0, so that connection gets verified
+          # upon reentering the request loop
+          @last_verification = 0
           message = "#{e.class.name}: #{e.message}: #{sql}"
           log_info(message, name, 0)
           raise ActiveRecord::StatementInvalid, message

data/lib/active_record/connection_adapters/db2_adapter.rb

@@ -14,16 +14,17 @@ begin
         config = config.symbolize_keys
         usr = config[:username]
         pwd = config[:password]
+        schema = config[:schema]
 
         if config.has_key?(:database)
           database = config[:database]
         else
-          raise ArgumentError, "No database specified. Missing argument: database."
+          raise ArgumentError, 'No database specified. Missing argument: database.'
         end
 
         connection = DB2::Connection.new(DB2::Environment.new)
         connection.connect(database, usr, pwd)
-        ConnectionAdapters::DB2Adapter.new(connection)
+        ConnectionAdapters::DB2Adapter.new(connection, logger, :schema => schema)
       end
     end
 
@@ -35,7 +36,18 @@ begin
       # * <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</tt> -- Database schema to be set initially.
       class DB2Adapter < AbstractAdapter
+        def initialize(connection, logger, connection_options)
+          super(connection, logger)
+          @connection_options = connection_options
+          if schema = @connection_options[:schema]
+            with_statement do |stmt|
+              stmt.exec_direct("SET SCHEMA=#{schema}")
+            end
+          end
+        end
+        
         def select_all(sql, name = nil)
           select(sql, name)
         end
@@ -51,14 +63,12 @@ begin
 
         def execute(sql, name = nil)
           rows_affected = 0
-
-          log(sql, name) do
-            stmt = DB2::Statement.new(@connection)
-            stmt.exec_direct(sql)
-            rows_affected = stmt.row_count
-            stmt.free
+          with_statement do |stmt|
+            log(sql, name) do
+              stmt.exec_direct(sql)
+              rows_affected = stmt.row_count
+            end
           end
-
           rows_affected
         end
 
@@ -92,64 +102,72 @@ begin
         end
 
         def add_limit_offset!(sql, options)
-          if options[:limit] and !options[:limit].nil?
-            # "FETCH FIRST 0 ROWS ONLY" is not allowed, so we have
-            # to use a cheap trick.
-            if options[:limit] == 0
-              if sql =~ /WHERE/i
-                sql.sub!(/WHERE/i, 'WHERE 1 = 2 AND ')
-              elsif
-                sql =~ /ORDER\s+BY/i
-                sql.sub!(/ORDER\s+BY/i, 'WHERE 1 = 2 ORDER BY')
-              else
-                sql << 'WHERE 1 = 2'
-              end
-            else
-              sql << " FETCH FIRST #{options[:limit]} ROWS ONLY" 
-            end
-          end
-          if options[:offset] and !options[:offset].nil?
-            raise ArgumentError, ':offset option is not yet supported!'
+          if limit = options[:limit]
+            offset = options[:offset] || 0
+            # The following trick was added by andrea+rails@webcom.it.
+            sql.gsub!(/SELECT/i, 'SELECT B.* FROM (SELECT A.*, row_number() over () AS internal$rownum FROM (SELECT')
+            sql << ") A ) B WHERE B.internal$rownum > #{offset} AND B.internal$rownum <= #{limit + offset}"
           end
         end
 
         def tables(name = nil)
-          stmt = DB2::Statement.new(@connection)
           result = []
-          stmt.tables.each { |t| result << t[2].downcase }
-          stmt.free
+          schema = @connection_options[:schema] || '%'
+          with_statement do |stmt|
+            stmt.tables(schema).each { |t| result << t[2].downcase }
+          end
           result
         end
 
+        def indexes(table_name, name = nil)
+          tmp = {}
+          schema = @connection_options[:schema] || ''
+          with_statement do |stmt|
+            stmt.indexes(table_name, schema).each do |t|
+              next unless t[5]
+              next if t[4] == 'SYSIBM' # Skip system indexes.
+              idx_name = t[5].downcase
+              col_name = t[8].downcase
+              if tmp.has_key?(idx_name)
+                tmp[idx_name].columns << col_name
+              else
+                is_unique = t[3] == 0
+                tmp[idx_name] = IndexDefinition.new(table_name, idx_name, is_unique, [col_name])
+              end
+            end
+          end
+          tmp.values
+        end
+
         def columns(table_name, name = nil)
-          stmt = DB2::Statement.new(@connection)
           result = []
-
-          stmt.columns(table_name.upcase).each do |c| 
-            c_name = c[3].downcase
-            c_default = c[12] == 'NULL' ? nil : c[12]
-            c_type = c[5].downcase
-            c_type += "(#{c[6]})" if !c[6].nil? && c[6] != ''
-            result << Column.new(c_name, c_default, c_type)
-          end 
-
-          stmt.free
+          schema = @connection_options[:schema] || '%'
+          with_statement do |stmt|
+            stmt.columns(table_name, schema).each do |c| 
+              c_name = c[3].downcase
+              c_default = c[12] == 'NULL' ? nil : c[12]
+              c_default.gsub!(/^'(.*)'$/, '\1') if !c_default.nil?
+              c_type = c[5].downcase
+              c_type += "(#{c[6]})" if !c[6].nil? && c[6] != ''
+              result << Column.new(c_name, c_default, c_type, c[17] == 'YES')
+            end 
+          end
           result
         end
 
         def native_database_types
           {
-            :primary_key => "int generated by default as identity primary key",
-            :string      => { :name => "varchar", :limit => 255 },
-            :text        => { :name => "clob", :limit => 32768 },
-            :integer     => { :name => "int" },
-            :float       => { :name => "float" },
-            :datetime    => { :name => "timestamp" },
-            :timestamp   => { :name => "timestamp" },
-            :time        => { :name => "time" },
-            :date        => { :name => "date" },
-            :binary      => { :name => "blob", :limit => 32768 },
-            :boolean     => { :name => "decimal", :limit => 1 }
+            :primary_key => 'int generated by default as identity (start with 42) primary key',
+            :string      => { :name => 'varchar', :limit => 255 },
+            :text        => { :name => 'clob', :limit => 32768 },
+            :integer     => { :name => 'int' },
+            :float       => { :name => 'float' },
+            :datetime    => { :name => 'timestamp' },
+            :timestamp   => { :name => 'timestamp' },
+            :time        => { :name => 'time' },
+            :date        => { :name => 'date' },
+            :binary      => { :name => 'blob', :limit => 32768 },
+            :boolean     => { :name => 'decimal', :limit => 1 }
           }
         end
 
@@ -161,8 +179,28 @@ begin
           '0'
         end
 
+        def active?
+          @connection.select_one 'select 1 from ibm.sysdummy1'
+          true
+        rescue Exception
+          false
+        end
+
+        def reconnect!
+        end
+
+        def table_alias_length
+          128
+        end
+
         private
 
+        def with_statement
+          stmt = DB2::Statement.new(@connection)
+          yield stmt
+          stmt.free
+        end
+
         def last_insert_id
           row = select_one(<<-GETID.strip)
           with temp(id) as (values (identity_val_local())) select * from temp
@@ -171,17 +209,17 @@ begin
         end
 
         def select(sql, name = nil)
-          stmt = nil
-          log(sql, name) do
-            stmt = DB2::Statement.new(@connection)
-            stmt.exec_direct("#{sql.gsub(/=\s*null/i, 'IS NULL')} with ur")
-          end
-
           rows = []
-          while row = stmt.fetch_as_hash
-            rows << row
+          with_statement do |stmt|
+            log(sql, name) do
+              stmt.exec_direct("#{sql.gsub(/=\s*null/i, 'IS NULL')} with ur")
+            end
+
+            while row = stmt.fetch_as_hash
+              row.delete('internal$rownum')
+              rows << row
+            end
           end
-          stmt.free
           rows
         end
       end
@@ -189,4 +227,12 @@ begin
   end
 rescue LoadError
   # DB2 driver is unavailable.
+  module ActiveRecord # :nodoc:
+    class Base
+      def self.db2_connection(config) # :nodoc:
+        # Set up a reasonable error message
+        raise LoadError, "DB2 Libraries could not be loaded."
+      end
+    end
+  end
 end

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -42,7 +42,8 @@ module ActiveRecord
     class MysqlColumn < Column #:nodoc:
       private
         def simplified_type(field_type)
-          return :boolean if MysqlAdapter.emulate_booleans && field_type.downcase == "tinyint(1)"
+          return :boolean if MysqlAdapter.emulate_booleans && field_type.downcase.index("tinyint(1)")
+          return :string  if field_type =~ /enum/i
           super
         end
     end
@@ -115,7 +116,7 @@ module ActiveRecord
       # QUOTING ==================================================
 
       def quote(value, column = nil)
-        if value.kind_of?(String) && column && column.type == :binary
+        if value.kind_of?(String) && column && column.type == :binary && column.class.respond_to?(:string_to_binary)
           s = column.class.string_to_binary(value).unpack("H*")[0]
           "x'#{s}'"
         else
@@ -160,9 +161,13 @@ module ActiveRecord
       end
 
       def reconnect!
-        @connection.close rescue nil
+        disconnect!
         connect
       end
+      
+      def disconnect!
+        @connection.close rescue nil
+      end
 
 
       # DATABASE STATEMENTS ======================================
@@ -232,7 +237,14 @@ module ActiveRecord
       # SCHEMA STATEMENTS ========================================
 
       def structure_dump #:nodoc:
-        select_all("SHOW TABLES").inject("") do |structure, table|
+        if supports_views?
+          sql = "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"
+        else
+          sql = "SHOW TABLES"
+        end
+        
+        select_all(sql).inject("") do |structure, table|
+          table.delete('Table_type')
           structure += select_one("SHOW CREATE TABLE #{table.to_a.first.last}")["Create Table"] + ";\n\n"
         end
       end
@@ -243,13 +255,16 @@ module ActiveRecord
       end
 
       def create_database(name) #:nodoc:
-        execute "CREATE DATABASE #{name}"
+        execute "CREATE DATABASE `#{name}`"
       end
       
       def drop_database(name) #:nodoc:
-        execute "DROP DATABASE IF EXISTS #{name}"
+        execute "DROP DATABASE IF EXISTS `#{name}`"
       end
 
+      def current_database
+        select_one("SELECT DATABASE() as db")["db"]
+      end
 
       def tables(name = nil) #:nodoc:
         tables = []
@@ -330,6 +345,14 @@ module ActiveRecord
           result.free
           rows
         end
+        
+        def supports_views?
+          version[0] >= 5
+        end
+        
+        def version
+          @version ||= @connection.server_info.scan(/^(\d+)\.(\d+)\.(\d+)/).flatten.map { |v| v.to_i }
+        end
     end
   end
 end