spiderfw 0.5.11 → 0.5.12

data/CHANGELOG

@@ -1,3 +1,7 @@
+= 0.5.12
+== 17 June, 2010
+* JRuby support, Oracle JDBC connector
+
 = 0.5.11
 === 15 June, 2010
 * Many bugfixes

data/VERSION

@@ -1 +1 @@
-0.5.11
+0.5.12

data/lib/spiderfw/cmd/cmd.rb

@@ -61,7 +61,6 @@ module Spider; module CommandLine
                 end
             end
             cmd_name ||= 'help'
-            require 'ruby-debug'
             if !@cmd.main_command.commands[cmd_name]
                 require 'spiderfw'
                 if Spider.apps_by_short_name[cmd_name] && Spider.apps_by_short_name[cmd_name].const_defined?(:Cmd)

data/lib/spiderfw/model/storage/db/adapters/{oci8.rb → oracle.rb}

@@ -1,9 +1,8 @@
 require 'spiderfw/model/storage/db/db_storage'
-require 'oci8'
 
 module Spider; module Model; module Storage; module Db
     
-    class OCI8 < DbStorage
+    class Oracle < DbStorage
         @capabilities = {
             :autoincrement => false,
             :sequences => true,
@@ -22,36 +21,7 @@ module Spider; module Model; module Storage; module Db
             super << Spider::DataTypes::Binary
         end
         
-        def self.new_connection(user, pass, dbname, role)
-            conn ||= ::OCI8.new(user, pass, dbname, role)
-            conn.autocommit = true
-            conn.non_blocking = true
-            return conn
-        end
-        
-        def self.disconnect(conn)
-            conn.logoff
-        end
-        
-        def self.connection_alive?(conn)
-            # TODO: move to ping method when ruby-oci8 2.x is stable
-            begin
-                conn.autocommit?
-                return true
-            rescue
-                return false
-            end
-        end
-        
-        def release
-            begin
-                curr[:conn].autocommit = true if curr[:conn]
-                super
-            rescue
-                self.class.remove_connection(curr[:conn], @connection_params)
-                curr[:conn] = nil
-            end
-        end
+
         
         def parse_url(url)
             # db:oracle://<username:password>:connect_role@<database>
@@ -64,46 +34,12 @@ module Spider; module Model; module Storage; module Db
                 @role = $3
                 @dbname = $4
             else
-                raise ArgumentError, "OCI8 url '#{url}' is invalid"
+                raise ArgumentError, "Oracle url '#{url}' is invalid"
             end
             @connection_params = [@user, @pass, @dbname, @role]
         end
         
 
-        def do_start_transaction
-            return unless transactions_enabled?
-            connection.autocommit = false
-        end
-        
-        def in_transaction?
-            return false unless transactions_enabled?
-            return curr[:conn] && !curr[:conn].autocommit?
-        end
-        
-        def do_commit
-            return release unless transactions_enabled?
-            curr[:conn].commit if curr[:conn]
-            release
-        end
-        
-        def do_rollback
-            return release unless transactions_enabled?
-            curr[:conn].rollback
-            release
-        end
-        
-        def prepare_value(type, value)
-            value = super
-            if (type < Spider::Model::BaseModel)
-                type = type.primary_keys[0].type
-            end
-            return OCI8NilValue.new(Spider::Model.ruby_type(type)) if (value == nil)
-            case type.name
-            when 'Spider::DataTypes::Binary'
-                return OCI8::BLOB.new(curr[:conn], value)
-            end
-            return value
-        end
         
         def value_for_condition(type, value)
             return value if value.nil?
@@ -125,83 +61,7 @@ module Spider; module Model; module Storage; module Db
             return super(type, value)
         end
 
-         def execute(sql, *bind_vars)
-             begin
-                 if (bind_vars && bind_vars.length > 0)
-                     debug_vars = bind_vars.map{|var| var = var.to_s; var && var.length > 50 ? var[0..50]+"...(#{var.length-50} chars more)" : var}
-                 end
-                 curr[:last_executed] = [sql, bind_vars]
-                 if (Spider.conf.get('storage.db.replace_debug_vars'))
-                     debug("oci8 #{connection} executing: "+sql.gsub(/:(\d+)/){
-                         i = $1.to_i
-                         v = bind_vars[i-1]
-                         dv = debug_vars[i-1]
-                         v.is_a?(String) ? "'#{dv}'" : dv
-                     })
-                 else
-                     debug_vars_str = debug_vars ? debug_vars.join(', ') : ''
-                     debug("oci8 #{connection} executing:\n#{sql}\n[#{debug_vars_str}]")
-                 end
-                 cursor = connection.parse(sql)
-                 return cursor if (!cursor || cursor.is_a?(Fixnum))
-                 bind_vars.each_index do |i|
-                     var = bind_vars[i]
-                     if (var.is_a?(OCI8NilValue))
-                         cursor.bind_param(i+1, nil, var.type, 0)
-                     else
-                         cursor.bind_param(i+1, var)
-                     end
-                 end
-                 res = cursor.exec
-                 have_result = (cursor.type == ::OCI8::STMT_SELECT)
-                 # @cursor = connection.exec(sql, *bind_vars)
-                 if (have_result)
-                     result = []
-                     while (h = cursor.fetch_hash)
-                         h.each do |key, val|
-                             if val.respond_to?(:read)
-                                 h[key] = val.read
-                             end
-                         end
-                         if block_given?
-                             yield h
-                         else
-                             result << h
-                         end
-                     end
-                 end
-                 if (have_result)
-                     unless block_given?
-                         result.extend(StorageResult)
-                         curr[:last_result] = result
-                         return result
-                     end
-                 else
-                     return res
-                 end
-                 cursor.close
-
-             rescue => exc
-                 curr[:conn].break if curr[:conn]
-                 rollback! if in_transaction?
-                 #curr[:conn].logoff
-                 release
-                 raise
-             ensure
-                 cursor.close if cursor
-                 release if curr[:conn] && !in_transaction?
-             end
-         end
-         
-
-         def prepare(sql)
-             debug("oci8 preparing: #{sql}")
-             return connection.parse(sql)
-         end
 
-         def execute_statement(stmt, *bind_vars)
-             stmt.exec(bind_vars)
-         end
          
          def total_rows
              return nil unless curr[:last_executed]
@@ -251,9 +111,8 @@ module Spider; module Model; module Storage; module Db
              # Spider::Logger.debug("SQL SELECT:")
              # Spider::Logger.debug(query)
              bind_vars = query[:bind_vars] || []
-             order_on_different_table = false
+             query[:order_replacements] ||= {}
              if query[:limit] # Oracle is so braindead
-                 replaced_fields = {}
                  replace_cnt = 0
                  # add first field to order if none is found; order is needed for limit
                  query[:order] << [query[:keys][0], 'desc'] if query[:order].length < 1
@@ -265,15 +124,18 @@ module Spider; module Model; module Storage; module Db
                      #       i = query[:keys].length < 1
                      #   end
                      transformed = "O#{replace_cnt += 1}"
-                     replaced_fields[field.to_s] = transformed
-                     order_on_different_table = true if field.is_a?(Spider::Model::Storage::Db::Field) && !query[:tables].include?(field.table)
+                     query[:order_replacements][field.to_s] = transformed
+                     if field.is_a?(Spider::Model::Storage::Db::Field) && !query[:tables].include?(field.table)
+                         query[:order_on_different_table] = true 
+                     end
                      if field.is_a?(FieldFunction)
-                         order_on_different_table = true if field.joins.length > 0
+                         query[:order_on_different_table] = true if field.joins.length > 0
                      end
                      if (field.is_a?(Spider::Model::Storage::Db::Field) && field.type == 'CLOB')
                          field = "CAST(#{field} as varchar2(100))"
                      end
-                     query[:keys] << "#{field} AS #{transformed}"
+                     
+                     query[:keys] << Db::FieldExpression.new(field.table, transformed, field.type, :expression => "#{field}")
                  end
              end
              keys = sql_keys(query)
@@ -284,7 +146,7 @@ module Spider; module Model; module Storage; module Db
              where, vals = sql_condition(query)
              bind_vars += vals
              sql += "WHERE #{where} " if where && !where.empty?
-             order = sql_order(query, replaced_fields)
+             order = sql_order(query, query[:order_replacements])
              if (query[:limit] || query[:query_type] == :count)
                  limit = nil
                  if (query[:offset])
@@ -296,7 +158,7 @@ module Spider; module Model; module Storage; module Db
                      bind_vars << query[:limit] + 1
                  end
                  if (!query[:joins].empty?)
-                     data_tables_sql = order_on_different_table ? tables_sql : query[:tables].join(', ')
+                     data_tables_sql = query[:order_on_different_table] ? tables_sql : query[:tables].join(', ')
                      pk_sql = query[:primary_keys].join(', ')
                      distinct_sql = "SELECT DISTINCT #{pk_sql} FROM #{tables_sql}"
                      distinct_sql += " WHERE #{where}" if where && !where.empty?
@@ -406,31 +268,20 @@ module Spider; module Model; module Storage; module Db
          end
 
          def describe_table(table)
-             columns = {}
              primary_keys = []
              o_foreign_keys = {}
+             columns = {}
              connection do |conn|
-                 t = conn.describe_table(table)
-                 t.columns.each do |c|
-                     col = {
-                         :type => c.data_type.to_s.upcase,
-                         :length => c.data_size,
-                         :precision => c.precision,
-                         :scale => c.scale,
-                         :null => c.nullable?
-                     }
-                     col.delete(:length) if (col[:precision])
-                     columns[c.name] = col
-                 end
-                 res = conn.exec("SELECT cols.table_name, cols.COLUMN_NAME, cols.position, cons.status, cons.owner
+                 columns = do_describe_table(conn, table)
+                 res = execute("SELECT cols.table_name, cols.COLUMN_NAME, cols.position, cons.status, cons.owner
                  FROM user_constraints cons, user_cons_columns cols
                  WHERE cons.constraint_type = 'P'
                  AND cons.constraint_name = cols.constraint_name
                  AND cols.table_name = '#{table}'")
-                 while h = res.fetch_hash
+                 res.each do |h|
                      primary_keys << h['COLUMN_NAME']
                  end
-                 res = conn.exec("SELECT cons.constraint_name as CONSTRAINT_NAME, cols.column_name as REFERENCED_COLUMN,
+                 res = execute("SELECT cons.constraint_name as CONSTRAINT_NAME, cols.column_name as REFERENCED_COLUMN,
                  cols.table_name as REFERENCED_TABLE, cons.column_name as COLUMN_NAME
                  FROM user_tab_columns col
                      join user_cons_columns cons
@@ -443,7 +294,7 @@ module Spider; module Model; module Storage; module Db
                       and cons.position = cols.position
                  WHERE cc.constraint_type = 'R'
                  AND cons.table_name = '#{table}'")
-                 while h = res.fetch_hash
+                 res.each do |h|
                      fk_name = h['CONSTRAINT_NAME']
                      o_foreign_keys[fk_name] ||= {:table => h['REFERENCED_TABLE'], :columns => {}}
                      o_foreign_keys[fk_name][:columns][h['COLUMN_NAME']] = h['REFERENCED_COLUMN']
@@ -457,17 +308,6 @@ module Spider; module Model; module Storage; module Db
 
          end
 
-         def table_exists?(table)
-             begin
-                 connection do |c|
-                     c.describe_table(table)
-                 end
-                 Spider.logger.debug("TABLE EXISTS #{table}")
-                 return true
-             rescue OCIError
-                 return false
-             end
-         end
          
          # Schema methods
          
@@ -535,28 +375,32 @@ module Spider; module Model; module Storage; module Db
              return true
          end
          
+         class OracleNilValue
+             attr_accessor :type
+
+             def initialize(type)
+                 @type = type
+                 @type = Fixnum if @type == TrueClass || @type == FalseClass
+             end
+
+             def to_s
+                 'NULL'
+             end
+
+         end
+         
         
     end
     
-    class OCI8NilValue
-        attr_accessor :type
-        
-        def initialize(type)
-            @type = type
-            @type = Fixnum if @type == TrueClass || @type == FalseClass
-        end
-        
-        def to_s
-            'NULL'
-        end
-        
-    end
+
+    
+
     
     ###############################
     #   Exceptions                #
     ###############################
     
-    class OCI8Exception < RuntimeError
+    class OracleException < RuntimeError
     end
     
 end; end; end; end

data/lib/spiderfw/model/storage/db/connectors/jdbc.rb

@@ -0,0 +1,32 @@
+module Spider; module Model; module Storage; module Db; module Connectors
+
+    module JDBC
+        Mutex = java.lang.Object.new
+        DriverManager = java.sql.DriverManager
+        Statement = java.sql.Statement
+        Types = java.sql.Types
+
+        
+        def self.driver_class(name)
+            driver_class ||= begin
+                driver_class_const = (name[0...1].capitalize + name[1..name.length]).gsub(/\./, '_')
+                JDBC::Mutex.synchronized do
+                    unless JDBC.const_defined?(driver_class_const)
+                        driver_class_name = name
+                        JDBC.module_eval do
+                            include_class(driver_class_name) { driver_class_const }
+                        end
+                    end
+                end
+                JDBC.const_get(driver_class_const)
+            end
+            JDBC::DriverManager.registerDriver(driver_class)
+            @driver_classes ||= {}
+            @driver_classes[name] = driver_class
+            driver_class
+        end
+        
+    end
+
+
+end; end; end; end; end

data/lib/spiderfw/model/storage/db/connectors/jdbc_oracle.rb

@@ -0,0 +1,347 @@
+require 'spiderfw/model/storage/db/connectors/jdbc'
+
+module Spider; module Model; module Storage; module Db; module Connectors
+
+    module JDBCOracle
+        include Connectors::JDBC
+        
+        def self.included(klass)
+            klass.extend(ClassMethods)
+        end
+        
+        RUBY_CLASS_TO_SQL_TYPE = {
+          Fixnum => java.sql.Types::INTEGER,
+          Bignum => java.sql.Types::INTEGER,
+          Integer => java.sql.Types::INTEGER,
+          Float => java.sql.Types::FLOAT,
+          BigDecimal => java.sql.Types::NUMERIC,
+          String => java.sql.Types::VARCHAR,
+          Java::OracleSql::CLOB => Java::oracle.jdbc.OracleTypes::CLOB,
+          Java::OracleSql::BLOB => Java::oracle.jdbc.OracleTypes::BLOB,
+          Date => java.sql.Types::DATE,
+          Time => java.sql.Types::TIMESTAMP,
+          DateTime => java.sql.Types::DATE,
+          Java::OracleSql::ARRAY => Java::oracle.jdbc.OracleTypes::ARRAY,
+          Array => Java::oracle.jdbc.OracleTypes::ARRAY,
+          Java::OracleSql::STRUCT => Java::oracle.jdbc.OracleTypes::STRUCT,
+          Hash => Java::oracle.jdbc.OracleTypes::STRUCT,
+          java.sql.ResultSet => Java::oracle.jdbc.OracleTypes::CURSOR,
+        }
+        
+        module ClassMethods
+        
+            def new_connection(user, pass, dbname, role)
+                driver = Connectors::JDBC.driver_class('oracle.jdbc.driver.OracleDriver')
+                host = nil; port = nil; sid = nil
+                if dbname =~ /(.+)(?::(\d+))?\/(.+)/
+                    host = $1
+                    port = $2
+                    sid = $3
+                else
+                    raise ArgumentError, "Oracle db name must be in the host:port/SID form"
+                end
+                port ||= 1521
+                url = "jdbc:oracle:thin:@#{host}:#{port}:#{sid}"
+                conn = begin
+                    Jdbc::DriverManager.getConnection(url, user, pass)
+                rescue => exc
+                    # bypass DriverManager to get around problem with dynamically loaded jdbc drivers
+                    props = java.util.Properties.new
+                    props.setProperty("user", user)
+                    props.setProperty("password", pass)
+                    driver.new.connect(url, props)
+                end
+                conn.setAutoCommit(true)
+                return conn
+            end
+        
+            def connection_alive?(conn)
+                conn.pingDatabase()
+            end
+            
+        end
+        
+        def release
+            begin
+                curr[:conn].setAutoCommit(true) if curr[:conn]
+                super
+            rescue
+                self.class.remove_connection(curr[:conn], @connection_params)
+                curr[:conn] = nil
+            end
+        end
+        
+        def do_start_transaction
+            return unless transactions_enabled?
+            connection.setAutoCommit(false)
+        end
+        
+        def in_transaction?
+            return false unless transactions_enabled?
+            return curr[:conn] && !curr[:conn].getAutoCommit()
+        end
+        
+        def do_commit
+            return release unless transactions_enabled?
+            curr[:conn].commit if curr[:conn]
+            release
+        end
+        
+        def do_rollback
+            return release unless transactions_enabled?
+            curr[:conn].rollback
+            release
+        end
+        
+        def value_to_mapper(type, value)
+            return value if value.nil?
+            case type.name
+            when 'Time', 'Date', 'DateTime'
+                return nil unless value
+                d = value.dateValue
+                t = value.timeValue
+                value = Time.local(d.year + 1900, d.month + 1, d.date, t.hours, t.minutes, t.seconds)
+                return value.to_datetime if type == DateTime
+                return value.to_date
+            when 'Spider::DataTypes::Text'
+                if value.isEmptyLob
+                    value = nil
+                else
+                    value = value.getSubString(1, value.length)
+                end
+            when 'Spider::DataTypes::Binary'
+                if value.isEmptyLob
+                    nil
+                else
+                    String.from_java_bytes(value.getBytes(1, value.length))
+                end
+            when 'Spider::DataTypes::Decimal', 'BigDecimal'
+                value = value.to_s
+            end
+            return super(type, value)
+        end
+        
+        def prepare_value(type, value)
+            return Oracle::OracleNilValue.new(Spider::Model.ruby_type(type)) if (value == nil)
+            case type.name
+            when 'Spider::DataTypes::Decimal', 'BigDecimal'
+                java_bigdecimal(value)
+            when 'Spider::DataTypes::Bool'
+                value ? 1 : 0
+            when 'Date', 'DateTime'
+                java_date(value)
+            when 'Time'
+                java_timestamp(value)
+            when 'Spider::DataTypes::Text'
+                if value
+                    clob = Java::OracleSql::CLOB.createTemporary(connection, false, Java::OracleSql::CLOB::DURATION_SESSION)
+                    clob.setString(1, value)
+                    clob
+                else
+                    Java::OracleSql::CLOB.getEmptyCLOB
+                end
+            when 'Spider::DataTypes::Binary'
+                if value
+                    blob = Java::OracleSql::BLOB.createTemporary(connection, false, Java::OracleSql::BLOB::DURATION_SESSION)
+                    blob.setBytes(1, value.to_java_bytes)
+                    blob
+                else
+                    Java::OracleSql::BLOB.getEmptyBLOB
+                end
+            else
+                super(type, value)
+            end
+        end
+        
+        
+        def set_bind_variable(stmt, i, val)
+            method = nil
+            if val.is_a?(Oracle::OracleNilValue)
+                type = RUBY_CLASS_TO_SQL_TYPE[val.type] || java.sql.Types::VARCHAR
+                return stmt.setNull(i, type)
+            else
+                method = case val.class.name
+                when 'Fixnum', 'Float'
+                    :setInt
+                when 'Java::JavaMath::BigDecimal'
+                    :setBigDecimal
+                when 'String'
+                    :setString
+                when 'Java::OracleSql::CLOB'
+                    :setClob
+                when 'Java::OracleSql::BLOB'
+                    :setBlob
+                when 'Java::OracleSql::DATE'
+                    :setDATE
+                when 'Java::OracleSql::Timestamp'
+                    :setTimestamp
+                end
+            end
+            raise "Can't find how to bind variable #{val}" unless method
+            stmt.send(method, i, val)
+        end
+        
+        def value_from_resultset(res, i, type)
+            method = case type
+            when :INTEGER, :SMALLINT, :TINYING, :BIGINTEGER, :NUMBER, :NUMERIC
+                :getInt
+            when :FLOAT, :REAL
+                :getFloat
+            when :DECIMAL
+                :getBigDecimal
+            when :VARCHAR, :VARCHAR2, :LONGVARCHAR, :NCHAR, :CHAR
+                :getString
+            when :CLOB
+                :getClob
+            when :DATE, :TIME
+                :getDATE
+            when :TIMESTAMP
+                :getTimestamp
+            else
+                raise "Don't know how to convert Oracle value of type #{type}"
+            end
+            res.send(method, i)
+        end
+        
+        
+        def execute(sql, *bind_vars)
+            begin
+                if (bind_vars && bind_vars.length > 0)
+                    debug_vars = bind_vars.map{|var| var = var.to_s; var && var.length > 50 ? var[0..50]+"...(#{var.length-50} chars more)" : var}
+                end
+                curr[:last_executed] = [sql, bind_vars]
+                if (Spider.conf.get('storage.db.replace_debug_vars'))
+                    debug("oci8 #{connection} executing: "+sql.gsub(/:(\d+)/){
+                        i = $1.to_i
+                        v = bind_vars[i-1]
+                        dv = debug_vars[i-1]
+                        v.is_a?(String) ? "'#{dv}'" : dv
+                    })
+                else
+                    debug_vars_str = debug_vars ? debug_vars.join(', ') : ''
+                    debug("oci8 #{connection} executing:\n#{sql}\n[#{debug_vars_str}]")
+                end
+                query = curr[:last_query]
+                stmt = connection.prepareStatement(sql)
+                return unless stmt
+                bind_vars.each_index do |i|
+                    set_bind_variable(stmt, i+1, bind_vars[i])
+                end
+                res = nil
+                if stmt.execute() # false means this is an update query
+                    res = stmt.getResultSet()
+                end
+                if (res)
+                    result = []
+                    metadata = res.getMetaData
+                    column_count = metadata.getColumnCount
+                    column_names = []
+                    column_types = []
+                    1.upto(column_count) do |i|
+                        column_names[i] = metadata.getColumnName(i)
+                        column_types[i] = metadata.getColumnTypeName(i).to_sym
+                    end
+                    
+                    while res.next()
+                        h = {}
+                        1.upto(column_count) do |i|
+                            h[column_names[i]] = value_from_resultset(res, i, column_types[i])
+                        end
+                        if block_given?
+                            yield h
+                        else
+                            result << h
+                        end
+                    end
+                    res.close
+                end
+                if (res)
+                    unless block_given?
+                        result.extend(StorageResult)
+                        curr[:last_result] = result
+                        return result
+                    end
+                else
+                    return res
+                end
+                stmt.close
+            rescue => exc
+                stmt.cancel if stmt
+                # curr[:conn].break if curr[:conn]
+                rollback! if in_transaction?
+                #curr[:conn].logoff
+                release
+                raise
+            ensure
+                stmt.close if stmt
+                release if curr[:conn] && !in_transaction?
+            end
+        end
+        
+
+        def prepare(sql)
+            debug("oci8 preparing: #{sql}")
+            return connection.prepareStatement(sql)
+        end
+
+        def execute_statement(stmt, *bind_vars)
+            bind_vars.each_index do |i|
+                set_bind_variable(stmt, i+1, bind_vars[i])
+            end
+            stmt.execute()
+        end
+        
+
+        def table_exists?(table)
+            connection do |c|
+                res = get_table_metadata(c, table)
+                while res.next()
+                    return true
+                end
+                return false
+            end
+        end
+
+        def do_describe_table(conn, table)
+            md = get_db_metadata(conn)
+            res = md.getColumns(nil, @user.upcase, table, nil)
+            columns = {}
+            while res.next()
+                col_name = res.getString("COLUMN_NAME")
+                col = {
+                    :type => res.getString("TYPE_NAME"),
+                    :length => res.getInt("COLUMN_SIZE"),
+                    :precision => res.getInt("DECIMAL_DIGITS"),
+                }
+                col.delete(:length) if (col[:precision])
+                columns[col_name] = col
+            end
+            columns
+        end
+
+        
+        def get_db_metadata(conn)
+            @db_metadata ||= conn.getMetaData()
+        end
+        
+        def get_table_metadata(conn, table)
+            get_db_metadata(conn).getTables(nil, @user.upcase, table, nil)
+        end
+
+        def java_date(value)
+            value && Java::oracle.sql.DATE.new(value.strftime("%Y-%m-%d %H:%M:%S"))
+        end
+
+        def java_timestamp(value)
+            value && Java::java.sql.Timestamp.new(value.year-1900, value.month-1, value.day, value.hour, value.min, value.sec, value.usec * 1000)
+        end
+
+        def java_bigdecimal(value)
+            value && java.math.BigDecimal.new(value.to_s)
+        end
+
+        
+    end
+    
+    
+end; end; end; end; end

data/lib/spiderfw/model/storage/db/connectors/oci8.rb

@@ -0,0 +1,193 @@
+require 'oci8'
+
+module Spider; module Model; module Storage; module Db; module Connectors
+
+    module OCI8
+        
+        def self.included(klass)
+            klass.extend(ClassMethods)
+        end
+        
+        module ClassMethods
+            
+            def new_connection(user, pass, dbname, role)
+                conn ||= ::OCI8.new(user, pass, dbname, role)
+                conn.autocommit = true
+                conn.non_blocking = true
+                return conn
+            end
+
+            def disconnect(conn)
+                conn.logoff
+            end
+
+            def connection_alive?(conn)
+                begin
+                    conn.autocommit?
+                    return true
+                rescue
+                    return false
+                end
+            end
+            
+        end
+        
+        def release
+            begin
+                curr[:conn].autocommit = true if curr[:conn]
+                super
+            rescue
+                self.class.remove_connection(curr[:conn], @connection_params)
+                curr[:conn] = nil
+            end
+        end
+        
+        def do_start_transaction
+            return unless transactions_enabled?
+            connection.autocommit = false
+        end
+        
+        def in_transaction?
+            return false unless transactions_enabled?
+            return curr[:conn] && !curr[:conn].autocommit?
+        end
+        
+        def do_commit
+            return release unless transactions_enabled?
+            curr[:conn].commit if curr[:conn]
+            release
+        end
+        
+        def do_rollback
+            return release unless transactions_enabled?
+            curr[:conn].rollback
+            release
+        end
+        
+        def prepare_value(type, value)
+            value = super
+            if (type < Spider::Model::BaseModel)
+                type = type.primary_keys[0].type
+            end
+            return Oracle::OracleNilValue.new(Spider::Model.ruby_type(type)) if (value == nil)
+            case type.name
+            when 'Spider::DataTypes::Binary'
+                return OCI8::BLOB.new(curr[:conn], value)
+            end
+            return value
+        end
+        
+        
+        def execute(sql, *bind_vars)
+            begin
+                if (bind_vars && bind_vars.length > 0)
+                    debug_vars = bind_vars.map{|var| var = var.to_s; var && var.length > 50 ? var[0..50]+"...(#{var.length-50} chars more)" : var}
+                end
+                curr[:last_executed] = [sql, bind_vars]
+                if (Spider.conf.get('storage.db.replace_debug_vars'))
+                    debug("oci8 #{connection} executing: "+sql.gsub(/:(\d+)/){
+                        i = $1.to_i
+                        v = bind_vars[i-1]
+                        dv = debug_vars[i-1]
+                        v.is_a?(String) ? "'#{dv}'" : dv
+                    })
+                else
+                    debug_vars_str = debug_vars ? debug_vars.join(', ') : ''
+                    debug("oci8 #{connection} executing:\n#{sql}\n[#{debug_vars_str}]")
+                end
+                cursor = connection.parse(sql)
+                return cursor if (!cursor || cursor.is_a?(Fixnum))
+                bind_vars.each_index do |i|
+                    var = bind_vars[i]
+                    if (var.is_a?(Oracle::OracleNilValue))
+                        cursor.bind_param(i+1, nil, var.type, 0)
+                    else
+                        cursor.bind_param(i+1, var)
+                    end
+                end
+                res = cursor.exec
+                have_result = (cursor.type == ::OCI8::STMT_SELECT)
+                # @cursor = connection.exec(sql, *bind_vars)
+                if (have_result)
+                    result = []
+                    while (h = cursor.fetch_hash)
+                        h.each do |key, val|
+                            if val.respond_to?(:read)
+                                h[key] = val.read
+                            end
+                        end
+                        if block_given?
+                            yield h
+                        else
+                            result << h
+                        end
+                    end
+                end
+                if (have_result)
+                    unless block_given?
+                        result.extend(StorageResult)
+                        curr[:last_result] = result
+                        return result
+                    end
+                else
+                    return res
+                end
+                cursor.close
+
+            rescue => exc
+                curr[:conn].break if curr[:conn]
+                rollback! if in_transaction?
+                #curr[:conn].logoff
+                release
+                raise
+            ensure
+                cursor.close if cursor
+                release if curr[:conn] && !in_transaction?
+            end
+        end
+        
+
+        def prepare(sql)
+            debug("oci8 preparing: #{sql}")
+            return connection.parse(sql)
+        end
+
+        def execute_statement(stmt, *bind_vars)
+            stmt.exec(bind_vars)
+        end
+        
+        
+        def table_exists?(table)
+            begin
+                connection do |c|
+                    c.describe_table(table)
+                end
+                Spider.logger.debug("TABLE EXISTS #{table}")
+                return true
+            rescue OCIError
+                return false
+            end
+        end
+        
+        def do_describe_table(conn, table)
+            columns = {}
+            t = conn.describe_table(table)
+            t.columns.each do |c|
+                col = {
+                    :type => c.data_type.to_s.upcase,
+                    :length => c.data_size,
+                    :precision => c.precision,
+                    :scale => c.scale,
+                    :null => c.nullable?
+                }
+                col.delete(:length) if (col[:precision])
+                columns[c.name] = col
+            end
+            columns
+        end
+        
+        
+    end
+    
+    
+end; end; end; end; end

data/lib/spiderfw/model/storage/db/db.rb

@@ -1,13 +1,18 @@
 module Spider; module Model; module Storage
     
     module Db
+        module Connectors
+        end
         
     end
     
     Db.autoload(:DbSchema, 'spiderfw/model/storage/db/db_schema')
     Db.autoload(:SQLite, 'spiderfw/model/storage/db/adapters/sqlite')
-    Db.autoload(:OCI8, 'spiderfw/model/storage/db/adapters/oci8')
+    Db.autoload(:Oracle, 'spiderfw/model/storage/db/adapters/oracle')
     Db.autoload(:Mysql, 'spiderfw/model/storage/db/adapters/mysql')
     Db.autoload(:MSSQL, 'spiderfw/model/storage/db/adapters/mssql')
+    Db::Connectors.autoload(:ODBC, 'spiderfw/model/storage/db/connectors/odbc')
+    Db::Connectors.autoload(:OCI8, 'spiderfw/model/storage/db/connectors/oci8')
+    Db::Connectors.autoload(:JDBCOracle, 'spiderfw/model/storage/db/connectors/jdbc_oracle')
     
 end; end; end

data/lib/spiderfw/model/storage/db/db_storage.rb

@@ -77,6 +77,13 @@ module Spider; module Model; module Storage; module Db
                 raise "Virtual"
             end
             
+             def inherited(subclass)
+                 subclass.instance_variable_set("@reserved_keywords", @reserved_keywords)
+                 subclass.instance_variable_set("@type_synonyms", @type_synonyms)
+                 subclass.instance_variable_set("@safe_conversions", @safe_conversions)
+                 subclass.instance_variable_set("@capabilities", @capabilities)
+             end
+            
         end
         
         def curr

data/lib/spiderfw/model/storage.rb

@@ -19,28 +19,39 @@ module Spider; module Model
                     adapter = $2
                     url = "#{adapter}://#{rest}"
                 end
-                case adapter
+                class_name = case adapter
                 when 'sqlite'
-                    class_name = :SQLite
-                when 'oci8'
-                    class_name = :OCI8
+                    :SQLite
+                when 'oci8', 'oracle'
+                    :Oracle
                 when 'mysql'
-                    class_name = :Mysql
+                    :Mysql
                 when 'mssql'
-                    class_name = :MSSQL
+                    :MSSQL
                 end
                 klass = Db.const_get(class_name)
+                unless connector
+                    connector = case adapter
+                    when 'oci8', 'oracle'
+                        RUBY_PLATFORM =~ /java/ ? 'jdbc' : 'oci8'
+                    end
+                end
                 if (connector)
-                    case connector
+                    conn_mod_name = case connector
                     when 'odbc'
-                        conn_mod = :ODBC
+                        :ODBC
+                    when 'jdbc'
+                        :JDBC
+                    when 'oci8'
+                        :OCI8
                     end
-                    conn_class = "#{conn_mod}#{class_name}"
-                    if Db.const_defined?(conn_class)
-                        klass = Db.const_get(conn_class)
+                    full_name = "#{conn_mod_name}#{class_name}"
+                    if Db.const_defined?(full_name)
+                        klass = Db.const_get(full_name)
                     else
-                        klass = Db.const_set(conn_class, Class.new(klass))
-                        klass.instance_eval{ include Db::Connectors.const_get(conn_mod)}
+                        conn_mod = Db::Connectors.const_defined?(full_name) ? Db::Connectors.const_get(full_name) : Db::Connectors.const_get(conn_mod_name)
+                        klass = Db.const_set(full_name, Class.new(klass))
+                        klass.instance_eval{ include conn_mod }
                     end
                 end
                 Thread.current[:storages][type][url] = klass.new(url)

data/lib/spiderfw/utils/monkey/date_time.rb

@@ -31,7 +31,7 @@ class Date
     private
     def to_time(dest, method)
         #Convert a fraction of a day to a number of microseconds
-        usec = (dest.sec_fraction * 60 * 60 * 24 * (10**6)).to_i
+        usec = (dest.send(:sec_fraction) * 60 * 60 * 24 * (10**6)).to_i
         Time.send(method, dest.year, dest.month, dest.day, dest.hour, dest.min,
         dest.sec, usec)
     end

data/lib/spiderfw.rb

@@ -484,7 +484,7 @@ module Spider
                         Debugger.post_mortem
                     end
                     require 'ruby-prof' 
-                rescue LoadError; end
+                rescue LoadError, RuntimeError; end
             end
         end
         

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: spiderfw
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 19
   prerelease: false
   segments: 
   - 0
   - 5
-  - 11
-  version: 0.5.11
+  - 12
+  version: 0.5.12
 platform: ruby
 authors: 
 - Ivan Pirlik
@@ -840,8 +840,11 @@ files:
 - lib/spiderfw/model/storage/base_storage.rb
 - lib/spiderfw/model/storage/db/adapters/mssql.rb
 - lib/spiderfw/model/storage/db/adapters/mysql.rb
-- lib/spiderfw/model/storage/db/adapters/oci8.rb
+- lib/spiderfw/model/storage/db/adapters/oracle.rb
 - lib/spiderfw/model/storage/db/adapters/sqlite.rb
+- lib/spiderfw/model/storage/db/connectors/jdbc.rb
+- lib/spiderfw/model/storage/db/connectors/jdbc_oracle.rb
+- lib/spiderfw/model/storage/db/connectors/oci8.rb
 - lib/spiderfw/model/storage/db/connectors/odbc.rb
 - lib/spiderfw/model/storage/db/db.rb
 - lib/spiderfw/model/storage/db/db_connection_pool.rb