activerecord-interbase-adapter 0.1.0

data/lib/active_record/connection_adapters/ibrails_case_fix.rb

@@ -0,0 +1,37 @@
+
+## replace the validates_uniqueness_of method because we have to use UPPER and it uses LOWER.
+
+ActiveRecord::Validations::ClassMethods.class_eval do
+	alias_method :old_validates_uniqueness_of, :validates_uniqueness_of
+
+	def validates_uniqueness_of(*attr_names)
+	  configuration = { :message => ActiveRecord::Errors.default_error_messages[:taken], :case_sensitive => true }
+	  configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
+
+	  validates_each(attr_names,configuration) do |record, attr_name, value|
+		if value.nil? || (configuration[:case_sensitive] || !columns_hash[attr_name.to_s].text?)
+		  condition_sql = "#{record.class.table_name}.#{attr_name} #{attribute_condition(value)}"
+		  condition_params = [value]
+		else
+		  condition_sql = "UPPER(#{record.class.table_name}.#{attr_name}) #{attribute_condition(value)}"
+		  condition_params = [value.upcase]
+		end
+		if scope = configuration[:scope]
+		  Array(scope).map do |scope_item|
+			scope_value = record.send(scope_item)
+			condition_sql << " AND #{record.class.table_name}.#{scope_item} #{attribute_condition(scope_value)}"
+			condition_params << scope_value
+		  end
+		end
+		unless record.new_record?
+		  condition_sql << " AND #{record.class.table_name}.#{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
+end
+
+

data/lib/active_record/connection_adapters/interbase_adapter.rb

@@ -0,0 +1,857 @@
+# Original Firebird code by Ken Kunz <kennethkunz@gmail.com>,
+# Extensive InterBase modifications by Richard Vowles - Blue Train Software, www.bluetrainsoftware.com
+# roles functionality added - tested and works
+#
+# Updating for Rails 2.0.2
+
+require 'active_record/connection_adapters/abstract_adapter'
+require 'active_record/connection_adapters/ibrails_case_fix'
+require_library_or_gem 'ibruby'
+
+include IBRuby
+
+module IBRuby # :nodoc: all
+  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
+  	
+    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 interbase_connection(config) # :nodoc:
+      unless defined? IBRuby::InterBaseColumn
+        raise AdapterNotFound,
+          'The InterBase adapter requires IBRuby version 0.5.4 or greater; you appear ' <<
+          'to be running an older version -- please update IBRuby (gem install ibruby).'
+      end
+	  
+      config = config.symbolize_keys
+	  
+      unless config.has_key?(:database)
+        raise ArgumentError, "No database specified. Missing argument: database."
+      end
+	  
+      options = config[:charset] ? { IBRuby::Connection::CHARACTER_SET => config[:charset] } : {}
+      options[IBRuby::Connection::ROLE] = config[:role] if config[:role]
+	  
+      # need to add :role to options
+      connection_params = [config[:username], config[:password], options]
+      db = IBRuby::Database.new( config[:database] )
+	  begin
+	    connection = db.connect(*connection_params)	
+	  rescue IBRuby::IBRubyException
+	  	if config.has_key?(:create_when_missing)
+	  	  IBRuby::Database.create( config[:database], config[:username], config[:password], 4096, config[:charset] )
+          connection = db.connect(*connection_params)
+  	    else
+  	      raise
+	  	end
+	  end
+      
+      ConnectionAdapters::InterBaseAdapter.new(connection, logger, connection_params)
+    end
+  end
+  
+  module ConnectionAdapters
+    class InterBaseTableDefinition < TableDefinition
+      attr_reader :pk_field
+        
+      def primary_key(name)
+        col_count = @columns ? @columns.size : 0
+        
+        column(name, :integer, {:null => false} )
+        
+        if col_count != @columns.size # a column got added
+          @pk_field = @columns.last
+        end
+      end    
+    end
+  
+    class InterBaseColumn < Column # :nodoc:
+      VARCHAR_MAX_LENGTH = 32_765
+      BLOB_MAX_LENGTH    = 32_767  # because activerecord has no parameterized inserts/updates!!!!!
+      DEFAULT_STRING_LENGTH = 252  # to allow :string fields to be indexes
+      attr_reader :interBaseColumn
+      
+      def initialize(interBaseColumn)
+        @interBaseColumn = interBaseColumn
+        
+        @name = InterBaseAdapter.ib_to_ar_case(interBaseColumn.name.downcase)
+        @sql_type = interBaseColumn.to_s
+        @null = !interBaseColumn.not_null
+        @limit = !interBaseColumn.type == IBRuby::InterBaseColumn::BLOB ? BLOB_MAX_LENGTH : interBaseColumn.length
+        @precision = interBaseColumn.precision
+        @scale = interBaseColumn.scale
+        @type = simplified_type(@sql_type)
+        
+        @default = typecast_default
+        
+        @primary = nil
+      end #def initialize
+      
+      def default
+        if !@interBaseColumn.default.nil?
+          if ( [:timestamp, :time, :date].detect() {|val| @type == val } ) && 
+           ( @interBaseColumn.default.to_s =~ /^current_/i )
+            request_db_value( @interBaseColumn.default )
+          else
+            @default
+          end
+        else
+          nil
+        end
+      end # def default
+      
+      def type_cast(value)
+        retVal = super
+        #puts "type_cast #{@name}:#{@interbase_type} = #{value} ==> #{retVal}"
+        retVal
+      end
+      
+      private
+      # Submits a _CAST_ query to the database, casting the default value to the specified SQL type.
+      # This enables InterBase to provide an actual value when context variables are used as column
+      # defaults (such as CURRENT_TIMESTAMP).
+      def request_db_value( value )
+        connection = ActiveRecord::Base.active_connections.values.detect { |conn| conn && conn.adapter_name == 'InterBase' }
+        
+        if connection
+          type_cast InterBaseMetaFunctions.db_type_cast( conn, value, @sql_type )
+        else
+          raise ConnectionNotEstablished, "No InterBase connections established."
+        end
+      end
+      
+      def typecast_default
+        def_val = nil
+        #puts "interbase default: #{@interBaseColumn.default} name is #{@name}:#{@type}"
+        
+        if !@interBaseColumn.default.nil?
+          case @type
+          when :boolean
+            def_val = ( @interBaseColumn.default.to_s.casecmp( 'true' ) == 0)
+          when :string, :text
+            def_val = @interBaseColumn.default.to_s
+          when :integer
+            def_val = @interBaseColumn.default.to_s.to_i
+          when :float
+            def_val = @interBaseColumn.default.to_s.to_f
+          when :text
+            def_val = @interBaseColumn.default.to_s
+          when :timestamp, :time, :date
+            if @interBaseColumn.default =~ /^current_/i
+              def_val = nil
+            else
+              def_val = type_cast(@interBaseColumn.default)
+            end
+          else
+            if ((@interBaseColumn.type == IBRuby::InterBaseColumn::BLOB) && (@interBaseColumn.sub_type == 1 ) )
+              def_val = @interBaseColumn.default.to_s
+            end
+          end
+        end
+        
+        #puts "default is #{def_val.class}:#{def_val}"
+        def_val
+      end
+      
+      def simplified_type(field_type)
+        case interBaseColumn.type
+        when IBRuby::InterBaseColumn::INTEGER, IBRuby::InterBaseColumn::INT64, IBRuby::InterBaseColumn::SMALLINT
+          :integer
+        when IBRuby::InterBaseColumn::FLOAT, IBRuby::InterBaseColumn::DOUBLE
+          :float
+        when IBRuby::InterBaseColumn::DECIMAL, IBRuby::InterBaseColumn::NUMERIC
+          interBaseColumn.scale == 0 ? :integer : :decimal
+        when IBRuby::InterBaseColumn::TIMESTAMP
+          :timestamp
+        when IBRuby::InterBaseColumn::TIME
+          :time
+        when IBRuby::InterBaseColumn::DATE
+          :date
+        when IBRuby::InterBaseColumn::BLOB
+          interBaseColumn.sub_type == 1 ? :text : :binary
+        when IBRuby::InterBaseColumn::CHAR, IBRuby::InterBaseColumn::VARCHAR
+          :string
+        when IBRuby::InterBaseColumn::BOOLEAN
+          :boolean
+        end
+      end
+    end
+    
+    # The InterBase adapter relies on the IBRuby[http://rubyforge.org/projects/ibruby/]
+    # extension, version 0.5.1 or later (available as a gem or from
+    # RubyForge[http://rubyforge.org/projects/ibruby/]). IBRuby works with
+    # InterBase 7.1, 7.5 and 2007 on Linux, Solaris and Win32 platforms.
+    #
+    # == Usage Notes
+    #
+    # === Sequence (Generator) Names
+    # The InterBase adapter supports the same approach adopted for the Oracle & Firebird
+    # adapters. 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 InterBase sequence generator when using
+    # ActiveRecord. In other words, you don't have to try to make InterBase
+    # 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 InterBase
+    # adapter to report back the +id+ after a successful insert.)
+    #
+    # === BLOB Elements
+    # The InterBase 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
+    # InterBase and ActiveRecord have somewhat conflicting case semantics for
+    # column names.
+    #
+    # [*InterBase*]
+    #   The standard practice is to use unquoted column names, which can be
+    #   thought of as case-insensitive. (In fact, InterBase 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 InterBase and ActiveRecord, uppercase column names
+    # in InterBase are converted to lowercase attribute names in ActiveRecord,
+    # and vice-versa. Mixed-case column names retain their case in both
+    # directions. Lowercase (quoted) InterBase 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 InterBase DDL (or if you must quote, use uppercase column
+    # names). These will correspond to lowercase attributes in ActiveRecord.
+    #
+    # For example, a InterBase table based on the following DDL:
+    #
+    #  CREATE TABLE products (
+    #    id INTEGER 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 InterBase reserved words:
+    # In ActiveRecord, the default inheritance column name is +type+. The word
+    # _type_ is a InterBase reserved word, so it must be quoted in any InterBase
+    # SQL statements. Because of the case mapping described above, you should
+    # always reference this column using quoted-lowercase syntax
+    # (<tt>"type"</tt>) within InterBase DDL or other SQL statements (as in the
+    # example above). This holds true for any other InterBase reserved words used
+    # as column names as well as this driver keeps a list of all reserved words and will
+    # ensure they are not mapped to upper case and they are always used quoted in the database.
+    #
+    # === Migrations
+    # The InterBase adapter does support Migrations.  
+    # 
+    #
+    # === SQL
+    # ActiveRecord has as part of its test suite syntax which is not strictly compliant with the SQL standard
+    # i.e. field IN (NULL). NULL is not valid in the IN clause, and where this particular part of SQL has appeared
+    # I change it to field IS NULL instead using Ruby's pattern matching
+    # 
+    # The same is true of = NULL in the WHERE clause, this is also not SQL standard and in those cases, I break the
+    # SQL statement up into the before WHERE and after WHERE and replace all = NULL after the WHERE with IS NULL. This
+    # is clearly time consuming on the SQL so I really wish they wouldn't do it.
+    #
+    # == Connection Options
+    # The following options are supported by the InterBase adapter. None of the
+    # options have default values.
+    #
+    # <tt>:database</tt>::
+    #   <i>Required option.</i> Specifies one of: (i) a InterBase database alias;
+    #   (ii) the full path of a database file; _or_ (iii) a full InterBase
+    #   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 InterBase
+    #   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
+    #   InterBase documentation for valid options.
+    # <tt>:role</tt>:
+    #   Specifies the role that the username is using when connecting to the database (if any)
+    
+    class InterBaseAdapter < AbstractAdapter
+      
+      # class property
+      @@reserved_words_array = [ "ACTION", "AFTER", "ANY", "AT", "BASED", "BEGIN", "BOOLEAN",
+         "CASCADE", "CHARACTER", "ACTIVE", "ALL", "AS", "AUTO", "BASENAME", "BETWEEN", "BUFFER", "CAST",
+         "CHAR_LENGTH", "ADD", "ALTER", "ASC", "AUTODDL", "BASE_NAME", "BLOB", "BY", "CHAR", "CHECK",
+         "ADMIN", "AND", "ASCENDING", "AVG", "BEFORE", "BLOBEDIT", "CACHE", "CHARACTER", "CHECK_POINT_LEN",
+         "CHECK_POINT_LENGTH", "COLLATE", "COLLATION", "COLUMN", "COMMIT", "COMMITTED", "COMPILETIME",
+         "COMPUTED", "CLOSE", "CONDITIONAL", "CONNECT", "CONSTRAINT", "CONTAINING", "CONTINUE", "COUNT",
+         "CREATE", "CSTRING", "CURRENT", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURSOR", "DATABASE",
+         "DATE", "DAY", "DB_KEY", "DEBUG", "DEC", "DECIMAL", "DECLARE", "DEFAULT", "DELETE", "DESC", "DESCENDING",
+         "DESCRIBE", "DESCRIPTOR", "DISCONNECT", "DISPLAY", "DISTINCT", "DO", "DOMAIN", "DOUBLE", "DROP", "ECHO",
+         "EDIT", "ELSE", "END", "ENTRY_POINT", "ESCAPE", "EVENT", "EXCEPTION", "EXECUTE", "EXISTS", "EXIT", "EXTERN",
+         "EXTERNAL", "EXTRACT", "FALSE", "FETCH", "FILE", "FILTER", "FLOAT", "FOR", "FOREIGN", "FOUND", "FREE_IT",
+         "FROM", "FULL", "FUNCTION", "GDSCODE", "GENERATOR", "GEN_ID", "GLOBAL", "GOTO", "GRANT", "GROUP", "GROUP_COMMIT_WAIT",
+         "GROUP_COMMIT_WAIT_TIME", "HAVING", "HELP", "HOUR", "IF", "IMMEDIATE", "IN", "INACTIVE", "INDEX", "INDICATOR",
+         "INIT", "INNER", "INPUT", "INPUT_TYPE", "INSERT", "INT", "INTEGER", "INTO", "IS", "ISOLATION", "ISQL", "JOIN",
+         "KEY", "LC_MESSAGES", "LC_TYPE", "LEFT", "LENGTH", "LEV", "LEVEL", "LIKE", "LOGFILE", "LOG_BUFFER_SIZE",
+         "LOG_BUF_SIZE", "LONG", "MANUAL", "MAX", "MAXIMUM", "MAXIMUM_SEGMENT", "MAX_SEGMENT", "MERGE", "MESSAGE", "MIN",
+         "MINIMUM", "MINUTE", "MODULE_NAME", "MONTH", "NAMES", "NATIONAL", "NATURAL", "NCHAR", "NO", "NOAUTO", "NOT", "NULL",
+         "NUMERIC", "NUM_LOG_BUFS", "NUM_LOG_BUFFERS", "OCTET_LENGTH", "OF", "ON", "ONLY", "OPEN", "OPTION", "OR", "ORDER",
+         "OUTER", "OUTPUT", "OUTPUT_TYPE", "OVERFLOW", "PAGE", "PAGELENGTH", "PAGES", "PAGE_SIZE", "PARAMETER", "PASSWORD",
+         "PERCENT", "PLAN", "POSITION", "POST_EVENT", "PRECISION", "PREPARE", "PRESERVE", "PROCEDURE", "PROTECTED", "PRIMARY",
+         "PRIVILEGES", "PUBLIC", "QUIT", "RAW_PARTITIONS", "READ", "REAL", "RECORD_VERSION", "REFERENCES", "RELEASE", "RESERV",
+         "RESERVING", "RESTRICT", "RETAIN", "RETURN", "RETURNING_VALUES", "RETURNS", "REVOKE", "RIGHT", "ROLE", "ROLLBACK", "ROWS",
+         "RUNTIME", "SCHEMA", "SECOND", "SEGMENT", "SELECT", "SET", "SHADOW", "SHARED", "SHELL", "SHOW", "SINGULAR", "SIZE",
+         "SMALLINT", "SNAPSHOT", "SOME", "SORT", "SQLCODE", "SQLERROR", "SQLWARNING", "STABILITY", "STARTING", "STARTS", "STATEMENT",
+         "STATIC", "STATISTICS", "SUB_TYPE", "SUM", "SUSPEND", "TABLE", "TEMPORARY", "TERMINATOR", "THEN", "TIES", "TIME", "TIMESTAMP",
+         "TO", "TRANSACTION", "TRANSLATE", "TRANSLATION", "TRIGGER", "TRIM", "TRUE", "TYPE", "UNCOMMITTED", "UNION", "UNIQUE", "UNKNOWN",
+         "UPDATE", "UPPER", "USER", "USING", "VALUE", "VALUES", "VARCHAR", "VARIABLE", "VARYING", "VERSION", "VIEW", "WAIT", "WEEKDAY",
+         "WHEN", "WHENEVER", "WHERE", "WHILE", "WITH", "WORK", "WRITE", "YEAR", "YEARDAY"
+      ]
+      
+      ## will turn it into a hash for faster access
+      @@reserved_words_hash = {}
+      
+      # You can make a column case sensitive by adding it to the list of reserved words. This method builds the fast hash when first accessed.
+      def self.reserved_words
+        if @@reserved_words_hash.size == 0
+          @@reserved_words_array.each() do |value|
+            @@reserved_words_hash[ value ] = true
+          end
+        end
+        
+        @@reserved_words_hash
+      end
+      
+      def initialize(connection, logger, connection_params=nil)
+        super(connection, logger)
+        @connection_params = connection_params
+      end
+      
+      def case_insignificant_uses_lower
+        false
+      end
+      
+      
+      def adapter_name # :nodoc:
+        'InterBase'
+      end
+      
+      # Returns true for InterBase adapter (since InterBase 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) # :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:
+        if InterBaseAdapter.reserved_words[column_name.to_s.upcase] 
+          %Q("#{column_name.to_s.downcase}")
+        else
+          InterBaseAdapter.ar_to_ib_case(column_name)
+        end
+      end
+
+      def quoted_true # :nodoc:
+        'true'
+        #true
+      end
+
+      def quoted_false # :nodoc:
+        'false'
+        #false
+      end
+
+
+      # CONNECTION MANAGEMENT ====================================
+
+      def active?
+        not @connection.closed?
+      end
+      
+      def reconnect!
+        @connection.close
+        @connection = @connection.database.connect(*@connection_params)
+      end
+      
+      def disconnect!
+        @connection.close
+      end
+
+      # DATABASE STATEMENTS ======================================
+
+      def interbaseSQL( sql )
+        sql = sql.sub( / (IN|in) \(NULL\)/, ' IS NULL' )
+        # anything after the WHERE clause where we find = NULL, we need replace this with IS NULL
+        if ((sql !=~ /~INSERT /) && (sql =~ /= NULL/) )
+          sqlMatch = / WHERE /
+          matched = sqlMatch.match( sql )
+          if !matched.nil? # this of course will break if the = NULL is in a bit of text
+            sql = matched.pre_match << ' WHERE ' << matched.post_match.gsub( /= NULL/, 'IS NULL' )
+          end
+        end
+        #puts "SQL = #{sql}"
+        sql
+      end
+
+      def select_all(sql, name = nil) # :nodoc:
+        select(sql, name)
+      end
+
+      def select_one(sql, name = nil) # :nodoc:
+        if sql !=~ / ROWS / 
+          sql << " ROWS 1 TO 1"
+        end
+        result = select(sql, name)
+        result.nil? ? nil : result.first  #first element in array
+      end
+      
+      def select_value(sql, name = nil)
+        result = select_one(sql, name)
+        
+        result.nil? ? nil : result.values.first
+      end
+
+      def execute(sql, name = nil, &block) # :nodoc:
+        sql = interbaseSQL(sql)
+        #~ begin
+        log(sql, name) do
+          if @transaction
+            #puts "within trans: #{sql}"
+            @connection.execute(sql, @transaction, &block)
+          else
+            #puts "immediate: #{sql}"
+            @connection.execute_immediate(sql, &block)
+          end
+        end
+        #~ rescue Exception => boom
+          #~ puts "sql went boom #{boom.message}"
+          #~ nil
+        #~ 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:
+        #puts "begin_transaction"
+        #~ if @transaction.nil? or !transaction.active?
+          #~ if raw_connection.transactions.size > 0
+            #~ @transaction = raw_connection.transactions[0]
+          #~ else
+            @transaction = @connection.start_transaction
+          #~ end
+        #~ end
+      end
+
+      def commit_db_transaction() # :nodoc:
+        #puts "commit transaction"
+        if @total_count
+          @total_count += 1
+        else
+          @total_count = 0
+        end
+        #raise Exception, 'someone called commit?' if @total_count == 1
+        @transaction.commit unless @transaction.nil? or !@transaction.active?
+      ensure
+        @transaction = nil
+      end
+
+      def rollback_db_transaction() # :nodoc:
+        #puts "rollback transaction"
+        @transaction.rollback unless @transaction.nil? or !@transaction.active?
+      ensure
+        @transaction = nil
+      end
+
+      def add_limit_offset!(sql, options) # :nodoc:
+        if options[:limit]
+          limit_string = " ROWS "
+          offset = options[:offset] ? (options[:offset] + 1) : 1
+          if offset.to_i < 1
+            offset = 1
+          end
+          limit_string << offset.to_s
+          limit = offset.to_i + options[:limit].to_i - 1
+          limit_string << " TO #{limit}"
+          #sql.sub!(/\A(\s*SELECT\s)/i, '\&' + limit_string + ' ')
+          sql << 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)
+        IBRuby::Generator.new(sequence_name, @connection).next(1)
+      end
+
+
+      # SCHEMA STATEMENTS ========================================
+      def supports_migrations?
+        true
+      end
+	  
+	  # should really put this in IBRuby but don't want to change it for the release of 3rdRail
+      def recreate_database!
+        sql = "SELECT rdb$character_set_name FROM rdb$database"
+        charset = execute(sql).to_a.first[0]
+		    filename = @connection.database.file
+        disconnect!
+		    db = IBRuby::Database.new( filename )
+        db.drop(@connection_params[0], @connection_params[1])
+		    db = nil
+		    if charset.nil?
+			    IBRuby::Database.create(@connection.database.file,
+			    @connection_params[0], @connection_params[1], 4096)
+		    else
+			    IBRuby::Database.create(@connection.database.file,
+			    @connection_params[0], @connection_params[1], 4096, charset.rstrip)
+		    end
+		    db = IBRuby::Database.new( filename )
+		    @connection = db.connect( @connection_params[0], @connection_params[1], @connection_params[2] )
+      end
+	  
+      
+      # have to create a sequence for each table because of the "prefetching of the primary key"
+      def create_table(name, options = {})
+        # this from super
+        table_definition = InterBaseTableDefinition.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
+        # to here
+        # 
+        # now build the proper IB meta structures
+        columns = []
+        
+        table_definition.columns.each() do |col|
+          new_col = IBRuby::InterBaseColumn.new( quote_column_name(col.name), name, rails_type_to_native_type[col.type],
+            nil, !col.null.nil? && !col.null, col.limit, col.precision, col.scale, rails_type_to_native_sub_type[col.type], 
+            col.default )
+            
+          columns << new_col
+        end
+
+        if ( table_definition.pk_field )        
+          pk_constraints = [InterBaseConstraint.new(IBRuby::InterBaseConstraint::PRIMARY_KEY,
+             [table_definition.pk_field.name] ) ]
+        end
+        
+        table = InterBaseTable.new(name, columns, nil, pk_constraints )
+        
+        table.create_table( raw_connection )
+        
+        seq_name = name.to_s + "_SEQ"
+        if !IBRuby::Generator.exists?( seq_name, raw_connection )
+          IBRuby::Generator::create(seq_name, @connection)
+        end
+      end
+      
+      # should drop the indexes as well as any other meta data associated with this table!
+      def drop_table(name)
+        #puts "transactions? #{@transaction.nil?}"
+        InterBaseTable.new(name).drop_table(raw_connection)
+        
+        seq_name = name.to_s + "_SEQ"
+        if IBRuby::Generator.exists?( seq_name, raw_connection )
+          IBRuby::Generator.new(seq_name, @connection).drop
+        end
+      end
+      
+      def rename_column(table_name, column_name, new_column_name)
+        # will break if there is an index based on this column!
+        # 
+        col = InterBaseMetaFunctions.table_fields( raw_connection, table_name.to_s, true, quote_column_name(column_name) )
+        col.rename_column( raw_connection, quote_column_name(new_column_name) )
+      end
+
+      def change_column(table_name, column_name, type, options = {})
+        col = InterBaseMetaFunctions.table_fields( raw_connection, table_name.to_s, true, column_name )
+
+        new_col = col.dup
+        
+        if !type.nil?
+          new_col.type = rails_type_to_native_type[type]
+          new_col.sub_type = rails_type_to_native_sub_type[type]
+        end
+        
+        push_options_into_ib_column( new_col, options )        
+        
+        if !options[:default].nil?
+          new_col.default = options[:default]
+        end
+        
+        col.change_column( raw_connection, new_col )
+      end
+      
+      def change_column_default(table_name, column_name, default)
+        change_column( table_name.to_s, column_name, nil, { :default => default } )
+      end
+      
+      def native_database_types #:nodoc
+        {
+          :primary_key => "integer not null PRIMARY KEY",
+          :string      => { :name => "varchar", :limit => 252 }, # allows default string to be index (index limit 252 in InterBase)
+          :text        => { :name => "blob sub_type 1" },
+          :integer     => { :name => "integer" },
+          :float       => { :name => "double precision" },
+          :decimal     => { :name => "decimal" },
+          :datetime    => { :name => "timestamp" },
+          :timestamp   => { :name => "timestamp" },
+          :time        => { :name => "time" },
+          :date        => { :name => "date" },
+          :binary      => { :name => "blob" },
+          :boolean     => { :name => "boolean" }
+        }
+      end
+      
+      def rails_type_to_native_type
+        {  
+          :string      => IBRuby::InterBaseColumn::VARCHAR,
+          :text        => IBRuby::InterBaseColumn::BLOB,
+          :integer     => IBRuby::InterBaseColumn::INTEGER,
+          :float       => IBRuby::InterBaseColumn::DOUBLE,
+          :decimal     => IBRuby::InterBaseColumn::DECIMAL,
+          :datetime    => IBRuby::InterBaseColumn::TIMESTAMP,
+          :timestamp   => IBRuby::InterBaseColumn::TIMESTAMP,
+          :time        => IBRuby::InterBaseColumn::TIME,
+          :date        => IBRuby::InterBaseColumn::DATE,
+          :binary      => IBRuby::InterBaseColumn::BLOB,
+          :boolean     => IBRuby::InterBaseColumn::BOOLEAN
+        }
+      end
+
+      def rails_type_to_native_sub_type
+        {  
+          :string      => 0,
+          :text        => 1,
+          :integer     => 0,
+          :float       => 0,
+          :decimal     => 0, # 0 is decimal, 1 is numeric
+          :datetime    => 0,
+          :timestamp   => 0,
+          :time        => 0,
+          :date        => 0,
+          :binary      => 0,
+          :boolean     => 0
+        }
+      end
+
+      
+      def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+        return super unless type.to_s == 'integer'
+
+        if limit.nil? || limit == 4
+          'integer'
+        elsif limit < 4
+          'smallint'
+        else
+          'decimal(#{limit},0)'
+        end
+      end  
+      
+      def add_index(table_name, column_name, options = {})
+        column_names = Array(column_name)
+        index_name   = index_name(table_name.to_s, :column => column_names)
+
+        if Hash === options # legacy support, since this param was a string
+          index_type = options[:unique] ? "UNIQUE" : ""
+          index_name = options[:name] || index_name
+        else
+          index_type = options
+        end
+        
+        columns = column_names.collect() { |col| quote_column_name(col) }
+        
+        begin
+          index = IBRuby::InterBaseIndex.new( table_name.to_s, index_name, "UNIQUE".casecmp(index_type) == 0, columns )
+          index.create_index( raw_connection )
+        rescue Exception => indexFailed
+          puts "Warning: Index creation failed #{indexFailed.message} - please read up on InterBase Index size limitations in Operations Guide"
+        end
+      end
+      
+      def add_column(table_name, column_name, type, options = {})
+        new_col = IBRuby::InterBaseColumn.new( quote_column_name(column_name), table_name.to_s, 
+           rails_type_to_native_type[type] )
+           
+        new_col.sub_type = rails_type_to_native_sub_type[type]
+        
+        push_options_into_ib_column( new_col, options )
+        
+        if (new_col.type == IBRuby::InterBaseColumn::VARCHAR) && new_col.length.nil?
+          new_col.length = 255;
+        end
+        
+        new_col.default = options[:default]
+        
+        #puts "#{new_col.name} precision:#{new_col.precision}:#{new_col.scale}"
+        
+#        if ( type == :decimal )
+#          new_col.precision = 10 unless new_col.precision?
+#          new_col.scale = 0 unless new_col.scale?
+#        end
+        
+        new_col.add_column(raw_connection)
+      end
+
+      # returns an array of IndexDefinitions which include a string array of columns
+      def indexes(table_name, name = nil) #:nodoc:
+        indices = []
+
+        ibIndices = InterBaseMetaFunctions.indices(raw_connection,table_name.to_s)
+        
+        # returns array of InterBaseIndex's
+        ibIndices.each() do |ibIndex|
+          index = IndexDefinition.new(InterBaseAdapter.ib_to_ar_case(ibIndex.table), 
+                InterBaseAdapter.ib_to_ar_case(ibIndex.name), ibIndex.unique, [])
+
+          ibIndex.columns.each() do |col|
+            index.columns << InterBaseAdapter.ib_to_ar_case(col.name)
+          end
+          
+          indices << index
+        end
+        
+        indices
+      end
+      
+      # returns a string array of tables!
+      def tables
+        table_names = InterBaseMetaFunctions.table_names(raw_connection)
+        table_names.each() { |table_name| table_name.downcase! }
+      end
+      
+      def rename_table(name, new_name)
+        table = IBRuby::InterBaseTable.new(name)
+        table.rename_table(raw_connection, new_name )
+      end
+      
+      # no table name specified for InterBase
+          def remove_index(table_name, options = {})
+            InterBaseMetaFunctions.remove_index(raw_connection, index_name(table_name.to_s, options) )
+          end
+          
+          def columns(table_name, name = nil) # :nodoc:
+            columns = InterBaseMetaFunctions.table_fields(raw_connection,table_name.to_s,true)
+            
+            cols = columns.collect() do |field|
+              ConnectionAdapters::InterBaseColumn.new( field )
+            end
+            
+            cols
+          end
+          
+          protected
+          ## returns an array of hashes
+          def select(sql, name = nil)
+            rs = execute(sql, name)
+            results = rs.collect do |row|
+              hashed_row = {}
+              row.each do |column, value|
+                value = value.to_s if IBRuby::Blob === value
+                hashed_row[InterBaseAdapter.ib_to_ar_case(column)] = value
+              end
+              hashed_row
+            end
+            rs.close # otherwise we temporarily and unnecessarily leak result sets, which lock meta-data
+            results
+          end
+          
+          # Maps uppercase InterBase column names to lowercase for ActiveRecord;
+          # mixed-case columns retain their original case.
+          def self.ib_to_ar_case(column_name)
+            column_name =~ /[[:lower:]]/ ? column_name : column_name.to_s.downcase
+          end
+          
+          # Maps lowercase ActiveRecord column names to uppercase for Fierbird;
+          # mixed-case columns retain their original case.
+          def self.ar_to_ib_case(column_name)
+            column_name =~ /[[:upper:]]/ ? column_name : column_name.to_s.upcase
+          end
+          
+          def push_options_into_ib_column( new_col, options )
+            new_col.length = options[:limit].to_i unless options[:limit].nil?
+            new_col.precision = options[:precision].to_i unless options[:precision].nil?
+            new_col.not_null = options[:null] == false unless options[:null].nil?
+            new_col.scale = options[:scale].to_i unless options[:scale].nil?
+          end
+        end
+      end
+    end

data/lib/tasks/interbase.rake

@@ -0,0 +1,86 @@
+# Richard Vowles - Developers Inc Ltd, www.developers-inc.co.nz
+# Thank you Matthew Bass!
+# Basic code taken from http://matthewbass.com/2007/03/07/overriding-existing-rake-tasks/
+# 
+
+Rake::TaskManager.class_eval do
+  def remove_task(task_name)
+  	t_name = task_name.to_s 
+    @tasks.delete(t_name)
+  end  
+end
+ 
+def remove_task(task_name)
+  Rake.application.remove_task(task_name)
+end
+
+remove_task( "db:structure:dump" )
+remove_task( "db:test:clone_structure" )
+remove_task( "db:test:purge" )
+remove_task( "db:sessions:create" )
+
+# now replace the tasks from database.rake
+namespace :db do
+  namespace :structure do
+    desc "Dump the database structure to a SQL file"
+    task :dump => :environment do
+      abcs = ActiveRecord::Base.configurations
+      case abcs[RAILS_ENV]["adapter"]
+        when "interbase"
+          set_firebird_env(abcs[RAILS_ENV])
+          db_string = IBRuby::Database.db_string_for(abcs[RAILS_ENV].symbolize_keys)
+          sh "isql -a #{db_string} > db/#{RAILS_ENV}_structure.sql"
+        else
+          raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+      end
+
+      if ActiveRecord::Base.connection.supports_migrations?
+        File.open("db/#{RAILS_ENV}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+      end
+    end
+  end #namespace :structure
+  
+  namespace :test do
+	  desc "Recreate the test databases from the development structure"
+	  task :clone_structure => [ "db:structure:dump", "db:test:purge" ] do
+		abcs = ActiveRecord::Base.configurations
+		case abcs["test"]["adapter"]
+		  when "interbase"
+			set_firebird_env(abcs["test"]) # actually InterBase ones, Firebird being a fork!
+			db_string = IBRuby::Database.db_string_for(abcs["test"].symbolize_keys)
+			begin
+			  ## outputs an EOF but don't know why
+			  sh "isql -i db/#{RAILS_ENV}_structure.sql #{db_string}"
+			rescue
+		  
+			end
+		  else
+			raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+		end
+	  end
+  
+	  desc "Empty the test database"
+	  task :purge => :environment do
+		abcs = ActiveRecord::Base.configurations
+		case abcs["test"]["adapter"]
+		  when "interbase"
+			ActiveRecord::Base.establish_connection(:test)
+			ActiveRecord::Base.connection.recreate_database!
+		  else
+			raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+		end
+	  end
+  end #namespace :test
+  
+  namespace :sessions do
+    desc "Creates a sessions table for use with CGI::Session::ActiveRecordStore"
+    task :create => :environment do
+      raise "Task unavailable to this database (no migration support)" unless ActiveRecord::Base.connection.supports_migrations?
+      require 'rails_generator'
+      require 'rails_generator/scripts/generate'
+      Rails::Generator::Scripts::Generate.new.run(["session_migration", ENV["MIGRATION"] || "AddSessions"],
+      	:source => "#{RAILS_ROOT}/vendor/plugins/ibrails_plugin/db")
+    end
+  end #namespace :sessions    
+end #namespace :database
+  

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: activerecord-interbase-adapter
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2008-01-30 00:00:00 +13:00
+summary: Rails interface library for the InterBase database.
+require_paths: 
+- lib
+email: richard@bluetrainsoftware.com
+homepage: http://rubyforge.org/projects/activerecord-interbase-adapter/
+rubyforge_project: 
+description: requires IBRuby
+autorequire: ibruby
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: 
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Richard Vowles
+files: 
+- lib/active_record
+- lib/active_record/connection_adapters
+- lib/active_record/connection_adapters/ibrails_case_fix.rb
+- lib/active_record/connection_adapters/interbase_adapter.rb
+- lib/tasks
+- lib/tasks/interbase.rake
+test_files: []
+
+rdoc_options: 
+- --main
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+