activerecord-jdbc-adapter 1.2.9.1 → 1.3.0.beta1

data/lib/arjdbc/postgresql/column_cast.rb

@@ -0,0 +1,136 @@
+module ArJdbc
+  module PostgreSQL
+    module Column
+      # based on active_record/connection_adapters/postgresql/cast.rb
+      module Cast
+        
+        def string_to_time(string)
+          return string unless String === string
+
+          case string
+          when 'infinity'; 1.0 / 0.0
+          when '-infinity'; -1.0 / 0.0
+          when / BC$/
+            super("-" + string.sub(/ BC$/, ""))
+          else
+            super
+          end
+        end
+
+        def hstore_to_string(object)
+          if Hash === object
+            object.map { |k,v|
+              "#{escape_hstore(k)}=>#{escape_hstore(v)}"
+            }.join ','
+          else
+            object
+          end
+        end
+
+        def string_to_hstore(string)
+          if string.nil?
+            nil
+          elsif String === string
+            Hash[string.scan(HstorePair).map { |k,v|
+              v = v.upcase == 'NULL' ? nil : v.gsub(/^"(.*)"$/,'\1').gsub(/\\(.)/, '\1')
+              k = k.gsub(/^"(.*)"$/,'\1').gsub(/\\(.)/, '\1')
+              [k,v]
+            }]
+          else
+            string
+          end
+        end
+
+        def json_to_string(object)
+          if Hash === object
+            ActiveSupport::JSON.encode(object)
+          else
+            object
+          end
+        end
+
+        def array_to_string(value, column, adapter, should_be_quoted = false)
+          casted_values = value.map do |val|
+            if String === val
+              if val == "NULL"
+                "\"#{val}\""
+              else
+                quote_and_escape(adapter.type_cast(val, column, true))
+              end
+            else
+              adapter.type_cast(val, column, true)
+            end
+          end
+          "{#{casted_values.join(',')}}"
+        end
+
+        def range_to_string(object)
+          from = object.begin.respond_to?(:infinite?) && object.begin.infinite? ? '' : object.begin
+          to   = object.end.respond_to?(:infinite?) && object.end.infinite? ? '' : object.end
+          "[#{from},#{to}#{object.exclude_end? ? ')' : ']'}"
+        end
+
+        def string_to_json(string)
+          if String === string
+            ActiveSupport::JSON.decode(string)
+          else
+            string
+          end
+        end
+
+        def string_to_cidr(string)
+          if string.nil?
+            nil
+          elsif String === string
+            IPAddr.new(string)
+          else
+            string
+          end
+        end
+
+        def cidr_to_string(object)
+          if IPAddr === object
+            "#{object.to_s}/#{object.instance_variable_get(:@mask_addr).to_s(2).count('1')}"
+          else
+            object
+          end
+        end
+
+        # NOTE: not used - we get "parsed" array value from connection
+        #def string_to_array(string, oid)
+        #  parse_pg_array(string).map { |val| oid.type_cast val }
+        #end
+
+        private
+
+          HstorePair = begin
+            quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
+            unquoted_string = /(?:\\.|[^\s,])[^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
+            /(#{quoted_string}|#{unquoted_string})\s*=>\s*(#{quoted_string}|#{unquoted_string})/
+          end
+
+          def escape_hstore(value)
+            if value.nil?
+              'NULL'
+            else
+              if value == ""
+                '""'
+              else
+                '"%s"' % value.to_s.gsub(/(["\\])/, '\\\\\1')
+              end
+            end
+          end
+
+          def quote_and_escape(value)
+            case value
+            when "NULL"
+              value
+            else
+              "\"#{value.gsub(/"/,"\\\"")}\""
+            end
+          end
+          
+      end
+    end
+  end
+end

data/lib/arjdbc/postgresql/connection_methods.rb

@@ -1,24 +1,22 @@
-class ActiveRecord::Base
-  class << self
-    def postgresql_connection(config)
-      begin
-        require 'jdbc/postgres'
-        ::Jdbc::Postgres.load_driver(:require) if defined?(::Jdbc::Postgres.load_driver)
-      rescue LoadError # assuming driver.jar is on the class-path
-      end
-
-      config[:username] ||= Java::JavaLang::System.get_property("user.name")
-      config[:host] ||= "localhost"
-      config[:port] ||= 5432
-      config[:url] ||= "jdbc:postgresql://#{config[:host]}:#{config[:port]}/#{config[:database]}"
-      config[:url] << config[:pg_params] if config[:pg_params]
-      config[:driver] ||= defined?(::Jdbc::Postgres.driver_name) ? ::Jdbc::Postgres.driver_name : 'org.postgresql.Driver'
-      config[:adapter_class] = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-      config[:adapter_spec] = ::ArJdbc::PostgreSQL
-      conn = jdbc_connection(config)
-      conn.execute("SET SEARCH_PATH TO #{config[:schema_search_path]}") if config[:schema_search_path]
-      conn
+ArJdbc::ConnectionMethods.module_eval do
+  def postgresql_connection(config)
+    begin
+      require 'jdbc/postgres'
+      ::Jdbc::Postgres.load_driver(:require) if defined?(::Jdbc::Postgres.load_driver)
+    rescue LoadError # assuming driver.jar is on the class-path
     end
-    alias_method :jdbcpostgresql_connection, :postgresql_connection
+
+    config[:username] ||= Java::JavaLang::System.get_property("user.name")
+    config[:host] ||= "localhost"
+    config[:port] ||= 5432
+    config[:url] ||= "jdbc:postgresql://#{config[:host]}:#{config[:port]}/#{config[:database]}"
+    config[:url] << config[:pg_params] if config[:pg_params]
+    config[:driver] ||= defined?(::Jdbc::Postgres.driver_name) ? ::Jdbc::Postgres.driver_name : 'org.postgresql.Driver'
+    config[:adapter_class] = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+    config[:adapter_spec] = ::ArJdbc::PostgreSQL
+    conn = jdbc_connection(config)
+    conn.execute("SET SEARCH_PATH TO #{config[:schema_search_path]}") if config[:schema_search_path]
+    conn
   end
+  alias_method :jdbcpostgresql_connection, :postgresql_connection
 end

data/lib/arjdbc/postgresql/explain_support.rb

@@ -1,4 +1,4 @@
-module ::ArJdbc
+module ArJdbc
   module PostgreSQL
     module ExplainSupport
       def supports_explain?
@@ -7,11 +7,8 @@ module ::ArJdbc
 
       def explain(arel, binds = [])
         sql = "EXPLAIN #{to_sql(arel, binds)}"
-        raw_result = execute(sql, "EXPLAIN", binds)
-        # TODO we should refactor to exce_query once it returns Result ASAP :
-        keys = raw_result[0] ? raw_result[0].keys : {}
-        rows = raw_result.map { |hash| hash.values }
-        ExplainPrettyPrinter.new.pp ActiveRecord::Result.new(keys, rows)
+        result = exec_query(sql, "EXPLAIN", binds)
+        ExplainPrettyPrinter.new.pp result # we can assume AR >= 3.1
       end
 
       class ExplainPrettyPrinter # :nodoc:

data/lib/arjdbc/railtie.rb

@@ -0,0 +1,9 @@
+require 'rails/railtie'
+
+module ArJdbc
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load File.expand_path('jdbc/rake_tasks.rb', File.dirname(__FILE__))
+    end
+  end
+end

data/lib/arjdbc/sqlite3.rb

@@ -1,3 +1,3 @@
-require 'arjdbc/jdbc'
+require 'arjdbc'
 require 'arjdbc/sqlite3/adapter'
 require 'arjdbc/sqlite3/connection_methods'

data/lib/arjdbc/sqlite3/adapter.rb

@@ -157,6 +157,30 @@ module ::ArJdbc
     def supports_index_sort_order? # :nodoc:
       sqlite_version >= '3.3.0'
     end
+
+    def supports_migrations? # :nodoc:
+      true
+    end
+
+    def supports_primary_key? # :nodoc:
+      true
+    end
+
+    def supports_add_column? # :nodoc:
+      true
+    end
+
+    def supports_count_distinct? # :nodoc:
+      true
+    end
+
+    def supports_autoincrement? # :nodoc:
+      true
+    end
+
+    def supports_index_sort_order? # :nodoc:
+      true
+    end
     
     def sqlite_version
       @sqlite_version ||= select_value('SELECT sqlite_version(*)')
@@ -197,9 +221,12 @@ module ::ArJdbc
     end
     
     def tables(name = nil, table_name = nil) # :nodoc:
-      sql = "SELECT name FROM sqlite_master " +
-      "WHERE type = 'table' AND NOT name = 'sqlite_sequence'"
-      sql << " AND name = #{quote_table_name(table_name)}" if table_name
+      sql = "SELECT name FROM sqlite_master WHERE type = 'table'"
+      if table_name
+        sql << " AND name = #{quote_table_name(table_name)}"
+      else
+        sql << " AND NOT name = 'sqlite_sequence'"
+      end
 
       select_rows(sql, name).map { |row| row[0] }
     end
@@ -223,6 +250,13 @@ module ::ArJdbc
         IndexDefinition.new(table_name, name, unique, columns)
       end
     end
+    
+    # Returns 62. SQLite supports index names up to 64
+    # characters. The rest is used by rails internally to perform
+    # temporary rename operations
+    def allowed_index_name_length
+      index_name_length - 2
+    end
 
     def create_savepoint
       execute("SAVEPOINT #{current_savepoint_name}")
@@ -239,49 +273,60 @@ module ::ArJdbc
     def recreate_database(name, options = {})
       tables.each { |table| drop_table(table) }
     end
-
+    
     def select(sql, name = nil, binds = [])
-      execute(sql, name, binds).map do |row|
-        record = {}
-        row.each_key do |key|
-          if key.is_a?(String)
-            record[key.sub(/^"?\w+"?\./, '')] = row[key]
+      result = super # AR::Result (4.0) or Array (<= 3.2)
+      if result.respond_to?(:columns) # 4.0
+        result.columns.map! do |key| # [ [ 'id', ... ]
+          key.is_a?(String) ? key.sub(/^"?\w+"?\./, '') : key
+        end
+      else
+        result.map! do |row| # [ { 'id' => ... }, {...} ]
+          record = {}
+          row.each_key do |key|
+            if key.is_a?(String)
+              record[key.sub(/^"?\w+"?\./, '')] = row[key]
+            end
           end
+          record
         end
-        record
       end
+      result
     end
 
+    # @override as <code>execute_insert</code> not implemented by SQLite JDBC
+    def exec_insert(sql, name, binds, pk = nil, sequence_name = nil) # :nodoc:
+      execute(sql, name, binds)
+    end
+    
     def table_structure(table_name)
       sql = "PRAGMA table_info(#{quote_table_name(table_name)})"
-      log(sql, 'SCHEMA') { @connection.execute_query(sql) }
+      log(sql, 'SCHEMA') { @connection.execute_query_raw(sql) }
     rescue ActiveRecord::JDBCError => error
       e = ActiveRecord::StatementInvalid.new("Could not find table '#{table_name}'")
       e.set_backtrace error.backtrace
       raise e
     end
 
-    def jdbc_columns(table_name, name = nil) #:nodoc:
+    def jdbc_columns(table_name, name = nil) # :nodoc:
+      klass = ::ActiveRecord::ConnectionAdapters::SQLite3Column
       table_structure(table_name).map do |field|
-        ::ActiveRecord::ConnectionAdapters::SQLite3Column.new(
-          @config, field['name'], field['dflt_value'], field['type'], field['notnull'] == 0
-        )
+        klass.new(field['name'], field['dflt_value'], field['type'], field['notnull'] == 0)
       end
     end
 
     def primary_key(table_name) #:nodoc:
-      column = table_structure(table_name).find { |field|
-        field['pk'].to_i == 1
-      }
+      column = table_structure(table_name).find { |field| field['pk'].to_i == 1 }
       column && column['name']
     end
 
-    def remove_index!(table_name, index_name) #:nodoc:
+    def remove_index!(table_name, index_name) # :nodoc:
       execute "DROP INDEX #{quote_column_name(index_name)}"
     end
 
-    def rename_table(name, new_name)
-      execute "ALTER TABLE #{quote_table_name(name)} RENAME TO #{quote_table_name(new_name)}"
+    def rename_table(table_name, new_name)
+      execute "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
+      rename_table_indexes(table_name, new_name) if respond_to?(:rename_table_indexes) # AR-4.0 SchemaStatements
     end
 
     # See: http://www.sqlite.org/lang_altertable.html
@@ -349,6 +394,7 @@ module ::ArJdbc
         raise ActiveRecord::ActiveRecordError, "Missing column #{table_name}.#{column_name}"
       end
       alter_table(table_name, :rename => {column_name.to_s => new_column_name.to_s})
+      rename_column_indexes(table_name, column_name, new_column_name) if respond_to?(:rename_column_indexes) # AR-4.0 SchemaStatements
     end
 
      # SELECT ... FOR UPDATE is redundant since the table is locked.
@@ -357,9 +403,13 @@ module ::ArJdbc
     end
 
     def empty_insert_statement_value
-      "VALUES(NULL)"
+      # inherited (default) on 3.2 : "VALUES(DEFAULT)"
+      # inherited (default) on 4.0 : "DEFAULT VALUES"
+      # re-defined in native adapter on 3.2 "VALUES(NULL)"
+      # on 4.0 no longer re-defined (thus inherits default)
+      "DEFAULT VALUES"
     end
-
+    
     protected
     
     include ArJdbc::MissingFunctionalityHelper
@@ -406,9 +456,6 @@ module ActiveRecord::ConnectionAdapters
       end
     end
 
-    def call_discovered_column_callbacks(*)
-    end
-
     def self.string_to_binary(value)
       value
     end

data/lib/arjdbc/sqlite3/connection_methods.rb

@@ -1,34 +1,33 @@
-class ActiveRecord::Base
-  class << self
-    def sqlite3_connection(config)
-      begin
-        require 'jdbc/sqlite3'
-        ::Jdbc::SQLite3.load_driver(:require) if defined?(::Jdbc::SQLite3.load_driver)
-      rescue LoadError # assuming driver.jar is on the class-path
-      end
-
-      parse_sqlite3_config!(config)
-      database = config[:database]
-      database = '' if database == ':memory:'
-      config[:url] ||= "jdbc:sqlite:#{database}"
-      config[:driver] ||= defined?(::Jdbc::SQLite3.driver_name) ? ::Jdbc::SQLite3.driver_name : 'org.sqlite.JDBC'
-      config[:adapter_class] = ActiveRecord::ConnectionAdapters::SQLite3Adapter
-      config[:adapter_spec] = ::ArJdbc::SQLite3
-      jdbc_connection(config)
+ArJdbc::ConnectionMethods.module_eval do
+  def sqlite3_connection(config)
+    begin
+      require 'jdbc/sqlite3'
+      ::Jdbc::SQLite3.load_driver(:require) if defined?(::Jdbc::SQLite3.load_driver)
+    rescue LoadError # assuming driver.jar is on the class-path
     end
-    alias_method :jdbcsqlite3_connection, :sqlite3_connection
 
-    def parse_sqlite3_config!(config)
-      config[:database] ||= config[:dbfile]
+    parse_sqlite3_config!(config)
+    database = config[:database]
+    database = '' if database == ':memory:'
+    config[:url] ||= "jdbc:sqlite:#{database}"
+    config[:driver] ||= defined?(::Jdbc::SQLite3.driver_name) ? ::Jdbc::SQLite3.driver_name : 'org.sqlite.JDBC'
+    config[:adapter_class] = ActiveRecord::ConnectionAdapters::SQLite3Adapter
+    config[:adapter_spec] = ::ArJdbc::SQLite3
+    jdbc_connection(config)
+  end
+  alias_method :jdbcsqlite3_connection, :sqlite3_connection
 
-      # 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.
-      rails_root_defined = defined?(Rails.root) || Object.const_defined?(:RAILS_ROOT)
-      if rails_root_defined && ':memory:' != config[:database]
-        rails_root = defined?(Rails.root) ? Rails.root : RAILS_ROOT
-        config[:database] = File.expand_path(config[:database], rails_root)
-      end
+  private
+  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.
+    rails_root_defined = defined?(Rails.root) || Object.const_defined?(:RAILS_ROOT)
+    if rails_root_defined && ':memory:' != config[:database]
+      rails_root = defined?(Rails.root) ? Rails.root : RAILS_ROOT
+      config[:database] = File.expand_path(config[:database], rails_root)
     end
   end
 end