Ticket #1874: firebird_adapter_r2032.diff

test/deprecated_associations_test.rb

@@ -311 +311 @@
-  end
-
-  def test_has_many_find_all
-type
+#{QUOTED_TYPE}
-    assert_equal 1, Firm.find_first.find_all_in_clients("name = 'Summit'").length
-  end
-

test/connections/native_firebird/connection.rb

@@ +1 @@
+print "Using native Firebird\n"
+require 'fixtures/course'
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+db1 = 'activerecord_unittest'
+db2 = 'activerecord_unittest2'
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => "firebird",
+  :host     => "localhost",
+  :username => "rails",
+  :password => "rails",
+  :database => db1
+)
+
+Course.establish_connection(
+  :adapter  => "firebird",
+  :host     => "localhost",
+  :username => "rails",
+  :password => "rails",
+  :database => db2
+)

test/associations_test.rb

@@ -338 +338 @@
-  def test_find_all
-    firm = Firm.find_first
-    assert_equal firm.clients, firm.clients.find_all
-type
+#{QUOTED_TYPE}
-    assert_equal 1, firm.clients.find(:all, :conditions => "name = 'Summit'").length
-  end
-
@@ -354 +354 @@
-    firm = Firm.find_first
-    client2 = Client.find(2)
-    assert_equal firm.clients.first, firm.clients.find_first
-type
-type
+#{QUOTED_TYPE}
+#{QUOTED_TYPE}
-  end
-
-  def test_find_first_sanitized
-    firm = Firm.find_first
-    client2 = Client.find(2)
-type
-'type = ?'
-'type = :type'
+#{QUOTED_TYPE}
+"#{QUOTED_TYPE} = ?"
+"#{QUOTED_TYPE} = :type"
-  end
-
-  def test_find_in_collection

test/base_test.rb

@@ -859 +859 @@
-  end
-
-  def test_count_with_join
-type
+#{QUOTED_TYPE}
-    res2 = res + 1
-    assert_nothing_raised do
-type
+#{QUOTED_TYPE}
-                        "LEFT JOIN comments ON posts.id=comments.post_id")
-    end
-    assert_equal res, res2

test/binary_test.rb

@@ -24 +24 @@
-    if ActiveRecord::ConnectionAdapters.const_defined? :OracleAdapter
-      return true if ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::OracleAdapter)
-    end
+
+    # For Firebird, length of SQL statement is limited to 32KB
+    # let's be honest about it and explicitly flunk the test :)
+    if ActiveRecord::Base.connection.adapter_name == 'Firebird'
+      return flunk("Firebird adapter doesn't support large BLOB values inline in SQL statement.")
+    end
+
-    bin = Binary.new
-    bin.data = @data
-

test/inheritance_test.rb

@@ -11 +11 @@
-    if ActiveRecord::ConnectionAdapters.const_defined? :SQLServerAdapter and ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::SQLServerAdapter)
-      Company.connection.execute "SET IDENTITY_INSERT companies ON"
-    end
-type
+#{QUOTED_TYPE}
-    #We then need to turn it back Off before continuing.
-    if ActiveRecord::ConnectionAdapters.const_defined? :SQLServerAdapter and ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::SQLServerAdapter)
-      Company.connection.execute "SET IDENTITY_INSERT companies OFF"

test/default_test_firebird.rb

@@ +1 @@
+require 'abstract_unit'
+require 'fixtures/default'
+
+class DefaultTest < Test::Unit::TestCase
+  def test_default_timestamp
+    default = Default.new
+    assert_instance_of(Time, default.default_timestamp)
+    assert_equal(:datetime, default.column_for_attribute(:default_timestamp).type)
+
+    # Variance should be small; increase if required -- e.g., if test db is on
+    # remote host and clocks aren't synchronized.
+    t1 = Time.new
+    accepted_variance = 1.0
+    assert_in_delta(t1.to_f, default.default_timestamp.to_f, accepted_variance)
+  end
+end

test/abstract_unit.rb

@@ -8 +8 @@
-require 'active_support/breakpoint'
-require 'connection'
-
+QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name('type')
+
-class Test::Unit::TestCase #:nodoc:
-  def create_fixtures(*table_names)
-    if block_given?

test/fixtures/comment.rb

@@ -6 +6 @@
-  end
-  
-  def self.search_by_type(q)
-'type = ?'
+"#{QUOTED_TYPE} = ?"
-  end
-end
-

test/fixtures/db_definitions/firebird.sql

@@ +1 @@
+CREATE DOMAIN D_BOOLEAN AS CHAR(1) CHECK (VALUE IN ('t', 'f'));
+
+CREATE TABLE accounts (
+  id BIGINT NOT NULL,
+  firm_id BIGINT,
+  credit_limit INTEGER,
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR accounts_seq;
+SET GENERATOR accounts_seq TO 10000;
+
+CREATE TABLE companies (
+  id BIGINT NOT NULL,
+  "TYPE" VARCHAR(50),
+  ruby_type VARCHAR(50),
+  firm_id BIGINT,
+  name VARCHAR(50),
+  client_of INTEGER,
+  rating INTEGER DEFAULT 1,
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR companies_nonstd_seq;
+SET GENERATOR companies_nonstd_seq TO 10000;
+
+CREATE TABLE topics (
+  id BIGINT NOT NULL,
+  title VARCHAR(255),
+  author_name VARCHAR(255),
+  author_email_address VARCHAR(255),
+  written_on TIMESTAMP,
+  bonus_time TIME,
+  last_read DATE,
+  content VARCHAR(4000),
+  approved SMALLINT DEFAULT 1,
+  replies_count INTEGER DEFAULT 0,
+  parent_id BIGINT,
+  "TYPE" VARCHAR(50),
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR topics_seq;
+SET GENERATOR topics_seq TO 10000;
+
+CREATE TABLE developers (
+  id BIGINT NOT NULL,
+  name VARCHAR(100),
+  salary INTEGER DEFAULT 70000,
+  created_at TIMESTAMP,
+  updated_at TIMESTAMP,
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR developers_seq;
+SET GENERATOR developers_seq TO 10000;
+
+CREATE TABLE projects (
+  id BIGINT NOT NULL,
+  name VARCHAR(100),
+  "TYPE" VARCHAR(255),
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR projects_seq;
+SET GENERATOR projects_seq TO 10000;
+
+CREATE TABLE developers_projects (
+  developer_id BIGINT NOT NULL,
+  project_id BIGINT NOT NULL,
+  joined_on DATE,
+  access_level SMALLINT DEFAULT 1
+);
+
+CREATE TABLE customers (
+  id BIGINT NOT NULL,
+  name VARCHAR(100),
+  balance INTEGER DEFAULT 0,
+  address_street VARCHAR(100),
+  address_city VARCHAR(100),
+  address_country VARCHAR(100),
+  gps_location VARCHAR(100),
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR customers_seq;
+SET GENERATOR customers_seq TO 10000;
+
+CREATE TABLE movies (
+  movieid BIGINT NOT NULL,
+  name varchar(100),
+  PRIMARY KEY (movieid)
+);
+CREATE GENERATOR movies_seq;
+SET GENERATOR movies_seq TO 10000;
+
+CREATE TABLE subscribers (
+  nick VARCHAR(100) NOT NULL,
+  name VARCHAR(100),
+  PRIMARY KEY (nick)
+);
+
+CREATE TABLE booleantests (
+  id BIGINT NOT NULL,
+  "VALUE" D_BOOLEAN,
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR booleantests_seq;
+SET GENERATOR booleantests_seq TO 10000;
+
+CREATE TABLE auto_id_tests (
+  auto_id BIGINT NOT NULL,
+  "VALUE" INTEGER,
+  PRIMARY KEY (auto_id)
+);
+CREATE GENERATOR auto_id_tests_seq;
+SET GENERATOR auto_id_tests_seq TO 10000;
+
+CREATE TABLE entrants (
+  id BIGINT NOT NULL,
+  name VARCHAR(255) NOT NULL,
+  course_id INTEGER NOT NULL,
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR entrants_seq;
+SET GENERATOR entrants_seq TO 10000;
+
+CREATE TABLE colnametests (
+  id BIGINT NOT NULL,
+  "REFERENCES" INTEGER NOT NULL,
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR colnametests_seq;
+SET GENERATOR colnametests_seq TO 10000;
+
+CREATE TABLE mixins (
+  id BIGINT NOT NULL,
+  parent_id BIGINT,
+  pos INTEGER,
+  created_at TIMESTAMP,
+  updated_at TIMESTAMP,
+  lft INTEGER,
+  rgt INTEGER,
+  root_id BIGINT,
+  "TYPE" VARCHAR(40),
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR mixins_seq;
+SET GENERATOR mixins_seq TO 10000;
+
+CREATE TABLE people (
+  id BIGINT NOT NULL,
+  first_name VARCHAR(40) NOT NULL,
+  lock_version INTEGER DEFAULT 0 NOT NULL,
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR people_seq;
+SET GENERATOR people_seq TO 10000;
+
+CREATE TABLE binaries (
+  id BIGINT NOT NULL,
+  data BLOB,
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR binaries_seq;
+SET GENERATOR binaries_seq TO 10000;
+
+CREATE TABLE computers (
+  id BIGINT NOT NULL,
+  developer INTEGER NOT NULL,
+  "extendedWarranty" INTEGER NOT NULL,
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR computers_seq;
+SET GENERATOR computers_seq TO 10000;
+
+CREATE TABLE posts (
+  id BIGINT NOT NULL,
+  author_id BIGINT,
+  title VARCHAR(255) NOT NULL,
+  "TYPE" VARCHAR(255) NOT NULL,
+  body VARCHAR(3000) NOT NULL,
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR posts_seq;
+SET GENERATOR posts_seq TO 10000;
+
+CREATE TABLE comments (
+  id BIGINT NOT NULL,
+  post_id BIGINT NOT NULL,
+  "TYPE" VARCHAR(255) NOT NULL,
+  body VARCHAR(3000) NOT NULL,
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR comments_seq;
+SET GENERATOR comments_seq TO 10000;
+
+CREATE TABLE authors (
+  id BIGINT NOT NULL,
+  name VARCHAR(255) NOT NULL,
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR authors_seq;
+SET GENERATOR authors_seq TO 10000;
+
+CREATE TABLE tasks (
+  id BIGINT NOT NULL,
+  "STARTING" TIMESTAMP,
+  ending TIMESTAMP,
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR tasks_seq;
+SET GENERATOR tasks_seq TO 10000;
+
+CREATE TABLE categories (
+  id BIGINT NOT NULL,
+  name VARCHAR(255) NOT NULL,
+  "TYPE" VARCHAR(255) NOT NULL,
+  PRIMARY KEY (id)
+);
+CREATE GENERATOR categories_seq;
+SET GENERATOR categories_seq TO 10000;
+
+CREATE TABLE categories_posts (
+  category_id BIGINT NOT NULL,
+  post_id BIGINT NOT NULL,
+  PRIMARY KEY (category_id, post_id)
+);
+
+CREATE TABLE fk_test_has_pk (
+  id BIGINT NOT NULL,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE fk_test_has_fk (
+  id BIGINT NOT NULL,
+  fk_id BIGINT NOT NULL,
+  PRIMARY KEY (id),
+  FOREIGN KEY (fk_id) REFERENCES fk_test_has_pk(id)
+);
+
+CREATE TABLE defaults (
+  id BIGINT NOT NULL,
+  default_timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+CREATE GENERATOR defaults_seq;
+SET GENERATOR defaults_seq TO 10000;

test/fixtures/db_definitions/firebird.drop.sql

@@ +1 @@
+DROP TABLE accounts;
+DROP TABLE companies;
+DROP TABLE topics;
+DROP TABLE developers;
+DROP TABLE projects;
+DROP TABLE developers_projects;
+DROP TABLE customers;
+DROP TABLE movies;
+DROP TABLE subscribers;
+DROP TABLE booleantests;
+DROP TABLE auto_id_tests;
+DROP TABLE entrants;
+DROP TABLE colnametests;
+DROP TABLE mixins;
+DROP TABLE people;
+DROP TABLE binaries;
+DROP TABLE computers;
+DROP TABLE posts;
+DROP TABLE comments;
+DROP TABLE authors;
+DROP TABLE tasks;
+DROP TABLE categories;
+DROP TABLE categories_posts;
+DROP TABLE fk_test_has_fk;
+DROP TABLE fk_test_has_pk;
+DROP TABLE defaults;
+
+DROP DOMAIN D_BOOLEAN;
+
+DROP GENERATOR accounts_seq;
+DROP GENERATOR companies_nonstd_seq;
+DROP GENERATOR topics_seq;
+DROP GENERATOR developers_seq;
+DROP GENERATOR projects_seq;
+DROP GENERATOR customers_seq;
+DROP GENERATOR movies_seq;
+DROP GENERATOR booleantests_seq;
+DROP GENERATOR auto_id_tests_seq;
+DROP GENERATOR entrants_seq;
+DROP GENERATOR colnametests_seq;
+DROP GENERATOR mixins_seq;
+DROP GENERATOR people_seq;
+DROP GENERATOR binaries_seq;
+DROP GENERATOR computers_seq;
+DROP GENERATOR posts_seq;
+DROP GENERATOR comments_seq;
+DROP GENERATOR authors_seq;
+DROP GENERATOR tasks_seq;
+DROP GENERATOR categories_seq;
+DROP GENERATOR defaults_seq;

test/fixtures/db_definitions/firebird2.sql

@@ +1 @@
+CREATE TABLE courses (
+  id BIGINT NOT NULL PRIMARY KEY,
+  name VARCHAR(255) NOT NULL
+);
+CREATE GENERATOR courses_seq;
+SET GENERATOR courses_seq TO 10000;

test/fixtures/db_definitions/firebird2.drop.sql

@@ +1 @@
+DROP TABLE courses;
+DROP GENERATOR courses_seq;

test/fixtures/company.rb

@@ -7 +7 @@
-
-
-class Firm < Company
-
+
+
+
-  has_many :clients_sorted_desc, :class_name => "Client", :order => "id DESC"
-  has_many :clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id"
-  has_many :clients_like_ms, :conditions => "name = 'Microsoft'", :class_name => "Client", :order => "id"

Rakefile

@@ -26 +26 @@
-
-# Run the unit tests
-
-
+firebird 
-  Rake::TestTask.new("test_#{adapter}") { |t|
-    t.libs << "test" << "test/connections/native_#{adapter}"
-    t.pattern = "test/*_test{,_#{adapter}}.rb"

lib/active_record/validations.rb

@@ -464 +464 @@
-        configuration = { :message => ActiveRecord::Errors.default_error_messages[:taken] }
-        configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
-
-
-
-
+
+
+
+
+
+
+
-          end
-else
-validates_each(attr_names,configuration) do |record, attr_name, value|
-record.errors.add(attr_name, configuration[:message]) if record.class.find(:first, :conditions => (record.new_record? ? ["#{attr_name} = ?", record.send(attr_name)] : ["#{attr_name} = ? AND #{record.class.primary_key} <> ?", record.send(attr_name), record.send(:id) ] )
+  unless record.new_record?
+  condition_sql << " AND #{record.class.primary_key} <> ?"
+condition_params << record.send(:id
-          end
+          if record.class.find(:first, :conditions => [condition_sql, *condition_params])
+            record.errors.add(attr_name, configuration[:message])
+          end
-        end
-      end
-      

lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -171 +171 @@
-      end
-
-      def quote_column_name(name)
-"'#{name}'"
+%Q("#{name}")
-      end
-
-      def adapter_name()

lib/active_record/connection_adapters/abstract_adapter.rb

@@ -155 +155 @@
-      attr_reader :name, :default, :type, :limit
-      # The name should contain the name of the column, such as "name" in "name varchar(250)"
-      # The default should contain the type-casted default of the column, such as 1 in "count int(11) DEFAULT 1"
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-      end
-
-      def klass
@@ -365 +371 @@
-        sql << " OFFSET #{options[:offset]}" if options.has_key?(:offset) and !options[:offset].nil?
-      end
-
+      # A concrete adapter should return true here if it requires primary key values to be pre-fetched before
+      # performing an insert.  If the adapter returns true, it must also implement next_sequence_value (see
+      # Firebird adapter for a reference implementation).
+      def prefetch_primary_key?
+        false
+      end
-
-      def initialize_schema_information
-        begin

lib/active_record/connection_adapters/firebird_adapter.rb

@@ +1 @@
+# Author: Ken Kunz <kennethkunz@gmail.com>
+
+require 'active_record/connection_adapters/abstract_adapter'
+
+module FireRuby # :nodoc: all
+  class ResultSet
+    include Enumerable
+  end
+
+  class Database
+    def self.new_from_params(database, host, port, service)
+      db_string = ""
+      if host
+        db_string << host
+        db_string << "/#{service || port}" if service || port
+        db_string << ":"
+      end
+      db_string << database
+      new(db_string)
+    end
+  end
+end
+
+module ActiveRecord
+  class << Base
+    def firebird_connection(config) # :nodoc:
+      require_library_or_gem 'fireruby'
+      symbolize_strings_in_hash(config)
+      unless config.has_key?(:database)
+        raise ArgumentError, "No database specified. Missing argument: database."
+      end
+      options = config[:charset] ? { CHARACTER_SET => config[:charset] } : {}
+      db = FireRuby::Database.new_from_params(*config.values_at(:database, :host, :port, :service))
+      connection = db.connect(config[:username], config[:password], options)
+      ConnectionAdapters::FirebirdAdapter.new(connection, logger)
+    end
+  end
+
+  module ConnectionAdapters
+    class FirebirdColumn < Column # :nodoc:
+      # 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 default
+        if @default
+          sql = "SELECT CAST(#{@default[:value]} AS #{@default[:cast_type]}) FROM RDB$DATABASE"
+          connection = ActiveRecord::Base.active_connections.values.detect { |conn| conn && conn.adapter_name == 'Firebird' }
+          if connection
+            type_cast connection.execute(sql).to_a.first['CAST']
+          else
+            raise ConnectionNotEstablished, "No Firebird connections established."
+          end
+        end
+      end
+
+      def type_cast(value)
+        if type == :date and value.instance_of?(Time)
+          value.to_date
+        else
+          super
+        end
+      end
+
+      private
+        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.3.2 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 CHAR(1) CHECK (VALUE IN ('t', 'f'));
+    #
+    # 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+.
+    #
+    # === +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 does not currently support Migrations.  I hope to
+    # add this feature in the near future.
+    #
+    # == 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
+      BLOB_MAX_LENGTH = 32_767
+
+      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 = <<-END_OF_SQL
+          SELECT R.RDB$FIELD_NAME, R.RDB$FIELD_SOURCE, T.RDB$TYPE_NAME, 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
+          FROM RDB$RELATION_FIELDS R, RDB$FIELDS F, RDB$TYPES T
+          WHERE R.RDB$FIELD_SOURCE = F.RDB$FIELD_NAME
+          AND R.RDB$RELATION_NAME = '#{table_name.upcase}'
+          AND F.RDB$FIELD_TYPE = T.RDB$TYPE
+          AND T.RDB$FIELD_NAME = 'RDB$FIELD_TYPE'
+          ORDER BY R.RDB$FIELD_POSITION
+        END_OF_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
+          create_column(*field_values)
+        end
+      end
+
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        execute(sql, name)
+        id_value
+      end
+
+      def execute(sql, name = nil, &block)
+        log(sql, name) do
+          if @transaction
+            @connection.execute(sql, @transaction, &block)
+          else
+            @connection.execute_immediate(sql, &block)
+          end
+        end
+      end
+
+      alias_method :update, :execute
+      alias_method :delete, :execute
+
+      def begin_db_transaction()
+        @transaction = @connection.start_transaction
+      end
+
+      def commit_db_transaction()
+        @transaction.commit
+        @transaction = nil
+      end
+
+      def rollback_db_transaction()
+        @transaction.rollback
+        @transaction = nil
+      end
+
+      def quote(value, column = nil)
+        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)
+        string.gsub(/'/, "''")
+      end
+
+      def quote_column_name(column_name)
+        %Q("#{ar_to_fb_case(column_name)}")
+      end
+
+      def adapter_name
+        'Firebird'
+      end
+
+      def add_limit_offset!(sql, options)
+        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
+
+      def prefetch_primary_key?
+        true
+      end
+
+      def next_sequence_value(sequence_name)
+        FireRuby::Generator.new(sequence_name, @connection).next(1)
+      end
+
+      private
+        def select(sql, name = nil)
+          execute(sql, name).collect do |row|
+            hashed_row = {}
+            row.aliases.zip(row.values) do |column_alias, value|
+              value = case value
+                when Time           then guess_date_or_time(value)
+                when FireRuby::Blob then value.to_s
+                else value
+              end
+              hashed_row[fb_to_ar_case(column_alias)] = value
+            end
+            hashed_row
+          end
+        end
+
+        # FireRuby (as of 0.3.2) returns a Time object for TIME, TIMESTAMP and
+        # DATE columns. This method guesses whether time is really a date, and
+        # returns a string representing the date if it is. This date string gets
+        # properly type-cast later (as a Time or Date object) based on the
+        # column type.
+        def guess_date_or_time(time)
+          if (time.hour + time.min + time.sec + time.usec).zero?
+            time.strftime("%Y-%m-%d")
+          else
+            time
+          end
+        end
+
+        def create_column(field_name, field_source, field_type, field_sub_type,
+                          field_length, field_precision, field_scale, default_source)
+          column_type = metadata_to_column_type(field_type, field_sub_type)
+          default = parse_default(default_source, column_type, field_length, field_precision, field_scale) if default_source
+          sql_type = field_source =~ /BOOLEAN/ ? 'BOOLEAN' : column_type
+          limit = field_type == 'BLOB' ? BLOB_MAX_LENGTH : field_length
+          FirebirdColumn.new(field_name.downcase, default, sql_type, limit)
+        end
+
+        # Maps the internal type returned by Firebird metadata tables to a
+        # SQL type that can be passed to #firebird_cast_type and Column#new
+        def metadata_to_column_type(field_type, field_sub_type)
+          case field_type
+            when 'TEXT'    then 'CHAR'
+            when 'VARYING' then 'VARCHAR'
+            when 'DOUBLE'  then 'DOUBLE PRECISION'
+            when 'BLOB'    then field_sub_type == 1 ? 'CLOB' : 'BLOB'
+            when 'SHORT', 'LONG', 'INT64'
+              case field_sub_type
+                when 1 then 'NUMERIC'
+                when 2 then 'DECIMAL'
+                else 'BIGINT'
+              end
+            else field_type
+          end
+        end
+
+        def parse_default(default_source, column_type, field_length, field_precision, field_scale)
+          default_source =~ /^DEFAULT\s+(.*)\s*$/i
+          default_value = $1
+          unless default_value.upcase == "NULL"
+            cast_type = firebird_cast_type(column_type, field_length, field_precision, field_scale)
+            { :value => default_value, :cast_type => cast_type }
+          end
+        end
+
+        # Returns a column definition that can be used in a Firebird CAST statement
+        def firebird_cast_type(sql_type, field_length, field_precision, field_scale)
+          case sql_type
+            when 'BLOB', 'CLOB'       then "VARCHAR(255)"
+            when 'CHAR', 'VARCHAR'    then "#{sql_type}(#{field_length})"
+            when 'NUMERIC', 'DECIMAL' then "#{sql_type}(#{field_precision},#{field_scale.abs})"
+            else sql_type
+          end
+        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

lib/active_record/associations.rb

@@ -864 +864 @@
-        end
-
-        def column_aliases(schema_abbreviations)
-.join(".")
+[0]}.#{connection.quote_column_name tc[1]
-        end
-
-        def association_join(reflection)

lib/active_record/base.rb

@@ -569 +569 @@
-        "type"
-      end
-
-
+ and Firebird
-      def sequence_name
-        "#{table_name}_seq"
-      end
@@ -619 +619 @@
-
-      # Sets the name of the sequence to use when generating ids to the given
-      # value, or (if the value is nil or false) to the value returned by the
-, which requires
-
+ or Firebird, which
+require 
-      #
-      # Setting the sequence name when using other dbs will have no effect.
-, it will
-
+ or Firebird,
+it will 
-      #
-      # Example:
-      #
@@ -808 +808 @@
-        end
-
-        def type_condition
-
-
+
+
+
-          end
-
-          " (#{type_condition}) "
@@ -837 +838 @@
-            attributes.each { |attr_name| super unless column_methods_hash.include?(attr_name.to_sym) }
-
-            attr_index = -1
-attr_name
+connection.quote_column_name(attr_name)
-
-            if arguments[attributes.length].is_a?(Hash)
-              find(finder, { :conditions => [conditions, *arguments[0...attributes.length]] }.update(arguments[attributes.length]))
@@ -1212 +1213 @@
-
-      # Creates a new record with values matching those of the instant attributes.
-      def create
+        if self.id.nil? and connection.prefetch_primary_key?
+          self.id = connection.next_sequence_value(self.class.sequence_name)
+        end
+
-        self.id = connection.insert(
-          "INSERT INTO #{self.class.table_name} " +
-          "(#{quoted_column_names.join(', ')}) " +

lib/active_record.rb

@@ -67 +67 @@
-require 'active_record/connection_adapters/sqlserver_adapter'
-require 'active_record/connection_adapters/db2_adapter'
-require 'active_record/connection_adapters/oci_adapter'
+require 'active_record/connection_adapters/firebird_adapter'
-
-require 'active_record/query_cache'