backlog 0.0.2 → 0.0.3

data/vendor/rails/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -1,421 +0,0 @@
-require 'active_record/connection_adapters/abstract_adapter'
-require 'set'
-
-module MysqlCompat #:nodoc:
-  # add all_hashes method to standard mysql-c bindings or pure ruby version
-  def self.define_all_hashes_method!
-    raise 'Mysql not loaded' unless defined?(::Mysql)
-
-    target = defined?(Mysql::Result) ? Mysql::Result : MysqlRes
-    return if target.instance_methods.include?('all_hashes')
-
-    # Ruby driver has a version string and returns null values in each_hash
-    # C driver >= 2.7 returns null values in each_hash
-    if Mysql.const_defined?(:VERSION) && (Mysql::VERSION.is_a?(String) || Mysql::VERSION >= 20700)
-      target.class_eval <<-'end_eval'
-      def all_hashes
-        rows = []
-        each_hash { |row| rows << row }
-        rows
-      end
-      end_eval
-
-    # adapters before 2.7 don't have a version constant
-    # and don't return null values in each_hash
-    else
-      target.class_eval <<-'end_eval'
-      def all_hashes
-        rows = []
-        all_fields = fetch_fields.inject({}) { |fields, f| fields[f.name] = nil; fields }
-        each_hash { |row| rows << all_fields.dup.update(row) }
-        rows
-      end
-      end_eval
-    end
-
-    unless target.instance_methods.include?('all_hashes')
-      raise "Failed to defined #{target.name}#all_hashes method. Mysql::VERSION = #{Mysql::VERSION.inspect}"
-    end
-  end
-end
-
-module ActiveRecord
-  class Base
-    def self.require_mysql
-      # Include the MySQL driver if one hasn't already been loaded
-      unless defined? Mysql
-        begin
-          require_library_or_gem 'mysql'
-        rescue LoadError => cannot_require_mysql
-          # Use the bundled Ruby/MySQL driver if no driver is already in place
-          begin
-            require 'active_record/vendor/mysql'
-          rescue LoadError
-            raise cannot_require_mysql
-          end
-        end
-      end
-
-      # Define Mysql::Result.all_hashes
-      MysqlCompat.define_all_hashes_method!
-    end
-
-    # Establishes a connection to the database that's used by all Active Record objects.
-    def self.mysql_connection(config) # :nodoc:
-      config = config.symbolize_keys
-      host     = config[:host]
-      port     = config[:port]
-      socket   = config[:socket]
-      username = config[:username] ? config[:username].to_s : 'root'
-      password = config[:password].to_s
-
-      if config.has_key?(:database)
-        database = config[:database]
-      else
-        raise ArgumentError, "No database specified. Missing argument: database."
-      end
-
-      require_mysql
-      mysql = Mysql.init
-      mysql.ssl_set(config[:sslkey], config[:sslcert], config[:sslca], config[:sslcapath], config[:sslcipher]) if config[:sslkey]
-
-      ConnectionAdapters::MysqlAdapter.new(mysql, logger, [host, username, password, database, port, socket], config)
-    end
-  end
-
-  module ConnectionAdapters
-    class MysqlColumn < Column #:nodoc:
-      TYPES_DISALLOWING_DEFAULT = Set.new([:binary, :text])
-      TYPES_ALLOWING_EMPTY_STRING_DEFAULT = Set.new([:string])
-
-      def initialize(name, default, sql_type = nil, null = true)
-        @original_default = default
-        super
-        @default = nil if no_default_allowed? || missing_default_forged_as_empty_string?
-      end
-
-      private
-        def simplified_type(field_type)
-          return :boolean if MysqlAdapter.emulate_booleans && field_type.downcase.index("tinyint(1)")
-          return :string  if field_type =~ /enum/i
-          super
-        end
-
-        # MySQL misreports NOT NULL column default when none is given.
-        # We can't detect this for columns which may have a legitimate ''
-        # default (string) but we can for others (integer, datetime, boolean,
-        # and the rest).
-        #
-        # Test whether the column has default '', is not null, and is not
-        # a type allowing default ''.
-        def missing_default_forged_as_empty_string?
-          !null && @original_default == '' && !TYPES_ALLOWING_EMPTY_STRING_DEFAULT.include?(type)
-        end
-
-        # MySQL 5.0 does not allow text and binary columns to have defaults
-        def no_default_allowed?
-          TYPES_DISALLOWING_DEFAULT.include?(type)
-        end
-    end
-
-    # The MySQL adapter will work with both Ruby/MySQL, which is a Ruby-based MySQL adapter that comes bundled with Active Record, and with
-    # the faster C-based MySQL/Ruby adapter (available both as a gem and from http://www.tmtm.org/en/mysql/ruby/).
-    #
-    # Options:
-    #
-    # * <tt>:host</tt> -- Defaults to localhost
-    # * <tt>:port</tt> -- Defaults to 3306
-    # * <tt>:socket</tt> -- Defaults to /tmp/mysql.sock
-    # * <tt>:username</tt> -- Defaults to root
-    # * <tt>:password</tt> -- Defaults to nothing
-    # * <tt>:database</tt> -- The name of the database. No default, must be provided.
-    # * <tt>:encoding</tt> -- (Optional) Sets the client encoding by executing "SET NAMES <encoding>" after connection
-    # * <tt>:sslkey</tt> -- Necessary to use MySQL with an SSL connection
-    # * <tt>:sslcert</tt> -- Necessary to use MySQL with an SSL connection
-    # * <tt>:sslcapath</tt> -- Necessary to use MySQL with an SSL connection
-    # * <tt>:sslcipher</tt> -- Necessary to use MySQL with an SSL connection
-    #
-    # By default, the MysqlAdapter will consider all columns of type tinyint(1)
-    # as boolean. If you wish to disable this emulation (which was the default
-    # behavior in versions 0.13.1 and earlier) you can add the following line
-    # to your environment.rb file:
-    #
-    #   ActiveRecord::ConnectionAdapters::MysqlAdapter.emulate_booleans = false
-    class MysqlAdapter < AbstractAdapter
-      @@emulate_booleans = true
-      cattr_accessor :emulate_booleans
-
-      LOST_CONNECTION_ERROR_MESSAGES = [
-        "Server shutdown in progress",
-        "Broken pipe",
-        "Lost connection to MySQL server during query",
-        "MySQL server has gone away"
-      ]
-
-      def initialize(connection, logger, connection_options, config)
-        super(connection, logger)
-        @connection_options, @config = connection_options, config
-
-        connect
-      end
-
-      def adapter_name #:nodoc:
-        'MySQL'
-      end
-
-      def supports_migrations? #:nodoc:
-        true
-      end
-
-      def native_database_types #:nodoc:
-        {
-          :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY",
-          :string      => { :name => "varchar", :limit => 255 },
-          :text        => { :name => "text" },
-          :integer     => { :name => "int", :limit => 11 },
-          :float       => { :name => "float" },
-          :decimal     => { :name => "decimal" },
-          :datetime    => { :name => "datetime" },
-          :timestamp   => { :name => "datetime" },
-          :time        => { :name => "time" },
-          :date        => { :name => "date" },
-          :binary      => { :name => "blob" },
-          :boolean     => { :name => "tinyint", :limit => 1 }
-        }
-      end
-
-
-      # QUOTING ==================================================
-
-      def quote(value, column = nil)
-        if value.kind_of?(String) && column && column.type == :binary && column.class.respond_to?(:string_to_binary)
-          s = column.class.string_to_binary(value).unpack("H*")[0]
-          "x'#{s}'"
-        elsif value.kind_of?(BigDecimal)
-          "'#{value.to_s("F")}'"
-        else
-          super
-        end
-      end
-
-      def quote_column_name(name) #:nodoc:
-        "`#{name}`"
-      end
-
-      def quote_string(string) #:nodoc:
-        @connection.quote(string)
-      end
-
-      def quoted_true
-        "1"
-      end
-      
-      def quoted_false
-        "0"
-      end
-
-
-      # CONNECTION MANAGEMENT ====================================
-
-      def active?
-        if @connection.respond_to?(:stat)
-          @connection.stat
-        else
-          @connection.query 'select 1'
-        end
-
-        # mysql-ruby doesn't raise an exception when stat fails.
-        if @connection.respond_to?(:errno)
-          @connection.errno.zero?
-        else
-          true
-        end
-      rescue Mysql::Error
-        false
-      end
-
-      def reconnect!
-        disconnect!
-        connect
-      end
-      
-      def disconnect!
-        @connection.close rescue nil
-      end
-
-
-      # DATABASE STATEMENTS ======================================
-
-      def execute(sql, name = nil) #:nodoc:
-        log(sql, name) { @connection.query(sql) }
-      rescue ActiveRecord::StatementInvalid => exception
-        if exception.message.split(":").first =~ /Packets out of order/
-          raise ActiveRecord::StatementInvalid, "'Packets out of order' error was received from the database. Please update your mysql bindings (gem install mysql) and read http://dev.mysql.com/doc/mysql/en/password-hashing.html for more information.  If you're on Windows, use the Instant Rails installer to get the updated mysql bindings."
-        else
-          raise
-        end
-      end
-
-      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
-        execute(sql, name = nil)
-        id_value || @connection.insert_id
-      end
-
-      def update(sql, name = nil) #:nodoc:
-        execute(sql, name)
-        @connection.affected_rows
-      end
-
-      def begin_db_transaction #:nodoc:
-        execute "BEGIN"
-      rescue Exception
-        # Transactions aren't supported
-      end
-
-      def commit_db_transaction #:nodoc:
-        execute "COMMIT"
-      rescue Exception
-        # Transactions aren't supported
-      end
-
-      def rollback_db_transaction #:nodoc:
-        execute "ROLLBACK"
-      rescue Exception
-        # Transactions aren't supported
-      end
-
-
-      def add_limit_offset!(sql, options) #:nodoc:
-        if limit = options[:limit]
-          unless offset = options[:offset]
-            sql << " LIMIT #{limit}"
-          else
-            sql << " LIMIT #{offset}, #{limit}"
-          end
-        end
-      end
-
-
-      # SCHEMA STATEMENTS ========================================
-
-      def structure_dump #:nodoc:
-        if supports_views?
-          sql = "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"
-        else
-          sql = "SHOW TABLES"
-        end
-        
-        select_all(sql).inject("") do |structure, table|
-          table.delete('Table_type')
-          structure += select_one("SHOW CREATE TABLE #{table.to_a.first.last}")["Create Table"] + ";\n\n"
-        end
-      end
-
-      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:
-        execute "DROP DATABASE IF EXISTS `#{name}`"
-      end
-
-      def current_database
-        select_one("SELECT DATABASE() as db")["db"]
-      end
-
-      def tables(name = nil) #:nodoc:
-        tables = []
-        execute("SHOW TABLES", name).each { |field| tables << field[0] }
-        tables
-      end
-
-      def indexes(table_name, name = nil)#:nodoc:
-        indexes = []
-        current_index = nil
-        execute("SHOW KEYS FROM #{table_name}", name).each do |row|
-          if current_index != row[2]
-            next if row[2] == "PRIMARY" # skip the primary key
-            current_index = row[2]
-            indexes << IndexDefinition.new(row[0], row[2], row[1] == "0", [])
-          end
-
-          indexes.last.columns << row[4]
-        end
-        indexes
-      end
-
-      def columns(table_name, name = nil)#:nodoc:
-        sql = "SHOW FIELDS FROM #{table_name}"
-        columns = []
-        execute(sql, name).each { |field| columns << MysqlColumn.new(field[0], field[4], field[1], field[2] == "YES") }
-        columns
-      end
-
-      def create_table(name, options = {}) #:nodoc:
-        super(name, {:options => "ENGINE=InnoDB"}.merge(options))
-      end
-      
-      def rename_table(name, new_name)
-        execute "RENAME TABLE #{name} TO #{new_name}"
-      end  
-
-      def change_column_default(table_name, column_name, default) #:nodoc:
-        current_type = select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["Type"]
-
-        execute("ALTER TABLE #{table_name} CHANGE #{column_name} #{column_name} #{current_type} DEFAULT #{quote(default)}")
-      end
-
-      def change_column(table_name, column_name, type, options = {}) #:nodoc:
-        unless options_include_default?(options)
-          options[:default] = select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["Default"]
-        end
-
-        change_column_sql = "ALTER TABLE #{table_name} CHANGE #{column_name} #{column_name} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        add_column_options!(change_column_sql, options)
-        execute(change_column_sql)
-      end
-
-      def rename_column(table_name, column_name, new_column_name) #:nodoc:
-        current_type = select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["Type"]
-        execute "ALTER TABLE #{table_name} CHANGE #{column_name} #{new_column_name} #{current_type}"
-      end
-
-
-      private
-        def connect
-          encoding = @config[:encoding]
-          if encoding
-            @connection.options(Mysql::SET_CHARSET_NAME, encoding) rescue nil
-          end
-          @connection.ssl_set(@config[:sslkey], @config[:sslcert], @config[:sslca], @config[:sslcapath], @config[:sslcipher]) if @config[:sslkey]
-          @connection.real_connect(*@connection_options)
-          execute("SET NAMES '#{encoding}'") if encoding
-
-          # By default, MySQL 'where id is null' selects the last inserted id.
-          # Turn this off. http://dev.rubyonrails.org/ticket/6778
-          execute("SET SQL_AUTO_IS_NULL=0")
-        end
-
-        def select(sql, name = nil)
-          @connection.query_with_result = true
-          result = execute(sql, name)
-          rows = result.all_hashes
-          result.free
-          rows
-        end
-
-        def supports_views?
-          version[0] >= 5
-        end
-
-        def version
-          @version ||= @connection.server_info.scan(/^(\d+)\.(\d+)\.(\d+)/).flatten.map { |v| v.to_i }
-        end
-    end
-  end
-end

data/vendor/rails/activerecord/lib/active_record/connection_adapters/openbase_adapter.rb

@@ -1,349 +0,0 @@
-require 'active_record/connection_adapters/abstract_adapter'
-
-module ActiveRecord
-  class Base
-    # Establishes a connection to the database that's used by all Active Record objects
-    def self.openbase_connection(config) # :nodoc:
-      require_library_or_gem 'openbase' unless self.class.const_defined?(:OpenBase)
-
-      config = config.symbolize_keys
-      host     = config[:host]
-      username = config[:username].to_s
-      password = config[:password].to_s
-      
-
-      if config.has_key?(:database)
-        database = config[:database]
-      else
-        raise ArgumentError, "No database specified. Missing argument: database."
-      end
-
-      oba = ConnectionAdapters::OpenBaseAdapter.new(
-        OpenBase.new(database, host, username, password), logger
-      )
-      
-      oba
-    end
-    
-  end
-
-  module ConnectionAdapters
-    class OpenBaseColumn < Column #:nodoc:
-      private
-        def simplified_type(field_type)
-          return :integer if field_type.downcase =~ /long/
-          return :decimal if field_type.downcase == "money"
-          return :binary  if field_type.downcase == "object"
-          super
-        end
-    end
-    # The OpenBase adapter works with the Ruby/Openbase driver by Tetsuya Suzuki.
-    # http://www.spice-of-life.net/ruby-openbase/ (needs version 0.7.3+)
-    #
-    # Options:
-    #
-    # * <tt>:host</tt> -- Defaults to localhost
-    # * <tt>:username</tt> -- Defaults to nothing
-    # * <tt>:password</tt> -- Defaults to nothing
-    # * <tt>:database</tt> -- The name of the database. No default, must be provided.
-    #
-    # The OpenBase adapter will make use of OpenBase's ability to generate unique ids
-    # for any column with an unique index applied.  Thus, if the value of a primary
-    # key is not specified at the time an INSERT is performed, the adapter will prefetch
-    # a unique id for the primary key.  This prefetching is also necessary in order 
-    # to return the id after an insert.
-    #
-    # Caveat: Operations involving LIMIT and OFFSET do not yet work!
-    #
-    # Maintainer: derrick.spell@gmail.com
-    class OpenBaseAdapter < AbstractAdapter
-      def adapter_name
-        'OpenBase'
-      end
-      
-      def native_database_types
-        {
-          :primary_key => "integer UNIQUE INDEX DEFAULT _rowid",
-          :string      => { :name => "char", :limit => 4096 },
-          :text        => { :name => "text" },
-          :integer     => { :name => "integer" },
-          :float       => { :name => "float" },
-          :decimal     => { :name => "decimal" },
-          :datetime    => { :name => "datetime" },
-          :timestamp   => { :name => "timestamp" },
-          :time        => { :name => "time" },
-          :date        => { :name => "date" },
-          :binary      => { :name => "object" },
-          :boolean     => { :name => "boolean" }
-        }
-      end
-      
-      def supports_migrations?
-        false
-      end      
-      
-      def prefetch_primary_key?(table_name = nil)
-        true
-      end
-      
-      def default_sequence_name(table_name, primary_key) # :nodoc:
-        "#{table_name} #{primary_key}"
-      end
-      
-      def next_sequence_value(sequence_name)
-        ary = sequence_name.split(' ')
-        if (!ary[1]) then
-          ary[0] =~ /(\w+)_nonstd_seq/
-          ary[0] = $1
-        end
-        @connection.unique_row_id(ary[0], ary[1])
-      end
-
-      
-      # QUOTING ==================================================
-      
-      def quote(value, column = nil)
-        if value.kind_of?(String) && column && column.type == :binary
-          "'#{@connection.insert_binary(value)}'"
-        else
-          super
-        end
-      end
-      
-      def quoted_true
-        "1"
-      end
-      
-      def quoted_false
-        "0"
-      end
-      
-
-
-      # DATABASE STATEMENTS ======================================
-
-      def add_limit_offset!(sql, options) #:nodoc:
-        if limit = options[:limit]
-          unless offset = options[:offset]
-            sql << " RETURN RESULTS #{limit}"
-          else
-            limit = limit + offset
-            sql << " RETURN RESULTS #{offset} TO #{limit}"
-          end
-        end
-      end
-      
-      def select_all(sql, name = nil) #:nodoc:
-        select(sql, name)
-      end
-
-      def select_one(sql, name = nil) #:nodoc:
-        add_limit_offset!(sql,{:limit => 1})
-        results = select(sql, name)
-        results.first if results
-      end
-
-      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
-        execute(sql, name)
-        update_nulls_after_insert(sql, name, pk, id_value, sequence_name)
-        id_value
-      end
-      
-      def execute(sql, name = nil) #:nodoc:
-        log(sql, name) { @connection.execute(sql) }
-      end
-
-      def update(sql, name = nil) #:nodoc:
-        execute(sql, name).rows_affected
-      end
-
-      alias_method :delete, :update #:nodoc:
-#=begin
-      def begin_db_transaction #:nodoc:
-        execute "START TRANSACTION"
-      rescue Exception
-        # Transactions aren't supported
-      end
-
-      def commit_db_transaction #:nodoc:
-        execute "COMMIT"
-      rescue Exception
-        # Transactions aren't supported
-      end
-
-      def rollback_db_transaction #:nodoc:
-        execute "ROLLBACK"
-      rescue Exception
-        # Transactions aren't supported
-      end
-#=end      
-
-      # SCHEMA STATEMENTS ========================================
-
-      # Return the list of all tables in the schema search path.
-      def tables(name = nil) #:nodoc:
-        tables = @connection.tables
-        tables.reject! { |t| /\A_SYS_/ === t }
-        tables
-      end
-
-      def columns(table_name, name = nil) #:nodoc:
-        sql = "SELECT * FROM _sys_tables "
-        sql << "WHERE tablename='#{table_name}' AND INDEXOF(fieldname,'_')<>0 "
-        sql << "ORDER BY columnNumber"
-        columns = []
-        select_all(sql, name).each do |row|
-          columns << OpenBaseColumn.new(row["fieldname"],
-                                default_value(row["defaultvalue"]),
-                                sql_type_name(row["typename"],row["length"]),
-                                row["notnull"]
-                                )
-        end
-        columns
-      end
-
-      def indexes(table_name, name = nil)#:nodoc:
-        sql = "SELECT fieldname, notnull, searchindex, uniqueindex, clusteredindex FROM _sys_tables "
-        sql << "WHERE tablename='#{table_name}' AND INDEXOF(fieldname,'_')<>0 "
-        sql << "AND primarykey=0 "
-        sql << "AND (searchindex=1 OR uniqueindex=1 OR clusteredindex=1) "
-        sql << "ORDER BY columnNumber"
-        indexes = []
-        execute(sql, name).each do |row|
-          indexes << IndexDefinition.new(table_name,index_name(row),row[3]==1,[row[0]])
-        end
-        indexes
-      end
-
-
-      private
-        def select(sql, name = nil)
-          sql = translate_sql(sql)
-          results = execute(sql, name)
-
-          date_cols = []
-          col_names = []
-          results.column_infos.each do |info|
-            col_names << info.name
-            date_cols << info.name if info.type == "date"
-          end
-          
-          rows = []
-          if ( results.rows_affected )
-            results.each do |row|  # loop through result rows
-              hashed_row = {}
-              row.each_index do |index| 
-                hashed_row["#{col_names[index]}"] = row[index] unless col_names[index] == "_rowid"
-              end
-              date_cols.each do |name|
-                unless hashed_row["#{name}"].nil? or hashed_row["#{name}"].empty?
-                  hashed_row["#{name}"] = Date.parse(hashed_row["#{name}"],false).to_s
-                end
-              end
-              rows << hashed_row
-            end
-          end
-          rows
-        end
-        
-        def default_value(value)
-          # Boolean type values
-          return true if value =~ /true/
-          return false if value =~ /false/
- 
-          # Date / Time magic values
-          return Time.now.to_s if value =~ /^now\(\)/i
- 
-          # Empty strings should be set to null
-          return nil if value.empty?
-          
-          # Otherwise return what we got from OpenBase
-          # and hope for the best...
-          return value
-        end 
-        
-        def sql_type_name(type_name, length)
-          return "#{type_name}(#{length})" if ( type_name =~ /char/ )
-          type_name
-        end
-                
-        def index_name(row = [])
-          name = ""
-          name << "UNIQUE " if row[3]
-          name << "CLUSTERED " if row[4]
-          name << "INDEX"
-          name
-        end
-        
-        def translate_sql(sql)
-          
-          # Change table.* to list of columns in table
-          while (sql =~ /SELECT.*\s(\w+)\.\*/)
-            table = $1
-            cols = columns(table)
-            if ( cols.size == 0 ) then
-              # Maybe this is a table alias
-              sql =~ /FROM(.+?)(?:LEFT|OUTER|JOIN|WHERE|GROUP|HAVING|ORDER|RETURN|$)/  
-              $1 =~ /[\s|,](\w+)\s+#{table}[\s|,]/ # get the tablename for this alias
-              cols = columns($1)
-            end
-            select_columns = []
-            cols.each do |col|
-              select_columns << table + '.' + col.name
-            end
-            sql.gsub!(table + '.*',select_columns.join(", ")) if select_columns
-          end
-   
-          # Change JOIN clause to table list and WHERE condition
-          while (sql =~ /JOIN/)
-            sql =~ /((LEFT )?(OUTER )?JOIN (\w+) ON )(.+?)(?:LEFT|OUTER|JOIN|WHERE|GROUP|HAVING|ORDER|RETURN|$)/
-            join_clause = $1 + $5
-            is_outer_join = $3
-            join_table = $4
-            join_condition = $5
-            join_condition.gsub!(/=/,"*") if is_outer_join
-            if (sql =~ /WHERE/)
-              sql.gsub!(/WHERE/,"WHERE (#{join_condition}) AND")
-            else
-              sql.gsub!(join_clause,"#{join_clause} WHERE #{join_condition}")
-            end
-            sql =~ /(FROM .+?)(?:LEFT|OUTER|JOIN|WHERE|$)/
-            from_clause = $1
-            sql.gsub!(from_clause,"#{from_clause}, #{join_table} ")
-            sql.gsub!(join_clause,"")
-          end
-    
-          # ORDER BY _rowid if no explicit ORDER BY
-          # This will ensure that find(:first) returns the first inserted row
-          if (sql !~ /(ORDER BY)|(GROUP BY)/)
-            if (sql =~ /RETURN RESULTS/)
-              sql.sub!(/RETURN RESULTS/,"ORDER BY _rowid RETURN RESULTS")
-            else
-              sql << " ORDER BY _rowid"
-            end
-          end
-          
-          sql
-        end
-        
-        def update_nulls_after_insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-          sql =~ /INSERT INTO (\w+) \((.*)\) VALUES\s*\((.*)\)/m
-          table = $1
-          cols = $2
-          values = $3
-          cols = cols.split(',')
-          values.gsub!(/'[^']*'/,"''")
-          values.gsub!(/"[^"]*"/,"\"\"")
-          values = values.split(',')
-          update_cols = []
-          values.each_index { |index| update_cols << cols[index] if values[index] =~ /\s*NULL\s*/ }
-          update_sql = "UPDATE #{table} SET"
-          update_cols.each { |col| update_sql << " #{col}=NULL," unless col.empty? }
-          update_sql.chop!()
-          update_sql << " WHERE #{pk}=#{quote(id_value)}"
-          execute(update_sql, name + " NULL Correction") if update_cols.size > 0
-        end
-        
-      end
-  end
-end