activerecord-jdbc-adapter 0.9.2 → 1.1.0

data/lib/jdbc_adapter/jdbc_mysql.rb

@@ -1,236 +0,0 @@
-require 'active_record/connection_adapters/abstract/schema_definitions'
-
-module ::JdbcSpec
-  # Don't need to load native mysql adapter
-  $LOADED_FEATURES << "active_record/connection_adapters/mysql_adapter.rb"
-
-  module ActiveRecordExtensions
-    add_method_to_remove_from_ar_base(:mysql_connection)
-
-    def mysql_connection(config)
-      require File.dirname(__FILE__) + "/../active_record/connection_adapters/mysql_adapter"
-      config[:port] ||= 3306
-      url_options = "zeroDateTimeBehavior=convertToNull&jdbcCompliantTruncation=false&useUnicode=true&characterEncoding="
-      url_options << (config[:encoding] || 'utf8')
-      if config[:url]
-        config[:url] = config[:url]['?'] ? "#{config[:url]}&#{url_options}" : "#{config[:url]}?#{url_options}"
-      else
-        config[:url] = "jdbc:mysql://#{config[:host]}:#{config[:port]}/#{config[:database]}?#{url_options}"
-      end
-      config[:driver] = "com.mysql.jdbc.Driver"
-      connection = jdbc_connection(config)
-      ::JdbcSpec::MySQL.kill_cancel_timer(connection.raw_connection)
-      connection
-    end
-  end
-
-  module MySQL
-    def self.adapter_matcher(name, *)
-      name =~ /mysql/i ? self : false
-    end
-
-    def self.column_selector
-      [/mysql/i, lambda {|cfg,col| col.extend(::JdbcSpec::MySQL::Column)}]
-    end
-
-    def self.extended(adapter)
-      adapter.execute("SET SQL_AUTO_IS_NULL=0")
-    end
-
-    module Column
-      TYPES_ALLOWING_EMPTY_STRING_DEFAULT = Set.new([:binary, :string, :text])
-
-      def simplified_type(field_type)
-        return :boolean if field_type =~ /tinyint\(1\)|bit/i
-        return :string  if field_type =~ /enum/i
-        super
-      end
-
-      def init_column(name, default, *args)
-        @original_default = default
-        @default = nil if missing_default_forged_as_empty_string?
-      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, text, binary) 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
-    end
-
-    def modify_types(tp)
-      tp[:primary_key] = "int(11) DEFAULT NULL auto_increment PRIMARY KEY"
-      tp[:decimal] = { :name => "decimal" }
-      tp[:timestamp] = { :name => "datetime" }
-      tp[:datetime][:limit] = nil
-      tp
-    end
-
-    # QUOTING ==================================================
-
-    def quote(value, column = nil)
-      return value.quoted_id if value.respond_to?(:quoted_id)
-
-      if column && column.type == :primary_key
-        value.to_s
-      elsif column && String === value && column.type == :binary && column.class.respond_to?(:string_to_binary)
-        s = column.class.string_to_binary(value).unpack("H*")[0]
-        "x'#{s}'"
-      elsif BigDecimal === value
-        "'#{value.to_s("F")}'"
-      else
-        super
-      end
-    end
-
-    def quoted_true
-        "1"
-    end
-
-    def quoted_false
-        "0"
-    end
-
-    def begin_db_transaction #:nodoc:
-      @connection.begin
-    rescue Exception
-      # Transactions aren't supported
-    end
-
-    def commit_db_transaction #:nodoc:
-      @connection.commit
-    rescue Exception
-      # Transactions aren't supported
-    end
-
-    def rollback_db_transaction #:nodoc:
-      @connection.rollback
-    rescue Exception
-      # Transactions aren't supported
-    end
-
-    def disable_referential_integrity(&block) #:nodoc:
-      old = select_value("SELECT @@FOREIGN_KEY_CHECKS")
-      begin
-        update("SET FOREIGN_KEY_CHECKS = 0")
-        yield
-      ensure
-        update("SET FOREIGN_KEY_CHECKS = #{old}")
-      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')
-
-        hash = select_one("SHOW CREATE TABLE #{quote_table_name(table.to_a.first.last)}")
-
-        if(table = hash["Create Table"])
-          structure += table + ";\n\n"
-        elsif(view = hash["Create View"])
-          structure += view + ";\n\n"
-        end
-      end
-    end
-
-    def recreate_database(name) #:nodoc:
-      drop_database(name)
-      create_database(name)
-    end
-
-    def character_set(options) #:nodoc:
-      str = "CHARACTER SET `#{options[:charset] || 'utf8'}`"
-      str += " COLLATE `#{options[:collation]}`" if options[:collation]
-      str
-    end
-    private :character_set
-
-    def create_database(name, options = {}) #:nodoc:
-      execute "CREATE DATABASE `#{name}` DEFAULT #{character_set(options)}"
-    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 create_table(name, options = {}) #:nodoc:
-      super(name, {:options => "ENGINE=InnoDB #{character_set(options)}"}.merge(options))
-    end
-
-    def rename_table(name, new_name)
-      execute "RENAME TABLE #{quote_table_name(name)} TO #{quote_table_name(new_name)}"
-    end
-
-    def change_column_default(table_name, column_name, default) #:nodoc:
-      current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")["Type"]
-
-      execute("ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_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)
-        if column = columns(table_name).find { |c| c.name == column_name.to_s }
-          options[:default] = column.default
-        else
-          raise "No such column: #{table_name}.#{column_name}"
-        end
-      end
-
-      change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_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:
-      cols = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")
-      current_type = cols["Type"] || cols["COLUMN_TYPE"]
-      execute "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_table_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
-    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
-
-    def show_variable(var)
-      res = execute("show variables like '#{var}'")
-      row = res.detect {|row| row["Variable_name"] == var }
-      row && row["Value"]
-    end
-
-    def charset
-      show_variable("character_set_database")
-    end
-
-    def collation
-      show_variable("collation_database")
-    end
-
-    private
-    def supports_views?
-      false
-    end
-  end
-end

data/lib/jdbc_adapter/jdbc_sqlite3.rb

@@ -1,379 +0,0 @@
-module ::JdbcSpec
-  # Don't need to load native postgres adapter
-  $LOADED_FEATURES << "active_record/connection_adapters/sqlite3_adapter.rb"
-
-  module ActiveRecordExtensions
-    add_method_to_remove_from_ar_base(:sqlite3_connection)
-
-    def sqlite3_connection(config)
-      require File.dirname(__FILE__) + "/../active_record/connection_adapters/sqlite3_adapter"
-
-      parse_sqlite3_config!(config)
-
-      config[:url] ||= "jdbc:sqlite:#{config[:database]}"
-      config[:driver] ||= "org.sqlite.JDBC"
-      jdbc_connection(config)
-    end
-
-    def parse_sqlite3_config!(config)
-      config[:database] ||= config[:dbfile]
-
-      # Allow database path relative to RAILS_ROOT, but only if
-      # the database path is not the special path that tells
-      # Sqlite to build a database only in memory.
-      if Object.const_defined?(:RAILS_ROOT) && ':memory:' != config[:database]
-        config[:database] = File.expand_path(config[:database], RAILS_ROOT)
-      end
-    end
-  end
-
-  module SQLite3
-    def self.adapter_matcher(name, *)
-      name =~ /sqlite/i ? self : false
-    end
-
-    def self.column_selector
-      [/sqlite/i, lambda {|cfg,col| col.extend(::JdbcSpec::SQLite3::Column)}]
-    end
-
-    def self.jdbc_connection_class
-      ::ActiveRecord::ConnectionAdapters::Sqlite3JdbcConnection
-    end
-
-    module Column
-      def init_column(name, default, *args)
-        @default = '' if default =~ /NULL/
-      end
-
-      def type_cast(value)
-        return nil if value.nil?
-        case type
-        when :string   then value
-        when :integer  then JdbcSpec::SQLite3::Column.cast_to_integer(value)
-        when :primary_key then defined?(value.to_i) ? value.to_i : (value ? 1 : 0)
-        when :float    then value.to_f
-        when :datetime then JdbcSpec::SQLite3::Column.cast_to_date_or_time(value)
-        when :date then JdbcSpec::SQLite3::Column.cast_to_date_or_time(value)
-        when :time     then JdbcSpec::SQLite3::Column.cast_to_time(value)
-        when :decimal  then self.class.value_to_decimal(value)
-        when :boolean  then self.class.value_to_boolean(value)
-        else value
-        end
-      end
-
-      def type_cast_code(var_name)
-        case type
-          when :integer  then "JdbcSpec::SQLite3::Column.cast_to_integer(#{var_name})"
-          when :datetime then "JdbcSpec::SQLite3::Column.cast_to_date_or_time(#{var_name})"
-          when :date     then "JdbcSpec::SQLite3::Column.cast_to_date_or_time(#{var_name})"
-          when :time     then "JdbcSpec::SQLite3::Column.cast_to_time(#{var_name})"
-        else
-          super
-        end
-      end
-
-      private
-      def simplified_type(field_type)
-        case field_type
-        when /boolean/i                        then :boolean
-        when /text/i                           then :text
-        when /varchar/i                        then :string
-        when /int/i                            then :integer
-        when /float/i                          then :float
-        when /real/i                           then @scale == 0 ? :integer : :decimal
-        when /datetime/i                       then :datetime
-        when /date/i                           then :date
-        when /time/i                           then :time
-        when /blob/i                           then :binary
-        end
-      end
-
-      def extract_precision(sql_type)
-        case sql_type
-          when /^(real)\((\d+)(,\d+)?\)/i then $2.to_i 
-          else super
-        end 
-      end
-      
-      def extract_scale(sql_type)
-        case sql_type
-          when /^(real)\((\d+)\)/i then 0
-          when /^(real)\((\d+)(,(\d+))\)/i then $4.to_i
-          else super
-        end
-      end
-
-      # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
-      def default_value(value)
-        # jdbc returns column default strings with actual single quotes around the value.
-        return $1 if value =~ /^'(.*)'$/
-
-        value
-      end
-
-      def self.cast_to_integer(value)
-        return nil if value =~ /NULL/ or value.to_s.empty? or value.nil?
-        return (value.to_i) ? value.to_i : (value ? 1 : 0)
-      end
-
-      def self.cast_to_date_or_time(value)
-        return value if value.is_a? Date
-        return nil if value.blank?
-        guess_date_or_time((value.is_a? Time) ? value : cast_to_time(value))
-      end
-
-      def self.cast_to_time(value)
-        return value if value.is_a? Time
-        time_array = ParseDate.parsedate value
-        time_array[0] ||= 2000; time_array[1] ||= 1; time_array[2] ||= 1;
-        Time.send(ActiveRecord::Base.default_timezone, *time_array) rescue nil
-      end
-
-      def self.guess_date_or_time(value)
-        (value.hour == 0 and value.min == 0 and value.sec == 0) ?
-        Date.new(value.year, value.month, value.day) : value
-      end
-    end
-
-    def adapter_name #:nodoc:
-      'SQLite'
-    end
-
-    def supports_count_distinct? #:nodoc:
-      sqlite_version >= '3.2.6'
-    end
-
-    def supports_autoincrement? #:nodoc:
-      sqlite_version >= '3.1.0'
-    end
-
-    def sqlite_version
-      @sqlite_version ||= select_value('select sqlite_version(*)')
-    end
-
-    def modify_types(tp)
-      tp[:primary_key] = "INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL"
-      tp[:string] = { :name => "VARCHAR", :limit => 255 }
-      tp[:float] = { :name => "REAL" }
-      tp[:decimal] = { :name => "REAL" }
-      tp[:datetime] = { :name => "DATETIME" }
-      tp[:timestamp] = { :name => "DATETIME" }
-      tp[:time] = { :name => "TIME" }
-      tp[:date] = { :name => "DATE" }
-      tp[:boolean] = { :name => "BOOLEAN" }
-      tp
-    end
-
-    def quote(value, column = nil) # :nodoc:
-      return value.quoted_id if value.respond_to?(:quoted_id)
-      case value
-      when String
-        if column && column.type == :binary
-          "'#{quote_string(column.class.string_to_binary(value))}'"
-        elsif column && [:integer, :float].include?(column.type)
-          (column.type == :integer ? value.to_i : value.to_f).to_s
-        elsif column && column.respond_to?(:primary) && column.primary
-          value.to_i.to_s
-        else
-          "'#{quote_string(value)}'"
-        end
-      else super
-      end
-    end
-
-    def quote_column_name(name) #:nodoc:
-      name = name.to_s
-      # Did not find reference on values needing quoting, but these
-      # happen in AR unit tests
-      if name == "references" || name =~ /-/
-        %Q("#{name}") 
-      else
-        name
-      end
-    end
-
-    def quote_string(str)
-      str.gsub(/'/, "''")
-    end
-
-    def quoted_true
-      %Q{'t'}
-    end
-
-    def quoted_false
-      %Q{'f'}
-    end
-
-    def add_column(table_name, column_name, type, options = {})
-      if option_not_null = options[:null] == false
-        option_not_null = options.delete(:null)
-      end
-      add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-      add_column_options!(add_column_sql, options)
-      execute(add_column_sql)
-      if option_not_null
-        alter_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} NOT NULL"
-      end
-    end
-
-    def remove_column(table_name, *column_names) #:nodoc:
-      column_names.flatten.each do |column_name|
-        alter_table(table_name) do |definition|
-          definition.columns.delete(definition[column_name])
-        end
-      end
-    end
-    alias :remove_columns :remove_column
-
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
-      alter_table(table_name) do |definition|
-        include_default = options_include_default?(options)
-        definition[column_name].instance_eval do
-          self.type    = type
-          self.limit   = options[:limit] if options.include?(:limit)
-          self.default = options[:default] if include_default
-          self.null    = options[:null] if options.include?(:null)
-        end
-      end
-    end
-
-    def change_column_default(table_name, column_name, default) #:nodoc:
-      alter_table(table_name) do |definition|
-        definition[column_name].default = default
-      end
-    end
-
-    def rename_column(table_name, column_name, new_column_name) #:nodoc:
-      unless columns(table_name).detect{|c| c.name == column_name.to_s }
-        raise ActiveRecord::ActiveRecordError, "Missing column #{table_name}.#{column_name}"
-      end
-      alter_table(table_name, :rename => {column_name.to_s => new_column_name.to_s})
-    end
-
-    def rename_table(name, new_name)
-      execute "ALTER TABLE #{name} RENAME TO #{new_name}"
-    end
-
-    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
-      log(sql,name) do
-        @connection.execute_update(sql)
-        clear_query_cache
-      end
-      table = sql.split(" ", 4)[2]
-      id_value || last_insert_id(table, nil)
-    end
-
-    def last_insert_id(table, sequence_name)
-      Integer(select_value("SELECT SEQ FROM SQLITE_SEQUENCE WHERE NAME = '#{table}'"))
-    end
-
-    def add_limit_offset!(sql, options) #:nodoc:
-      if options[:limit]
-        sql << " LIMIT #{options[:limit]}"
-        sql << " OFFSET #{options[:offset]}" if options[:offset]
-      end
-    end
-
-    def tables(name = nil) #:nodoc:
-      sql = <<-SQL
-        SELECT name
-        FROM sqlite_master
-        WHERE type = 'table' AND NOT name = 'sqlite_sequence'
-      SQL
-
-      select_rows(sql, name).map do |row|
-        row[0]
-      end
-    end
-
-    def remove_index(table_name, options = {})
-      execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
-    end
-
-    def indexes(table_name, name = nil)
-      result = select_rows("SELECT name, sql FROM sqlite_master WHERE tbl_name = '#{table_name}' AND type = 'index'", name)
-
-      result.collect do |row|
-        name = row[0]
-        index_sql = row[1]
-        unique = (index_sql =~ /unique/i)
-        cols = index_sql.match(/\((.*)\)/)[1].gsub(/,/,' ').split
-        ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, name, unique, cols)
-      end
-    end
-    
-    def primary_key(table_name) #:nodoc:
-      column = table_structure(table_name).find {|field| field['pk'].to_i == 1}
-      column ? column['name'] : nil
-    end
-
-    def recreate_database(name)
-      tables.each{ |table| drop_table(table) }
-    end
-
-    def _execute(sql, name = nil)
-      if ActiveRecord::ConnectionAdapters::JdbcConnection::select?(sql)
-        @connection.execute_query(sql)
-      else
-        affected_rows = @connection.execute_update(sql)
-        ActiveRecord::ConnectionAdapters::JdbcConnection::insert?(sql) ? last_insert_id(sql.split(" ", 4)[2], nil) : affected_rows
-      end
-    end
-    
-    def select(sql, name=nil)
-      execute(sql, name).map do |row|
-        record = {}
-        row.each_key do |key|
-          if key.is_a?(String)
-            record[key.sub(/^"?\w+"?\./, '')] = row[key]
-          end
-        end
-        record
-      end
-    end
-    
-    def table_structure(table_name)
-      returning structure = @connection.execute_query("PRAGMA table_info(#{quote_table_name(table_name)})") do
-        raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty?
-      end
-    end
-    
-    def columns(table_name, name = nil) #:nodoc:        
-      table_structure(table_name).map do |field|
-        ::ActiveRecord::ConnectionAdapters::JdbcColumn.new(@config, field['name'], field['dflt_value'], field['type'], field['notnull'] == 0)
-      end
-    end
-    
-     # SELECT ... FOR UPDATE is redundant since the table is locked.
-    def add_lock!(sql, options) #:nodoc:
-      sql
-    end
-    
-    protected
-      include JdbcSpec::MissingFunctionalityHelper
-  end
-end
-
-module ActiveRecord
-  module ConnectionAdapters
-    class JdbcColumn < Column
-      def self.string_to_binary(value)
-        value.gsub(/\0|%/n) do |b|
-          case b
-            when "\0" then "%00"
-            when "\%"  then "%25"
-          end
-        end
-      end
-
-      def self.binary_to_string(value)
-        value.gsub(/%00|%25/n) do |b|
-          case b
-            when "%00" then "\0"
-            when "%25" then "%"
-          end
-        end
-      end
-    end
-  end
-end