activerecord-oracle_enhanced-adapter 1.3.1 → 1.3.2

data/lib/active_record/connection_adapters/oracle_enhanced_column.rb

@@ -2,12 +2,15 @@ module ActiveRecord
   module ConnectionAdapters #:nodoc:
     class OracleEnhancedColumn < Column
 
-      attr_reader :table_name, :forced_column_type #:nodoc:
+      attr_reader :table_name, :forced_column_type, :nchar #:nodoc:
       
       def initialize(name, default, sql_type = nil, null = true, table_name = nil, forced_column_type = nil) #:nodoc:
         @table_name = table_name
         @forced_column_type = forced_column_type
         super(name, default, sql_type, null)
+        # Is column NCHAR or NVARCHAR2 (will need to use N'...' value quoting for these data types)?
+        # Define only when needed as adapter "quote" method will check at first if instance variable is defined.
+        @nchar = true if @type == :string && sql_type[0,1] == 'N'
       end
 
       def type_cast(value) #:nodoc:
@@ -46,26 +49,39 @@ module ActiveRecord
       end
       
       private
+
       def simplified_type(field_type)
         forced_column_type ||
         case field_type
-          when /decimal|numeric|number/i
-            return :boolean if OracleEnhancedAdapter.emulate_booleans && field_type == 'NUMBER(1)'
-            return :integer if extract_scale(field_type) == 0
-            # if column name is ID or ends with _ID
-            return :integer if OracleEnhancedAdapter.emulate_integers_by_column_name && OracleEnhancedAdapter.is_integer_column?(name, table_name)
+        when /decimal|numeric|number/i
+          if OracleEnhancedAdapter.emulate_booleans && field_type == 'NUMBER(1)'
+            :boolean
+          elsif extract_scale(field_type) == 0 ||
+                # if column name is ID or ends with _ID
+                OracleEnhancedAdapter.emulate_integers_by_column_name && OracleEnhancedAdapter.is_integer_column?(name, table_name)
+            :integer
+          else
             :decimal
-          when /char/i
-            return :boolean if OracleEnhancedAdapter.emulate_booleans_from_strings &&
-                               OracleEnhancedAdapter.is_boolean_column?(name, field_type, table_name)
+          end
+        when /char/i
+          if OracleEnhancedAdapter.emulate_booleans_from_strings &&
+             OracleEnhancedAdapter.is_boolean_column?(name, field_type, table_name)
+            :boolean
+          else
             :string
-          when /date/i
-            forced_column_type ||
-            (:date if OracleEnhancedAdapter.emulate_dates_by_column_name && OracleEnhancedAdapter.is_date_column?(name, table_name)) ||
+          end
+        when /date/i
+          if OracleEnhancedAdapter.emulate_dates_by_column_name && OracleEnhancedAdapter.is_date_column?(name, table_name)
+            :date
+          else
             :datetime
-          when /timestamp/i then :timestamp
-          when /time/i then :datetime
-          else super
+          end
+        when /timestamp/i
+          :timestamp
+        when /time/i
+          :datetime
+        else
+          super
         end
       end
 

data/lib/active_record/connection_adapters/oracle_enhanced_connection.rb

@@ -77,8 +77,6 @@ module ActiveRecord
         end
       end
 
-      private
-      
       # Returns a record hash with the column names as keys and column values
       # as values.
       def select_one(sql)

data/lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb

@@ -49,12 +49,12 @@ module ActiveRecord
       # modified method to support JNDI connections
       def new_connection(config)
         username = nil
-  
+
         if config[:jndi]
           jndi = config[:jndi].to_s
           ctx = javax.naming.InitialContext.new
           ds = nil
-          
+
           # tomcat needs first lookup method, oc4j (and maybe other application servers) need second method
           begin
             env = ctx.lookup('java:/comp/env')
@@ -62,73 +62,90 @@ module ActiveRecord
           rescue
             ds = ctx.lookup(jndi)
           end
-  
+
           # check if datasource supports pooled connections, otherwise use default
           if ds.respond_to?(:pooled_connection)
             @raw_connection = ds.pooled_connection
           else
             @raw_connection = ds.connection
           end
-  
+
+          # get Oracle JDBC connection when using DBCP in Tomcat or jBoss
+          if @raw_connection.respond_to?(:getInnermostDelegate)
+            @pooled_connection = @raw_connection
+            @raw_connection = @raw_connection.innermost_delegate
+          elsif @raw_connection.respond_to?(:getUnderlyingConnection)
+            @pooled_connection = @raw_connection
+            @raw_connection = @raw_connection.underlying_connection            
+          end
+
           config[:driver] ||= @raw_connection.meta_data.connection.java_class.name
           username = @raw_connection.meta_data.user_name
         else
-          username, password, database = config[:username], config[:password], config[:database]
-          privilege = config[:privilege] && config[:privilege].to_s
+          # to_s needed if username, password or database is specified as number in database.yml file
+          username = config[:username] && config[:username].to_s
+          password = config[:password] && config[:password].to_s
+          database = config[:database] && config[:database].to_s
           host, port = config[:host], config[:port]
-  
+          privilege = config[:privilege] && config[:privilege].to_s
+
           # connection using TNS alias
           if database && !host && !config[:url] && ENV['TNS_ADMIN']
             url = "jdbc:oracle:thin:@#{database || 'XE'}"
           else
             url = config[:url] || "jdbc:oracle:thin:@#{host || 'localhost'}:#{port || 1521}:#{database || 'XE'}"
           end
-  
+
           prefetch_rows = config[:prefetch_rows] || 100
           # get session time_zone from configuration or from TZ environment variable
           time_zone = config[:time_zone] || ENV['TZ'] || java.util.TimeZone.default.getID
-  
+
           properties = java.util.Properties.new
           properties.put("user", username)
           properties.put("password", password)
           properties.put("defaultRowPrefetch", "#{prefetch_rows}") if prefetch_rows
           properties.put("internal_logon", privilege) if privilege
-      
+
           @raw_connection = java.sql.DriverManager.getConnection(url, properties)
-  
+
           # Set session time zone to current time zone
           @raw_connection.setSessionTimeZone(time_zone)
-  
+
           # Set default number of rows to prefetch
           # @raw_connection.setDefaultRowPrefetch(prefetch_rows) if prefetch_rows
         end
 
-        # by default VARCHAR2 column size will be interpreted as max number of characters (and not bytes)
-        nls_length_semantics = config[:nls_length_semantics] || 'CHAR'
         cursor_sharing = config[:cursor_sharing] || 'force'
-  
-        # from here it remaings common for both connections types
-        exec %q{alter session set nls_date_format = 'YYYY-MM-DD HH24:MI:SS'}
-        exec %q{alter session set nls_timestamp_format = 'YYYY-MM-DD HH24:MI:SS:FF6'}
         exec "alter session set cursor_sharing = #{cursor_sharing}"
-        exec "alter session set nls_length_semantics = '#{nls_length_semantics}'"
+
+        # Initialize NLS parameters
+        OracleEnhancedAdapter::DEFAULT_NLS_PARAMETERS.each do |key, default_value|
+          value = config[key] || ENV[key.to_s.upcase] || default_value
+          if value
+            exec "alter session set #{key} = '#{value}'"
+          end
+        end
+
         self.autocommit = true
-  
+
         # default schema owner
         @owner = username.upcase unless username.nil?
-        
+
         @raw_connection
       end
 
-      
       def logoff
         @active = false
-        @raw_connection.close
+        if defined?(@pooled_connection)
+          @pooled_connection.close
+        else
+          @raw_connection.close
+        end
         true
       rescue
         false
       end
-      
+
       def commit
         @raw_connection.commit
       end
@@ -159,7 +176,7 @@ module ActiveRecord
           raise
         end
       end
-      
+
       # Resets connection, by logging off and creating a new connection.
       def reset!
         logoff rescue nil
@@ -174,7 +191,7 @@ module ActiveRecord
             raise
           end
         end
-      end      
+      end
 
       # mark connection as dead if connection lost
       def with_retry(&block)
@@ -261,10 +278,100 @@ module ActiveRecord
         end
       end
 
+      def prepare(sql)
+        Cursor.new(self, @raw_connection.prepareStatement(sql))
+      end
+
+      class Cursor
+        def initialize(connection, raw_statement)
+          @connection = connection
+          @raw_statement = raw_statement
+        end
+
+        def bind_param(position, value)
+          java_value = ruby_to_java_value(value)
+          case value
+          when Integer
+            @raw_statement.setInt(position, java_value)
+          when Float
+            @raw_statement.setFloat(position, java_value)
+          when BigDecimal
+            @raw_statement.setBigDecimal(position, java_value)
+          when String
+            @raw_statement.setString(position, java_value)
+          when Date, DateTime
+            @raw_statement.setDATE(position, java_value)
+          when Time
+            @raw_statement.setTimestamp(position, java_value)
+          when NilClass
+            # TODO: currently nil is always bound as NULL with VARCHAR type.
+            # When nils will actually be used by ActiveRecord as bound parameters
+            # then need to pass actual column type.
+            @raw_statement.setNull(position, java.sql.Types::VARCHAR)
+          else
+            raise ArgumentError, "Don't know how to bind variable with type #{value.class}"
+          end
+        end
+
+        def exec
+          @raw_result_set = @raw_statement.executeQuery
+          get_metadata
+          true
+        end
+
+        def get_metadata
+          metadata = @raw_result_set.getMetaData
+          column_count = metadata.getColumnCount
+          @column_names = (1..column_count).map{|i| metadata.getColumnName(i)}
+          @column_types = (1..column_count).map{|i| metadata.getColumnTypeName(i).to_sym}
+        end
+
+        def get_col_names
+          @column_names
+        end
+
+        def fetch(options={})
+          if @raw_result_set.next
+            get_lob_value = options[:get_lob_value]
+            row_values = []
+            @column_types.each_with_index do |column_type, i|
+              row_values <<
+                @connection.get_ruby_value_from_result_set(@raw_result_set, i+1, column_type, get_lob_value)
+            end
+            row_values
+          else
+            @raw_result_set.close
+            nil
+          end
+        end
+
+        def close
+          @raw_statement.close
+        end
+
+        private
+
+        def ruby_to_java_value(value)
+          case value
+          when Fixnum, String, Float
+            value
+          when BigDecimal
+            java.math.BigDecimal.new(value.to_s)
+          when Date, DateTime
+            Java::oracle.sql.DATE.new(value.strftime("%Y-%m-%d %H:%M:%S"))
+          when Time
+            Java::java.sql.Timestamp.new(value.year-1900, value.month-1, value.day, value.hour, value.min, value.sec, value.usec * 1000)
+          else
+            value
+          end
+        end
+
+      end
+
       def select(sql, name = nil, return_column_names = false)
         with_retry do
           select_no_retry(sql, name, return_column_names)
-        end        
+        end
       end
 
       def select_no_retry(sql, name = nil, return_column_names = false)
@@ -276,7 +383,7 @@ module ActiveRecord
 
         metadata = rset.getMetaData
         column_count = metadata.getColumnCount
-        
+
         cols_types_index = (1..column_count).map do |i|
           col_name = oracle_downcase(metadata.getColumnName(i))
           next if col_name == 'raw_rnum_'
@@ -287,7 +394,7 @@ module ActiveRecord
 
         rows = []
         get_lob_value = !(name == 'Writable Large Object')
-        
+
         while rset.next
           hash = column_hash.dup
           cols_types_index.each do |col, column_type, i|
@@ -312,31 +419,17 @@ module ActiveRecord
 
       # Return NativeException / java.sql.SQLException error code
       def error_code(exception)
-        exception.cause.getErrorCode
+        case exception
+        when NativeException
+          exception.cause.getErrorCode
+        else
+          nil
+        end
       end
 
-      private
-
-      # def prepare_statement(sql)
-      #   @raw_connection.prepareStatement(sql)
-      # end
-
-      # def prepare_call(sql, *bindvars)
-      #   @raw_connection.prepareCall(sql)
-      # end
-
       def get_ruby_value_from_result_set(rset, i, type_name, get_lob_value = true)
         case type_name
         when :NUMBER
-          # d = rset.getBigDecimal(i)
-          # if d.nil?
-          #   nil
-          # elsif d.scale == 0
-          #   d.toBigInteger+0
-          # else
-          #   # Is there better way how to convert Java BigDecimal to Ruby BigDecimal?
-          #   d.toString.to_d
-          # end
           d = rset.getNUMBER(i)
           if d.nil?
             nil
@@ -371,7 +464,9 @@ module ActiveRecord
           nil
         end
       end
-      
+
+      private
+
       def lob_to_ruby_value(val)
         case val
         when ::Java::OracleSql::CLOB
@@ -390,6 +485,6 @@ module ActiveRecord
       end
 
     end
-    
+
   end
 end

data/lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb

@@ -77,7 +77,7 @@ module ActiveRecord
       def exec(sql, *bindvars, &block)
         @raw_connection.exec(sql, *bindvars, &block)
       end
-      
+
       def returning_clause(quoted_pk)
         " RETURNING #{quoted_pk} INTO :insert_id"
       end
@@ -93,6 +93,42 @@ module ActiveRecord
         cursor.close rescue nil
       end
 
+      def prepare(sql)
+        Cursor.new(self, @raw_connection.parse(sql))
+      end
+
+      class Cursor
+        def initialize(connection, raw_cursor)
+          @connection = connection
+          @raw_cursor = raw_cursor
+        end
+
+        def bind_param(position, value)
+          @raw_cursor.bind_param(position, value)
+        end
+
+        def exec
+          @raw_cursor.exec
+        end
+
+        def get_col_names
+          @raw_cursor.get_col_names
+        end
+
+        def fetch(options={})
+          if row = @raw_cursor.fetch
+            get_lob_value = options[:get_lob_value]
+            row.map do |col|
+              @connection.typecast_result_value(col, get_lob_value)
+            end
+          end
+        end
+
+        def close
+          @raw_cursor.close
+        end
+      end
+
       def select(sql, name = nil, return_column_names = false)
         cursor = @raw_connection.exec(sql)
         cols = []
@@ -146,8 +182,6 @@ module ActiveRecord
         end
       end
 
-      private
-
       def typecast_result_value(value, get_lob_value)
         case value
         when Fixnum, Bignum
@@ -181,7 +215,9 @@ module ActiveRecord
           value
         end
       end
-      
+
+      private
+
       def date_without_time?(value)
         case value
         when OraDate
@@ -215,41 +251,44 @@ module ActiveRecord
     # configure an Oracle/OCI connection.
     class OracleEnhancedOCIFactory #:nodoc:
       def self.new_connection(config)
-        username, password, database = config[:username], config[:password], config[:database]
+        # to_s needed if username, password or database is specified as number in database.yml file
+        username = config[:username] && config[:username].to_s
+        password = config[:password] && config[:password].to_s
+        database = config[:database] && config[:database].to_s
         host, port = config[:host], config[:port]
         privilege = config[:privilege] && config[:privilege].to_sym
         async = config[:allow_concurrency]
         prefetch_rows = config[:prefetch_rows] || 100
         cursor_sharing = config[:cursor_sharing] || 'force'
-        # by default VARCHAR2 column size will be interpreted as max number of characters (and not bytes)
-        nls_length_semantics = config[:nls_length_semantics] || 'CHAR'
         # get session time_zone from configuration or from TZ environment variable
         time_zone = config[:time_zone] || ENV['TZ']
 
-
-        # connection using TNS alias
-        connection_string = if database && !host && ENV['TNS_ADMIN']
-          database
-        # database parameter includes host or TNS connection string
-        elsif database =~ %r{[/(]}
-          database
         # connection using host, port and database name
-        else
+        connection_string = if host || port
           host ||= 'localhost'
           host = "[#{host}]" if host =~ /^[^\[].*:/  # IPv6
           port ||= 1521
           "//#{host}:#{port}/#{database}"
+        # if no host is specified then assume that
+        # database parameter is TNS alias or TNS connection string
+        else
+          database
         end
 
         conn = OCI8.new username, password, connection_string, privilege
-        conn.exec %q{alter session set nls_date_format = 'YYYY-MM-DD HH24:MI:SS'}
-        conn.exec %q{alter session set nls_timestamp_format = 'YYYY-MM-DD HH24:MI:SS:FF6'} rescue nil
         conn.autocommit = true
         conn.non_blocking = true if async
         conn.prefetch_rows = prefetch_rows
         conn.exec "alter session set cursor_sharing = #{cursor_sharing}" rescue nil
-        conn.exec "alter session set nls_length_semantics = '#{nls_length_semantics}'"
         conn.exec "alter session set time_zone = '#{time_zone}'" unless time_zone.blank?
+
+        # Initialize NLS parameters
+        OracleEnhancedAdapter::DEFAULT_NLS_PARAMETERS.each do |key, default_value|
+          value = config[key] || ENV[key.to_s.upcase] || default_value
+          if value
+            conn.exec "alter session set #{key} = '#{value}'"
+          end
+        end
         conn
       end
     end