rails-plsql 0.2.5

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZDI1NzUzYjdlZWVkZDMyN2M0N2E1OTg0YzUzMWE3ZjhhODJlNjE0Zg==
+  data.tar.gz: !binary |-
+    MTgyMzYyZmU5OWJlMzgxZjYzNzY2NzQwODNiNDkwZmUyOTk5YTJkZA==
+SHA512:
+  metadata.gz: !binary |-
+    ODgwN2M4ZGQyNzU2MjllZWI4NzI5MjkzYWIwMDc3MWQwNDdkMTgxYTNhZjE1
+    MGU3ZjAzZDUxMzg4YjY2NzMxODQ1M2NkNThjN2M5ZTI4NmZiZTY3NzkxNjRl
+    YmQ5YjQ2NjgwZGQ5MWE0MzI0ZjBlYmZhMzcwNzk0YzU3ZWYyNTQ=
+  data.tar.gz: !binary |-
+    MzhkZDk3MmY4YzJkOGQ3ZjQwZTEwNGEwNmVjYjg0ZjA3M2ZlNTVjYjU0MTNh
+    YmE1ZjU4M2U5MGUzNzExNDg4Njk4YzU1MDlmYTFmOTMyMTcxYWIwNzMzMjMx
+    ODhkZTIyMTBlNmUyNjA4NTdlNmVlYmE1NTgwNzY2M2JlYzFjNDc=

data/MIT-LICENSE

@@ -0,0 +1,7 @@
+Copyright © 2012 Nikita Shilnikov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,157 @@
+[![Code Climate](https://codeclimate.com/github/flash-gordon/rails-plsql.png)](https://codeclimate.com/github/flash-gordon/rails-plsql)
+rails-plsql
+====================================
+
+Middleware between ActiveRecord and Oracle Database
+
+Description
+-----------
+
+This gem is ActiveRecord extension for some Oracle Database specific features such as pipelined functions or PL/SQL procedures. It uses [ruby-plsql](https://github.com/rsim/ruby-plsql) and [oracle enhanced adapter](https://github.com/rsim/oracle-enhanced) gems as dependencies for connection to Oracle and calling PL/SQL procedures and functions. It also adds basic logger to [my fork](https://github.com/flash-gordon/ruby-plsql) of ruby-plsql gem.
+
+Installation
+------------
+
+### Rails 3.2
+
+Just put this line into your Gemfile
+
+    gem 'rails-plsql', '~> 0.1', github: 'flash-gordon/rails-plsql'
+
+Gem tested with MRI 1.9.2, 1.9.3, 2.0.0 and JRuby 1.7.4. So if you use ruby-oci8 then add also
+
+    gem 'ruby-oci8', '~> 2.1.0'
+
+And run
+
+    bundle install
+
+to install all gems.
+
+Other versions of Rails not tested.
+
+Usage
+-----
+
+### Pipelined functions as tables in ActiveRecord models
+
+Oracle pipelined functions could be used as data source instead of ordinary tables (or views).
+
+If you have such PL/SQL function
+
+```sql
+
+CREATE OR REPLACE
+PACKAGE users_pkg IS
+
+  TYPE users_list IS TABLE OF USERS%ROWTYPE;
+
+  FUNCTION find_users_by_name(
+    p_name    USERS.NAME%TYPE)
+  RETURN users_list
+  PIPELINED;
+
+END users_pkg;
+/
+
+CREATE OR REPLACE
+PACKAGE BODY users_pkg IS
+
+  FUNCTION find_users_by_name(
+    p_name    USERS.NAME%TYPE)
+  RETURN users_list
+  PIPELINED
+  IS
+  BEGIN
+    FOR l_user IN (
+      SELECT *
+      FROM   users
+      WHERE  name = p_name)
+    LOOP
+      PIPE ROW(l_user);
+    END LOOP;
+  END FIND_USERS_BY_NAME;
+
+END users_pkg;
+/
+```
+
+So you can set this function in your model instead of table name
+
+```ruby
+class User < ActiveRecord::Base
+  include ActiveRecord::PLSQL::Pipelined
+
+  self.pipelined_function = 'users_pkg.find_users_by_name'
+
+  scope :alberts, where(p_name: 'Albert')
+  scope :einsteins, where(surname: 'Einstein')
+end
+```
+
+and use standard Rails scopes and finders
+
+```ruby
+User.alberts
+# [#<User id: #<BigDecimal:6fec77a4,'0.1E1',9(36)>, name: "Albert", surname: "Einstein">]
+User.alberts.einsteins.first
+# #<User id: #<BigDecimal:6fec77a4,'0.1E1',9(36)>, name: "Albert", surname: "Einstein">
+
+User.all(conditions: {p_name: 'Max'})
+# [#<User id: #<BigDecimal:6ee2c728,'0.3E1',9(36)>, name: "Max", surname: "Planck">]
+```
+
+Pipelined function arguments must be set via `where` condition (see `p_name` usage above). If not they will be set to NULL.
+
+### Oracle procedures and functions as methods of ActiveRecord objects
+
+If you have some PL/SQL package related with AR model you could bind it to class.
+
+```sql
+CREATE OR REPLACE
+PACKAGE users_pkg IS
+
+  FUNCTION salute(
+    p_name    IN VARCHAR2)
+  RETURN VARCHAR2;
+
+END users_pkg;
+/
+
+CREATE OR REPLACE
+PACKAGE BODY users_pkg IS
+
+  FUNCTION salute(
+    p_name    IN VARCHAR2)
+  RETURN VARCHAR2
+  IS
+  BEGIN
+    RETURN 'Hello, ' || p_name || '!';
+  END salute;
+
+END users_pkg;
+/
+```
+
+```ruby
+class User < ActiveRecord::Base
+  include ActiveRecord::PLSQL::ProcedureMethods
+
+  self.plsql_package = plsql.users_pkg
+  procedure_method :salute
+end
+```
+
+After that you can call procedure as method
+
+```ruby
+einstein = User.find_by_name('Albert')
+# Just pass arguments as array or hash
+einstein.salute(p_name: einstein.name)  # 'Hello, Albert!'
+einstein.salute([einstein.surname])     # 'Hello, Einstein!'
+```
+
+Support
+-------
+
+Feel free to contact me at fg@flashgordon.ru or send a pull request.

data/lib/active_record/oracle_enhanced_adapter_patch.rb

@@ -0,0 +1,78 @@
+require 'active_record/connection_adapters/oracle_enhanced_adapter'
+require 'plsql/pipelined_function'
+
+class ActiveRecord::StatementInvalid
+  attr_reader :original_exception
+
+  def initialize(message, original_exception)
+    @original_exception = original_exception
+    super(message)
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    # interface independent methods
+    class OracleEnhancedAdapter
+      def columns_without_cache_with_pipelined(table, name)
+        begin
+          return columns_without_cache_without_pipelined(table, name)
+        rescue OracleEnhancedConnectionException => error
+          # Will try to find a pipelined function
+        end
+
+        function_name, package_name = parse_function_name(table)
+
+        if package_name
+          function = plsql.send(package_name.downcase.to_sym)[function_name.downcase]
+        else
+          raise error.class, error.message
+        end
+
+        if function
+          arguments_metadata = function.arguments[0].sort_by {|arg| arg[1][:position]}
+          arguments = arguments_metadata.map do |(arg_name, argument)|
+            OracleEnhancedColumn.new(arg_name.to_s, nil, argument[:data_type], table)
+          end
+
+          return_columns = function.return[:element][:fields].sort_by {|(col_name, col)| col[:position]}.map do |(col_name, metadata)|
+            metadata.merge(name: col_name)
+          end
+
+          return_columns.map do |col|
+            OracleEnhancedColumn.new(col[:name].to_s, nil, col[:data_type], table)
+          end + arguments
+        else
+          raise error.class, error.message
+        end
+      end
+
+      alias_method_chain :columns_without_cache, :pipelined
+
+      def parse_function_name(name)
+        name = name.to_s.upcase
+        # We can get name of function with calling syntax
+        # Just extract function name
+        if name =~ /\ATABLE\((([^.]+\.)[^.]+)\([^)]+\)\)\z/
+          name = $1
+        end
+        name.split('.').reverse
+      end
+
+    protected
+
+      def translate_exception(exception, message) #:nodoc:
+        case @connection.error_code(exception)
+        when 1
+          RecordNotUnique.new(message, exception)
+        when 2291
+          InvalidForeignKey.new(message, exception)
+        when 20000..20999 # Skip user-defined errors
+          raise
+        else
+          ActiveRecord::StatementInvalid.new(message, exception)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/plsql/base.rb

@@ -0,0 +1,7 @@
+module ActiveRecord::PLSQL
+  class Base < ActiveRecord::Base
+    self.abstract_class = true
+    include Pipelined
+    include ProcedureMethods
+  end
+end

data/lib/active_record/plsql/engine.rb

@@ -0,0 +1,14 @@
+require 'active_record/plsql/pipelined'
+require 'active_record/plsql/procedure_methods'
+require 'active_record/plsql/base'
+require 'active_record/plsql/pipelined_relation'
+require 'active_record/oracle_enhanced_adapter_patch'
+require 'plsql/log_subscriber'
+
+module ActiveRecord::PLSQL
+  class Engine < ::Rails::Engine
+    initializer 'plsql.logger', after: 'active_record.logger' do
+      PLSQL::LogSubscriber.logger = ActiveRecord::Base.logger
+    end
+  end
+end

data/lib/active_record/plsql/pipelined.rb

@@ -0,0 +1,137 @@
+require 'active_support/concern'
+
+module ActiveRecord::PLSQL
+  module Pipelined
+    extend ActiveSupport::Concern
+
+    class PipelinedFunctionError < ActiveRecord::ActiveRecordError; end
+
+    class PipelinedFunctionTableName < Arel::Nodes::SqlLiteral
+      def to_s;self end
+    end
+
+    included do
+      self.pipelined_function = nil
+    end
+
+    module ClassMethods
+      def pipelined_arguments
+        raise PipelinedFunctionError, "Pipelined function didn't set" unless pipelined?
+        @pipelined_arguments ||= get_pipelined_arguments
+      end
+
+      def pipelined_arguments_names
+        pipelined_arguments.map(&:name)
+      end
+
+      def pipelined_function
+        @pipelined_function
+      end
+
+      alias pipelined? pipelined_function
+
+      def pipelined_function=(function)
+        case function
+        when String, Symbol
+          # Name without schema expected
+          function_name = function.to_s.split('.').map(&:downcase).map(&:to_sym)
+          case function_name.size
+          when 2
+            pipelined_function = plsql.send(function_name.first)[function_name.second]
+          when 1
+            pipelined_function = PLSQL::PipelinedFunction.find(plsql, function_name.first)
+          else
+            raise ArgumentError, 'Setting schema via string not supported yed'
+          end
+          raise ArgumentError, 'Pipelined function not found by string: %s' % function unless pipelined_function
+        when ::PLSQL::PipelinedFunction, nil
+          pipelined_function = function
+        else
+          raise ArgumentError, 'Unsupported type of pipelined function: %s' % function.inspect
+        end
+
+        if pipelined_function && pipelined_function.overloaded?
+          raise ArgumentError, 'Overloaded functions are not supported yet'
+        end
+
+        @pipelined_function = pipelined_function
+        @pipelined_arguments = nil
+        @table_name = pipelined_function_name if @pipelined_function
+      end
+
+      def pipelined_function_name
+        return @full_function_name if defined? @full_function_name
+        package_name, function_name = @pipelined_function.package, @pipelined_function.procedure
+        @full_function_name = [package_name, function_name].compact.join('.')
+      end
+
+      def arel_table
+        if pipelined?
+          @arel_table ||= Arel::Table.new(table_name_with_arguments, engine: arel_engine, as: pipelined_function_alias)
+        else
+          super
+        end
+      end
+
+      def pipelined_function_alias
+        # GET_USER_BY_NAME => GUBN
+        @pipelined_function.procedure.scan(/^\w|_\w/).join('').gsub('_', '')
+      end
+
+      def table_name_with_arguments
+        @table_name_with_arguments ||= PipelinedFunctionTableName.new(
+            "TABLE(%s(%s))" % [table_name, pipelined_arguments.map{|a| ":#{a.name}"}.join(',')]
+        )
+      end
+
+      def table_exist?
+        pipelined? || super
+      end
+
+      private
+
+        def get_pipelined_arguments
+          # Always select arguments of first function (overloading not supported)
+          arguments_metadata = pipelined_function.arguments[0].sort_by {|arg| arg[1][:position]}
+          arguments_metadata.map do |(name, argument)|
+            ActiveRecord::ConnectionAdapters::OracleEnhancedColumn.new(name.to_s, nil, argument[:data_type], pipelined_function_name)
+          end
+        end
+
+        def relation
+          return super unless pipelined?
+          @relation ||= PipelinedRelation.new(self, arel_table)
+        end
+    end
+
+    delegate :pipelined?, to: 'self.class'
+
+    attr_accessor :found_by_arguments
+
+    def reload(options = nil)
+      return super unless pipelined? && (found_by_arguments.present? || options)
+
+      clear_aggregation_cache
+      clear_association_cache
+
+      ActiveRecord::IdentityMap.without do
+        fresh_object = self.class.unscoped do
+          relation = self.class.where(self.class.primary_key => id)
+
+          if found_by_arguments
+            relation.bind_values += found_by_arguments
+            relation.to_a.first
+          else
+            relation.where(options).to_a.first
+          end
+        end
+
+        @attributes.update(fresh_object.instance_variable_get('@attributes'))
+      end
+
+      @attributes_cache = {}
+      self
+    end
+
+  end
+end

data/lib/active_record/plsql/pipelined_relation.rb

@@ -0,0 +1,93 @@
+module ActiveRecord::PLSQL
+  class PipelinedRelation < ActiveRecord::Relation
+    attr_accessor :pipelined_arguments_values
+
+    def where(opts, *rest)
+      return super unless @klass.pipelined? && pipelined_arguments.any?
+
+      pipelined_args = pipelined_arguments_names.map(&:to_sym)
+      opts = normalize_arguments_conditions(opts, pipelined_args)
+      return super if opts.blank?
+
+      relation = bind_pipelined_arguments(opts)
+
+      opts.reject! {|k| pipelined_args.include?(k)}
+      # bind rest of arguments
+      relation.where_values += build_where(opts, rest)
+      relation
+    end
+
+    def bind_pipelined_arguments(values)
+      relation = clone
+      if values.is_a?(Hash)
+        arguments_values = values.values_at(*pipelined_arguments_names.map(&:to_sym))
+        relation.bind_values += pipelined_arguments.zip(arguments_values)
+      else
+        relation.where_values += values
+      end
+      relation
+    end
+
+    def merge_pipelined_arguments(pos, values)
+      new_values_pos = pos + pipelined_arguments.size
+      exist_args = values[pos...new_values_pos]
+      new_values = values[new_values_pos..-1]
+      new_args_pos = pipelined_arguments_binds_pos(new_values)
+      # return if there are no new argument values
+      return unless new_args_pos
+      new_arguments = new_values[new_args_pos...(new_args_pos + pipelined_arguments.size)]
+      # overriding nil arguments
+      new_arguments.each_with_index {|val, idx| exist_args[idx][1] ||= val[1]}
+      # exclude new arguments
+      values[(new_values_pos + new_args_pos)...(new_values_pos + new_args_pos + pipelined_arguments.size)] = nil
+      # drop nil
+      values.compact!
+    end
+
+    def pipelined_arguments_binds_pos(binds = @bind_values)
+      binds.index {|(col,_)| col.name == pipelined_arguments.first.name}
+    end
+
+    # Safe arguments binding
+    def bind_values=(vals)
+      if @klass.pipelined? && (pos = pipelined_arguments_binds_pos)
+        vals = vals.map(&:dup)
+        merge_pipelined_arguments(pos, vals)
+        super(vals)
+      else
+        super
+      end
+    end
+
+    def exec_queries
+      return super unless @klass.pipelined? && pipelined_arguments.any?
+      return @records if loaded?
+      super
+      return @records if @records.empty?
+
+      pos = pipelined_arguments_binds_pos
+      found_by_arguments = @bind_values[pos...(pos + pipelined_arguments.size)]
+      # save arguments for easy reloading
+      @records.each {|record| record.found_by_arguments = found_by_arguments}
+      @records
+    end
+
+    protected
+
+      def normalize_arguments_conditions(opts, args)
+        case opts
+        when Hash
+          opts.symbolize_keys
+        when Arel::Nodes::Equality
+          column = opts.left.name.to_sym
+
+          # only simple types for a while
+          if args.include?(column) && !opts.right.is_a?(Arel::Attributes::Attribute)
+            {column => opts.right}
+          end
+        else
+          [opts]
+        end
+      end
+  end
+end

data/lib/active_record/plsql/procedure_methods.rb

@@ -0,0 +1,154 @@
+require 'active_support/concern'
+
+module ActiveRecord::PLSQL
+  module ProcedureMethods
+    extend ActiveSupport::Concern
+
+    class CannotFetchId < StandardError; end
+
+    included do
+      class_attribute :plsql_package, :procedure_methods_cache, instance_writer: false
+      self.plsql_package = nil
+      self.procedure_methods_cache = Hash.new do |cache, klass|
+        cache[klass] = Hash.new do |methods, method|
+          # Inherits procedure methods from base class
+          if klass.superclass.respond_to?(:procedure_methods)
+            methods[method] = klass.superclass.procedure_methods[method]
+          else
+            nil
+          end
+        end
+      end
+    end
+
+    module ClassMethods
+      def set_create_procedure(procedure, options = {}, &reload_block)
+        block ||= proc do |record, result|
+          case result
+          when Hash
+            record.id = result.values.first
+          when Numeric
+            record.id = result
+          else
+            raise CannotFetchId, "Couldn't fetch primary key from create procedure (%s) result: %s" %
+              [procedure, result.inspect]
+          end
+
+          reload_block ? reload_block.call(record) : record.reload
+
+          record.instance_variable_set(:@new_record, true)
+          record.id
+        end
+
+        procedure_method(:create, procedure, options, &block)
+        set_create_method {call_procedure_method(:create)}
+      end
+
+      def set_update_procedure(procedure, options = {})
+        procedure_method(:update, procedure, options) do |record|
+          record.reload
+          record.id
+        end
+        set_update_method {call_procedure_method(:update)}
+      end
+
+      def set_destroy_procedure(procedure, options = {})
+        procedure_method(:destroy, procedure, options)
+        set_delete_method {call_procedure_method(:destroy)}
+      end
+
+      def procedure_methods
+        procedure_methods_cache[self]
+      end
+
+      def procedure_method(method, procedure_name = method, options = {}, &block)
+        procedure = if PLSQL::Procedure === procedure_name
+          procedure_name
+        else
+          find_procedure(procedure_name)
+        end
+
+        # Raise error if procedure not found
+        raise ArgumentError, "Procedure (%s) not found for method (%s)" % [procedure_name, method] unless procedure
+
+        procedure_methods[method] = {procedure: procedure, options: options, block: block}
+
+        unless (instance_methods + private_instance_methods).find {|m| m == method}
+          generated_feature_methods.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{method}(arguments = {}, options = {})
+              call_procedure_method(:#{method}, arguments, options)
+            end
+          RUBY
+        end
+      end
+
+      def procedures_arguments
+        @procedures_arguments ||= Hash.new do |cache, procedure|
+          # Always select arguments of first function (overloading not supported)
+          cache[procedure] = Hash[ procedure.arguments[0].sort_by {|arg| arg[1][:position]} ]
+        end
+      end
+
+      private
+
+        def find_procedure(procedure_name)
+          procedure_name = procedure_name.to_s.split('.').compact
+
+          case procedure_name.size
+          when 2
+            plsql.send(procedure_name[0].to_sym)[procedure_name[1]]
+          when 1
+            if plsql_package
+              plsql_package[procedure_name[0]] || PLSQL::Procedure.find(plsql, procedure_name[0])
+            else
+              PLSQL::Procedure.find(plsql, procedure_name[0])
+            end
+          end
+        end
+    end
+
+    delegate :procedures_arguments, :procedure_methods, to: 'self.class'
+
+    private
+
+      def call_procedure_method(method, arguments = {}, opts = {})
+        procedure, options, block = procedure_methods[method].values_at(:procedure, :options, :block)
+        options = options.merge(opts)
+
+        if options[:arguments]
+          if arguments.is_a?(Hash)
+            arguments = arguments.merge(instance_exec(&options[:arguments]))
+          else
+            arguments += options[:arguments]
+          end
+        end
+
+        options[:arguments] = arguments
+        call_procedure(procedure, options, &block)
+      end
+
+      def call_procedure(procedure, options = {})
+        result = procedure.exec(*get_procedure_arguments(procedure, options))
+        if block_given?
+          yield(self, result)
+        else
+          result
+        end
+      end
+
+      def get_procedure_arguments(procedure, options)
+        arguments = options[:arguments]
+        arguments = arguments.dup if arguments.duplicable?
+
+        if Hash === arguments
+          arguments.symbolize_keys!
+          arguments_metadata = procedures_arguments[procedure]
+          # throw away unnecessary arguments
+          [arguments.select {|k,_| arguments_metadata[k]}]
+        else
+          arguments
+        end
+      end
+  end
+end
+

data/lib/java/oracle_sql_named_error.rb

@@ -0,0 +1,27 @@
+class OracleNamedError < StandardError
+  class_attribute :error_code, instance_writer: false
+
+  UNHANDLED_ERROR = 6512
+
+  class << self
+    def ===(error)
+      error = error.original_exception if error.respond_to?(:original_exception)
+      error = error.cause if error.respond_to?(:cause) && error.cause
+
+      Java::JavaSql::SQLException === error &&
+          (error.get_error_code.in?([*error_code]) ||
+           # ORA-06512: at line 1
+           # ORA-20100: some exception description <--- real exception code in the second line
+           error.get_error_code == UNHANDLED_ERROR &&
+               error.message.split("\n")[1].try(:[], /\AORA-(\d+)/, 1).try(:to_i).in?([*error_code]))
+    end
+
+    def define_exception(class_name, error_code)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        class ::#{class_name} < OracleNamedError
+          self.error_code = #{error_code}
+        end
+      RUBY
+    end
+  end
+end

data/lib/oci8/oci_named_error.rb

@@ -0,0 +1,33 @@
+class OCI8
+  class OCINamedError < OCIError
+    class_attribute :oci_error_code, instance_writer: false
+
+    UNHANDLED_ERROR = 6512
+
+    class << self
+      alias error_code= oci_error_code=
+
+      def error_code
+        oci_error_code
+      end
+
+      def ===(error)
+        error = error.original_exception if error.respond_to?(:original_exception)
+        OCIError === error &&
+            (error.code.in?([*error_code]) ||
+             # ORA-06512: at line 1
+             # ORA-20100: some exception description <--- real exception code in the second line
+             error.code == UNHANDLED_ERROR &&
+                 error.message.split("\n")[1].try(:[], /\AORA-(\d+)/, 1).try(:to_i).in?([*error_code]))
+      end
+
+      def define_exception(class_name, error_code)
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          class ::#{class_name} < OCI8::OCINamedError
+            self.error_code = #{error_code}
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/oracle/named_error.rb

@@ -0,0 +1,9 @@
+module Oracle; end
+
+if RUBY_ENGINE == 'ruby'
+  require 'oci8/oci_named_error'
+  Oracle::NamedError = OCI8::OCINamedError
+elsif RUBY_ENGINE == 'jruby'
+  require 'java/oracle_sql_named_error'
+  Oracle::NamedError = OracleNamedError
+end

data/lib/plsql/log_subscriber.rb

@@ -0,0 +1,40 @@
+module PLSQL
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def procedure_call(event)
+      return unless logger && (logger.debug? || uncaught_exception?(event.payload[:error]))
+      payload = event.payload
+      name = 'PL/SQL Procedure call (%.1fms)' % event.duration
+      sql = payload[:sql].strip
+
+      if payload[:arguments].empty?
+        arguments = nil
+      elsif payload[:arguments].size == 1 && Hash === payload[:arguments].first
+        arguments = '  ' + payload[:arguments].first.inspect
+      else
+        arguments = '  ' + payload[:arguments].inspect
+      end
+
+      if event.payload[:error]
+        exception = "Error occurred: %s\n%s" %
+          [event.payload[:error].class, event.payload[:error].message.split("\n").map{|l| "  #{l}"}.join("\n")]
+
+        name = color(name, RED, true)
+        exception = color(exception, RED, true)
+        sql = color(sql, nil, true)
+
+        error "  #{name}  #{sql}#{arguments}\n  #{exception}"
+      else
+        name = color(name, YELLOW, true)
+        sql = color(sql, nil, true)
+
+        debug "  #{name}  #{sql}#{arguments}"
+      end
+    end
+
+    def uncaught_exception?(error)
+      error && OCIError === error && !error.code.in?(20000..20999)
+    end
+  end
+end
+
+PLSQL::LogSubscriber.attach_to :plsql

data/lib/rails-plsql.rb

@@ -0,0 +1,9 @@
+if RUBY_ENGINE == 'ruby'
+  require 'oci8'
+end
+require 'active_record'
+require 'activerecord-oracle_enhanced-adapter'
+require 'ruby-plsql'
+require 'oracle/named_error'
+require 'rails/engine'
+require 'active_record/plsql/engine'

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: rails-plsql
+version: !ruby/object:Gem::Version
+  version: 0.2.5
+platform: ruby
+authors:
+- Nikita Shilnikov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: flash-gordons-ruby-plsql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: activerecord-oracle_enhanced-adapter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+description: rails-plsql adds functional that allows to use some special Oracle Database
+  features in standard ActiveRecord models.
+email:
+- fg@flashgordon.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/active_record/oracle_enhanced_adapter_patch.rb
+- lib/active_record/plsql/base.rb
+- lib/active_record/plsql/engine.rb
+- lib/active_record/plsql/pipelined.rb
+- lib/active_record/plsql/pipelined_relation.rb
+- lib/active_record/plsql/procedure_methods.rb
+- lib/java/oracle_sql_named_error.rb
+- lib/oci8/oci_named_error.rb
+- lib/oracle/named_error.rb
+- lib/plsql/log_subscriber.rb
+- lib/rails-plsql.rb
+homepage: http://github.com/flash-gordon/rails-plsql
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Extension for ActiveRecord that provides convenient using some of Oracle
+  PL/SQL features.
+test_files: []