ruby-plsql 0.4.0 → 0.4.1

data/lib/plsql/table.rb

@@ -12,12 +12,18 @@ module PLSQL
       elsif (row = schema.select_first(
             "SELECT t.owner, t.table_name
             FROM all_synonyms s, all_tables t
-            WHERE s.owner IN (:owner, 'PUBLIC')
+            WHERE s.owner = :owner
               AND s.synonym_name = :synonym_name
               AND t.owner = s.table_owner
               AND t.table_name = s.table_name
-            ORDER BY DECODE(s.owner, 'PUBLIC', 1, 0)",
-            schema.schema_name, table.to_s.upcase))
+            UNION ALL
+            SELECT t.owner, t.table_name
+            FROM all_synonyms s, all_tables t
+            WHERE s.owner = 'PUBLIC'
+              AND s.synonym_name = :synonym_name
+              AND t.owner = s.table_owner
+              AND t.table_name = s.table_name",
+            schema.schema_name, table.to_s.upcase, table.to_s.upcase))
         new(schema, row[1], row[0])
       else
         nil
@@ -36,16 +42,17 @@ module PLSQL
       @table_name = table.to_s.upcase
       @columns = {}
 
-      @schema.connection.select_all("
-        SELECT c.column_name, c.column_id position,
+      @schema.select_all(
+        "SELECT c.column_name, c.column_id position,
               c.data_type, c.data_length, c.data_precision, c.data_scale, c.char_used,
-              c.data_type_owner, c.data_type_mod, t.typecode
-        FROM all_tab_columns c, all_types t
+              c.data_type_owner, c.data_type_mod,
+              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
+        FROM all_tab_columns c
         WHERE c.owner = :owner
-        AND c.table_name = :table_name
-        AND t.owner(+) = c.data_type_owner
-        AND t.type_name(+) = c.data_type
-        ORDER BY c.column_id",
+        AND c.table_name = :table_name",
         @schema_name, @table_name
       ) do |r|
         column_name, position,
@@ -65,6 +72,11 @@ module PLSQL
       end
     end
 
+    # list of table column names
+    def column_names
+      @column_names ||= @columns.keys.sort_by{|k| columns[k][:position]}
+    end
+
     # General select method with :first, :all or :count as first parameter.
     # It is recommended to use #first, #all or #count method instead of this one.
     def select(first_or_all, sql_params='', *bindvars)
@@ -87,6 +99,8 @@ module PLSQL
         sql_params.each do |k,v|
           if k == :order_by
             order_by_sql = "ORDER BY #{v} "
+          elsif v.nil?
+            where_sqls << "#{k} IS NULL"
           else
             where_sqls << "#{k} = :#{k}"
             bindvars << v
@@ -150,10 +164,44 @@ module PLSQL
         return nil
       end
 
-      call = ProcedureCall.new(TableProcedure.new(@schema, self, :insert), [record])
+      table_proc = TableProcedure.new(@schema, self, :insert)
+      table_proc.add_insert_arguments(record)
+
+      call = ProcedureCall.new(table_proc, table_proc.argument_values)
       call.exec
     end
 
+    # Insert record or records in table using array of values. Examples:
+    # 
+    #   # with values for all columns
+    #   plsql.employees.insert_values [1, 'First', 'Last', Time.local(2000,01,31)]
+    #   # => INSERT INTO employees VALUES (1, 'First', 'Last', ...)
+    # 
+    #   # with values for specified columns
+    #   plsql.employees.insert_values [:employee_id, :first_name, :last_name], [1, 'First', 'Last']
+    #   # => INSERT INTO employees (employee_id, first_name, last_name) VALUES (1, 'First', 'Last')
+    # 
+    #   # with values for many records
+    #   plsql.employees.insert_values [:employee_id, :first_name, :last_name], [1, 'First', 'Last'], [2, 'Second', 'Last']
+    #   # => INSERT INTO employees (employee_id, first_name, last_name) VALUES (1, 'First', 'Last')
+    #   # => INSERT INTO employees (employee_id, first_name, last_name) VALUES (2, 'Second', 'Last')
+    #
+    def insert_values(*args)
+      raise ArgumentError, "no arguments given" unless args.first
+      # if first argument is array of symbols then use it as list of fields
+      if args.first.all?{|a| a.instance_of?(Symbol)}
+        fields = args.shift
+      # otherwise use all columns as list of fields
+      else
+        fields = column_names
+      end
+      args.each do |record|
+        raise ArgumentError, "record should be Array of values" unless record.is_a?(Array)
+        raise ArgumentError, "wrong number of column values" unless record.size == fields.size
+        insert(ArrayHelpers::to_hash(fields, record))
+      end
+    end
+
     # Update table records using optional conditions. Example:
     # 
     #   plsql.employees.update(:first_name => 'Second', :where => {:employee_id => 1})
@@ -194,12 +242,6 @@ module PLSQL
       @schema.execute(delete_sql, *bindvars)
     end
 
-    private
-
-    def get_typecode(owner, type_name)
-      
-    end
-
     # wrapper class to simulate Procedure class for ProcedureClass#exec
     class TableProcedure #:nodoc:
       attr_reader :arguments, :argument_list, :return, :out_list, :schema
@@ -214,11 +256,10 @@ module PLSQL
 
         case @operation
         when :insert
-          @argument_list = [[:p_record]]
-          @arguments = [{:p_record => {
-            :data_type => 'PL/SQL RECORD',
-            :fields => @table.columns
-          }}]
+          @argument_list = [[]]
+          @arguments = [{}]
+          @insert_columns = []
+          @insert_values = []
         when :update
           @argument_list = [[]]
           @arguments = [{}]
@@ -237,6 +278,15 @@ module PLSQL
         nil
       end
 
+      def add_insert_arguments(params)
+        params.each do |k,v|
+          raise ArgumentError, "Invalid column name #{k.inspect} specified as argument" unless (column_metadata = @table.columns[k])
+          @argument_list[0] << k
+          @arguments[0][k] = column_metadata
+          @insert_values << v
+        end
+      end
+
       def add_set_arguments(params)
         params.each do |k,v|
           raise ArgumentError, "Invalid column name #{k.inspect} specified as argument" unless (column_metadata = @table.columns[k])
@@ -263,13 +313,18 @@ module PLSQL
       end
 
       def argument_values
-        @set_values + @where_values
+        case @operation
+        when :insert
+          @insert_values
+        when :update
+          @set_values + @where_values
+        end
       end
 
       def call_sql(params_string)
         case @operation
         when :insert
-          "INSERT INTO \"#{@table.schema_name}\".\"#{@table.table_name}\" VALUES #{params_string};\n"
+          "INSERT INTO \"#{@table.schema_name}\".\"#{@table.table_name}\"(#{@argument_list[0].map{|a| a.to_s}.join(', ')}) VALUES (#{params_string});\n"
         when :update
           update_sql = "UPDATE \"#{@table.schema_name}\".\"#{@table.table_name}\" SET #{@set_sqls.join(', ')}"
           update_sql << " WHERE #{@where_sqls.join(' AND ')}" unless @where_sqls.empty?

data/lib/plsql/type.rb

@@ -0,0 +1,87 @@
+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",
+            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",
+            schema.schema_name, type.to_s.upcase, type.to_s.upcase))
+        new(schema, row[1], row[0])
+      else
+        nil
+      end
+    end
+  end
+
+  class Type
+    extend TypeClassMethods
+
+    attr_reader :typecode, :attributes, :schema_name, :type_name #: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 = {}
+
+      @typecode = @schema.select_first(
+        "SELECT typecode FROM all_types
+        WHERE owner = :owner
+        AND type_name = :type_name",
+        @schema_name, @type_name)[0]
+
+      @schema.select_all(
+        "SELECT attr_name, attr_no,
+              attr_type_name, length, precision, scale,
+              attr_type_owner, attr_type_mod,
+              (SELECT t.typecode FROM all_types t
+              WHERE t.owner = attr_type_owner
+              AND t.type_name = attr_type_name) typecode
+        FROM all_type_attrs
+        WHERE owner = :owner
+        AND type_name = :type_name
+        ORDER BY attr_no",
+        @schema_name, @type_name
+      ) do |r|
+        attr_name, position,
+              data_type, data_length, data_precision, data_scale,
+              data_type_owner, data_type_mod, 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}"
+        }
+      end
+    end
+
+    # list of object type attribute names
+    def attribute_names
+      @attribute_names ||= @attributes.keys.sort_by{|k| @attributes[k][:position]}
+    end
+
+  end
+
+end

data/lib/plsql/variable.rb

@@ -0,0 +1,146 @@
+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",
+            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
+          return new(schema, variable, package, $2.strip, override_schema_name)
+        end
+      end
+      nil
+    end
+  end
+
+  class Variable #:nodoc:
+    extend VariableClassMethods
+
+    attr_reader :schema_name, :package_name, :variable_name #:nodoc:
+
+    def initialize(schema, variable, package, variable_type, override_schema_name = nil)
+      @schema = schema
+      @schema_name = override_schema_name || schema.schema_name
+      @variable_name = variable.to_s.upcase
+      @package_name = package
+      @variable_type = variable_type.upcase
+      @metadata = metadata(@variable_type)
+    end
+
+    def value
+      @variable_get_proc ||= VariableProcedure.new(@schema, self, :get, @metadata)
+      ProcedureCall.new(@variable_get_proc).exec
+    end
+
+    def value=(new_value)
+      @variable_set_proc ||= VariableProcedure.new(@schema, self, :set, @metadata)
+      ProcedureCall.new(@variable_set_proc, [new_value]).exec
+      new_value
+    end
+
+    private
+
+    def metadata(type_string)
+      case type_string
+      when /^(VARCHAR2|CHAR|NVARCHAR2|NCHAR)(\((\d+)\))?$/
+        {: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 ? plsql.send($1.chop) : plsql
+        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
+      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'}
+        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]
+        end
+
+      end
+
+      def overloaded?
+        false
+      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"
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/plsql/version.rb

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

data/lib/plsql/view.rb

@@ -0,0 +1,41 @@
+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",
+            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",
+            schema.schema_name, view.to_s.upcase, view.to_s.upcase))
+        new(schema, row[1], row[0])
+      else
+        nil
+      end
+    end
+  end
+
+  class View < Table
+    extend ViewClassMethods
+
+    alias :view_name :table_name #:nodoc:
+
+  end
+
+end