activerecord 1.15.6 → 2.0.0

data/lib/active_record/acts/tree.rb

@@ -1,96 +0,0 @@
-module ActiveRecord
-  module Acts #:nodoc:
-    module Tree #:nodoc:
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      # Specify this act if you want to model a tree structure by providing a parent association and a children
-      # association. This act requires that you have a foreign key column, which by default is called parent_id.
-      #
-      #   class Category < ActiveRecord::Base
-      #     acts_as_tree :order => "name"
-      #   end
-      #
-      #   Example:
-      #   root
-      #    \_ child1
-      #         \_ subchild1
-      #         \_ subchild2
-      #
-      #   root      = Category.create("name" => "root")
-      #   child1    = root.children.create("name" => "child1")
-      #   subchild1 = child1.children.create("name" => "subchild1")
-      #
-      #   root.parent   # => nil
-      #   child1.parent # => root
-      #   root.children # => [child1]
-      #   root.children.first.children.first # => subchild1
-      #
-      # In addition to the parent and children associations, the following instance methods are added to the class
-      # after specifying the act:
-      # * siblings          : Returns all the children of the parent, excluding the current node ([ subchild2 ] when called from subchild1)
-      # * self_and_siblings : Returns all the children of the parent, including the current node ([ subchild1, subchild2 ] when called from subchild1)
-      # * ancestors         : Returns all the ancestors of the current node ([child1, root] when called from subchild2)
-      # * root              : Returns the root of the current node (root when called from subchild2)
-      module ClassMethods
-        # Configuration options are:
-        #
-        # * <tt>foreign_key</tt> - specifies the column name to use for tracking of the tree (default: parent_id)
-        # * <tt>order</tt> - makes it possible to sort the children according to this SQL snippet.
-        # * <tt>counter_cache</tt> - keeps a count in a children_count column if set to true (default: false).
-        def acts_as_tree(options = {})
-          configuration = { :foreign_key => "parent_id", :order => nil, :counter_cache => nil }
-          configuration.update(options) if options.is_a?(Hash)
-
-          belongs_to :parent, :class_name => name, :foreign_key => configuration[:foreign_key], :counter_cache => configuration[:counter_cache]
-          has_many :children, :class_name => name, :foreign_key => configuration[:foreign_key], :order => configuration[:order], :dependent => :destroy
-
-          class_eval <<-EOV
-            include ActiveRecord::Acts::Tree::InstanceMethods
-
-            def self.roots
-              find(:all, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => #{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}})
-            end
-
-            def self.root
-              find(:first, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => #{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}})
-            end
-          EOV
-        end
-      end
-
-      module InstanceMethods
-        # Returns list of ancestors, starting from parent until root.
-        #
-        #   subchild1.ancestors # => [child1, root]
-        def ancestors
-          node, nodes = self, []
-          nodes << node = node.parent while node.parent
-          nodes
-        end
-
-        # Returns the root node of the tree.
-        def root
-          node = self
-          node = node.parent while node.parent
-          node
-        end
-
-        # Returns all siblings of the current node.
-        #
-        #   subchild1.siblings # => [subchild2]
-        def siblings
-          self_and_siblings - [self]
-        end
-
-        # Returns all siblings and a reference to the current node.
-        #
-        #   subchild1.self_and_siblings # => [subchild1, subchild2]
-        def self_and_siblings
-          parent ? parent.children : self.class.roots
-        end
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/db2_adapter.rb

@@ -1,228 +0,0 @@
-# Author/Maintainer: Maik Schmidt <contact@maik-schmidt.de>
-
-require 'active_record/connection_adapters/abstract_adapter'
-
-begin
-  require 'db2/db2cli' unless self.class.const_defined?(:DB2CLI)
-  require 'active_record/vendor/db2'
-
-  module ActiveRecord
-    class Base
-      # Establishes a connection to the database that's used by
-      # all Active Record objects
-      def self.db2_connection(config) # :nodoc:
-        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.'
-        end
-
-        connection = DB2::Connection.new(DB2::Environment.new)
-        connection.connect(database, usr, pwd)
-        ConnectionAdapters::DB2Adapter.new(connection, logger, :schema => schema)
-      end
-    end
-
-    module ConnectionAdapters
-      # The DB2 adapter works with the C-based CLI driver (http://rubyforge.org/projects/ruby-dbi/)
-      #
-      # Options:
-      #
-      # * <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 insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-          execute(sql, name = nil)
-          id_value || last_insert_id
-        end
-
-        def execute(sql, name = nil)
-          rows_affected = 0
-          with_statement do |stmt|
-            log(sql, name) do
-              stmt.exec_direct(sql)
-              rows_affected = stmt.row_count
-            end
-          end
-          rows_affected
-        end
-
-        def begin_db_transaction
-          @connection.set_auto_commit_off
-        end
-
-        def commit_db_transaction
-          @connection.commit
-          @connection.set_auto_commit_on
-        end
-        
-        def rollback_db_transaction
-          @connection.rollback
-          @connection.set_auto_commit_on
-        end
-
-        def quote_column_name(column_name)
-          column_name
-        end
-
-        def adapter_name()
-          'DB2'
-        end
-
-        def quote_string(string)
-          string.gsub(/'/, "''") # ' (for ruby-mode)
-        end
-
-        def add_limit_offset!(sql, options)
-          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)
-          result = []
-          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)
-          result = []
-          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 (start with 42) primary key',
-            :string      => { :name => 'varchar', :limit => 255 },
-            :text        => { :name => 'clob', :limit => 32768 },
-            :integer     => { :name => 'int' },
-            :float       => { :name => 'float' },
-            :decimal     => { :name => 'decimal' },
-            :datetime    => { :name => 'timestamp' },
-            :timestamp   => { :name => 'timestamp' },
-            :time        => { :name => 'time' },
-            :date        => { :name => 'date' },
-            :binary      => { :name => 'blob', :limit => 32768 },
-            :boolean     => { :name => 'decimal', :limit => 1 }
-          }
-        end
-
-        def quoted_true
-          '1'
-        end
-
-        def quoted_false
-          '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
-          GETID
-          row['id'].to_i
-        end
-
-        def select(sql, name = nil)
-          rows = []
-          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
-          rows
-        end
-      end
-    end
-  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/firebird_adapter.rb

@@ -1,728 +0,0 @@
-# Author: Ken Kunz <kennethkunz@gmail.com>
-
-require 'active_record/connection_adapters/abstract_adapter'
-
-module FireRuby # :nodoc: all
-  NON_EXISTENT_DOMAIN_ERROR = "335544569"
-  class Database
-    def self.db_string_for(config)
-      unless config.has_key?(:database)
-        raise ArgumentError, "No database specified. Missing argument: database."
-      end
-      host_string = config.values_at(:host, :service, :port).compact.first(2).join("/") if config[:host]
-      [host_string, config[:database]].join(":")
-    end
-
-    def self.new_from_config(config)
-      db = new db_string_for(config)
-      db.character_set = config[:charset]
-      return db
-    end
-  end
-end
-
-module ActiveRecord
-  class << Base
-    def firebird_connection(config) # :nodoc:
-      require_library_or_gem 'fireruby'
-      unless defined? FireRuby::SQLType
-        raise AdapterNotFound,
-          'The Firebird adapter requires FireRuby version 0.4.0 or greater; you appear ' <<
-          'to be running an older version -- please update FireRuby (gem install fireruby).'
-      end
-      config.symbolize_keys!
-      db = FireRuby::Database.new_from_config(config)
-      connection_params = config.values_at(:username, :password)
-      connection = db.connect(*connection_params)
-      ConnectionAdapters::FirebirdAdapter.new(connection, logger, connection_params)
-    end
-  end
-
-  module ConnectionAdapters
-    class FirebirdColumn < Column # :nodoc:
-      VARCHAR_MAX_LENGTH = 32_765
-      BLOB_MAX_LENGTH    = 32_767
-
-      def initialize(name, domain, type, sub_type, length, precision, scale, default_source, null_flag)
-        @firebird_type = FireRuby::SQLType.to_base_type(type, sub_type).to_s
-
-        super(name.downcase, nil, @firebird_type, !null_flag)
-
-        @default = parse_default(default_source) if default_source
-        @limit = decide_limit(length)
-        @domain, @sub_type, @precision, @scale = domain, sub_type, precision, scale.abs
-      end
-
-      def type
-        if @domain =~ /BOOLEAN/
-          :boolean
-        elsif @type == :binary and @sub_type == 1
-          :text
-        else
-          @type
-        end
-      end
-
-      def default
-        type_cast(decide_default) if @default
-      end
-
-      def self.value_to_boolean(value)
-        %W(#{FirebirdAdapter.boolean_domain[:true]} true t 1).include? value.to_s.downcase
-      end
-
-      private
-        def parse_default(default_source)
-          default_source =~ /^\s*DEFAULT\s+(.*)\s*$/i
-          return $1 unless $1.upcase == "NULL"
-        end
-
-        def decide_default
-          if @default =~ /^'?(\d*\.?\d+)'?$/ or
-             @default =~ /^'(.*)'$/ && [:text, :string, :binary, :boolean].include?(type)
-            $1
-          else
-            firebird_cast_default
-          end
-        end
-
-        # Submits a _CAST_ query to the database, casting the default value to the specified SQL type.
-        # This enables Firebird to provide an actual value when context variables are used as column
-        # defaults (such as CURRENT_TIMESTAMP).
-        def firebird_cast_default
-          sql = "SELECT CAST(#{@default} AS #{column_def}) FROM RDB$DATABASE"
-          if connection = Base.active_connections.values.detect { |conn| conn && conn.adapter_name == 'Firebird' }
-            connection.execute(sql).to_a.first['CAST']
-          else
-            raise ConnectionNotEstablished, "No Firebird connections established."
-          end
-        end
-
-        def decide_limit(length)
-          if text? or number?
-            length
-          elsif @firebird_type == 'BLOB'
-            BLOB_MAX_LENGTH
-          end
-        end
-
-        def column_def
-          case @firebird_type
-            when 'BLOB'               then "VARCHAR(#{VARCHAR_MAX_LENGTH})"
-            when 'CHAR', 'VARCHAR'    then "#{@firebird_type}(#{@limit})"
-            when 'NUMERIC', 'DECIMAL' then "#{@firebird_type}(#{@precision},#{@scale.abs})"
-            when 'DOUBLE'             then "DOUBLE PRECISION"
-            else @firebird_type
-          end
-        end
-
-        def simplified_type(field_type)
-          if field_type == 'TIMESTAMP'
-            :datetime
-          else
-            super
-          end
-        end
-    end
-
-    # The Firebird adapter relies on the FireRuby[http://rubyforge.org/projects/fireruby/]
-    # extension, version 0.4.0 or later (available as a gem or from
-    # RubyForge[http://rubyforge.org/projects/fireruby/]). FireRuby works with
-    # Firebird 1.5.x on Linux, OS X and Win32 platforms.
-    #
-    # == Usage Notes
-    #
-    # === Sequence (Generator) Names
-    # The Firebird adapter supports the same approach adopted for the Oracle
-    # adapter. See ActiveRecord::Base#set_sequence_name for more details.
-    #
-    # Note that in general there is no need to create a <tt>BEFORE INSERT</tt>
-    # trigger corresponding to a Firebird sequence generator when using
-    # ActiveRecord. In other words, you don't have to try to make Firebird
-    # simulate an <tt>AUTO_INCREMENT</tt> or +IDENTITY+ column. When saving a
-    # new record, ActiveRecord pre-fetches the next sequence value for the table
-    # and explicitly includes it in the +INSERT+ statement. (Pre-fetching the
-    # next primary key value is the only reliable method for the Firebird
-    # adapter to report back the +id+ after a successful insert.)
-    #
-    # === BOOLEAN Domain
-    # Firebird 1.5 does not provide a native +BOOLEAN+ type. But you can easily
-    # define a +BOOLEAN+ _domain_ for this purpose, e.g.:
-    #
-    #  CREATE DOMAIN D_BOOLEAN AS SMALLINT CHECK (VALUE IN (0, 1) OR VALUE IS NULL);
-    #
-    # When the Firebird adapter encounters a column that is based on a domain
-    # that includes "BOOLEAN" in the domain name, it will attempt to treat
-    # the column as a +BOOLEAN+.
-    #
-    # By default, the Firebird adapter will assume that the BOOLEAN domain is
-    # defined as above.  This can be modified if needed.  For example, if you
-    # have a legacy schema with the following +BOOLEAN+ domain defined:
-    #
-    #  CREATE DOMAIN BOOLEAN AS CHAR(1) CHECK (VALUE IN ('T', 'F'));
-    #
-    # ...you can add the following line to your <tt>environment.rb</tt> file:
-    #
-    #  ActiveRecord::ConnectionAdapters::FirebirdAdapter.boolean_domain = { :true => 'T', :false => 'F' }
-    #
-    # === BLOB Elements
-    # The Firebird adapter currently provides only limited support for +BLOB+
-    # columns. You cannot currently retrieve or insert a +BLOB+ as an IO stream.
-    # When selecting a +BLOB+, the entire element is converted into a String.
-    # When inserting or updating a +BLOB+, the entire value is included in-line
-    # in the SQL statement, limiting you to values <= 32KB in size.
-    #
-    # === Column Name Case Semantics
-    # Firebird and ActiveRecord have somewhat conflicting case semantics for
-    # column names.
-    #
-    # [*Firebird*]
-    #   The standard practice is to use unquoted column names, which can be
-    #   thought of as case-insensitive. (In fact, Firebird converts them to
-    #   uppercase.) Quoted column names (not typically used) are case-sensitive.
-    # [*ActiveRecord*]
-    #   Attribute accessors corresponding to column names are case-sensitive.
-    #   The defaults for primary key and inheritance columns are lowercase, and
-    #   in general, people use lowercase attribute names.
-    #
-    # In order to map between the differing semantics in a way that conforms
-    # to common usage for both Firebird and ActiveRecord, uppercase column names
-    # in Firebird are converted to lowercase attribute names in ActiveRecord,
-    # and vice-versa. Mixed-case column names retain their case in both
-    # directions. Lowercase (quoted) Firebird column names are not supported.
-    # This is similar to the solutions adopted by other adapters.
-    #
-    # In general, the best approach is to use unqouted (case-insensitive) column
-    # names in your Firebird DDL (or if you must quote, use uppercase column
-    # names). These will correspond to lowercase attributes in ActiveRecord.
-    #
-    # For example, a Firebird table based on the following DDL:
-    #
-    #  CREATE TABLE products (
-    #    id BIGINT NOT NULL PRIMARY KEY,
-    #    "TYPE" VARCHAR(50),
-    #    name VARCHAR(255) );
-    #
-    # ...will correspond to an ActiveRecord model class called +Product+ with
-    # the following attributes: +id+, +type+, +name+.
-    #
-    # ==== Quoting <tt>"TYPE"</tt> and other Firebird reserved words:
-    # In ActiveRecord, the default inheritance column name is +type+. The word
-    # _type_ is a Firebird reserved word, so it must be quoted in any Firebird
-    # SQL statements. Because of the case mapping described above, you should
-    # always reference this column using quoted-uppercase syntax
-    # (<tt>"TYPE"</tt>) within Firebird DDL or other SQL statements (as in the
-    # example above). This holds true for any other Firebird reserved words used
-    # as column names as well.
-    #
-    # === Migrations
-    # The Firebird Adapter now supports Migrations.
-    #
-    # ==== Create/Drop Table and Sequence Generators
-    # Creating or dropping a table will automatically create/drop a
-    # correpsonding sequence generator, using the default naming convension.
-    # You can specify a different name using the <tt>:sequence</tt> option; no
-    # generator is created if <tt>:sequence</tt> is set to +false+.
-    #
-    # ==== Rename Table
-    # The Firebird #rename_table Migration should be used with caution.
-    # Firebird 1.5 lacks built-in support for this feature, so it is
-    # implemented by making a copy of the original table (including column
-    # definitions, indexes and data records), and then dropping the original
-    # table. Constraints and Triggers are _not_ properly copied, so avoid
-    # this method if your original table includes constraints (other than
-    # the primary key) or triggers. (Consider manually copying your table
-    # or using a view instead.)
-    #
-    # == Connection Options
-    # The following options are supported by the Firebird adapter. None of the
-    # options have default values.
-    #
-    # <tt>:database</tt>::
-    #   <i>Required option.</i> Specifies one of: (i) a Firebird database alias;
-    #   (ii) the full path of a database file; _or_ (iii) a full Firebird
-    #   connection string. <i>Do not specify <tt>:host</tt>, <tt>:service</tt>
-    #   or <tt>:port</tt> as separate options when using a full connection
-    #   string.</i>
-    # <tt>:host</tt>::
-    #   Set to <tt>"remote.host.name"</tt> for remote database connections.
-    #   May be omitted for local connections if a full database path is
-    #   specified for <tt>:database</tt>. Some platforms require a value of
-    #   <tt>"localhost"</tt> for local connections when using a Firebird
-    #   database _alias_.
-    # <tt>:service</tt>::
-    #   Specifies a service name for the connection. Only used if <tt>:host</tt>
-    #   is provided. Required when connecting to a non-standard service.
-    # <tt>:port</tt>::
-    #   Specifies the connection port. Only used if <tt>:host</tt> is provided
-    #   and <tt>:service</tt> is not. Required when connecting to a non-standard
-    #   port and <tt>:service</tt> is not defined.
-    # <tt>:username</tt>::
-    #   Specifies the database user. May be omitted or set to +nil+ (together
-    #   with <tt>:password</tt>) to use the underlying operating system user
-    #   credentials on supported platforms.
-    # <tt>:password</tt>::
-    #   Specifies the database password. Must be provided if <tt>:username</tt>
-    #   is explicitly specified; should be omitted if OS user credentials are
-    #   are being used.
-    # <tt>:charset</tt>::
-    #   Specifies the character set to be used by the connection. Refer to
-    #   Firebird documentation for valid options.
-    class FirebirdAdapter < AbstractAdapter
-      TEMP_COLUMN_NAME = 'AR$TEMP_COLUMN'
-
-      @@boolean_domain = { :name => "d_boolean", :type => "smallint", :true => 1, :false => 0 }
-      cattr_accessor :boolean_domain
-
-      def initialize(connection, logger, connection_params = nil)
-        super(connection, logger)
-        @connection_params = connection_params
-      end
-
-      def adapter_name # :nodoc:
-        'Firebird'
-      end
-
-      def supports_migrations? # :nodoc:
-        true
-      end
-
-      def native_database_types # :nodoc:
-        {
-          :primary_key => "BIGINT NOT NULL PRIMARY KEY",
-          :string      => { :name => "varchar", :limit => 255 },
-          :text        => { :name => "blob sub_type text" },
-          :integer     => { :name => "bigint" },
-          :decimal     => { :name => "decimal" },
-          :numeric     => { :name => "numeric" },
-          :float       => { :name => "float" },
-          :datetime    => { :name => "timestamp" },
-          :timestamp   => { :name => "timestamp" },
-          :time        => { :name => "time" },
-          :date        => { :name => "date" },
-          :binary      => { :name => "blob sub_type 0" },
-          :boolean     => boolean_domain
-        }
-      end
-
-      # Returns true for Firebird adapter (since Firebird requires primary key
-      # values to be pre-fetched before insert). See also #next_sequence_value.
-      def prefetch_primary_key?(table_name = nil)
-        true
-      end
-
-      def default_sequence_name(table_name, primary_key = nil) # :nodoc:
-        "#{table_name}_seq"
-      end
-
-
-      # QUOTING ==================================================
-
-      def quote(value, column = nil) # :nodoc:
-        if [Time, DateTime].include?(value.class)
-          "CAST('#{value.strftime("%Y-%m-%d %H:%M:%S")}' AS TIMESTAMP)"
-        else
-          super
-        end
-      end
-
-      def quote_string(string) # :nodoc:
-        string.gsub(/'/, "''")
-      end
-
-      def quote_column_name(column_name) # :nodoc:
-        %Q("#{ar_to_fb_case(column_name.to_s)}")
-      end
-
-      def quoted_true # :nodoc:
-        quote(boolean_domain[:true])
-      end
-
-      def quoted_false # :nodoc:
-        quote(boolean_domain[:false])
-      end
-
-
-      # CONNECTION MANAGEMENT ====================================
-
-      def active? # :nodoc:
-        not @connection.closed?
-      end
-
-      def disconnect! # :nodoc:
-        @connection.close rescue nil
-      end
-
-      def reconnect! # :nodoc:
-        disconnect!
-        @connection = @connection.database.connect(*@connection_params)
-      end
-
-
-      # DATABASE STATEMENTS ======================================
-
-      def select_all(sql, name = nil) # :nodoc:
-        select(sql, name)
-      end
-
-      def select_one(sql, name = nil) # :nodoc:
-        select(sql, name).first
-      end
-
-      def execute(sql, name = nil, &block) # :nodoc:
-        log(sql, name) do
-          if @transaction
-            @connection.execute(sql, @transaction, &block)
-          else
-            @connection.execute_immediate(sql, &block)
-          end
-        end
-      end
-
-      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) # :nodoc:
-        execute(sql, name)
-        id_value
-      end
-
-      alias_method :update, :execute
-      alias_method :delete, :execute
-
-      def begin_db_transaction() # :nodoc:
-        @transaction = @connection.start_transaction
-      end
-
-      def commit_db_transaction() # :nodoc:
-        @transaction.commit
-      ensure
-        @transaction = nil
-      end
-
-      def rollback_db_transaction() # :nodoc:
-        @transaction.rollback
-      ensure
-        @transaction = nil
-      end
-
-      def add_limit_offset!(sql, options) # :nodoc:
-        if options[:limit]
-          limit_string = "FIRST #{options[:limit]}"
-          limit_string << " SKIP #{options[:offset]}" if options[:offset]
-          sql.sub!(/\A(\s*SELECT\s)/i, '\&' + limit_string + ' ')
-        end
-      end
-
-      # Returns the next sequence value from a sequence generator. Not generally
-      # called directly; used by ActiveRecord to get the next primary key value
-      # when inserting a new database record (see #prefetch_primary_key?).
-      def next_sequence_value(sequence_name)
-        FireRuby::Generator.new(sequence_name, @connection).next(1)
-      end
-
-
-      # SCHEMA STATEMENTS ========================================
-
-      def current_database # :nodoc:
-        file = @connection.database.file.split(':').last
-        File.basename(file, '.*')
-      end
-
-      def recreate_database! # :nodoc:
-        sql = "SELECT rdb$character_set_name FROM rdb$database"
-        charset = execute(sql).to_a.first[0].rstrip
-        disconnect!
-        @connection.database.drop(*@connection_params)
-        FireRuby::Database.create(@connection.database.file,
-          @connection_params[0], @connection_params[1], 4096, charset)
-      end
-
-      def tables(name = nil) # :nodoc:
-        sql = "SELECT rdb$relation_name FROM rdb$relations WHERE rdb$system_flag = 0"
-        execute(sql, name).collect { |row| row[0].rstrip.downcase }
-      end
-
-      def indexes(table_name, name = nil) # :nodoc:
-        index_metadata(table_name, false, name).inject([]) do |indexes, row|
-          if indexes.empty? or indexes.last.name != row[0]
-            indexes << IndexDefinition.new(table_name, row[0].rstrip.downcase, row[1] == 1, [])
-          end
-          indexes.last.columns << row[2].rstrip.downcase
-          indexes
-        end
-      end
-
-      def columns(table_name, name = nil) # :nodoc:
-        sql = <<-end_sql
-          SELECT r.rdb$field_name, r.rdb$field_source, f.rdb$field_type, f.rdb$field_sub_type,
-                 f.rdb$field_length, f.rdb$field_precision, f.rdb$field_scale,
-                 COALESCE(r.rdb$default_source, f.rdb$default_source) rdb$default_source,
-                 COALESCE(r.rdb$null_flag, f.rdb$null_flag) rdb$null_flag
-          FROM rdb$relation_fields r
-          JOIN rdb$fields f ON r.rdb$field_source = f.rdb$field_name
-          WHERE r.rdb$relation_name = '#{table_name.to_s.upcase}'
-          ORDER BY r.rdb$field_position
-        end_sql
-        execute(sql, name).collect do |field|
-          field_values = field.values.collect do |value|
-            case value
-              when String         then value.rstrip
-              when FireRuby::Blob then value.to_s
-              else value
-            end
-          end
-          FirebirdColumn.new(*field_values)
-        end
-      end
-
-      def create_table(name, options = {}) # :nodoc:
-        begin
-          super
-        rescue StatementInvalid
-          raise unless non_existent_domain_error?
-          create_boolean_domain
-          super
-        end
-        unless options[:id] == false or options[:sequence] == false
-          sequence_name = options[:sequence] || default_sequence_name(name)
-          create_sequence(sequence_name)
-        end
-      end
-
-      def drop_table(name, options = {}) # :nodoc:
-        super(name)
-        unless options[:sequence] == false
-          sequence_name = options[:sequence] || default_sequence_name(name)
-          drop_sequence(sequence_name) if sequence_exists?(sequence_name)
-        end
-      end
-
-      def add_column(table_name, column_name, type, options = {}) # :nodoc:
-        super
-      rescue StatementInvalid
-        raise unless non_existent_domain_error?
-        create_boolean_domain
-        super
-      end
-
-      def change_column(table_name, column_name, type, options = {}) # :nodoc:
-        change_column_type(table_name, column_name, type, options)
-        change_column_position(table_name, column_name, options[:position]) if options.include?(:position)
-        change_column_default(table_name, column_name, options[:default]) if options_include_default?(options)
-      end
-
-      def change_column_default(table_name, column_name, default) # :nodoc:
-        table_name = table_name.to_s.upcase
-        sql = <<-end_sql
-          UPDATE rdb$relation_fields f1
-          SET f1.rdb$default_source =
-                (SELECT f2.rdb$default_source FROM rdb$relation_fields f2
-                 WHERE f2.rdb$relation_name = '#{table_name}'
-                 AND f2.rdb$field_name = '#{TEMP_COLUMN_NAME}'),
-              f1.rdb$default_value =
-                (SELECT f2.rdb$default_value FROM rdb$relation_fields f2
-                 WHERE f2.rdb$relation_name = '#{table_name}'
-                 AND f2.rdb$field_name = '#{TEMP_COLUMN_NAME}')
-          WHERE f1.rdb$relation_name = '#{table_name}'
-          AND f1.rdb$field_name = '#{ar_to_fb_case(column_name.to_s)}'
-        end_sql
-        transaction do
-          add_column(table_name, TEMP_COLUMN_NAME, :string, :default => default)
-          execute sql
-          remove_column(table_name, TEMP_COLUMN_NAME)
-        end
-      end
-
-      def rename_column(table_name, column_name, new_column_name) # :nodoc:
-        execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} TO #{new_column_name}"
-      end
-
-      def remove_index(table_name, options) #:nodoc:
-        execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
-      end
-
-      def rename_table(name, new_name) # :nodoc:
-        if table_has_constraints_or_dependencies?(name)
-          raise ActiveRecordError,
-            "Table #{name} includes constraints or dependencies that are not supported by " <<
-            "the Firebird rename_table migration. Try explicitly removing the constraints/" <<
-            "dependencies first, or manually renaming the table."
-        end
-
-        transaction do
-          copy_table(name, new_name)
-          copy_table_indexes(name, new_name)
-        end
-        begin
-          copy_table_data(name, new_name)
-          copy_sequence_value(name, new_name)
-        rescue
-          drop_table(new_name)
-          raise
-        end
-        drop_table(name)
-      end
-
-      def dump_schema_information # :nodoc:
-        super << ";\n"
-      end
-
-      def type_to_sql(type, limit = nil, precision = nil, scale = nil) # :nodoc:
-        case type
-          when :integer then integer_sql_type(limit)
-          when :float   then float_sql_type(limit)
-          when :string  then super(type, limit, precision, scale)
-          else super(type, limit, precision, scale)
-        end
-      end
-
-      private
-        def integer_sql_type(limit)
-          case limit
-            when (1..2) then 'smallint'
-            when (3..4) then 'integer'
-            else 'bigint'
-          end
-        end
-
-        def float_sql_type(limit)
-          limit.to_i <= 4 ? 'float' : 'double precision'
-        end
-
-        def select(sql, name = nil)
-          execute(sql, name).collect do |row|
-            hashed_row = {}
-            row.each do |column, value|
-              value = value.to_s if FireRuby::Blob === value
-              hashed_row[fb_to_ar_case(column)] = value
-            end
-            hashed_row
-          end
-        end
-
-        def primary_key(table_name)
-          if pk_row = index_metadata(table_name, true).to_a.first
-            pk_row[2].rstrip.downcase
-          end
-        end
-
-        def index_metadata(table_name, pk, name = nil)
-          sql = <<-end_sql
-            SELECT i.rdb$index_name, i.rdb$unique_flag, s.rdb$field_name
-            FROM rdb$indices i
-            JOIN rdb$index_segments s ON i.rdb$index_name = s.rdb$index_name
-            LEFT JOIN rdb$relation_constraints c ON i.rdb$index_name = c.rdb$index_name
-            WHERE i.rdb$relation_name = '#{table_name.to_s.upcase}'
-          end_sql
-          if pk
-            sql << "AND c.rdb$constraint_type = 'PRIMARY KEY'\n"
-          else
-            sql << "AND (c.rdb$constraint_type IS NULL OR c.rdb$constraint_type != 'PRIMARY KEY')\n"
-          end
-          sql << "ORDER BY i.rdb$index_name, s.rdb$field_position\n"
-          execute sql, name
-        end
-
-        def change_column_type(table_name, column_name, type, options = {})
-          sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} TYPE #{type_to_sql(type, options[:limit])}"
-          execute sql
-        rescue StatementInvalid
-          raise unless non_existent_domain_error?
-          create_boolean_domain
-          execute sql
-        end
-
-        def change_column_position(table_name, column_name, position)
-          execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} POSITION #{position}"
-        end
-
-        def copy_table(from, to)
-          table_opts = {}
-          if pk = primary_key(from)
-            table_opts[:primary_key] = pk
-          else
-            table_opts[:id] = false
-          end
-          create_table(to, table_opts) do |table|
-            from_columns = columns(from).reject { |col| col.name == table_opts[:primary_key] }
-            from_columns.each do |column|
-              col_opts = [:limit, :default, :null].inject({}) { |opts, opt| opts.merge(opt => column.send(opt)) }
-              table.column column.name, column.type, col_opts
-            end
-          end
-        end
-
-        def copy_table_indexes(from, to)
-          indexes(from).each do |index|
-            unless index.name[from.to_s]
-              raise ActiveRecordError,
-                "Cannot rename index #{index.name}, because the index name does not include " <<
-                "the original table name (#{from}). Try explicitly removing the index on the " <<
-                "original table and re-adding it on the new (renamed) table."
-            end
-            options = {}
-            options[:name] = index.name.gsub(from.to_s, to.to_s)
-            options[:unique] = index.unique
-            add_index(to, index.columns, options)
-          end
-        end
-
-        def copy_table_data(from, to)
-          execute "INSERT INTO #{to} SELECT * FROM #{from}", "Copy #{from} data to #{to}"
-        end
-
-        def copy_sequence_value(from, to)
-          sequence_value = FireRuby::Generator.new(default_sequence_name(from), @connection).last
-          execute "SET GENERATOR #{default_sequence_name(to)} TO #{sequence_value}"
-        end
-
-        def sequence_exists?(sequence_name)
-          FireRuby::Generator.exists?(sequence_name, @connection)
-        end
-
-        def create_sequence(sequence_name)
-          FireRuby::Generator.create(sequence_name.to_s, @connection)
-        end
-
-        def drop_sequence(sequence_name)
-          FireRuby::Generator.new(sequence_name.to_s, @connection).drop
-        end
-
-        def create_boolean_domain
-          sql = <<-end_sql
-            CREATE DOMAIN #{boolean_domain[:name]} AS #{boolean_domain[:type]}
-            CHECK (VALUE IN (#{quoted_true}, #{quoted_false}) OR VALUE IS NULL)
-          end_sql
-          execute sql rescue nil
-        end
-
-        def table_has_constraints_or_dependencies?(table_name)
-          table_name = table_name.to_s.upcase
-          sql = <<-end_sql
-            SELECT 1 FROM rdb$relation_constraints
-            WHERE rdb$relation_name = '#{table_name}'
-            AND rdb$constraint_type IN ('UNIQUE', 'FOREIGN KEY', 'CHECK')
-            UNION
-            SELECT 1 FROM rdb$dependencies
-            WHERE rdb$depended_on_name = '#{table_name}'
-            AND rdb$depended_on_type = 0
-          end_sql
-          !select(sql).empty?
-        end
-
-        def non_existent_domain_error?
-          $!.message.include? FireRuby::NON_EXISTENT_DOMAIN_ERROR
-        end
-
-        # Maps uppercase Firebird column names to lowercase for ActiveRecord;
-        # mixed-case columns retain their original case.
-        def fb_to_ar_case(column_name)
-          column_name =~ /[[:lower:]]/ ? column_name : column_name.downcase
-        end
-
-        # Maps lowercase ActiveRecord column names to uppercase for Fierbird;
-        # mixed-case columns retain their original case.
-        def ar_to_fb_case(column_name)
-          column_name =~ /[[:upper:]]/ ? column_name : column_name.upcase
-        end
-    end
-  end
-end