ruby-plsql 0.4.1 → 0.4.2

data/lib/plsql/schema.rb

@@ -25,6 +25,10 @@ module PLSQL
     # 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
@@ -32,16 +36,16 @@ module PLSQL
 
     # Set connection to OCI8 or JDBC connection:
     # 
-    #   plsql.connection = OCI8.new(database_user, database_password, DATABASE_NAME)
+    #   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}",
+    #     "jdbc:oracle:thin:@#{database_host}:#{database_port}:#{database_name}",
     #     database_user, database_password)
     #
     def connection=(conn)
-      if conn.is_a?(::PLSQL::Connection)
+      if conn.is_a?(Connection)
         @connection = conn
         reset_instance_variables
       else
@@ -50,6 +54,23 @@ module PLSQL
       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
@@ -156,12 +177,14 @@ module PLSQL
       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)
+         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
@@ -171,14 +194,24 @@ module PLSQL
       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
+          "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
+          FROM all_objects o
           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]
+        object_type, object_id, status, body_status = 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', 'FUNCTION'
-          Procedure.new(self, name, nil, override_schema_name, row[1])
-        when 'PACKAGE', 'PACKAGE BODY'
+          Procedure.new(self, name, nil, override_schema_name, object_id)
+        when 'PACKAGE'
           Package.new(self, name, override_schema_name)
         when 'TABLE'
           Table.new(self, name, override_schema_name)
@@ -195,6 +228,24 @@ module PLSQL
       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)

data/lib/plsql/sql_statements.rb

@@ -61,6 +61,27 @@ module PLSQL
       @connection.rollback
     end
 
+    # Create SAVEPOINT with specified name. Later use +rollback_to+ method to roll changes back
+    # to specified savepoint.
+    # Use beforehand
+    # 
+    #   plsql.connection.autocommit = false
+    # 
+    # to turn off automatic commits after each statement.
+    def savepoint(name)
+      execute "SAVEPOINT #{name}"
+    end
+
+    # Roll back changes to specified savepoint (that was created using +savepoint+ method)
+    # Use beforehand
+    # 
+    #   plsql.connection.autocommit = false
+    # 
+    # to turn off automatic commits after each statement.
+    def rollback_to(name)
+      execute "ROLLBACK TO #{name}"
+    end
+
   end
 end
 

data/lib/plsql/table.rb

@@ -49,7 +49,8 @@ module PLSQL
               CASE WHEN c.data_type_owner IS NULL THEN NULL
               ELSE (SELECT t.typecode FROM all_types t
                 WHERE t.owner = c.data_type_owner
-                AND t.type_name = c.data_type) END typecode
+                AND t.type_name = c.data_type) END typecode,
+              c.nullable, c.data_default
         FROM all_tab_columns c
         WHERE c.owner = :owner
         AND c.table_name = :table_name",
@@ -57,7 +58,10 @@ module PLSQL
       ) do |r|
         column_name, position,
               data_type, data_length, data_precision, data_scale, char_used,
-              data_type_owner, data_type_mod, typecode = r
+              data_type_owner, data_type_mod, typecode, nullable, data_default = r
+        # remove scale (n) from data_type (returned for TIMESTAMPs and INTERVALs)
+        data_type.sub!(/\(\d+\)/,'')
+        # store column metadata
         @columns[column_name.downcase.to_sym] = {
           :position => position && position.to_i,
           :data_type => data_type_owner && (typecode == 'COLLECTION' ? 'TABLE' : 'OBJECT' ) || data_type,
@@ -67,7 +71,9 @@ module PLSQL
           :char_used => char_used,
           :type_owner => data_type_owner,
           :type_name => data_type_owner && data_type,
-          :sql_type_name => data_type_owner && "#{data_type_owner}.#{data_type}"
+          :sql_type_name => data_type_owner && "#{data_type_owner}.#{data_type}",
+          :nullable => nullable == 'Y', # store as true or false
+          :data_default => data_default && data_default.strip # remove leading and trailing whitespace
         }
       end
     end
@@ -98,7 +104,7 @@ module PLSQL
         order_by_sql = nil
         sql_params.each do |k,v|
           if k == :order_by
-            order_by_sql = "ORDER BY #{v} "
+            order_by_sql = " ORDER BY #{v} "
           elsif v.nil?
             where_sqls << "#{k} IS NULL"
           else

data/lib/plsql/type.rb

@@ -34,19 +34,23 @@ module PLSQL
   class Type
     extend TypeClassMethods
 
-    attr_reader :typecode, :attributes, :schema_name, :type_name #:nodoc:
+    attr_reader :typecode, :attributes, :schema_name, :type_name, :type_object_id #:nodoc:
 
     def initialize(schema, type, override_schema_name = nil) #:nodoc:
       @schema = schema
       @schema_name = override_schema_name || schema.schema_name
       @type_name = type.to_s.upcase
       @attributes = {}
+      @type_procedures = {}
 
-      @typecode = @schema.select_first(
-        "SELECT typecode FROM all_types
-        WHERE owner = :owner
-        AND type_name = :type_name",
-        @schema_name, @type_name)[0]
+      @typecode, @type_object_id = @schema.select_first(
+        "SELECT t.typecode, o.object_id FROM all_types t, all_objects o
+        WHERE t.owner = :owner
+        AND t.type_name = :type_name
+        AND o.owner = t.owner
+        AND o.object_name = t.type_name
+        AND o.object_type = 'TYPE'",
+        @schema_name, @type_name)
 
       @schema.select_all(
         "SELECT attr_name, attr_no,
@@ -77,11 +81,195 @@ module PLSQL
       end
     end
 
+    # is type collection?
+    def collection?
+      @is_collection ||= @typecode == 'COLLECTION'
+    end
+
     # list of object type attribute names
     def attribute_names
       @attribute_names ||= @attributes.keys.sort_by{|k| @attributes[k][:position]}
     end
 
+    # create new PL/SQL object instance
+    def new(*args, &block)
+      procedure = find_procedure(:new)
+      # in case of collections pass array of elements as one argument for constructor
+      if collection? && !(args.size == 1 && args[0].is_a?(Array))
+        args = [args]
+      end
+      result = procedure.exec_with_options(args, {:skip_self => true}, &block)
+      # TODO: collection constructor should return Array of ObhjectInstance objects
+      if collection?
+        result
+      else
+        # TODO: what to do if block is passed to constructor?
+        ObjectInstance.create(self, result)
+      end
+    end
+
+    def method_missing(method, *args, &block) #:nodoc:
+      if procedure = find_procedure(method)
+        procedure.exec_with_options(args, {}, &block)
+      else
+        raise ArgumentError, "No PL/SQL procedure '#{method.to_s.upcase}' found for type '#{@type_name}'"
+      end
+    end
+
+    def find_procedure(new_or_procedure) #:nodoc:
+      @type_procedures[new_or_procedure] ||= begin
+        procedure_name = new_or_procedure == :new ? @type_name : new_or_procedure
+        # find defined procedure for type
+        if @schema.select_first(
+              "SELECT procedure_name FROM all_procedures
+              WHERE owner = :owner
+                AND object_name = :object_name
+                AND procedure_name = :procedure_name",
+              @schema_name, @type_name, procedure_name.to_s.upcase)
+          TypeProcedure.new(@schema, self, procedure_name)
+        # call default constructor
+        elsif new_or_procedure == :new
+          TypeProcedure.new(@schema, self, :new)
+        end
+      end
+    end
+
+    # wrapper class to simulate Procedure class for ProcedureClass#exec
+    class TypeProcedure #:nodoc:
+      include ProcedureCommon
+
+      def initialize(schema, type, procedure)
+        @schema = schema
+        @type = type
+        @schema_name = @type.schema_name
+        @type_name = @type.type_name
+        @object_id = @type.type_object_id
+
+        # if default constructor
+        if @default_constructor = (procedure == :new)
+          @procedure = @type.collection? ? nil : @type_name
+          set_default_constructor_arguments
+        # if defined type procedure
+        else
+          @procedure = procedure.to_s.upcase
+          get_argument_metadata
+          # add also definition for default constructor in case of custom constructor
+          set_default_constructor_arguments if @procedure == @type_name
+        end
+
+        # constructors do not need type prefix in call
+        @package = @procedure == @type_name ? nil : @type_name
+      end
+
+      # will be called for collection constructor
+      def call_sql(params_string)
+        "#{params_string};\n"
+      end
+
+      attr_reader :arguments, :argument_list, :out_list
+      def arguments_without_self
+        @arguments_without_self ||= begin
+          hash = {}
+          @arguments.each do |ov, args|
+            hash[ov] = args.reject{|key, value| key == :self}
+          end
+          hash
+        end
+      end
+
+      def argument_list_without_self
+        @argument_list_without_self ||= begin
+          hash = {}
+          @argument_list.each do |ov, arg_list|
+            hash[ov] = arg_list.select{|arg| arg != :self}
+          end
+          hash
+        end
+      end
+
+      def out_list_without_self
+        @out_list_without_self ||= begin
+          hash = {}
+          @out_list.each do |ov, out_list|
+            hash[ov] = out_list.select{|arg| arg != :self}
+          end
+          hash
+        end
+      end
+
+      def exec_with_options(args, options={}, &block)
+        call = ProcedureCall.new(self, args, options)
+        result = call.exec(&block)
+        # if procedure was called then modified object is returned in SELF output parameter
+        if result.is_a?(Hash) && result[:self]
+          object = result.delete(:self)
+          result.empty? ? object : [object, result]
+        else
+          result
+        end
+      end
+
+      private
+
+      def set_default_constructor_arguments
+        @arguments ||= {}
+        @argument_list ||= {}
+        @out_list ||= {}
+        @return ||= {}
+        # either this will be the only overload or it will be additional
+        overload = @arguments.keys.size
+        # if type is collection then expect array of objects as argument
+        if @type.collection?
+          @arguments[overload] = {
+            :value => {
+              :position => 1,
+              :data_type => 'TABLE',
+              :in_out => 'IN',
+              :type_owner => @schema_name,
+              :type_name => @type_name,
+              :sql_type_name => "#{@schema_name}.#{@type_name}"
+            }
+          }
+        # otherwise if type is object type then expect object attributes as argument list
+        else
+          @arguments[overload] = @type.attributes
+        end
+        attributes = @arguments[overload]
+        @argument_list[overload] = attributes.keys.sort {|k1, k2| attributes[k1][:position] <=> attributes[k2][:position]}
+        # returns object or collection
+        @return[overload] = {
+          :position => 0,
+          :data_type => @type.collection? ? 'TABLE' : 'OBJECT',
+          :in_out => 'OUT',
+          :type_owner => @schema_name,
+          :type_name => @type_name,
+          :sql_type_name => "#{@schema_name}.#{@type_name}"
+        }
+        @out_list[overload] = []
+        @overloaded = overload > 0
+      end
+
+    end
+
+  end
+
+  class ObjectInstance < Hash #:nodoc:
+    attr_accessor :plsql_type
+
+    def self.create(type, attributes)
+      object = self.new.merge!(attributes)
+      object.plsql_type = type
+      object
+    end
+
+    def method_missing(method, *args, &block)
+      if procedure = @plsql_type.find_procedure(method)
+        procedure.exec_with_options(args, :self => self, &block)
+      else
+        raise ArgumentError, "No PL/SQL procedure '#{method.to_s.upcase}' found for type '#{@plsql_type.type_name}' object"
+      end
+    end
+
   end
 
 end

data/lib/plsql/variable.rb

@@ -10,7 +10,7 @@ module PLSQL
               AND type = 'PACKAGE'
               AND UPPER(text) LIKE :variable_name",
             override_schema_name || schema.schema_name, package, "%#{variable_upcase}%").each do |row|
-        if row[0] =~ /^\s*#{variable_upcase}\s+(CONSTANT\s+)?([A-Z0-9_. %]+(\([0-9,]+\))?)\s*(NOT\s+NULL)?\s*((:=|DEFAULT).*)?;\s*(--.*)?$/i
+        if row[0] =~ /^\s*#{variable_upcase}\s+(CONSTANT\s+)?([A-Z0-9_. %]+(\([\w\s,]+\))?)\s*(NOT\s+NULL)?\s*((:=|DEFAULT).*)?;\s*(--.*)?$/i
           return new(schema, variable, package, $2.strip, override_schema_name)
         end
       end
@@ -47,7 +47,7 @@ module PLSQL
 
     def metadata(type_string)
       case type_string
-      when /^(VARCHAR2|CHAR|NVARCHAR2|NCHAR)(\((\d+)\))?$/
+      when /^(VARCHAR2|CHAR|NVARCHAR2|NCHAR)(\((\d+)[\s\w]*\))?$/
         {:data_type => $1, :data_length => $3.to_i, :in_out => 'IN/OUT'}
       when /^(CLOB|NCLOB|BLOB)$/,
           /^(NUMBER)(\(.*\))?$/, /^(PLS_INTEGER|BINARY_INTEGER)$/,
@@ -63,7 +63,7 @@ module PLSQL
         column = table.columns[$3.downcase.to_sym]
         {:data_type => column[:data_type], :data_length => column[:data_length], :sql_type_name => column[:sql_type_name], :in_out => 'IN/OUT'}
       when /^(\w+\.)?(\w+)$/
-        schema = $1 ? plsql.send($1.chop) : plsql
+        schema = $1 ? @schema.root_schema.send($1.chop) : @schema
         begin
           type = schema.send($2.downcase.to_sym)
           raise ArgumentError unless type.is_a?(PLSQL::Type)

data/spec/plsql/connection_spec.rb

@@ -404,11 +404,86 @@ describe "Connection" do
 
   end
 
-  describe "database version" do
+  describe "session information" do
     it "should get database version" do
       # using Oracle version 10.2.0.4 for unit tests
       @conn.database_version.should == [10, 2]
     end
+
+    it "should get session ID" do
+      @conn.session_id.should == @conn.select_first("SELECT USERENV('SESSIONID') FROM dual")[0].to_i
+    end
+  end
+
+  describe "drop ruby temporary tables" do
+    after(:all) do
+      @conn.drop_all_ruby_temporary_tables
+    end
+
+    it "should drop all ruby temporary tables" do
+      tmp_table = "ruby_111_222_333"
+      @conn.exec "CREATE GLOBAL TEMPORARY TABLE #{tmp_table} (dummy CHAR(1))"
+      lambda { @conn.select_first("SELECT * FROM #{tmp_table}") }.should_not raise_error
+      @conn.drop_all_ruby_temporary_tables
+      lambda { @conn.select_first("SELECT * FROM #{tmp_table}") }.should raise_error(/table or view does not exist/)
+    end
+
+    it "should drop current session ruby temporary tables" do
+      tmp_table = "ruby_#{@conn.session_id}_222_333"
+      @conn.exec "CREATE GLOBAL TEMPORARY TABLE #{tmp_table} (dummy CHAR(1))"
+      lambda { @conn.select_first("SELECT * FROM #{tmp_table}") }.should_not raise_error
+      @conn.drop_session_ruby_temporary_tables
+      lambda { @conn.select_first("SELECT * FROM #{tmp_table}") }.should raise_error(/table or view does not exist/)
+    end
+
+    it "should not drop other session ruby temporary tables" do
+      tmp_table = "ruby_#{@conn.session_id+1}_222_333"
+      @conn.exec "CREATE GLOBAL TEMPORARY TABLE #{tmp_table} (dummy CHAR(1))"
+      lambda { @conn.select_first("SELECT * FROM #{tmp_table}") }.should_not raise_error
+      @conn.drop_session_ruby_temporary_tables
+      lambda { @conn.select_first("SELECT * FROM #{tmp_table}") }.should_not raise_error
+    end
+
+  end
+
+  describe "logoff" do
+    before(:each) do
+      # restore connection before each test
+      reconnect_connection
+    end
+
+    after(:all) do
+      @conn.exec "DROP TABLE test_dummy_table" rescue nil
+    end
+
+    def reconnect_connection
+      @raw_conn = get_connection
+      @conn = PLSQL::Connection.create( @raw_conn )
+    end
+
+    it "should drop current session ruby temporary tables" do
+      tmp_table = "ruby_#{@conn.session_id}_222_333"
+      @conn.exec "CREATE GLOBAL TEMPORARY TABLE #{tmp_table} (dummy CHAR(1))"
+      lambda { @conn.select_first("SELECT * FROM #{tmp_table}") }.should_not raise_error
+      @conn.logoff
+      reconnect_connection
+      lambda { @conn.select_first("SELECT * FROM #{tmp_table}") }.should raise_error(/table or view does not exist/)
+    end
+
+    it "should rollback any uncommited transactions" do
+      tmp_table = "ruby_#{@conn.session_id}_222_333"
+      old_autocommit = @conn.autocommit?
+      @conn.autocommit = false
+      @conn.exec "CREATE GLOBAL TEMPORARY TABLE #{tmp_table} (dummy CHAR(1))"
+      @conn.exec "CREATE TABLE test_dummy_table (dummy CHAR(1))"
+      @conn.exec "INSERT INTO test_dummy_table VALUES ('1')"
+      # logoff will drop ruby temporary tables, it should do rollback before drop table
+      @conn.logoff
+      reconnect_connection
+      @conn.select_first("SELECT * FROM test_dummy_table").should == nil
+      @conn.autocommit = old_autocommit
+    end
+
   end
 
 end