flash-gordons-ruby-plsql 0.5.0

data/lib/plsql/procedure_call.rb

@@ -0,0 +1,124 @@
+module PLSQL
+  class ProcedureCall < SubprogramCall #:nodoc:
+    attr_reader :output_stream
+
+    def initialize(procedure, args = [], options = {})
+      @output_stream = procedure.schema.dbms_output_stream
+      super
+    end
+
+    def exec
+      # puts "DEBUG: sql = #{@sql.gsub("\n","<br/>\n")}"
+      @cursor = @schema.connection.parse(@sql)
+
+      @binds[:values].each do |arg, value|
+        @cursor.bind_param(":#{arg}", value, @binds[:metadata][arg])
+      end
+
+      @return[:variables].each do |var|
+        @cursor.bind_param(":#{var}", nil, @return[:metadata][var])
+      end
+
+      @cursor.exec
+
+      dbms_output_log
+
+      if block_given?
+        yield get_return_value
+        nil
+      else
+        get_return_value
+      end
+    ensure
+      @cursor.close if @cursor
+    end
+
+    private
+
+    def construct_sql(arguments)
+      prepare_sql_construction
+      call_sql = ""
+      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 subprogram_name
+        call_sql << "#{full_subprogram_name}(#{add_arguments(arguments)});\n"
+      else
+        call_sql << add_arguments(arguments)
+        call_sql = @subprogram.call_sql(call_sql)
+      end
+
+      add_out_variables
+
+      dbms_output_enable_sql, dbms_output_get_sql = dbms_output_sql
+
+      @sql = <<-SQL
+        DECLARE
+          #{@declare_sql}
+        BEGIN
+          #{@assignment_sql}
+          #{dbms_output_enable_sql}
+          #{call_sql}
+          #{dbms_output_get_sql}
+          #{@return[:sql]}
+        END;
+      SQL
+    end
+
+    def get_return_value
+      # create output hash if there are any out variables
+      output = out_list.inject({}) {|res, k| res[k] = out_variable_value(k); res} if out_list.size > 0
+      # if function with output parameters
+      if return_metadata && out_list.size > 0
+        [function_return_value, output]
+      # if function without output parameters
+      elsif return_metadata
+        function_return_value
+      # if procedure with output parameters
+      elsif out_list.size > 0
+        output
+      end
+      # nil if procedure without output parameters
+    end
+
+    def dbms_output_sql
+      return ["", ""] unless 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, 0]) >= 0
+        add_variable_declaration('dbms_output_numlines', 'integer', :value => Schema::DBMS_OUTPUT_MAX_LINES)
+        dbms_output_get_sql = "DBMS_OUTPUT.GET_LINES(:dbms_output_lines, l_dbms_output_numlines);\n"
+        bind_value(:dbms_output_lines, nil,
+                   :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]
+    end
+
+    def dbms_output_log
+      return unless output_stream
+
+      # if database version is at least 10.2 then :dbms_output_lines output bind variable has dbms_output lines
+      if @binds[:metadata][:dbms_output_lines]
+        @cursor[':dbms_output_lines'].each {|line| output_stream.puts("DBMS_OUTPUT: #{line}") if line}
+      # 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
+          output_stream.puts "DBMS_OUTPUT: #{cursor[':line']}"
+        end
+        cursor.close
+      end
+      output_stream.flush
+    end
+  end
+end

data/lib/plsql/schema.rb

@@ -0,0 +1,309 @@
+module PLSQL
+  class Schema
+    include SQLStatements
+
+    @@schemas = {}
+
+    class <<self
+      def find_or_new(connection_alias) #:nodoc:
+        connection_alias ||= :default
+        if @@schemas[connection_alias]
+          @@schemas[connection_alias]
+        else
+          @@schemas[connection_alias] = self.new
+        end
+      end
+
+    end
+
+    def initialize(raw_conn = nil, schema = nil, original_schema = nil) #:nodoc:
+      self.connection = raw_conn
+      @schema_name = schema ? schema.to_s.upcase : nil
+      @original_schema = original_schema
+    end
+
+    # Returns connection wrapper object (this is not raw OCI8 or JDBC connection!)
+    attr_reader :connection
+
+    def root_schema #:nodoc:
+      @original_schema || self
+    end
+
+    def raw_connection=(raw_conn) #:nodoc:
+      @connection = raw_conn ? Connection.create(raw_conn) : nil
+      reset_instance_variables
+    end
+
+    # Set connection to OCI8 or JDBC connection:
+    # 
+    #   plsql.connection = OCI8.new(database_user, database_password, database_name)
+    #
+    # or
+    #
+    #   plsql.connection = java.sql.DriverManager.getConnection(
+    #     "jdbc:oracle:thin:@#{database_host}:#{database_port}:#{database_name}",
+    #     database_user, database_password)
+    #
+    def connection=(conn)
+      if conn.is_a?(Connection)
+        @connection = conn
+        reset_instance_variables
+      else
+        self.raw_connection = conn
+      end
+      conn
+    end
+
+    # Create new OCI8 or JDBC connection using one of the following ways:
+    #
+    #   plsql.connect! username, password, database_tns_alias
+    #   plsql.connect! username, password, :host => host, :port => port, :database => database
+    #   plsql.connect! :username => username, :password => password, :database => database_tns_alias
+    #   plsql.connect! :username => username, :password => password, :host => host, :port => port, :database => database
+    #
+    def connect!(*args)
+      params = {}
+      params[:username] = args.shift if args[0].is_a?(String)
+      params[:password] = args.shift if args[0].is_a?(String)
+      params[:database] = args.shift if args[0].is_a?(String)
+      params.merge!(args.shift) if args[0].is_a?(Hash)
+      raise ArgumentError, "Wrong number of arguments" unless args.empty?
+      self.connection = Connection.create_new(params)
+    end
+
+    # Set connection to current ActiveRecord connection (use in initializer file):
+    #
+    #   plsql.activerecord_class = ActiveRecord::Base
+    #
+    def activerecord_class=(ar_class)
+      @connection = ar_class ? Connection.create(nil, ar_class) : nil
+      reset_instance_variables
+      ar_class
+    end
+
+    # Disconnect from Oracle
+    def logoff
+      @connection.logoff
+      self.connection = nil
+    end
+
+    # Current Oracle schema name
+    def schema_name
+      return nil unless connection
+      @schema_name ||= select_first("SELECT SYS_CONTEXT('userenv','session_user') FROM dual")[0]
+    end
+
+    # Default timezone to which database values will be converted - :utc or :local
+    def default_timezone
+      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
+      else
+        raise ArgumentError, "default timezone should be :local or :utc"
+      end
+    end
+
+    # Same implementation as for ActiveRecord
+    # DateTimes aren't aware of DST rules, so use a consistent non-DST offset when creating a DateTime with an offset in the local zone
+    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
+      if @connection
+        @schema_objects = {}
+      else
+        @schema_objects = nil
+      end
+      @schema_name = nil
+      @default_timezone = nil
+    end
+
+    def method_missing(method, *args, &block)
+      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)
+      elsif object.is_a?(Type) && !args.empty?
+        object.new(*args, &block)
+      else
+        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(<<-SQL, object_schema_name, object_name))
+          SELECT o.object_type,
+                 o.object_id,
+                 o.status,
+                (CASE
+                 WHEN o.object_type = 'PACKAGE' THEN
+                  (SELECT ob.status
+                   FROM   all_objects ob
+                   WHERE  ob.owner = o.owner
+                   AND    ob.object_name = o.object_name
+                   AND    ob.object_type = 'PACKAGE BODY')
+                 ELSE NULL
+                 END) body_status,
+                (CASE
+                 WHEN o.object_type = 'FUNCTION' THEN
+                  (SELECT p.pipelined
+                   FROM   all_procedures p
+                   WHERE  p.owner = o.owner
+                   AND    p.object_name = o.object_name
+                   AND    p.object_type = 'FUNCTION')
+                 ELSE NULL
+                 END) pipelined
+          FROM   all_objects o
+          WHERE  owner = :owner
+          AND    object_name = :object_name
+          AND    object_type IN ('PROCEDURE','FUNCTION','PACKAGE','TABLE','VIEW','SEQUENCE','TYPE','SYNONYM')
+        SQL
+
+        object_type, object_id, status, body_status, pipelined = row
+        raise ArgumentError, "Database object '#{object_schema_name}.#{object_name}' is not in valid status\n#{
+          _errors(object_schema_name, object_name, object_type)}" if status == 'INVALID'
+        raise ArgumentError, "Package '#{object_schema_name}.#{object_name}' body is not in valid status\n#{
+          _errors(object_schema_name, object_name, 'PACKAGE BODY')}" if body_status == 'INVALID'
+        case object_type
+        when 'PROCEDURE'
+          Procedure.new(self, name, nil, override_schema_name, object_id)
+        when 'FUNCTION'
+          if pipelined == 'NO'
+            Procedure.new(self, name, nil, override_schema_name, object_id)
+          else
+            PipelinedFunction.new(self, name, nil, override_schema_name, object_id)
+          end
+        when 'PACKAGE'
+          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 _errors(object_schema_name, object_name, object_type)
+      result = ""
+      previous_line = 0
+      select_all(
+        "SELECT e.line, e.position, e.text error_text, s.text source_text
+        FROM all_errors e, all_source s
+        WHERE e.owner = :owner AND e.name = :name AND e.type = :type
+          AND s.owner = e.owner AND s.name = e.name AND s.type = e.type AND s.line = e.line
+        ORDER BY e.sequence",
+        object_schema_name, object_name, object_type
+      ).each do |line, position, error_text, source_text|
+        result << "Error on line #{'%4d' % line}: #{source_text}" if line > previous_line
+        result << "     position #{'%4d' % position}: #{error_text}\n"
+        previous_line = line
+      end
+      result unless result.empty?
+    end
+
+    def find_other_schema(name)
+      return nil if @original_schema
+      if select_first("SELECT username FROM all_users WHERE username = :username", name.to_s.upcase)
+        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
+
+module Kernel
+  # Returns current schema object. You can now chain either database object (packages, procedures, tables, sequences)
+  # in current schema or specify different schema name. Examples:
+  #
+  #   plsql.test_function('some parameter')
+  #   plsql.test_package.test_function('some parameter')
+  #   plsql.other_schema.test_package.test_function('some parameter')
+  #   plsql.table_name.all
+  #   plsql.other_schema.table_name.all
+  #
+  def plsql(connection_alias = nil)
+    PLSQL::Schema.find_or_new(connection_alias)
+  end
+end

data/lib/plsql/sequence.rb

@@ -0,0 +1,49 @@
+module PLSQL
+
+  module SequenceClassMethods #:nodoc:
+    def find(schema, sequence)
+      if schema.select_first(
+            "SELECT sequence_name FROM all_sequences
+            WHERE sequence_owner = :owner
+              AND sequence_name = :sequence_name",
+            schema.schema_name, sequence.to_s.upcase)
+        new(schema, sequence)
+      # search for synonym
+      elsif (row = schema.select_first(
+            "SELECT t.sequence_owner, t.sequence_name
+            FROM all_synonyms s, all_sequences t
+            WHERE s.owner IN (:owner, 'PUBLIC')
+              AND s.synonym_name = :synonym_name
+              AND t.sequence_owner = s.table_owner
+              AND t.sequence_name = s.table_name
+            ORDER BY DECODE(s.owner, 'PUBLIC', 1, 0)",
+            schema.schema_name, sequence.to_s.upcase))
+        new(schema, row[1], row[0])
+      else
+        nil
+      end
+    end
+  end
+
+  class Sequence
+    extend SequenceClassMethods
+
+    def initialize(schema, sequence, override_schema_name = nil) #:nodoc:
+      @schema = schema
+      @schema_name = override_schema_name || schema.schema_name
+      @sequence_name = sequence.to_s.upcase
+    end
+
+    # Get NEXTVAL of sequence
+    def nextval
+      @schema.select_one "SELECT \"#{@schema_name}\".\"#{@sequence_name}\".NEXTVAL FROM dual"
+    end
+
+    # Get CURRVAL of sequence (can be called just after nextval)
+    def currval
+      @schema.select_one "SELECT \"#{@schema_name}\".\"#{@sequence_name}\".CURRVAL FROM dual"
+    end
+
+  end
+
+end