Ticket #4093: FrontBaseAdapter.4.patch

activerecord/Rakefile

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

activerecord/lib/active_record/base.rb

@@ -755 +755 @@
-        superclass == Base || !columns_hash.include?(inheritance_column)
-      end
-
-
-
+
+
+
-      end
-
-      # Used to sanitize objects before they're used in an SELECT SQL-statement. Delegates to <tt>connection.quote</tt>.
@@ -947 +948 @@
-      
-        def find_one(id, options)
-          conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
-sanitize(id
+quote(id,columns_hash[primary_key]
-
-          if result = find_initial(options)
-            result
@@ -958 +959 @@
-      
-        def find_some(ids, options)
-          conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
-sanitize(id
+quote(id,columns_hash[primary_key]
-          options.update :conditions => "#{table_name}.#{primary_key} IN (#{ids_list})#{conditions}"
-
-          result = find_every(options)

activerecord/lib/active_record/connection_adapters/frontbase_adapter.rb

@@ +1 @@
+require 'active_record/connection_adapters/abstract_adapter'
+require 'frontbase'
+
+module ActiveRecord
+
+### Hack around missing functionality
+  module Calculations
+    module ClassMethods      
+      def construct_calculation_sql(aggregate, aggregate_alias, options) #:nodoc:
+        scope = scope(:find)
+        sql  = "SELECT #{aggregate} AS #{aggregate_alias}"
+        sql << ", #{options[:group_field]} AS #{options[:group_alias]}" if options[:group]
+        sql << " FROM #{table_name} "
+        add_joins!(sql, options, scope)
+        add_conditions!(sql, options[:conditions], scope)
+     
+        # FrontBase requires a column reference for the GROUP BY and HAVING clauses
+        # Example: 'SELECT sum(credit_limit) AS sum_credit_limit, firm_id AS firm_id FROM accounts GROUP BY firm_id HAVING sum_credit_limit > 50'
+        sql << " GROUP BY #{options[:group_alias]}" if options[:group]
+        sql << " HAVING #{options[:having].gsub(aggregate,aggregate_alias)}" if options[:group] && options[:having]
+        sql << " ORDER BY #{options[:order]}" if options[:order]
+        add_limit!(sql, options)
+        sql
+      end
+    end
+  end    
+  
+  class Base
+
+    # FrontBase only supports one unnamed sequence per table
+    def self.set_sequence_name( value=nil, &block )
+    end
+    
+    # Establishes a connection to the database that's used by all Active Record objects.
+    def self.frontbase_connection(config) # :nodoc:
+      config = config.symbolize_keys
+      database     = config[:database]
+      port         = config[:port]
+      host         = config[:host]
+      username     = config[:username]
+      password     = config[:password]
+      dbpassword   = config[:dbpassword]
+      session_name = config[:session_name]
+
+      if dbpassword == nil
+        dbpassword = ""
+      end
+      
+      # Turn off colorization since it make tail/less output difficult
+      self.colorize_logging = false;
+      
+      
+      connection = FBSQL_Connect.connect(host, port, database, username, password, dbpassword,session_name)
+      ConnectionAdapters::FrontBaseAdapter.new(connection, logger, [host, port, database, username, password, dbpassword, session_name], config)
+    end        
+  end
+  
+  module ConnectionAdapters
+
+    class FrontBaseColumn < Column #:nodoc:
+      attr_reader :fb_autogen
+      
+      def initialize(base, name, type, typename, limit, precision, scale, default, nullable)
+        
+        @base, @name = base, name
+        @type = simplified_type(type,typename,limit)
+        @limit = limit
+        @precision, @scale = precision, scale
+        @default = default
+        @null = nullable == "YES" ? true : false
+        @text    = [:string, :text].include? @type
+        @number  = [:float, :integer].include? @type
+        @fb_autogen = false
+        if @default
+          @default.gsub!(/^'(.*)'$/,'\1') if @text
+          @fb_autogen =  @default.include?("SELECT UNIQUE FROM")
+          if @type == :boolean then
+            @default = (@default == "TRUE")
+          elsif @type == :binary
+            if @default != "X''"
+              buffer = ""
+              @default.scan(/../) { |h| buffer << h.hex.chr }
+              @default = buffer
+            else
+              @default = ""
+            end
+          else
+            @default = type_cast(@default)
+          end
+        end
+      end
+      
+      def self.hex_encode(value)
+        retvalue = ""
+        value.each_byte do |b|
+          retvalue << sprintf("%02X", b)
+        end
+        retvalue
+      end
+
+      def self.hex_decode(value)
+        retvalue = ""
+        value.scan(/../) do |h|
+          c = h.hex
+          retvalue << c.chr
+        end
+        retvalue
+      end
+
+      private
+      def simplified_type(field_type, type_name,limit)
+        ret_type = :string
+#         puts "typecode: [#{field_type}] [#{type_name}]"
+        case field_type
+          when 1 then ret_type = :boolean # BOOLEAN
+          when 2 then ret_type = :integer # INTEGER
+          when 4 then ret_type = :float   # FLOAT
+          when 10 then ret_type = :string # CHARACTER VARYING
+          when 11 then ret_type = :binary
+          when 12 then ret_type = :binary
+          when 13 then ret_type = :date
+          when 14 then ret_type = :time
+          when 16 then ret_type = :timestamp
+          when 22 then ret_type = :integer # TINYINT
+          else
+            puts "ERROR: Unknown typecode: [#{field_type}] [#{type_name}]"
+        end
+        ret_type
+      end
+    end
+
+    class FrontBaseAdapter < AbstractAdapter
+      
+      def initialize(connection, logger, connection_options, config)
+        super(connection, logger)
+        @connection_options, @config = connection_options, config
+        @transaction_mode = :pessimistic
+        
+        # threaded_connections_test.rb will fail unless we set the session
+        # to optimistic locking mode
+#         set_pessimistic_transactions
+#         execute "SET TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ WRITE, LOCKING OPTIMISTIC"
+      end
+
+      # Returns the human-readable name of the adapter.  Use mixed case - one
+      # can always use downcase if needed.
+      def adapter_name #:nodoc:
+        'FrontBase'
+      end
+
+      # Does this adapter support migrations?  Backend specific, as the
+      # abstract adapter always returns +false+.
+      def supports_migrations? #:nodoc:
+        true
+      end
+
+      def native_database_types #:nodoc
+        # !!! Lookup actual FB datatypes
+        {
+          :primary_key => "INTEGER DEFAULT UNIQUE PRIMARY KEY",
+          :string      => { :name => "VARCHAR", :limit => 255 },
+          :text        => { :name => "VARCHAR", :limit => 1073741824 },
+          :integer     => { :name => "INTEGER" },
+          :float       => { :name => "FLOAT" },
+          :datetime    => { :name => "TIMESTAMP" },
+          :timestamp   => { :name => "TIMESTAMP" },
+          :time        => { :name => "TIME" },
+          :date        => { :name => "DATE" },
+          :binary      => { :name => "BYTE VARYING" },
+          :boolean     => { :name => "BOOLEAN" }
+        }
+      end
+
+
+      # QUOTING ==================================================
+
+      # Quotes the column value to help prevent
+      # {SQL injection attacks}[http://en.wikipedia.org/wiki/SQL_injection].
+      def quote(value, column = nil)
+        retvalue = "<INVALID>"
+   
+        # If a column was passed in, use column type information
+        if ! value.nil?
+          if column
+            case column.type
+              when :string, :text
+                if value.kind_of?(String)
+                  retvalue = "'#{quote_string(value.to_s)}'" # ' (for ruby-mode)
+                else
+                  retvalue = "'#{quote_string(value.to_yaml)}'"
+                end
+              when :integer
+                if value.kind_of?(TrueClass)
+                  retvalue = '1'
+                elsif value.kind_of?(FalseClass)
+                  retvalue = '0'
+                else
+                  retvalue = value.to_i.to_s
+                end
+              when :float
+                retvalue = value.to_f.to_s
+              when :datetime, :timestamp
+                retvalue = "TIMESTAMP '#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
+              when :time
+                retvalue = "TIME '#{value.strftime("%H:%M:%S")}'"
+              when :date
+                retvalue = "DATE '#{value.strftime("%Y-%m-%d")}'"
+              when :binary
+                s = value.unpack("H*")[0]
+                retvalue = "X'#{s}'"
+              when :boolean
+                retvalue = quoted_true if value.kind_of?(TrueClass)
+                retvalue = quoted_false if value.kind_of?(FalseClass)
+              else
+                raise "*** UNKNOWN TYPE: #{column.type.inspect}"
+            end # case
+          # Since we don't have column type info, make a best guess based
+          # on the Ruby class of the value
+          else
+            case value
+              when String
+                if column && column.type == :binary
+                  s = value.unpack("H*")[0]
+                  retvalue = "X'#{s}'"
+                elsif column && [:integer, :float].include?(column.type) 
+                  retvalue = value.to_s
+                else
+                  retvalue = "'#{quote_string(value)}'" # ' (for ruby-mode)
+                end
+              when NilClass              then retvalue = "NULL"
+              when TrueClass             then retvalue = (column && column.type == :integer ? '1' : quoted_true)
+              when FalseClass            then retvalue = (column && column.type == :integer ? '0' : quoted_false)
+              when Float, Fixnum, Bignum then retvalue = value.to_s
+              when Time, Date, DateTime
+                if column
+                  case column.type
+                    when :date then retvalue = "DATE '#{value.strftime("%Y-%m-%d")}'"
+                    when :time then retvalue = "TIME '#{value.strftime("%H:%M:%S")}'"
+                    when :timestamp then retvalue = "TIMESTAMP '#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
+                  else
+                    raise NotImplementedError, "Unknown column type!"
+                  end # case
+                else # Column wasn't passed in, so try to guess the right type
+                  if value.kind_of? Date
+                    retvalue = "DATE '#{value.strftime("%Y-%m-%d")}'"
+                  else
+                    if value.hour == 0 && value.min == 0 && value.sec == 0
+                      retvalue = "TIME '#{value.strftime("%H:%M:%S")}'"
+                    else
+                      retvalue = "TIMESTAMP '#{quoted_date(value)}'"
+                    end
+                  end 
+                end #if column
+              else "'#{quote_string(value.to_yaml)}'"
+            end #case
+          end
+        else
+          retvalue = "NULL"
+        end
+         
+      retvalue
+      end # def
+
+      # Quotes a string, escaping any ' (single quote) characters.
+      def quote_string(s)
+        s.gsub(/'/, "''") # ' (for ruby-mode)
+      end
+
+      def quote_column_name(name) #:nodoc:
+        "\"#{name}\""
+      end
+
+      def quoted_true
+        "true"
+      end
+      
+      def quoted_false
+        "false"
+      end
+
+
+      # CONNECTION MANAGEMENT ====================================
+
+      def active?
+          retvalue = true
+          begin
+            retvalue = true if @connection.status == 1
+          rescue => e
+            retvalue = false
+          end
+          retvalue
+      end
+
+      def reconnect!
+        @connection.close rescue nil
+     
+        @connection = FBSQL_Connect.connect(@connection_options[0],
+        @connection_options[1],
+        @connection_options[2],
+        @connection_options[3],
+        @connection_options[4],
+        @connection_options[5],
+        @connection_options[6])        
+      end
+
+      # Close this connection
+      def disconnect!
+        @connection.close rescue nil
+        @active = false
+      end
+
+      # DATABASE STATEMENTS ======================================
+
+      # Returns an array of record hashes with the column names as keys and
+      # column values as values.
+      def select_all(sql, name = nil) #:nodoc:
+        fbsql = cleanup_fb_sql(sql)
+        retValue = []
+        fbresult = execute(sql, name)
+#         puts "select_all SQL -> #{fbsql}"
+        columns = fbresult.columns
+        fbresult.each do |row|
+#           puts "SQL <- #{row.inspect}"
+          hashed_row = {}    
+          colnum = 0
+          row.each do |col|
+            hashed_row[columns[colnum]] = col
+            colnum += 1
+          end
+          retValue << hashed_row
+        end
+        retValue
+      end
+
+      def select_one(sql, name = nil) #:nodoc:
+        fbsql = cleanup_fb_sql(sql)
+        retValue = []
+        fbresult = execute(fbsql, name)
+#         puts "SQL -> #{fbsql}"
+        columns = fbresult.columns
+        
+        fbresult.each do |row|
+#           puts "SQL <- #{row.inspect}"
+          hashed_row = {}    
+          colnum = 0
+          row.each do |col|
+            hashed_row[columns[colnum]] = col
+            colnum += 1
+          end
+          retValue << hashed_row
+          break
+        end
+        fbresult.clear
+        retValue = retValue.first
+      end
+
+      def query(sql, name = nil) #:nodoc:
+        fbsql = cleanup_fb_sql(sql)
+#         puts "SQL(query) -> #{fbsql}"
+        log(fbsql, name) { @connection.query(fbsql) }
+      rescue => e
+        puts "FB Exception: #{e.inspect}"
+        raise e
+      end
+
+      def execute(sql, name = nil) #:nodoc:
+        fbsql = cleanup_fb_sql(sql)
+#         puts "SQL(execute) -> #{fbsql}"
+        log(fbsql, name) { @connection.query(fbsql) }
+      rescue ActiveRecord::StatementInvalid => e
+        a = e.message.scan(/Table name - \w* - exists/)
+        if a.length == 0
+          raise e
+        end
+      end
+      
+      # Returns the last auto-generated ID from the affected table.
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
+#         puts "SQL -> #{sql.inspect}"
+        result = execute(sql, name)
+        id_value || pk
+      end
+
+      # Executes the update statement and returns the number of rows affected.
+      def update(sql, name = nil) #:nodoc:
+#         puts "SQL -> #{sql.inspect}"
+        execute(sql, name).num_rows
+      end
+
+      alias_method :delete, :update #:nodoc:
+
+      def set_pessimistic_transactions
+        if @transaction_mode == :optimistic
+          execute "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE, LOCKING PESSIMISTIC, READ WRITE"
+          @transaction_mode = :pessimistic
+        end
+      end
+
+      def set_optimistic_transactions
+        if @transaction_mode == :pessimistic
+          execute "SET TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ WRITE, LOCKING OPTIMISTIC"
+          @transaction_mode = :optimistic
+        end
+      end
+
+      def begin_db_transaction #:nodoc:
+        execute "SET COMMIT FALSE"
+      rescue
+      end
+
+      def commit_db_transaction #:nodoc:
+        execute "COMMIT"
+      ensure
+        execute "SET COMMIT TRUE"
+      end
+
+      def rollback_db_transaction #:nodoc:
+        execute "ROLLBACK"
+        ensure
+          execute "SET COMMIT TRUE"
+      end
+
+      def add_limit_offset!(sql, options) #:nodoc
+        if limit = options[:limit]
+          offset = options[:offset] || 0
+        
+# Here is the full syntax FrontBase supports:
+# (from gclem@frontbase.com)
+# 
+#       TOP <limit - unsigned integer>
+#       TOP ( <offset expr>, <limit expr>)
+        
+          # "TOP 0" is not allowed, so we have
+          # to use a cheap trick.
+          if limit == 0
+            if sql =~ /WHERE/i
+              sql.sub!(/WHERE/i, 'WHERE 0 = 1 AND ')
+            elsif
+              sql =~ /ORDER\s+BY/i
+              sql.sub!(/ORDER\s+BY/i, 'WHERE 0 = 1 ORDER BY')
+            else
+              sql << 'WHERE 0 = 1'
+            end
+          else
+            if offset == 0
+              sql.replace sql.gsub("SELECT ","SELECT TOP #{limit} ")
+            else
+              sql.replace sql.gsub("SELECT ","SELECT TOP(#{offset},#{limit}) ")
+          end
+        end
+          
+        end
+      end
+
+      def prefetch_primary_key?(table_name = nil)
+        true
+      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)
+        unique = select_value("SELECT UNIQUE FROM #{sequence_name}","Next Sequence Value")
+        # The test cases cannot handle a zero primary key
+        if unique == 0 then unique = select_value("SELECT UNIQUE FROM #{sequence_name}","Next Sequence Value") end
+        unique 
+      end
+
+      def default_sequence_name(table, column)
+        table;
+      end
+
+      # Set the sequence to the max value of the table's column.
+      def reset_sequence!(table, column, sequence = nil)
+        klasses = classes_for_table_name(table)
+        klass = klasses.nil? ? nil : klasses[0]
+        pk = klass.primary_key if klass != nil
+        if pk && klass.columns_hash[pk].type == :integer
+          execute("SET UNIQUE FOR #{klass.table_name}(#{pk})")
+        end
+      end
+
+      def classes_for_table_name(table)
+        klasses = []
+        # !!! Hack because subclasses is a protected method...
+        subclasses = ActiveRecord::Base.class_eval('@@subclasses')
+        subclasses.values.each do |a|
+          a.each {|n| klasses << n}
+        end
+        subset_klasses = klasses.select {|k| k.table_name == table}
+      end
+      
+      def reset_pk_sequence!(table, pk = nil, sequence = nil)
+        klasses = classes_for_table_name(table)
+        klass = klasses.nil? ? nil : klasses[0]
+        pk = klass.primary_key if klass != nil
+        if pk && klass.columns_hash[pk].type == :integer
+          mpk = select_value("SELECT MAX(#{pk}) FROM #{table}")
+          execute("SET UNIQUE FOR #{klass.table_name}(#{pk})")
+        end
+        
+      end
+
+      # SCHEMA STATEMENTS ========================================
+
+      def structure_dump #:nodoc:
+        select_all("SHOW TABLES").inject("") do |structure, table|
+          structure += select_one("SHOW CREATE TABLE #{table.to_a.first.last}")["Create Table"] + ";\n\n"
+        end
+      end
+
+      def recreate_database(name) #:nodoc:
+        drop_database(name)
+        create_database(name)
+      end
+
+      def create_database(name) #:nodoc:
+        execute "CREATE DATABASE #{name}"
+      end
+      
+      def drop_database(name) #:nodoc:
+        puts "TRACE: drop_database"
+        execute "DROP DATABASE #{name}"
+      end
+
+      def current_database
+        select_value('SELECT "CATALOG_NAME" FROM INFORMATION_SCHEMA.CATALOGS').downcase
+      end
+
+      def tables(name = nil) #:nodoc:
+        sql = "SELECT \"TABLE_NAME\" FROM INFORMATION_SCHEMA.TABLES AS T0,INFORMATION_SCHEMA.SCHEMATA AS T1 WHERE T0.SCHEMA_PK = T1.SCHEMA_PK AND \"SCHEMA_NAME\" = CURRENT_SCHEMA"
+        
+        select_values(sql,nil)
+      end
+
+      def indexes(table_name, name = nil)#:nodoc:
+        indexes = []
+        current_index = nil
+        sql = "SELECT INDEX_NAME, T2.ORDINAL_POSITION ,INDEX_COLUMN_COUNT, INDEX_TYPE, \"COLUMN_NAME\", IS_NULLABLE FROM INFORMATION_SCHEMA.TABLES AS T0, INFORMATION_SCHEMA.INDEXES AS T1, INFORMATION_SCHEMA.INDEX_COLUMN_USAGE AS T2, INFORMATION_SCHEMA.COLUMNS AS T3 WHERE T0.\"TABLE_NAME\" = \'#{table_name}\' AND INDEX_TYPE <> 0 AND T0.TABLE_PK = T1.TABLE_PK AND T0.TABLE_PK = T2.TABLE_PK AND T0.TABLE_PK = T3.TABLE_PK AND T1. INDEXES_PK = T2.INDEX_PK AND T2.COLUMN_PK = T3.COLUMN_PK ORDER BY INDEX_NAME, T2.ORDINAL_POSITION"
+
+        columns = []
+        query(sql).each do |row|
+          index_name   = row[0]
+          ord_position = row[1]
+          ndx_colcount = row[2]
+          index_type   = row[3]
+          column_name  = row[4]
+          
+          if index_type == 1
+            isUnique = true
+          else
+            isUnique = false
+          end
+          
+          columns << column_name
+          if ord_position == ndx_colcount
+            indexes << IndexDefinition.new(table_name, index_name, isUnique , columns)
+            columns = []
+          end
+        end
+        indexes
+      end
+
+      def columns(table_name, name = nil)#:nodoc:
+        sql = "SELECT \"TABLE_NAME\", \"COLUMN_NAME\", ORDINAL_POSITION, IS_NULLABLE, COLUMN_DEFAULT, DATA_TYPE, DATA_TYPE_CODE, CHARACTER_MAXIMUM_LENGTH, NUMERIC_PRECISION, NUMERIC_PRECISION_RADIX, NUMERIC_SCALE, DATETIME_PRECISION, DATETIME_PRECISION_LEADING FROM INFORMATION_SCHEMA.TABLES T0, INFORMATION_SCHEMA.COLUMNS T1, INFORMATION_SCHEMA.DATA_TYPE_DESCRIPTOR T3 WHERE \"TABLE_NAME\" = '#{table_name}' AND T0.TABLE_PK = T1.TABLE_PK AND T0.TABLE_PK = T3.TABLE_OR_DOMAIN_PK AND T1.COLUMN_PK = T3.COLUMN_NAME_PK ORDER BY T1.ORDINAL_POSITION"
+        rawresults = query(sql,name)
+        columns = []
+        rawresults.each do |field|
+          typestring = field[5]
+          typecode = field[6]
+          base = field[0]
+          name = field[1]
+          limit = field[7]
+          precision = field[8]
+          scale = field[9]
+          default = field[4]
+          nullable = field[3]
+          columns << FrontBaseColumn.new(base, name, typecode, typestring, limit, precision, scale, default, nullable)
+         end
+        columns
+      end
+      
+      def create_table(name, options = {})
+        table_definition = TableDefinition.new(self)
+        table_definition.primary_key(options[:primary_key] || "id") unless options[:id] == false
+
+        yield table_definition
+
+        if options[:force]
+          drop_table(name) rescue nil
+        end
+
+        create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE "
+        create_sql << "#{name} ("
+        create_sql << table_definition.to_sql
+        create_sql << ") #{options[:options]}"
+        begin_db_transaction
+        execute create_sql
+        commit_db_transaction
+        rescue ActiveRecord::StatementInvalid => e
+          a = e.message.scan(/Table name - \w* - exists/)
+          raise e if a.length == 0
+      end
+      
+      def rename_table(name, new_name)
+        columns = columns(name)
+        pkcol = columns.find {|c| c.fb_autogen}
+        execute "ALTER TABLE NAME #{name} TO #{new_name}"
+        if pkcol
+          change_column_default(new_name,pkcol.name,"UNIQUE")
+          begin_db_transaction
+          mpk = select_value("SELECT MAX(#{pkcol.name}) FROM #{new_name}")
+          mpk = 0 if mpk.nil?
+          execute "SET UNIQUE=#{mpk} FOR #{new_name}"
+          commit_db_transaction
+        end
+      end  
+
+      # Drops a table from the database.
+      def drop_table(name)
+        execute "DROP TABLE #{name} RESTRICT"
+      rescue ActiveRecord::StatementInvalid => e
+        a = e.message.scan(/Referenced TABLE - \w* - does not exist/)
+        raise e if a.length == 0
+      end
+
+      # Adds a new column to the named table.
+      # See TableDefinition#column for details of the options you can use.
+      def add_column(table_name, column_name, type, options = {})
+        add_column_sql = "ALTER TABLE #{table_name} ADD #{column_name} #{type_to_sql(type, options[:limit])}"
+        options[:type] = type
+        add_column_options!(add_column_sql, options)
+        execute(add_column_sql)
+      end
+
+      def add_column_options!(sql, options) #:nodoc:
+        default_value = quote(options[:default], options[:column])
+        if options[:default]
+          if options[:type] == :boolean
+            default_value = options[:default] == 0 ? quoted_false : quoted_true
+          end
+        end
+        sql << " DEFAULT #{default_value}" unless options[:default].nil?
+        sql << " NOT NULL" if options[:null] == false
+      end
+
+      # Removes the column from the table definition.
+      # ===== Examples
+      #  remove_column(:suppliers, :qualification)
+      def remove_column(table_name, column_name)
+        execute "ALTER TABLE #{table_name} DROP #{column_name} RESTRICT"
+      end
+
+      def remove_index(table_name, options = {}) #:nodoc:
+        execute "DROP INDEX #{index_name(table_name, options)}"
+      end
+
+      def change_column_default(table_name, column_name, default) #:nodoc:
+        execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DEFAULT #{default}" if default != "NULL"
+      end
+
+      def change_column(table_name, column_name, type, options = {}) #:nodoc:
+        change_column_sql = "ALTER COLUMN \"#{table_name}\".\"#{column_name}\" TO #{type_to_sql(type, options[:limit])}"
+        execute(change_column_sql)
+        change_column_sql = "ALTER TABLE \"#{table_name}\" ALTER COLUMN \"#{column_name}\""
+
+        default_value = quote(options[:default], options[:column])
+        if options[:default]
+          if type == :boolean
+            default_value = options[:default] == 0 ? quoted_false : quoted_true
+          end
+        end
+
+        if default_value != "NULL"
+          change_column_sql << " SET DEFAULT #{default_value}"
+          execute(change_column_sql)
+        end
+        
+#         change_column_sql = "ALTER TABLE #{table_name} CHANGE #{column_name} #{column_name} #{type_to_sql(type, options[:limit])}"
+#         add_column_options!(change_column_sql, options)
+#         execute(change_column_sql)
+      end
+
+      def rename_column(table_name, column_name, new_column_name) #:nodoc:
+        execute "ALTER COLUMN NAME \"#{table_name}\".\"#{column_name}\" TO \"#{new_column_name}\""
+      end
+            
+      private
+      
+      # Clean up sql to make it something FrontBase can digest
+      def cleanup_fb_sql(sql) #:nodoc:
+        cleansql = sql.gsub("!=","<>") # Turn non-standard != into standard <>
+        lines = cleansql.split("\n")
+        lines = lines.select { |l| l.length > 0} # Strip blank lines
+        lines = lines.select { |l| !(l =~ /^--/)} # Strip comments
+        cleansql = lines.join("\n")
+        cleansql
+      end
+    end
+  end
+end

activerecord/lib/active_record/fixtures.rb

@@ -391 +391 @@
-    columns.join(", ")
-  end
-
+## Original
+#   def value_list
+#     @fixture.values.map { |v| ActiveRecord::Base.connection.quote(v).gsub('\\n', "\n").gsub('\\r', "\r") }.join(", ")
+#   end
+
-  def value_list
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-  end
-
-  def find

activerecord/lib/active_record.rb

@@ -68 +68 @@
-end
-
-unless defined?(RAILS_CONNECTION_ADAPTERS)
-
+frontbase 
-end
-
-RAILS_CONNECTION_ADAPTERS.each do |adapter|

activerecord/test/adapter_test.rb

@@ -66 +66 @@
-  if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!)
-    require 'fixtures/movie'
-    require 'fixtures/subscriber'
+    
-    def test_reset_empty_table_with_custom_pk
-      Movie.delete_all
-      Movie.connection.reset_pk_sequence! 'movies'
-      assert_equal 1, Movie.create(:name => 'fight club').id
-    end
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-    end
-  end
-

activerecord/test/base_test.rb

@@ -1094 +1094 @@
-    end
-    assert_equal res, res3
-    
- WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=c
+o WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=co
-    res5 = nil
-    assert_nothing_raised do
-
-
+o
+o
-                        :select => "p.id")
-    end
-
-    assert_equal res4, res5 
-
- WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=c
+o WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=co
-    res7 = nil
-    assert_nothing_raised do
-
-
+o
+o
-                        :select => "p.id",
-                        :distinct => true)
-    end

activerecord/test/connections/native_frontbase/connection.rb

@@ +1 @@
+print "Using native Frontbase\n"
+require_dependency 'fixtures/course'
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+db1 = 'activerecord_unittest'
+db2 = 'activerecord_unittest2'
+
+ActiveRecord::Base.establish_connection(
+  :adapter      => "frontbase",
+  :host         => "localhost",
+  :username     => "rails",
+  :password     => "",
+  :database     => db1,
+  :session_name => "unittest-#{$$}"
+)
+
+Course.establish_connection(
+  :adapter      => "frontbase",
+  :host         => "localhost",
+  :username     => "rails",
+  :password     => "",
+  :database     => db2,
+  :session_name => "unittest-#{$$}"
+)

activerecord/test/deprecated_finder_test.rb

@@ -1 +1 @@
-require 'abstract_unit'
-require 'fixtures/company'
-require 'fixtures/topic'
+require 'fixtures/reply'
-require 'fixtures/entrant'
-require 'fixtures/developer'
-

activerecord/test/finder_test.rb

@@ -13 +13 @@
-    assert_equal(topics(:first).title, Topic.find(1).title)
-  end
-  
+  # find should handle strings that come from URLs
+  # (example: Category.find(params[:id]))
+  def test_find_with_string
+    assert_equal(Topic.find(1).title,Topic.find("1").title)
+  end
+  
-  def test_exists
-    assert (Topic.exists?(1))
-    assert !(Topic.exists?(45))

activerecord/test/fixtures/db_definitions/frontbase.drop.sql

@@ +1 @@
+DROP TABLE accounts CASCADE;
+DROP TABLE funny_jokes CASCADE;
+DROP TABLE companies CASCADE;
+DROP TABLE topics CASCADE;
+DROP TABLE developers CASCADE;
+DROP TABLE projects CASCADE;
+DROP TABLE developers_projects CASCADE;
+DROP TABLE orders CASCADE;
+DROP TABLE customers CASCADE;
+DROP TABLE movies CASCADE;
+DROP TABLE subscribers CASCADE;
+DROP TABLE booleantests CASCADE;
+DROP TABLE auto_id_tests CASCADE;
+DROP TABLE entrants CASCADE;
+DROP TABLE colnametests CASCADE;
+DROP TABLE mixins CASCADE;
+DROP TABLE people CASCADE;
+DROP TABLE readers CASCADE;
+DROP TABLE binaries CASCADE;
+DROP TABLE computers CASCADE;
+DROP TABLE posts CASCADE;
+DROP TABLE comments CASCADE;
+DROP TABLE authors CASCADE;
+DROP TABLE tasks CASCADE;
+DROP TABLE categories CASCADE;
+DROP TABLE categories_posts CASCADE;
+DROP TABLE fk_test_has_fk CASCADE;
+DROP TABLE fk_test_has_pk CASCADE;
+DROP TABLE keyboards CASCADE;
+DROP TABLE legacy_things CASCADE;

activerecord/test/fixtures/db_definitions/frontbase.sql

@@ +1 @@
+CREATE TABLE accounts (
+    id integer DEFAULT unique,
+    firm_id integer,
+    credit_limit integer,
+    PRIMARY KEY (id)
+);
+SET UNIQUE FOR accounts(id);
+
+CREATE TABLE funny_jokes (
+  id integer DEFAULT unique,
+  firm_id integer default NULL,
+  name character varying(50),
+  PRIMARY KEY (id)
+);
+SET UNIQUE FOR funny_jokes(id);
+  
+CREATE TABLE companies (
+  id integer DEFAULT unique,
+    "type" character varying(50),
+    "ruby_type" character varying(50),
+    firm_id integer,
+    name character varying(50),
+    client_of integer,
+    rating integer default 1,
+    PRIMARY KEY (id)
+);
+SET UNIQUE FOR companies(id);
+
+CREATE TABLE topics (
+  id integer DEFAULT unique,
+    title character varying(255),
+    author_name character varying(255),
+    author_email_address character varying(255),
+    written_on timestamp,
+    bonus_time time,
+    last_read date,
+    content varchar(65536),
+    approved boolean default true,
+    replies_count integer default 0,
+    parent_id integer,
+    "type" character varying(50),
+    PRIMARY KEY (id)
+);
+SET UNIQUE FOR topics(id);
+
+CREATE TABLE developers (
+  id integer DEFAULT unique,
+    name character varying(100),
+    salary integer DEFAULT 70000,
+    created_at timestamp,
+    updated_at timestamp,
+    PRIMARY KEY (id)
+);
+SET UNIQUE FOR developers(id);
+
+CREATE TABLE projects (
+  id integer DEFAULT unique,
+    name character varying(100),
+    type varchar(255),
+    PRIMARY KEY (id)
+);
+SET UNIQUE FOR projects(id);
+
+CREATE TABLE developers_projects (
+    developer_id integer NOT NULL,
+    project_id integer NOT NULL,
+    joined_on date,
+    access_level integer default 1
+);
+
+CREATE TABLE orders (
+  id integer DEFAULT unique,
+    name character varying(100),
+    billing_customer_id integer,
+    shipping_customer_id integer,
+    PRIMARY KEY (id)
+);
+SET UNIQUE FOR orders(id);
+
+CREATE TABLE customers (
+  id integer DEFAULT unique