activerecord-jdbc-adapter 0.9.0.1 → 0.9.1

data/lib/jdbc_adapter/jdbc_mysql.rb

@@ -7,24 +7,27 @@ module ::JdbcSpec
   module ActiveRecordExtensions
     def mysql_connection(config)
       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]}&#{MySQL::URL_OPTIONS}" : "#{config[:url]}?#{MySQL::URL_OPTIONS}"
+        config[:url] = config[:url]['?'] ? "#{config[:url]}&#{url_options}" : "#{config[:url]}?#{url_options}"
       else
-        config[:url] = "jdbc:mysql://#{config[:host]}:#{config[:port]}/#{config[:database]}?#{MySQL::URL_OPTIONS}"
+        config[:url] = "jdbc:mysql://#{config[:host]}:#{config[:port]}/#{config[:database]}?#{url_options}"
       end
       config[:driver] = "com.mysql.jdbc.Driver"
-      jdbc_connection(config)
+      connection = jdbc_connection(config)
+      ::JdbcSpec::MySQL.kill_cancel_timer(connection.raw_connection)
+      connection
     end
   end
 
   module MySQL
-    URL_OPTIONS = "zeroDateTimeBehavior=convertToNull&jdbcCompliantTruncation=false&useUnicode=true&characterEncoding=utf8"
-    def self.column_selector
-      [/mysql/i, lambda {|cfg,col| col.extend(::JdbcSpec::MySQL::Column)}]
+    def self.adapter_matcher(name, *)
+      name =~ /mysql/i ? self : false
     end
 
-    def self.adapter_selector
-      [/mysql/i, lambda {|cfg,adapt| adapt.extend(::JdbcSpec::MySQL)}]
+    def self.column_selector
+      [/mysql/i, lambda {|cfg,col| col.extend(::JdbcSpec::MySQL::Column)}]
     end
 
     def self.extended(adapter)
@@ -82,14 +85,6 @@ module ::JdbcSpec
       end
     end
 
-    def quote_column_name(name) #:nodoc:
-        "`#{name}`"
-    end
-
-    def quote_table_name(name) #:nodoc:
-      quote_column_name(name).gsub('.', '`.`')
-    end
-
     def quoted_true
         "1"
     end
@@ -153,12 +148,15 @@ module ::JdbcSpec
       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:
-      if options[:collation]
-        execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}` COLLATE `#{options[:collation]}`"
-      else
-        execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}`"
-      end
+      execute "CREATE DATABASE `#{name}` DEFAULT #{character_set(options)}"
     end
 
     def drop_database(name) #:nodoc:
@@ -170,7 +168,7 @@ module ::JdbcSpec
     end
 
     def create_table(name, options = {}) #:nodoc:
-      super(name, {:options => "ENGINE=InnoDB CHARACTER SET utf8 COLLATE utf8_bin"}.merge(options))
+      super(name, {:options => "ENGINE=InnoDB #{character_set(options)}"}.merge(options))
     end
 
     def rename_table(name, new_name)

data/lib/jdbc_adapter/jdbc_oracle.rb

@@ -1,19 +1,3 @@
-module ::ActiveRecord
-  class Base
-    def after_save_with_oracle_lob() #:nodoc:
-      if connection.is_a?(JdbcSpec::Oracle)
-        self.class.columns.select { |c| c.sql_type =~ /LOB\(|LOB$/i }.each { |c|
-          value = self[c.name]
-          value = value.to_yaml if unserializable_attribute?(c.name, c)
-          next if value.nil?  || (value == '')
-
-          connection.write_large_object(c.type == :binary, c.name, self.class.table_name, self.class.primary_key, quote_value(id), value)
-        }
-      end
-    end
-  end
-end
-
 module ::JdbcSpec
   module ActiveRecordExtensions
     def oracle_connection(config)
@@ -26,58 +10,59 @@ module ::JdbcSpec
 
   module Oracle
     def self.extended(mod)
-      ActiveRecord::Base.after_save :after_save_with_oracle_lob unless @lob_callback_added
-      @lob_callback_added = true
+      unless @lob_callback_added
+        ActiveRecord::Base.class_eval do
+          def after_save_with_oracle_lob
+            self.class.columns.select { |c| c.sql_type =~ /LOB\(|LOB$/i }.each do |c|
+              value = self[c.name]
+              value = value.to_yaml if unserializable_attribute?(c.name, c)
+              next if value.nil?  || (value == '')
+
+              connection.write_large_object(c.type == :binary, c.name, self.class.table_name, self.class.primary_key, quote_value(id), value)
+            end
+          end
+        end
+
+        ActiveRecord::Base.after_save :after_save_with_oracle_lob
+        @lob_callback_added = true
+      end
+    end
+
+    def self.adapter_matcher(name, *)
+      name =~ /oracle/i ? self : false
     end
 
     def self.column_selector
       [/oracle/i, lambda {|cfg,col| col.extend(::JdbcSpec::Oracle::Column)}]
     end
 
-    def self.adapter_selector
-      [/oracle/i, lambda {|cfg,adapt| adapt.extend(::JdbcSpec::Oracle)
-=begin
-         (adapt.methods - %w(send __send__ id class methods is_a? kind_of? verify! active?)).each do |name|
-           new_name = "__#{name}"
-           (class << adapt; self; end).send :alias_method, new_name, name
-           (class << adapt; self; end).send :define_method, name do |*args|
-             puts "#{name}(#{args.inspect})"
-             adapt.send new_name, *args
-           end
-         end
-=end
-       }]
-    end
-    
     module Column
       def type_cast(value)
         return nil if value.nil?
         case type
-        when :string      then value
-        when :integer     then defined?(value.to_i) ? value.to_i : (value ? 1 : 0)
-        when :primary_key then defined?(value.to_i) ? value.to_i : (value ? 1 : 0) 
-        when :float       then value.to_f
-        when :datetime    then JdbcSpec::Oracle::Column.cast_to_date_or_time(value)
-        when :time        then JdbcSpec::Oracle::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
+        when :datetime then JdbcSpec::Oracle::Column.string_to_time(value, self.class)
+        else
+          super
         end
       end
-      
+
       def type_cast_code(var_name)
         case type
-        when :string      then nil
-        when :integer     then "(#{var_name}.to_i rescue #{var_name} ? 1 : 0)"
-        when :primary_key then "(#{var_name}.to_i rescue #{var_name} ? 1 : 0)"
-        when :float       then "#{var_name}.to_f"
-        when :datetime    then "JdbcSpec::Oracle::Column.cast_to_date_or_time(#{var_name})"
-        when :time        then "JdbcSpec::Oracle::Column.cast_to_time(#{var_name})"
-        when :decimal     then "#{self.class.name}.value_to_decimal(#{var_name})"
-        when :boolean     then "#{self.class.name}.value_to_boolean(#{var_name})"
-        else nil
+        when :datetime  then "JdbcSpec::Oracle::Column.string_to_time(#{var_name}, self.class)"
+        else
+          super
         end
-      end      
+      end
+
+      def self.string_to_time(string, klass)
+        time = klass.string_to_time(string)
+        guess_date_or_time(time)
+      end
+
+      def self.guess_date_or_time(value)
+        (value.hour == 0 && value.min == 0 && value.sec == 0) ?
+        new_date(value.year, value.month, value.day) : value
+      end
 
       private
       def simplified_type(field_type)
@@ -93,33 +78,34 @@ module ::JdbcSpec
         end
       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
+      # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
+      def default_value(value)
+        return nil unless value
 
-      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
+        # Not sure why we need this for Oracle?
+        value = value.strip
 
-      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
+        return nil if value == "null"
+
+        # jdbc returns column default strings with actual single quotes around the value.
+        return $1 if value =~ /^'(.*)'$/
+
+        value
       end
     end
 
+    def adapter_name
+      'oracle'
+    end
+
     def table_alias_length
       30
     end
 
-    def default_sequence_name(table, column) #:nodoc:
+    def default_sequence_name(table, column = nil) #:nodoc:
       "#{table}_seq"
     end
-    
+
     def create_table(name, options = {}) #:nodoc:
       super(name, options)
       seq_name = options[:sequence_name] || "#{name}_seq"
@@ -130,7 +116,7 @@ module ::JdbcSpec
     def rename_table(name, new_name) #:nodoc:
       execute "RENAME #{name} TO #{new_name}"
       execute "RENAME #{name}_seq TO #{new_name}_seq" rescue nil
-    end  
+    end
 
     def drop_table(name, options = {}) #:nodoc:
       super(name)
@@ -141,17 +127,22 @@ module ::JdbcSpec
     def recreate_database(name)
       tables.each{ |table| drop_table(table) }
     end
-    
+
+    def drop_database(name)
+      recreate_database(name)
+    end
+
     def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
-      if pk.nil? # Who called us? What does the sql look like? No idea!
-        execute sql, name
-      elsif id_value # Pre-assigned id
+      if id_value # Pre-assigned id
         execute sql, name
       else # Assume the sql contains a bind-variable for the id
+        # Extract the table from the insert sql. Yuck.
+        table = sql.split(" ", 4)[2].gsub('"', '')
+        sequence_name ||= default_sequence_name(table)
         id_value = select_one("select #{sequence_name}.nextval id from dual")['id'].to_i
-        log(sql, name) { 
+        log(sql, name) do
           @connection.execute_id_insert(sql,id_value)
-        }
+        end
       end
       id_value
     end
@@ -159,7 +150,7 @@ module ::JdbcSpec
     def indexes(table, name = nil)
       @connection.indexes(table, name, @connection.connection.meta_data.user_name)
     end
-    
+
     def _execute(sql, name = nil)
       case sql.strip
         when /\A\(?\s*(select|show)/i:
@@ -168,7 +159,7 @@ module ::JdbcSpec
           @connection.execute_update(sql)
         end
     end
-    
+
     def modify_types(tp)
       tp[:primary_key] = "NUMBER(38) NOT NULL PRIMARY KEY"
       tp[:integer] = { :name => "NUMBER", :limit => 38 }
@@ -181,7 +172,7 @@ module ::JdbcSpec
 
     def add_limit_offset!(sql, options) #:nodoc:
       offset = options[:offset] || 0
-      
+
       if limit = options[:limit]
         sql.replace "select * from (select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_ where rownum <= #{offset+limit}) where raw_rnum_ > #{offset}"
       elsif offset > 0
@@ -204,7 +195,7 @@ module ::JdbcSpec
     def add_column_options!(sql, options) #:nodoc:
       # handle case  of defaults for CLOB columns, which would otherwise get "quoted" incorrectly
       if options_include_default?(options) && (column = options[:column]) && column.type == :text
-        sql << " DEFAULT #{quote(options.delete(:default))}" 
+        sql << " DEFAULT #{quote(options.delete(:default))}"
       end
       super
     end
@@ -214,7 +205,7 @@ module ::JdbcSpec
       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 TABLE #{table_name} RENAME COLUMN #{column_name} to #{new_column_name}"
     end
@@ -229,24 +220,24 @@ module ::JdbcSpec
       end
 
       select_all("select table_name from user_tables").inject(s) do |structure, table|
-        ddl = "create table #{table.to_a.first.last} (\n "  
+        ddl = "create table #{table.to_a.first.last} (\n "
         cols = select_all(%Q{
               select column_name, data_type, data_length, data_precision, data_scale, data_default, nullable
               from user_tab_columns
               where table_name = '#{table.to_a.first.last}'
               order by column_id
             }).map do |row|
-          row = row.inject({}) do |h,args| 
+          row = row.inject({}) do |h,args|
             h[args[0].downcase] = args[1]
-            h 
+            h
           end
-          col = "#{row['column_name'].downcase} #{row['data_type'].downcase}"      
+          col = "#{row['column_name'].downcase} #{row['data_type'].downcase}"
           if row['data_type'] =='NUMBER' and !row['data_precision'].nil?
             col << "(#{row['data_precision'].to_i}"
             col << ",#{row['data_scale'].to_i}" if !row['data_scale'].nil?
             col << ')'
           elsif row['data_type'].include?('CHAR')
-            col << "(#{row['data_length'].to_i})"  
+            col << "(#{row['data_length'].to_i})"
           end
           col << " default #{row['data_default']}" if !row['data_default'].nil?
           col << ' not null' if row['nullable'] == 'N'
@@ -267,13 +258,13 @@ module ::JdbcSpec
         drop << "drop table #{table.to_a.first.last} cascade constraints;\n\n"
       end
     end
-    
+
     # SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.
     #
     # Oracle requires the ORDER BY columns to be in the SELECT list for DISTINCT
     # queries. However, with those columns included in the SELECT DISTINCT list, you
     # won't actually get a distinct list of the column you want (presuming the column
-    # has duplicates with multiple values for the ordered-by columns. So we use the 
+    # has duplicates with multiple values for the ordered-by columns. So we use the
     # FIRST_VALUE function to get a single (first) value for each column, effectively
     # making every row the same.
     #
@@ -292,7 +283,7 @@ module ::JdbcSpec
     end
 
     # ORDER BY clause for the passed order option.
-    # 
+    #
     # Uses column aliases as defined by #distinct.
     def add_order_by_for_association_limiting!(sql, options)
       return sql if options[:order].blank?
@@ -303,25 +294,34 @@ module ::JdbcSpec
 
       sql << "ORDER BY #{order}"
     end
-    
-    
+
+    def tables
+      @connection.tables(nil, oracle_schema)
+    end
+
+    def columns(table_name, name=nil)
+      @connection.columns_internal(table_name, name, oracle_schema)
+    end
+
     # QUOTING ==================================================
     #
     # see: abstract/quoting.rb
-    
-    # camelCase column names need to be quoted; not that anyone using Oracle
-    # would really do this, but handling this case means we pass the test...
+
+    # Camelcase column names need to be quoted.
+    # Nonquoted identifiers can contain only alphanumeric characters from your 
+    # database character set and the underscore (_), dollar sign ($), and pound sign (#).
+    # Database links can also contain periods (.) and "at" signs (@).
+    # Oracle strongly discourages you from using $ and # in nonquoted identifiers.
+    # Source: http://download.oracle.com/docs/cd/B28359_01/server.111/b28286/sql_elements008.htm
     def quote_column_name(name) #:nodoc:
-      name.to_s =~ /[A-Z]/ ? "\"#{name}\"" : name.to_s
+      name.to_s =~ /^[a-z_$#]+$/ ? name.to_s : "\"#{name}\""
     end
 
     def quote_string(string) #:nodoc:
       string.gsub(/'/, "''")
     end
-    
+
     def quote(value, column = nil) #:nodoc:
-      return value.quoted_id if value.respond_to?(:quoted_id)
-      
       if column && [:text, :binary].include?(column.type)
         if /(.*?)\([0-9]+\)/ =~ column.sql_type
           %Q{empty_#{ $1.downcase }()}
@@ -329,35 +329,33 @@ module ::JdbcSpec
           %Q{empty_#{ column.sql_type.downcase rescue 'blob' }()}
         end
       else
-        if column && column.type == :primary_key
-          return value.to_s
-        end
-        case value
-        when String, ActiveSupport::Multibyte::Chars
-          if column.type == :datetime
-            %Q{TIMESTAMP'#{value}'}
-          else
-            %Q{'#{quote_string(value)}'}
-          end
-        when NilClass   : 'null'
-        when TrueClass  : '1'
-        when FalseClass : '0'
-        when Numeric    : value.to_s
-        when Date, Time : %Q{TIMESTAMP'#{value.strftime("%Y-%m-%d %H:%M:%S")}'}
-        else              %Q{'#{quote_string(value.to_yaml)}'}
+        quoted = super
+        if value.acts_like?(:date) || value.acts_like?(:time)
+          quoted = "#{quoted_date(value)}"
         end
+        quoted
       end
     end
-    
+
+    def quoted_date(value)
+      %Q{TIMESTAMP'#{value.strftime("%Y-%m-%d %H:%M:%S")}'}
+    end
+
     def quoted_true #:nodoc:
       '1'
     end
-    
+
     def quoted_false #:nodoc:
       '0'
     end
-    
+
     private
+    # In Oracle, schemas are created under your username:
+    # http://www.oracle.com/technology/obe/2day_dba/schema/schema.htm
+    def oracle_schema
+      @config[:username].to_s
+    end
+
     def select(sql, name=nil)
       records = execute(sql,name)
       records.each do |col|