ruby-plsql 0.5.3 → 0.8.0

data/lib/plsql/type.rb

@@ -1,28 +1,27 @@
 module PLSQL
-
   module TypeClassMethods #:nodoc:
     def find(schema, type)
       if schema.select_first(
-            "SELECT type_name FROM all_types
-            WHERE owner = :owner
-              AND type_name = :table_name",
+        "SELECT type_name FROM all_types
+        WHERE owner = :owner
+          AND type_name = :table_name",
             schema.schema_name, type.to_s.upcase)
         new(schema, type)
       # search for synonym
       elsif (row = schema.select_first(
-            "SELECT t.owner, t.type_name
-            FROM all_synonyms s, all_types t
-            WHERE s.owner = :owner
-              AND s.synonym_name = :synonym_name
-              AND t.owner = s.table_owner
-              AND t.type_name = s.table_name
-            UNION ALL
-            SELECT t.owner, t.type_name
-            FROM all_synonyms s, all_types t
-            WHERE s.owner = 'PUBLIC'
-              AND s.synonym_name = :synonym_name
-              AND t.owner = s.table_owner
-              AND t.type_name = s.table_name",
+        "SELECT t.owner, t.type_name
+        FROM all_synonyms s, all_types t
+        WHERE s.owner = :owner
+          AND s.synonym_name = :synonym_name
+          AND t.owner = s.table_owner
+          AND t.type_name = s.table_name
+        UNION ALL
+        SELECT t.owner, t.type_name
+        FROM all_synonyms s, all_types t
+        WHERE s.owner = 'PUBLIC'
+          AND s.synonym_name = :synonym_name
+          AND t.owner = s.table_owner
+          AND t.type_name = s.table_name",
             schema.schema_name, type.to_s.upcase, type.to_s.upcase))
         new(schema, row[1], row[0])
       else
@@ -67,28 +66,28 @@ module PLSQL
       ) do |r|
         attr_name, position,
               data_type, data_length, data_precision, data_scale,
-              data_type_owner, data_type_mod, typecode = r
+              data_type_owner, _, typecode = r
         @attributes[attr_name.downcase.to_sym] = {
-          :position => position && position.to_i,
-          :data_type => data_type_owner && (typecode == 'COLLECTION' ? 'TABLE' : 'OBJECT' ) || data_type,
-          :data_length => data_type_owner ? nil : data_length && data_length.to_i,
-          :data_precision => data_precision && data_precision.to_i,
-          :data_scale => data_scale && data_scale.to_i,
-          :type_owner => data_type_owner,
-          :type_name => data_type_owner && data_type,
-          :sql_type_name => data_type_owner && "#{data_type_owner}.#{data_type}"
+          position: position && position.to_i,
+          data_type: data_type_owner && (typecode == "COLLECTION" ? "TABLE" : "OBJECT") || data_type,
+          data_length: data_type_owner ? nil : data_length && data_length.to_i,
+          data_precision: data_precision && data_precision.to_i,
+          data_scale: data_scale && data_scale.to_i,
+          type_owner: data_type_owner,
+          type_name: data_type_owner && data_type,
+          sql_type_name: data_type_owner && "#{data_type_owner}.#{data_type}"
         }
       end
     end
 
     # is type collection?
     def collection?
-      @is_collection ||= @typecode == '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]}
+      @attribute_names ||= @attributes.keys.sort_by { |k| @attributes[k][:position] }
     end
 
     # create new PL/SQL object instance
@@ -98,7 +97,7 @@ module PLSQL
       if collection? && !(args.size == 1 && args[0].is_a?(Array))
         args = [args]
       end
-      result = procedure.exec_with_options(args, {:skip_self => true}, &block)
+      result = procedure.exec_with_options(args, { skip_self: true }, &block)
       # TODO: collection constructor should return Array of ObhjectInstance objects
       if collection?
         result
@@ -121,10 +120,10 @@ module PLSQL
         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",
+          "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
@@ -171,7 +170,7 @@ module PLSQL
         @arguments_without_self ||= begin
           hash = {}
           @arguments.each do |ov, args|
-            hash[ov] = args.reject{|key, value| key == :self}
+            hash[ov] = args.reject { |key, value| key == :self }
           end
           hash
         end
@@ -181,7 +180,7 @@ module PLSQL
         @argument_list_without_self ||= begin
           hash = {}
           @argument_list.each do |ov, arg_list|
-            hash[ov] = arg_list.select{|arg| arg != :self}
+            hash[ov] = arg_list.select { |arg| arg != :self }
           end
           hash
         end
@@ -191,13 +190,13 @@ module PLSQL
         @out_list_without_self ||= begin
           hash = {}
           @out_list.each do |ov, out_list|
-            hash[ov] = out_list.select{|arg| arg != :self}
+            hash[ov] = out_list.select { |arg| arg != :self }
           end
           hash
         end
       end
 
-      def exec_with_options(args, options={}, &block)
+      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
@@ -211,46 +210,44 @@ module PLSQL
 
       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}"
+        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}"
           }
-        # otherwise if type is object type then expect object attributes as argument list
-        else
-          @arguments[overload] = @type.attributes
+          @out_list[overload] = []
+          @overloaded = overload > 0
         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:
@@ -264,12 +261,10 @@ module PLSQL
 
     def method_missing(method, *args, &block)
       if procedure = @plsql_type.find_procedure(method)
-        procedure.exec_with_options(args, :self => self, &block)
+        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

@@ -1,14 +1,13 @@
 module PLSQL
-
   module VariableClassMethods #:nodoc:
     def find(schema, variable, package, override_schema_name = nil)
       variable_upcase = variable.to_s.upcase
       schema.select_all(
-            "SELECT text FROM all_source
-            WHERE owner = :owner
-              AND name = :object_name
-              AND type = 'PACKAGE'
-              AND UPPER(text) LIKE :variable_name",
+        "SELECT text FROM all_source
+        WHERE owner = :owner
+          AND name = :object_name
+          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_. %]+(\([\w\s,]+\))?)\s*(NOT\s+NULL)?\s*((:=|DEFAULT).*)?;\s*(--.*)?$/i
           return new(schema, variable, package, $2.strip, override_schema_name)
@@ -45,102 +44,99 @@ module PLSQL
 
     private
 
-    def metadata(type_string)
-      case type_string
-      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)$/,
-          /^(DATE|TIMESTAMP|TIMESTAMP WITH TIME ZONE|TIMESTAMP WITH LOCAL TIME ZONE)$/
-        {:data_type => $1, :in_out => 'IN/OUT'}
-      when /^INTEGER$/
-        {:data_type => 'NUMBER', :in_out => 'IN/OUT'}
-      when /^BOOLEAN$/
-        {:data_type => 'PL/SQL BOOLEAN', :in_out => 'IN/OUT'}
-      when /^(\w+\.)?(\w+)\.(\w+)%TYPE$/
-        schema = $1 ? plsql.send($1.chop) : plsql
-        table = schema.send($2.downcase.to_sym)
-        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 ? @schema.root_schema.send($1.chop) : @schema
-        begin
-          type = schema.send($2.downcase.to_sym)
-          raise ArgumentError unless type.is_a?(PLSQL::Type)
-          typecode = case type.typecode
-          when 'COLLECTION' then 'TABLE'
-          else 'OBJECT'
+      def metadata(type_string)
+        case type_string
+        when /^(VARCHAR|VARCHAR2|CHAR|NVARCHAR2|NCHAR)(\((\d+)[\s\w]*\))?$/
+          { data_type: $1, data_length: $3.to_i, in_out: "IN/OUT" }
+        when /^(CLOB|NCLOB|BLOB)$/,
+            /^(NUMBER)(\(.*\))?$/, /^(NATURAL|NATURALN|POSITIVE|POSITIVEN|SIGNTYPE|SIMPLE_INTEGER|PLS_INTEGER|BINARY_INTEGER)$/,
+            /^(DATE|TIMESTAMP|TIMESTAMP WITH TIME ZONE|TIMESTAMP WITH LOCAL TIME ZONE)$/,
+            /^(XMLTYPE)$/
+          { data_type: $1, in_out: "IN/OUT" }
+        when /^INTEGER$/
+          { data_type: "NUMBER", in_out: "IN/OUT" }
+        when /^BOOLEAN$/
+          { data_type: "PL/SQL BOOLEAN", in_out: "IN/OUT" }
+        when /^(\w+\.)?(\w+)\.(\w+)%TYPE$/
+          schema = $1 ? plsql.send($1.chop) : plsql
+          table = schema.send($2.downcase.to_sym)
+          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 ? @schema.root_schema.send($1.chop) : @schema
+          begin
+            type = schema.send($2.downcase.to_sym)
+            raise ArgumentError unless type.is_a?(PLSQL::Type)
+            typecode = case type.typecode
+                       when "COLLECTION" then "TABLE"
+                       else "OBJECT"
+            end
+            { data_type: typecode, data_length: nil, sql_type_name: "#{type.schema_name}.#{type.type_name}", in_out: "IN/OUT" }
+          rescue ArgumentError
+            raise ArgumentError, "Package variable data type #{type_string} is not object type defined in schema"
           end
-          {:data_type => typecode, :data_length => nil, :sql_type_name => "#{type.schema_name}.#{type.type_name}", :in_out => 'IN/OUT'}
-        rescue ArgumentError
-          raise ArgumentError, "Package variable data type #{type_string} is not object type defined in schema"
-        end
-      when /^(\w+\.)?(\w+)%ROWTYPE$/
-        schema = $1 ? plsql.send($1.chop) : plsql
-        table = schema.send($2.downcase.to_sym)
-        record_metadata = {
-          :data_type => 'PL/SQL RECORD',
-          :in_out => 'IN/OUT',
-          :fields => {}
-        }
-        table.columns.each do |name, column|
-          record_metadata[:fields][name] =
-            {:data_type => column[:data_type], :data_length => column[:data_length], :sql_type_name => column[:sql_type_name], 
-            :position => column[:position], :in_out => 'IN/OUT'}
+        when /^(\w+\.)?(\w+)%ROWTYPE$/
+          schema = $1 ? plsql.send($1.chop) : plsql
+          table = schema.send($2.downcase.to_sym)
+          record_metadata = {
+            data_type: "PL/SQL RECORD",
+            in_out: "IN/OUT",
+            fields: {}
+          }
+          table.columns.each do |name, col|
+            record_metadata[:fields][name] =
+              { data_type: col[:data_type], data_length: col[:data_length], sql_type_name: col[:sql_type_name],
+              position: col[:position], in_out: "IN/OUT" }
+          end
+          record_metadata
+        else
+          raise ArgumentError, "Package variable data type #{type_string} is not supported"
         end
-        record_metadata
-      else
-        raise ArgumentError, "Package variable data type #{type_string} is not supported"
       end
-    end
-
-    # wrapper class to simulate Procedure class for ProcedureClass#exec
-    class VariableProcedure #:nodoc:
-      attr_reader :arguments, :argument_list, :return, :out_list, :schema
 
-      def initialize(schema, variable, operation, metadata)
-        @schema = schema
-        @variable = variable
-        @operation = operation
-        @metadata = metadata
-
-        @out_list = [[]]
-
-        case @operation
-        when :get
-          @argument_list = [[]]
-          @arguments = [{}]
-          @return = [@metadata]
-        when :set
-          @argument_list = [[:value]]
-          @arguments = [{:value => @metadata}]
-          @return = [nil]
+      # wrapper class to simulate Procedure class for ProcedureClass#exec
+      class VariableProcedure #:nodoc:
+        attr_reader :arguments, :argument_list, :return, :out_list, :schema
+
+        def initialize(schema, variable, operation, metadata)
+          @schema = schema
+          @variable = variable
+          @operation = operation
+          @metadata = metadata
+
+          @out_list = [[]]
+
+          case @operation
+          when :get
+            @argument_list = [[]]
+            @arguments = [{}]
+            @return = [@metadata]
+          when :set
+            @argument_list = [[:value]]
+            @arguments = [{ value: @metadata }]
+            @return = [nil]
+          end
         end
 
-      end
-
-      def overloaded?
-        false
-      end
+        def overloaded?
+          false
+        end
 
-      def procedure
-        nil
-      end
+        def procedure
+          nil
+        end
 
-      def call_sql(params_string)
-        sql = (schema_name = @variable.schema_name) ? "#{schema_name}." : ""
-        sql << "#{@variable.package_name}.#{@variable.variable_name}"
-        case @operation
-        when :get
-          # params string contains assignment to return variable
-          "#{params_string} #{sql};\n"
-        when :set
-          "#{sql} := #{params_string};\n"
+        def call_sql(params_string)
+          sql = (schema_name = @variable.schema_name) ? "#{schema_name}." : ""
+          sql << "#{@variable.package_name}.#{@variable.variable_name}"
+          case @operation
+          when :get
+            # params string contains assignment to return variable
+            "#{params_string} #{sql};\n"
+          when :set
+            "#{sql} := #{params_string};\n"
+          end
         end
       end
-
-    end
-
   end
-
-end
+end

data/lib/plsql/version.rb

@@ -1,3 +1,3 @@
 module PLSQL #:nodoc:
-  VERSION = File.read(File.dirname(__FILE__)+'/../../VERSION').chomp
+  VERSION = File.read(File.dirname(__FILE__) + "/../../VERSION").chomp
 end

data/lib/plsql/view.rb

@@ -1,28 +1,27 @@
 module PLSQL
-
   module ViewClassMethods #:nodoc:
     def find(schema, view)
       if schema.select_first(
-            "SELECT view_name FROM all_views
-            WHERE owner = :owner
-              AND view_name = :view_name",
+        "SELECT view_name FROM all_views
+        WHERE owner = :owner
+          AND view_name = :view_name",
             schema.schema_name, view.to_s.upcase)
         new(schema, view)
       # search for synonym
       elsif (row = schema.select_first(
-            "SELECT v.owner, v.view_name
-            FROM all_synonyms s, all_views v
-            WHERE s.owner = :owner
-              AND s.synonym_name = :synonym_name
-              AND v.owner = s.table_owner
-              AND v.view_name = s.table_name
-            UNION ALL
-            SELECT v.owner, v.view_name
-            FROM all_synonyms s, all_views v
-            WHERE s.owner = 'PUBLIC'
-              AND s.synonym_name = :synonym_name
-              AND v.owner = s.table_owner
-              AND v.view_name = s.table_name",
+        "SELECT v.owner, v.view_name
+        FROM all_synonyms s, all_views v
+        WHERE s.owner = :owner
+          AND s.synonym_name = :synonym_name
+          AND v.owner = s.table_owner
+          AND v.view_name = s.table_name
+        UNION ALL
+        SELECT v.owner, v.view_name
+        FROM all_synonyms s, all_views v
+        WHERE s.owner = 'PUBLIC'
+          AND s.synonym_name = :synonym_name
+          AND v.owner = s.table_owner
+          AND v.view_name = s.table_name",
             schema.schema_name, view.to_s.upcase, view.to_s.upcase))
         new(schema, row[1], row[0])
       else
@@ -35,7 +34,5 @@ module PLSQL
     extend ViewClassMethods
 
     alias :view_name :table_name #:nodoc:
-
   end
-
 end