ruby-plsql 0.4.0 → 0.4.1

data/lib/plsql/procedure.rb

@@ -3,16 +3,16 @@ module PLSQL
   module ProcedureClassMethods #:nodoc:
     def find(schema, procedure, package = nil, override_schema_name = nil)
       if package.nil?
-        if schema.select_first("
-            SELECT object_name FROM all_objects
+        if (row = schema.select_first(
+            "SELECT object_id FROM all_objects
             WHERE owner = :owner
               AND object_name = :object_name
               AND object_type IN ('PROCEDURE','FUNCTION')",
-            schema.schema_name, procedure.to_s.upcase)
-          new(schema, procedure)
+            schema.schema_name, procedure.to_s.upcase))
+          new(schema, procedure, nil, nil, row[0])
         # search for synonym
-        elsif (row = schema.select_first("
-            SELECT o.owner, o.object_name
+        elsif (row = schema.select_first(
+            "SELECT o.owner, o.object_name, o.object_id
             FROM all_synonyms s, all_objects o
             WHERE s.owner IN (:owner, 'PUBLIC')
               AND s.synonym_name = :synonym_name
@@ -21,17 +21,21 @@ module PLSQL
               AND o.object_type IN ('PROCEDURE','FUNCTION')
               ORDER BY DECODE(s.owner, 'PUBLIC', 1, 0)",
             schema.schema_name, procedure.to_s.upcase))
-          new(schema, row[1], nil, row[0])
+          new(schema, row[1], nil, row[0], row[2])
         else
           nil
         end
-      elsif package && schema.select_first("
-            SELECT object_name FROM all_procedures
-            WHERE owner = :owner
-              AND object_name = :object_name
-              AND procedure_name = :procedure_name
-          ", override_schema_name || schema.schema_name, package, procedure.to_s.upcase)
-        new(schema, procedure, package, override_schema_name)
+      elsif package && (row = schema.select_first(
+            # older Oracle versions do not have object_id column in all_procedures
+            "SELECT o.object_id FROM all_procedures p, all_objects o
+            WHERE p.owner = :owner
+              AND p.object_name = :object_name
+              AND p.procedure_name = :procedure_name
+              AND o.owner = p.owner
+              AND o.object_name = p.object_name
+              AND o.object_type = 'PACKAGE'",
+            override_schema_name || schema.schema_name, package, procedure.to_s.upcase))
+        new(schema, procedure, package, override_schema_name, row[0])
       else
         nil
       end
@@ -44,7 +48,7 @@ module PLSQL
     attr_reader :arguments, :argument_list, :out_list, :return
     attr_reader :schema, :schema_name, :package, :procedure
 
-    def initialize(schema, procedure, package = nil, override_schema_name = nil)
+    def initialize(schema, procedure, package, override_schema_name, object_id)
       @schema = schema
       @schema_name = override_schema_name || schema.schema_name
       @procedure = procedure.to_s.upcase
@@ -58,18 +62,8 @@ module PLSQL
       # store reference to previous level record or collection metadata
       previous_level_argument_metadata = {}
 
-      # RSI: due to 10gR2 all_arguments performance issue SELECT split into two statements
-      # added condition to ensure that if object is package then package specification not body is selected
-      object_id = @schema.connection.select_first("
-        SELECT o.object_id
-        FROM all_objects o
-        WHERE o.owner = :owner
-        AND o.object_name = :object_name
-        AND o.object_type <> 'PACKAGE BODY'
-        ", @schema_name, @package ? @package : @procedure
-      )[0] rescue nil
-      num_rows = @schema.connection.select_all("
-        SELECT overload, argument_name, position, data_level,
+      @schema.select_all(
+        "SELECT overload, argument_name, position, data_level,
               data_type, in_out, data_length, data_precision, data_scale, char_used,
               type_owner, type_name, type_subname
         FROM all_arguments
@@ -77,8 +71,8 @@ module PLSQL
         AND owner = :owner
         AND object_name = :procedure_name
         AND NVL(package_name,'nil') = :package
-        ORDER BY overload, sequence
-        ", object_id, @schema_name, @procedure, @package ? @package : 'nil'
+        ORDER BY overload, sequence",
+        object_id, @schema_name, @procedure, @package ? @package : 'nil'
       ) do |r|
 
         overload, argument_name, position, data_level,

data/lib/plsql/procedure_call.rb

@@ -3,12 +3,14 @@ module PLSQL
 
     def initialize(procedure, args = [])
       @procedure = procedure
+      @schema = @procedure.schema
+      @dbms_output_stream = @schema.dbms_output_stream
       @overload = get_overload_from_arguments_list(args)
       construct_sql(args)
     end
 
     def exec
-      @cursor = @procedure.schema.connection.parse(@sql)
+      @cursor = @schema.connection.parse(@sql)
 
       @bind_values.each do |arg, value|
         @cursor.bind_param(":#{arg}", value, @bind_metadata[arg])
@@ -20,6 +22,8 @@ module PLSQL
 
       @cursor.exec
 
+      dbms_output_log
+
       if block_given?
         yield get_return_value
         nil
@@ -66,10 +70,10 @@ module PLSQL
       @return_vars = []
       @return_vars_metadata = {}
 
+      @call_sql << add_return if return_metadata
       # construct procedure call if procedure name is available
       # otherwise will get surrounding call_sql from @procedure (used for table statements)
       if procedure_name
-        @call_sql << add_return if return_metadata
         @call_sql << "#{schema_name}." if schema_name
         @call_sql << "#{package_name}." if package_name
         @call_sql << "#{procedure_name}("
@@ -122,8 +126,53 @@ module PLSQL
         @call_sql = @procedure.call_sql(@call_sql)
       end
       add_out_vars
-      @sql = "" << @declare_sql << @assignment_sql << @call_sql << @return_sql << "END;\n"
-      # puts "DEBUG: sql = #{@sql.gsub "\n", "<br/>\n"}"
+
+      dbms_output_enable_sql, dbms_output_get_sql = dbms_output_sql
+
+      @sql = "" << @declare_sql << @assignment_sql << dbms_output_enable_sql << @call_sql << dbms_output_get_sql << @return_sql << "END;\n"
+    end
+
+    def dbms_output_sql
+      if @dbms_output_stream
+        dbms_output_enable_sql = "DBMS_OUTPUT.ENABLE(#{@schema.dbms_output_buffer_size});\n"
+        # if database version is at least 10.2 then use DBMS_OUTPUT.GET_LINES with SYS.DBMSOUTPUT_LINESARRAY
+        if (@schema.connection.database_version <=> [10, 2]) >= 0
+          @declare_sql << "l_dbms_output_numlines INTEGER := #{Schema::DBMS_OUTPUT_MAX_LINES};\n"
+          dbms_output_get_sql = "DBMS_OUTPUT.GET_LINES(:dbms_output_lines, l_dbms_output_numlines);\n"
+          @bind_values[:dbms_output_lines] = nil
+          @bind_metadata[:dbms_output_lines] = {:data_type => 'TABLE', :data_length => nil,
+            :sql_type_name => "SYS.DBMSOUTPUT_LINESARRAY", :in_out => 'OUT'}
+        # if database version is less than 10.2 then use individual DBMS_OUTPUT.GET_LINE calls
+        else
+          dbms_output_get_sql = ""
+        end
+        [dbms_output_enable_sql, dbms_output_get_sql]
+      else
+        ["", ""]
+      end
+    end
+
+    def dbms_output_log
+      if @dbms_output_stream
+        # if database version is at least 10.2 then :dbms_output_lines output bind variable has dbms_output lines
+        if @bind_metadata[:dbms_output_lines]
+          @cursor[':dbms_output_lines'].each do |line|
+            @dbms_output_stream.puts "DBMS_OUTPUT: #{line}" if line
+          end
+        # if database version is less than 10.2 then use individual DBMS_OUTPUT.GET_LINE calls
+        else
+          cursor = @schema.connection.parse("BEGIN sys.dbms_output.get_line(:line, :status); END;")
+          while true do
+            cursor.bind_param(':line', nil, :data_type => 'VARCHAR2', :in_out => 'OUT')
+            cursor.bind_param(':status', nil, :data_type => 'NUMBER', :in_out => 'OUT')
+            cursor.exec
+            break unless cursor[':status'] == 0
+            @dbms_output_stream.puts "DBMS_OUTPUT: #{cursor[':line']}"
+          end
+          cursor.close
+        end
+        @dbms_output_stream.flush
+      end
     end
 
     def add_argument(argument, value)

data/lib/plsql/schema.rb

@@ -3,7 +3,7 @@ module PLSQL
     include SQLStatements
 
     @@schemas = {}
-    
+
     class <<self
       def find_or_new(connection_alias) #:nodoc:
         connection_alias ||= :default
@@ -15,18 +15,16 @@ module PLSQL
       end
 
     end
-    
-    def initialize(raw_conn = nil, schema = nil, first = true) #:nodoc:
+
+    def initialize(raw_conn = nil, schema = nil, original_schema = nil) #:nodoc:
       self.connection = raw_conn
       @schema_name = schema ? schema.to_s.upcase : nil
-      @first = first
+      @original_schema = original_schema
     end
-    
+
     # Returns connection wrapper object (this is not raw OCI8 or JDBC connection!)
-    def connection
-      @connection
-    end
-    
+    attr_reader :connection
+
     def raw_connection=(raw_conn) #:nodoc:
       @connection = raw_conn ? Connection.create(raw_conn) : nil
       reset_instance_variables
@@ -49,6 +47,7 @@ module PLSQL
       else
         self.raw_connection = conn
       end
+      conn
     end
 
     # Set connection to current ActiveRecord connection (use in initializer file):
@@ -58,6 +57,7 @@ module PLSQL
     def activerecord_class=(ar_class)
       @connection = ar_class ? Connection.create(nil, ar_class) : nil
       reset_instance_variables
+      ar_class
     end
 
     # Disconnect from Oracle
@@ -72,22 +72,23 @@ module PLSQL
       @schema_name ||= select_first("SELECT SYS_CONTEXT('userenv','session_user') FROM dual")[0]
     end
 
-    # Set to :local or :utc
-    @@default_timezone = nil
-
     # Default timezone to which database values will be converted - :utc or :local
     def default_timezone
-      @@default_timezone ||
-        # Use ActiveRecord class default_timezone when ActiveRecord connection is used
-        (@connection && (ar_class = @connection.activerecord_class) && ar_class.default_timezone) ||
-        # default to local timezone
-        :local
+      if @original_schema
+        @original_schema.default_timezone
+      else
+        @default_timezone ||
+          # Use ActiveRecord class default_timezone when ActiveRecord connection is used
+          (@connection && (ar_class = @connection.activerecord_class) && ar_class.default_timezone) ||
+          # default to local timezone
+          :local
+      end
     end
 
     # Set default timezone to which database values will be converted - :utc or :local
     def default_timezone=(value)
       if [:local, :utc].include?(value)
-        @@default_timezone = value
+        @default_timezone = value
       else
         raise ArgumentError, "default timezone should be :local or :utc"
       end
@@ -98,7 +99,47 @@ module PLSQL
     def local_timezone_offset #:nodoc:
       ::Time.local(2007).utc_offset.to_r / 86400
     end
-    
+
+    # DBMS_OUTPUT buffer size (default is 20_000)
+    def dbms_output_buffer_size
+      if @original_schema
+        @original_schema.dbms_output_buffer_size
+      else
+        @dbms_output_buffer_size || 20_000
+      end
+    end
+
+    # Seet DBMS_OUTPUT buffer size (default is 20_000). Example:
+    # 
+    #   plsql.dbms_output_buffer_size = 100_000
+    # 
+    def dbms_output_buffer_size=(value)
+      @dbms_output_buffer_size = value
+    end
+
+    # Maximum line numbers for DBMS_OUTPUT in one PL/SQL call (from DBMSOUTPUT_LINESARRAY type)
+    DBMS_OUTPUT_MAX_LINES = 2147483647
+
+    # Specify IO stream where to log DBMS_OUTPUT from PL/SQL procedures. Example:
+    # 
+    #   plsql.dbms_output_stream = STDOUT
+    # 
+    def dbms_output_stream=(stream)
+      @dbms_output_stream = stream
+      if @dbms_output_stream.nil? && @connection
+        sys.dbms_output.disable
+      end
+    end
+
+    # IO stream where to log DBMS_OUTPUT from PL/SQL procedures.
+    def dbms_output_stream
+      if @original_schema
+        @original_schema.dbms_output_stream
+      else
+        @dbms_output_stream
+      end
+    end
+
     private
 
     def reset_instance_variables
@@ -108,44 +149,72 @@ module PLSQL
         @schema_objects = nil
       end
       @schema_name = nil
-      @@default_timezone = nil
+      @default_timezone = nil
     end
-    
+
     def method_missing(method, *args, &block)
-      raise ArgumentError, "No PL/SQL connection" unless connection
-      # look in cache at first
-      if schema_object = @schema_objects[method]
-        if schema_object.is_a?(Procedure)
-          schema_object.exec(*args, &block)
-        else
-          schema_object
-        end
-      # search in database
-      elsif procedure = Procedure.find(self, method)
-        @schema_objects[method] = procedure
-        procedure.exec(*args, &block)
-      elsif package = Package.find(self, method)
-        @schema_objects[method] = package
-      elsif table = Table.find(self, method)
-        @schema_objects[method] = table
-      elsif sequence = Sequence.find(self, method)
-        @schema_objects[method] = sequence
-      elsif schema = find_other_schema(method)
-        @schema_objects[method] = schema
+      raise ArgumentError, "No database connection" unless connection
+      # search in database if not in cache at first
+      object = (@schema_objects[method] ||= find_database_object(method) || find_other_schema(method) ||
+         find_public_synonym(method)) || find_standard_procedure(method)
+
+      raise ArgumentError, "No database object '#{method.to_s.upcase}' found" unless object
+
+      if object.is_a?(Procedure)
+        object.exec(*args, &block)
       else
-        raise ArgumentError, "No PL/SQL procedure found"
+        object
+      end
+    end
+
+    def find_database_object(name, override_schema_name = nil)
+      object_schema_name = override_schema_name || schema_name
+      object_name = name.to_s.upcase
+      if row = select_first(
+          "SELECT object_type, object_id FROM all_objects
+          WHERE owner = :owner AND object_name = :object_name
+          AND object_type IN ('PROCEDURE','FUNCTION','PACKAGE','TABLE','VIEW','SEQUENCE','TYPE','SYNONYM')",
+          object_schema_name, object_name)
+        case row[0]
+        when 'PROCEDURE', 'FUNCTION'
+          Procedure.new(self, name, nil, override_schema_name, row[1])
+        when 'PACKAGE', 'PACKAGE BODY'
+          Package.new(self, name, override_schema_name)
+        when 'TABLE'
+          Table.new(self, name, override_schema_name)
+        when 'VIEW'
+          View.new(self, name, override_schema_name)
+        when 'SEQUENCE'
+          Sequence.new(self, name, override_schema_name)
+        when 'TYPE'
+          Type.new(self, name, override_schema_name)
+        when 'SYNONYM'
+          target_schema_name, target_object_name = @connection.describe_synonym(object_schema_name, object_name)
+          find_database_object(target_object_name, target_schema_name)
+        end
       end
     end
 
     def find_other_schema(name)
-      return nil unless @first && connection
+      return nil if @original_schema
       if select_first("SELECT username FROM all_users WHERE username = :username", name.to_s.upcase)
-        Schema.new(connection, name, false)
+        Schema.new(connection, name, self)
       else
         nil
       end
     end
-    
+
+    def find_standard_procedure(name)
+      return nil if @original_schema
+      Procedure.find(self, name, 'STANDARD', 'SYS')
+    end
+
+    def find_public_synonym(name)
+      return nil if @original_schema
+      target_schema_name, target_object_name = @connection.describe_synonym('PUBLIC', name)
+      find_database_object(target_object_name, target_schema_name) if target_schema_name
+    end
+
   end
 end
 

data/lib/plsql/sequence.rb

@@ -39,7 +39,7 @@ module PLSQL
       @schema.select_one "SELECT \"#{@schema_name}\".\"#{@sequence_name}\".NEXTVAL FROM dual"
     end
 
-    # Get CURRTVAL of sequence (can be called just after nextval)
+    # Get CURRVAL of sequence (can be called just after nextval)
     def currval
       @schema.select_one "SELECT \"#{@schema_name}\".\"#{@sequence_name}\".CURRVAL FROM dual"
     end

data/lib/plsql/sql_statements.rb

@@ -5,6 +5,11 @@ module PLSQL
       @connection.select_first(sql, *bindvars)
     end
 
+    # Select all rows as array or values (without column names)
+    def select_all(sql, *bindvars, &block)
+      @connection.select_all(sql, *bindvars, &block)
+    end
+
     # Select one value (use if only one row with one value is selected)
     def select_one(sql, *bindvars)
       (row = @connection.select_first(sql, *bindvars)) && row[0]
@@ -43,7 +48,7 @@ module PLSQL
     # 
     # to turn off automatic commits after each statement.
     def commit
-      connection.commit
+      @connection.commit
     end
 
     # Execute ROLLBACK in current database session.
@@ -53,7 +58,7 @@ module PLSQL
     # 
     # to turn off automatic commits after each statement.
     def rollback
-      connection.rollback
+      @connection.rollback
     end
 
   end