ruby-plsql 0.8.0 → 0.9.0

data/spec/plsql/view_spec.rb

@@ -1,264 +0,0 @@
-require "spec_helper"
-
-describe "View" do
-  before(:all) do
-    plsql.connect! CONNECTION_PARAMS
-    plsql.connection.autocommit = false
-    plsql.execute <<-SQL
-      CREATE TABLE test_employees (
-        employee_id   NUMBER(15) NOT NULL,
-        first_name    VARCHAR2(50),
-        last_name     VARCHAR2(50),
-        hire_date     DATE,
-        status        VARCHAR2(1) DEFAULT 'N'
-      )
-    SQL
-    plsql.execute "CREATE OR REPLACE VIEW test_employees_v AS SELECT * FROM test_employees"
-
-    @employees = (1..10).map do |i|
-      {
-        employee_id: i,
-        first_name: "First #{i}",
-        last_name: "Last #{i}",
-        hire_date: Time.local(2000, 01, i),
-        status: "A"
-      }
-    end
-    @employees_all_fields = [:employee_id, :first_name, :last_name, :hire_date, :status]
-    @employees_all_values = @employees.map { |e| @employees_all_fields.map { |f| e[f] } }
-    @employees_some_fields = [:employee_id, :first_name, :last_name]
-    @employees_some_values = @employees.map { |e| @employees_some_fields.map { |f| e[f] } }
-    @employee_default_values = { hire_date: nil, status: "N" }
-  end
-
-  after(:all) do
-    plsql.execute "DROP VIEW test_employees_v"
-    plsql.execute "DROP TABLE test_employees"
-    plsql.logoff
-  end
-
-  after(:each) do
-    plsql.rollback
-  end
-
-  describe "find" do
-
-    it "should find existing view" do
-      expect(PLSQL::View.find(plsql, :test_employees_v)).not_to be_nil
-    end
-
-    it "should not find nonexisting view" do
-      expect(PLSQL::View.find(plsql, :qwerty123456)).to be_nil
-    end
-
-    it "should find existing view in schema" do
-      expect(plsql.test_employees_v).to be_instance_of(PLSQL::View)
-    end
-
-  end
-
-  describe "synonym" do
-
-    before(:all) do
-      plsql.execute "CREATE SYNONYM test_employees_v_synonym FOR hr.test_employees_v"
-    end
-
-    after(:all) do
-      plsql.execute "DROP SYNONYM test_employees_v_synonym" rescue nil
-    end
-
-    it "should find synonym to view" do
-      expect(PLSQL::View.find(plsql, :test_employees_v_synonym)).not_to be_nil
-    end
-
-    it "should find view using synonym in schema" do
-      expect(plsql.test_employees_v_synonym).to be_instance_of(PLSQL::View)
-    end
-
-  end
-
-  describe "public synonym" do
-
-    it "should find public synonym to view" do
-      expect(PLSQL::View.find(plsql, :user_tables)).not_to be_nil
-    end
-
-    it "should find view using public synonym in schema" do
-      expect(plsql.user_tables).to be_instance_of(PLSQL::View)
-    end
-
-  end
-
-  describe "columns" do
-
-    it "should get column names for view" do
-      expect(plsql.test_employees_v.column_names).to eq([:employee_id, :first_name, :last_name, :hire_date, :status])
-    end
-
-    it "should get columns metadata for view" do
-      expect(plsql.test_employees_v.columns).to eq(
-        employee_id: {
-          position: 1, data_type: "NUMBER", data_length: 22, data_precision: 15, data_scale: 0, char_used: nil,
-          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: false, data_default: nil },
-        first_name: {
-          position: 2, data_type: "VARCHAR2", data_length: 50, data_precision: nil, data_scale: nil, char_used: "B",
-          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: nil },
-        last_name: {
-          position: 3, data_type: "VARCHAR2", data_length: 50, data_precision: nil, data_scale: nil, char_used: "B",
-          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: nil },
-        hire_date: {
-          position: 4, data_type: "DATE", data_length: 7, data_precision: nil, data_scale: nil, char_used: nil,
-          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: nil },
-        status: {
-          position: 5, data_type: "VARCHAR2", data_length: 1, data_precision: nil, data_scale: nil, char_used: "B",
-          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: nil }
-      )
-    end
-
-  end
-
-  describe "insert" do
-    it "should insert a record in view" do
-      plsql.test_employees_v.insert @employees.first
-      expect(plsql.test_employees_v.all).to eq([@employees.first])
-    end
-
-    it "should insert a record in view using partial list of columns" do
-      plsql.test_employees_v.insert @employees.first.except(:hire_date)
-      expect(plsql.test_employees_v.all).to eq([@employees.first.merge(hire_date: nil)])
-    end
-
-    it "should insert default value from table definition if value not provided" do
-      plsql.test_employees_v.insert @employees.first.except(:status)
-      expect(plsql.test_employees_v.all).to eq([@employees.first.merge(status: "N")])
-    end
-
-    it "should insert array of records in view" do
-      plsql.test_employees_v.insert @employees
-      expect(plsql.test_employees_v.all("ORDER BY employee_id")).to eq(@employees)
-    end
-
-  end
-
-  describe "insert values" do
-    it "should insert a record with array of values" do
-      plsql.test_employees_v.insert_values @employees_all_values.first
-      expect(plsql.test_employees_v.all).to eq([@employees.first])
-    end
-
-    it "should insert a record with list of all fields and array of values" do
-      plsql.test_employees_v.insert_values @employees_all_fields, @employees_all_values.first
-      expect(plsql.test_employees_v.all).to eq([@employees.first])
-    end
-
-    it "should insert a record with list of some fields and array of values" do
-      plsql.test_employees_v.insert_values @employees_some_fields, @employees_some_values.first
-      expect(plsql.test_employees_v.all).to eq([@employees.first.merge(@employee_default_values)])
-    end
-
-    it "should insert many records with array of values" do
-      plsql.test_employees_v.insert_values *@employees_all_values
-      expect(plsql.test_employees_v.all).to eq(@employees)
-    end
-
-    it "should insert many records with list of all fields and array of values" do
-      plsql.test_employees_v.insert_values @employees_all_fields, *@employees_all_values
-      expect(plsql.test_employees_v.all).to eq(@employees)
-    end
-
-    it "should insert many records with list of some fields and array of values" do
-      plsql.test_employees_v.insert_values @employees_some_fields, *@employees_some_values
-      expect(plsql.test_employees_v.all).to eq(@employees.map { |e| e.merge(@employee_default_values) })
-    end
-
-  end
-
-  describe "select" do
-    before(:each) do
-      plsql.test_employees_v.insert @employees
-    end
-
-    it "should select first record in view" do
-      expect(plsql.test_employees_v.select(:first, "ORDER BY employee_id")).to eq(@employees.first)
-      expect(plsql.test_employees_v.first("ORDER BY employee_id")).to eq(@employees.first)
-    end
-
-    it "should select all records in view" do
-      expect(plsql.test_employees_v.select(:all, "ORDER BY employee_id")).to eq(@employees)
-      expect(plsql.test_employees_v.all("ORDER BY employee_id")).to eq(@employees)
-      expect(plsql.test_employees_v.all(order_by: :employee_id)).to eq(@employees)
-    end
-
-    it "should select record in view using WHERE condition" do
-      expect(plsql.test_employees_v.select(:first, "WHERE employee_id = :1", @employees.first[:employee_id])).to eq(@employees.first)
-      expect(plsql.test_employees_v.first("WHERE employee_id = :1", @employees.first[:employee_id])).to eq(@employees.first)
-      expect(plsql.test_employees_v.first(employee_id: @employees.first[:employee_id])).to eq(@employees.first)
-    end
-
-    it "should select record in view using :column => nil condition" do
-      employee = @employees.last
-      employee[:employee_id] = employee[:employee_id] + 1
-      employee[:hire_date] = nil
-      plsql.test_employees_v.insert employee
-      expect(plsql.test_employees_v.first("WHERE hire_date IS NULL")).to eq(employee)
-      expect(plsql.test_employees_v.first(hire_date: nil)).to eq(employee)
-    end
-
-    it "should count records in view" do
-      expect(plsql.test_employees_v.select(:count)).to eq(@employees.size)
-      expect(plsql.test_employees_v.count).to eq(@employees.size)
-    end
-
-    it "should count records in view using condition" do
-      expect(plsql.test_employees_v.select(:count, "WHERE employee_id <= :1", @employees[2][:employee_id])).to eq(3)
-      expect(plsql.test_employees_v.count("WHERE employee_id <= :1", @employees[2][:employee_id])).to eq(3)
-    end
-
-  end
-
-  describe "update" do
-    it "should update a record in view" do
-      employee_id = @employees.first[:employee_id]
-      plsql.test_employees_v.insert @employees.first
-      plsql.test_employees_v.update first_name: "Test", where: { employee_id: employee_id }
-      expect(plsql.test_employees_v.first(employee_id: employee_id)[:first_name]).to eq("Test")
-    end
-
-    it "should update a record in view using String WHERE condition" do
-      employee_id = @employees.first[:employee_id]
-      plsql.test_employees_v.insert @employees
-      plsql.test_employees_v.update first_name: "Test", where: "employee_id = #{employee_id}"
-      expect(plsql.test_employees_v.first(employee_id: employee_id)[:first_name]).to eq("Test")
-      # all other records should not be changed
-      plsql.test_employees_v.all("WHERE employee_id > :1", employee_id) do |employee|
-        expect(employee[:first_name]).not_to eq("Test")
-      end
-    end
-
-    it "should update all records in view" do
-      plsql.test_employees_v.insert @employees
-      plsql.test_employees_v.update first_name: "Test"
-      plsql.test_employees_v.all do |employee|
-        expect(employee[:first_name]).to eq("Test")
-      end
-    end
-
-  end
-
-  describe "delete" do
-    it "should delete record from view" do
-      employee_id = @employees.first[:employee_id]
-      plsql.test_employees_v.insert @employees
-      plsql.test_employees_v.delete employee_id: employee_id
-      expect(plsql.test_employees_v.first(employee_id: employee_id)).to be_nil
-      expect(plsql.test_employees_v.all(order_by: :employee_id)).to eq(@employees[1, @employees.size - 1])
-    end
-
-    it "should delete all records from view" do
-      plsql.test_employees_v.insert @employees
-      plsql.test_employees_v.delete
-      expect(plsql.test_employees_v.all).to be_empty
-    end
-  end
-
-end

data/spec/spec.opts

@@ -1,6 +0,0 @@
---colour
---format
-progress
---loadby
-mtime
---reverse

data/spec/spec_helper.rb

@@ -1,121 +0,0 @@
-require "rubygems"
-require "bundler"
-Bundler.setup(:default, :development)
-require "simplecov"
-
-SimpleCov.configure do
-  load_profile "root_filter"
-  load_profile "test_frameworks"
-end
-
-ENV["COVERAGE"] && SimpleCov.start do
-  add_filter "/.rvm/"
-end
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
-require "rspec"
-
-unless ENV["NO_ACTIVERECORD"]
-  require "active_record"
-else
-  puts "Without ActiveRecord"
-end
-
-require "ruby-plsql"
-
-# Requires supporting ruby files with custom matchers and macros, etc,
-# in spec/support/ and its subdirectories.
-Dir[File.join(File.dirname(__FILE__), "support/**/*.rb")].each { |f| require f }
-
-if ENV["USE_VM_DATABASE"] == "Y"
-  DATABASE_NAME = "XE"
-else
-  DATABASE_NAME = ENV["DATABASE_NAME"] || "orcl"
-end
-
-DATABASE_SERVICE_NAME = (defined?(JRUBY_VERSION) ? "/" : "") +
-                        (ENV["DATABASE_SERVICE_NAME"] || DATABASE_NAME)
-DATABASE_HOST = ENV["DATABASE_HOST"] || "localhost"
-DATABASE_PORT = (ENV["DATABASE_PORT"] || 1521).to_i
-DATABASE_USERS_AND_PASSWORDS = [
-  [ENV["DATABASE_USER"] || "hr", ENV["DATABASE_PASSWORD"] || "hr"],
-  [ENV["DATABASE_USER2"] || "arunit", ENV["DATABASE_PASSWORD2"] || "arunit"]
-]
-# specify which database version is used (will be verified in one test)
-DATABASE_VERSION = ENV["DATABASE_VERSION"] || "10.2.0.4"
-
-if ENV["USE_VM_DATABASE"] == "Y"
-  RSpec.configure do |config|
-    config.before(:suite) do
-      TestDb.build
-
-      # Set Verbose off to hide warning: already initialized constant DATABASE_VERSION
-      original_verbosity = $VERBOSE
-      $VERBOSE           = nil
-      DATABASE_VERSION   = TestDb.database_version
-      $VERBOSE           = original_verbosity
-    end
-  end
-end
-
-def oracle_error_class
-  unless defined?(JRUBY_VERSION)
-    OCIError
-  else
-    java.sql.SQLException
-  end
-end
-
-def get_eazy_connect_url(svc_separator = "")
-  "#{DATABASE_HOST}:#{DATABASE_PORT}#{svc_separator}#{DATABASE_SERVICE_NAME}"
-end
-
-def get_connection_url
-  unless defined?(JRUBY_VERSION)
-    (ENV["DATABASE_USE_TNS"] == "NO") ? get_eazy_connect_url("/") : DATABASE_NAME
-  else
-    "jdbc:oracle:thin:@#{get_eazy_connect_url}"
-  end
-end
-
-def get_connection(user_number = 0)
-  database_user, database_password = DATABASE_USERS_AND_PASSWORDS[user_number]
-  unless defined?(JRUBY_VERSION)
-    try_to_connect(OCIError) do
-      OCI8.new(database_user, database_password, get_connection_url)
-    end
-  else
-    try_to_connect(Java::JavaSql::SQLException) do
-      java.sql.DriverManager.getConnection(get_connection_url, database_user, database_password)
-    end
-  end
-end
-
-def try_to_connect(exception)
-  begin
-    yield
-  # if connection fails then sleep 5 seconds and retry
-  rescue exception
-    sleep 5
-    yield
-  end
-end
-
-CONNECTION_PARAMS = {
-  adapter: "oracle_enhanced",
-  database: DATABASE_SERVICE_NAME,
-  host: DATABASE_HOST,
-  port: DATABASE_PORT,
-  username: DATABASE_USERS_AND_PASSWORDS[0][0],
-  password: DATABASE_USERS_AND_PASSWORDS[0][1]
-}
-
-class Hash
-  def except(*blacklist)
-    self.reject { |key, value| blacklist.include?(key) }
-  end unless method_defined?(:except)
-
-  def only(*whitelist)
-    self.reject { |key, value| !whitelist.include?(key) }
-  end unless method_defined?(:only)
-end

data/spec/support/create_arunit_user.sql

@@ -1,2 +0,0 @@
-create user arunit identified by arunit;
-grant create session to arunit;

data/spec/support/custom_config.rb.sample

@@ -1,14 +0,0 @@
-# Template file should be copied to locale_support.rb to be automatically included by code
-#
-
-# Set Oracle Database session timezone, if not already set in env variable
-#   This setting needs to be in place to make sure that Oracle properly represents the timestamp format on your local machine.
-#   Do not use 'OS_TZ' value or fixed offset values like '05:00', for daylight saving-enabled timezones.
-#   See: http://docs.oracle.com/cd/E18283_01/server.112/e10729/ch4datetime.htm#CBBEEAFB
-#   The setting cannot be derived directly from operating system or ruby, as different timezone names are used.
-ENV['ORA_SDTZ'] ||= 'Europe/Riga'
-#Sets the Ruby timezone to be used, if not already set in env variable
-ENV['TZ'] ||= 'Europe/Riga'
-#Sets the Language, locale and encoding settings to be used by Oracle session, if not already set in env variable
-ENV['NLS_LANG'] ||= 'AMERICAN_AMERICA.AL32UTF8'
-

data/spec/support/file_check_script.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-set -e
-
-FILE=/vagrant/oracle-xe-11.2.0-1.0.x86_64.rpm.zip
-
-if [ ! -f "$FILE" ] ; then
-  echo "Oracle XE database installation (oracle-xe-11.2.0-1.0.x86_64.rpm.zip) can not be found. Please download from Oracle homepage and put it into project home directory."
-  exit 1
-fi

data/spec/support/test_db.rb

@@ -1,149 +0,0 @@
-class TestDb
-  DATABASE_USERS = %w{hr arunit}
-
-  def self.build
-    db = self.new
-    db.cleanup_database_users
-    db.create_user_tablespace
-    db.setup_database_users
-    db.connection.logoff
-  end
-
-  def self.database_version
-    db = self.new
-    db.database_version
-  end
-
-  def connection
-    unless defined?(@connection)
-      begin
-        Timeout::timeout(5) {
-          if defined?(JRUBY_VERSION)
-            @connection = java.sql.DriverManager.get_connection(
-              "jdbc:oracle:thin:@127.0.0.1:1521/XE",
-              "system",
-              "oracle"
-            )
-          else
-            @connection = OCI8.new(
-              "system",
-              "oracle",
-              "(DESCRIPTION=(ADDRESS=(PROTOCOL=tcp)(HOST=127.0.0.1)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=XE)))"
-            )
-          end
-        }
-      rescue Timeout::Error
-        raise "Cannot establish connection with Oracle database as SYSTEM user. Seams you need to start local Oracle database"
-      end
-    end
-    @connection
-  end
-
-  def create_user_tablespace
-    return unless connection
-    execute_statement(<<-STATEMENT
-      DECLARE
-        v_exists number;
-      BEGIN
-        SELECT count(1)
-          INTO v_exists
-          FROM dba_tablespaces
-          WHERE tablespace_name = 'TBS_USERS';
-
-          IF v_exists = 0 THEN
-            EXECUTE IMMEDIATE 'ALTER SYSTEM SET DB_CREATE_FILE_DEST = ''/u01/app/oracle/oradata/XE''';
-            EXECUTE IMMEDIATE 'CREATE TABLESPACE TBS_USERS DATAFILE ''tbs_users.dat'' SIZE 10M REUSE AUTOEXTEND ON NEXT 10M MAXSIZE 200M';
-          END IF;
-      END;
-      STATEMENT
-      )
-  end
-
-  def database_users
-    DATABASE_USERS.inject([]) { |array, user| array << [user.upcase, user] }
-  end
-
-  def cleanup_database_users
-    return unless connection
-    database_users.each do | db, _ |
-      execute_statement(<<-STATEMENT
-        DECLARE
-           v_count INTEGER := 0;
-           l_cnt   INTEGER;
-        BEGIN
-
-          SELECT COUNT (1)
-            INTO v_count
-            FROM dba_users
-            WHERE username = '#{db}';
-
-          IF v_count != 0 THEN
-            FOR x IN (SELECT *
-                        FROM v$session
-                        WHERE username = '#{db}')
-            LOOP
-              EXECUTE IMMEDIATE 'ALTER SYSTEM DISCONNECT SESSION ''' || x.sid || ',' || x.serial# || ''' IMMEDIATE';
-            END LOOP;
-
-            EXECUTE IMMEDIATE ('DROP USER #{db} CASCADE');
-          END IF;
-        END;
-        STATEMENT
-      )
-    end
-  end
-
-  def setup_database_users
-    return unless connection
-    database_users.each do | db, passwd |
-      execute_statement(<<-STATEMENT
-        DECLARE
-           v_count INTEGER := 0;
-        BEGIN
-
-          SELECT COUNT (1)
-            INTO v_count
-            FROM dba_users
-            WHERE username = '#{db}';
-
-          IF v_count = 0 THEN
-            EXECUTE IMMEDIATE ('CREATE USER #{db} IDENTIFIED BY #{passwd} DEFAULT TABLESPACE TBS_USERS QUOTA 10m ON TBS_USERS');
-            EXECUTE IMMEDIATE ('GRANT create session, create table, create sequence, create procedure, create type, create view, create synonym TO #{db}');
-          END IF;
-        END;
-        STATEMENT
-      )
-    end
-  end
-
-  def database_version
-    query = "SELECT version FROM V$INSTANCE"
-
-    if defined?(JRUBY_VERSION)
-      statement = connection.create_statement
-      resource  = statement.execute_query(query)
-
-      resource.next
-      value = resource.get_string("VERSION")
-
-      resource.close
-      statement.close
-    else
-      cursor = execute_statement(query)
-      value = cursor.fetch()[0]
-      cursor.close
-    end
-
-    value.match(/(.*)\.\d$/)[1]
-  end
-
-  def execute_statement(statement)
-    if defined?(JRUBY_VERSION)
-      statement = connection.prepare_call(statement)
-      statement.execute
-      statement.close
-    else
-      connection.exec(statement)
-    end
-  end
-end

data/spec/support/unlock_and_setup_hr_user.sql

@@ -1,2 +0,0 @@
-alter user hr identified by hr account unlock;
-grant execute on dbms_lock to hr;