ruby-plsql 0.3.1 → 0.4.0

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 CURRTVAL of sequence (can be called just after nextval)
+    def currval
+      @schema.select_one "SELECT \"#{@schema_name}\".\"#{@sequence_name}\".CURRVAL FROM dual"
+    end
+
+  end
+
+end

data/lib/plsql/sql_statements.rb

@@ -0,0 +1,61 @@
+module PLSQL
+  module SQLStatements
+    # Select first row as array or values (without column names)
+    def select_first(sql, *bindvars)
+      @connection.select_first(sql, *bindvars)
+    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]
+    end
+
+    # Select :first or :all values. Examples:
+    # 
+    #   plsql.select :first, "SELECT * FROM employees WHERE employee_id = :1", 1
+    #   plsql.select :all, "SELECT * FROM employees ORDER BY employee_id"
+    def select(*args)
+      case args[0]
+      when nil
+        raise ArgumentError, "Not enough arguments"
+      when :first
+        args.shift
+        @connection.select_hash_first(*args)
+      when :all
+        args.shift
+        @connection.select_hash_all(*args)
+      else
+        @connection.select_hash_all(*args)
+      end
+    end
+
+    # Execute SQL statement. Example:
+    #
+    #   plsql.execute "DROP TABLE employees"
+    def execute(*args)
+      @connection.exec(*args)
+    end
+
+    # Execute COMMIT in current database session.
+    # Use beforehand
+    # 
+    #   plsql.connection.autocommit = false
+    # 
+    # to turn off automatic commits after each statement.
+    def commit
+      connection.commit
+    end
+
+    # Execute ROLLBACK in current database session.
+    # Use beforehand
+    # 
+    #   plsql.connection.autocommit = false
+    # 
+    # to turn off automatic commits after each statement.
+    def rollback
+      connection.rollback
+    end
+
+  end
+end
+

data/lib/plsql/table.rb

@@ -0,0 +1,285 @@
+module PLSQL
+
+  module TableClassMethods #:nodoc:
+    def find(schema, table)
+      if schema.select_first(
+            "SELECT table_name FROM all_tables
+            WHERE owner = :owner
+              AND table_name = :table_name",
+            schema.schema_name, table.to_s.upcase)
+        new(schema, table)
+      # search for synonym
+      elsif (row = schema.select_first(
+            "SELECT t.owner, t.table_name
+            FROM all_synonyms s, all_tables t
+            WHERE s.owner IN (:owner, 'PUBLIC')
+              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))
+        new(schema, row[1], row[0])
+      else
+        nil
+      end
+    end
+  end
+
+  class Table
+    extend TableClassMethods
+
+    attr_reader :columns, :schema_name, :table_name #:nodoc:
+
+    def initialize(schema, table, override_schema_name = nil) #:nodoc:
+      @schema = schema
+      @schema_name = override_schema_name || schema.schema_name
+      @table_name = table.to_s.upcase
+      @columns = {}
+
+      @schema.connection.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
+        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",
+        @schema_name, @table_name
+      ) do |r|
+        column_name, position,
+              data_type, data_length, data_precision, data_scale, char_used,
+              data_type_owner, data_type_mod, typecode = r
+        @columns[column_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,
+          :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}"
+        }
+      end
+    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)
+      case first_or_all
+      when :first, :all
+        select_sql = "SELECT * "
+      when :count
+        select_sql = "SELECT COUNT(*) "
+      else
+        raise ArgumentError, "Only :first, :all or :count are supported"
+      end
+      select_sql << "FROM \"#{@schema_name}\".\"#{@table_name}\" "
+      case sql_params
+      when String
+        select_sql << sql_params
+      when Hash
+        raise ArgumentError, "Cannot specify bind variables when passing WHERE conditions as Hash" unless bindvars.empty?
+        where_sqls = []
+        order_by_sql = nil
+        sql_params.each do |k,v|
+          if k == :order_by
+            order_by_sql = "ORDER BY #{v} "
+          else
+            where_sqls << "#{k} = :#{k}"
+            bindvars << v
+          end
+        end
+        select_sql << "WHERE " << where_sqls.join(' AND ') unless where_sqls.empty?
+        select_sql << order_by_sql if order_by_sql
+      else
+        raise ArgumentError, "Only String or Hash can be provided as SQL condition argument"
+      end
+      if first_or_all == :count
+        @schema.select_one(select_sql, *bindvars)
+      else
+        @schema.select(first_or_all, select_sql, *bindvars)
+      end
+    end
+
+    # Select all table records using optional conditions. Examples:
+    #
+    #   plsql.employees.all
+    #   plsql.employees.all(:order_by => :employee_id)
+    #   plsql.employees.all("WHERE employee_id > :employee_id", 5)
+    # 
+    def all(sql='', *bindvars)
+      select(:all, sql, *bindvars)
+    end
+
+    # Select first table record using optional conditions. Examples:
+    # 
+    #   plsql.employees.first
+    #   plsql.employees.first(:employee_id => 1)
+    #   plsql.employees.first("WHERE employee_id = 1")
+    #   plsql.employees.first("WHERE employee_id = :employee_id", 1)
+    # 
+    def first(sql='', *bindvars)
+      select(:first, sql, *bindvars)
+    end
+
+    # Count table records using optional conditions. Examples:
+    # 
+    #   plsql.employees.count
+    #   plsql.employees.count("WHERE employee_id > :employee_id", 5)
+    # 
+    def count(sql='', *bindvars)
+      select(:count, sql, *bindvars)
+    end
+
+    # Insert record or records in table. Examples:
+    # 
+    #   employee = { :employee_id => 1, :first_name => 'First', :last_name => 'Last', :hire_date => Time.local(2000,01,31) }
+    #   plsql.employees.insert employee
+    #   # => INSERT INTO employees VALUES (1, 'First', 'Last', ...)
+    # 
+    #   employees = [employee1, employee2, ... ]  # array of many Hashes
+    #   plsql.employees.insert employees
+    #
+    def insert(record)
+      # if Array of records is passed then insert each individually
+      if record.is_a?(Array)
+        record.each {|r| insert(r)}
+        return nil
+      end
+
+      call = ProcedureCall.new(TableProcedure.new(@schema, self, :insert), [record])
+      call.exec
+    end
+
+    # Update table records using optional conditions. Example:
+    # 
+    #   plsql.employees.update(:first_name => 'Second', :where => {:employee_id => 1})
+    #   # => UPDATE employees SET first_name = 'Second' WHERE employee_id = 1
+    #
+    def update(params)
+      raise ArgumentError, "Only Hash parameter can be passed to table update method" unless params.is_a?(Hash)
+      where = params.delete(:where)
+      
+      table_proc = TableProcedure.new(@schema, self, :update)
+      table_proc.add_set_arguments(params)
+      table_proc.add_where_arguments(where) if where
+      call = ProcedureCall.new(table_proc, table_proc.argument_values)
+      call.exec
+    end
+
+    # Delete table records using optional conditions. Example:
+    # 
+    #   plsql.employees.delete(:employee_id => 1)
+    #   # => DELETE FROM employees WHERE employee_id = 1
+    # 
+    def delete(sql_params='', *bindvars)
+      delete_sql = "DELETE FROM \"#{@schema_name}\".\"#{@table_name}\" "
+      case sql_params
+      when String
+        delete_sql << sql_params
+      when Hash
+        raise ArgumentError, "Cannot specify bind variables when passing WHERE conditions as Hash" unless bindvars.empty?
+        where_sqls = []
+        sql_params.each do |k,v|
+          where_sqls << "#{k} = :#{k}"
+          bindvars << v
+        end
+        delete_sql << "WHERE " << where_sqls.join(' AND ') unless where_sqls.empty?
+      else
+        raise ArgumentError, "Only String or Hash can be provided as SQL condition argument"
+      end
+      @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
+
+      def initialize(schema, table, operation)
+        @schema = schema
+        @table = table
+        @operation = operation
+
+        @return = [nil]
+        @out_list = [[]]
+
+        case @operation
+        when :insert
+          @argument_list = [[:p_record]]
+          @arguments = [{:p_record => {
+            :data_type => 'PL/SQL RECORD',
+            :fields => @table.columns
+          }}]
+        when :update
+          @argument_list = [[]]
+          @arguments = [{}]
+          @set_sqls = []
+          @set_values = []
+          @where_sqls = []
+          @where_values = []
+        end
+      end
+
+      def overloaded?
+        false
+      end
+
+      def procedure
+        nil
+      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])
+          @argument_list[0] << k
+          @arguments[0][k] = column_metadata
+          @set_sqls << "#{k}=:#{k}"
+          @set_values << v
+        end
+      end
+
+      def add_where_arguments(params)
+        case params
+        when Hash
+          params.each do |k,v|
+            raise ArgumentError, "Invalid column name #{k.inspect} specified as argument" unless (column_metadata = @table.columns[k])
+            @argument_list[0] << :"w_#{k}"
+            @arguments[0][:"w_#{k}"] = column_metadata
+            @where_sqls << "#{k}=:w_#{k}"
+            @where_values << v
+          end
+        when String
+          @where_sqls << params
+        end
+      end
+
+      def argument_values
+        @set_values + @where_values
+      end
+
+      def call_sql(params_string)
+        case @operation
+        when :insert
+          "INSERT INTO \"#{@table.schema_name}\".\"#{@table.table_name}\" 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?
+          update_sql << ";\n"
+          update_sql
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/plsql/version.rb

@@ -0,0 +1,3 @@
+module PLSQL #:nodoc:
+  VERSION = '0.4.0'
+end

data/lib/ruby-plsql.rb

@@ -0,0 +1 @@
+require "ruby_plsql"

data/lib/ruby_plsql.rb

@@ -1,46 +1,13 @@
-$:.unshift File.dirname(__FILE__)
+require "time"
+require "date"
+require "bigdecimal"
 
-module RubyPlsql #:nodoc:
+%w(connection sql_statements schema procedure procedure_call package table sequence).each do |file|
+  require "plsql/#{file}"
 end
 
 unless defined?(JRUBY_VERSION)
-  begin
-    require "oci8"
-  rescue LoadError
-      puts <<-EOS
-    To use ruby_plsql you must install ruby-oci8 library.
-      EOS
-  end
+  require "plsql/oci_connection"
 else
-  begin
-    require "java"
-    require "jruby"
-    # Adds JRuby classloader to current thread classloader - as a result ojdbc14.jar should not be in $JRUBY_HOME/lib
-    java.lang.Thread.currentThread.setContextClassLoader(JRuby.runtime.jruby_class_loader)
-
-    ojdbc_jar = "ojdbc14.jar"
-    if ojdbc_jar_path = ENV["PATH"].split(/[:;]/).find{|d| File.exists?(File.join(d,ojdbc_jar))}
-      require File.join(ojdbc_jar_path,ojdbc_jar)
-    else
-      require ojdbc_jar
-    end
-    # import java.sql.Statement
-    # import java.sql.Connection
-    # import java.sql.SQLException
-    # import java.sql.Types
-    # import java.sql.DriverManager
-    java.sql.DriverManager.registerDriver Java::oracle.jdbc.driver.OracleDriver.new
-  rescue LoadError
-      puts <<-EOS
-    To use ruby_plsql you must have Oracle JDBC driver installed.
-      EOS
-  end
-end
-
-require "time"
-require "date"
-require "bigdecimal"
-
-%w(connection oci_connection jdbc_connection schema procedure package).each do |file|
-  require File.dirname(__FILE__) + "/plsql/#{file}"
+  require "plsql/jdbc_connection"
 end