Current PL/SQL unit testing options

Unit testing and TDD (test driven development) practices are nowadays one of the key software development practices. It is especially important if you are doing agile software development in small iterations where you need to automate unit testing as much as possible, as you cannot do manual regression testing of all existing and new functionality at the end of each iteration.

In some languages (like Java, Ruby, Python, C# etc.) there is quite good tools and frameworks support for unit testing and as a result there is quite high testing culture among top developers in these communities. But unfortunately in PL/SQL community so far automated unit testing is not used very often. During recent Oracle OpenWorld conference in presentations about unit testing when it was asked who is doing automated unit testing then only few hands were raised.

Why is it so? And what are current options for doing automated PL/SQL unit testing?

The first unit testing framework for PL/SQL was utPLSQL which was created by Steven Feuerstein and based on API defined by many other xUnit style frameworks (like e.g. JUnit). But the issue with this approach was that PL/SQL syntax for tests was quite verbose and tests were not very readable (see example). As a result Steven stopped developing further utPLSQL and currently there are no other active maintainers of this project. There are some other alternative frameworks which tried to simplify writing tests in PL/SQL (OUnit, pl/unit, PLUTO etc.) but none of them are very actively used and maintained by PL/SQL community.

Because of the issues with utPLSQL Steven Feuerstein started development of graphical interface tool for PL/SQL unit testing which is now Quest Code Tester for Oracle. This tool is actively developed and maintained by Quest Software but there are several issues with it:

• It is a commercial tool and as a result it will not become widely accepted by all PL/SQL developers. There is also a freeware edition of it but the functionality of it is very limited.
• It is a graphical tool – it can help you with quick creation of simple tests but when you will need more complex logic you might get stuck that you cannot do it (or you need to do it again in plain PL/SQL and have the same issues as in utPLSQL).
• It stores tests in database repository – and it means that it might be hard to maintain unit tests in version control system like Subversion or Git.

And finally also Oracle started to do something in PL/SQL unit testing area and there is unit testing support in latest SQL Developer version 2.1 which currently still is in early adopter status. SQL Developer has very similar approach to Quest Code Tester – it is graphical tool which stores tests and test results in repository. So the benefit of SQL Developer over Quest Code Tester is that it is free But compared to Quest Code Tester it still has less features (e.g. currently not all complex data types are supported) and still is not released as final version and still has bugs.

Ruby as testing tool for PL/SQL

As you probably know I am quite big Ruby fan and always exploring new ways how to use Ruby to increase my productivity. And Ruby community has very high testing culture and has many good tools for testing support (I like and use RSpec testing framework). Therefore some time ago I started to use Ruby and RSpec also for testing PL/SQL code in our projects where we use Ruby on Rails on top of Oracle databases with existing PL/SQL business logic.

I have created ruby-plsql library which provides very easy API for calling PL/SQL procedures from Ruby and recent ruby-plsql version supports majority of PL/SQL data types.

So let’s start with with simple example how to use Ruby, RSpec and ruby-plsql to create PL/SQL procedure unit test. I will use BETWNSTR procedure example from utPLSQL examples:

CREATE OR REPLACE FUNCTION betwnstr (
   string_in   IN   VARCHAR2,
   start_in    IN   INTEGER,
   end_in      IN   INTEGER
)
   RETURN VARCHAR2
IS
   l_start PLS_INTEGER := start_in;
BEGIN
   IF l_start = 0
   THEN
      l_start := 1;
   END IF;
   RETURN (SUBSTR (string_in, l_start, end_in - l_start + 1));
END;

I took example tests from utPLSQL and wrote them in Ruby and RSpec:

describe "Between string" do
  it "should be correct in normal case" do
    plsql.betwnstr('abcdefg', 2, 5).should == 'bcde'
  end
  it "should be correct with zero start value" do
    plsql.betwnstr('abcdefg', 0, 5).should == 'abcde'
  end
  it "should be correct with way big end value" do
    plsql.betwnstr('abcdefg', 5, 500).should == 'efg'
  end
  it "should be correct with NULL string" do
    plsql.betwnstr(nil, 5, 500).should be_nil
  end
end

As you can see the tests are much shorter than in utPLSQL and are much more readable (also more readable than utPLSQL template which can be used to generate utPLSQL tests). And also you can create these tests faster than using GUI tools like Quest Code Tester or SQL Developer.

More complex example

Second more complex example I took from SQL Developer unit testing tutorial. We will create tests for PL/SQL procedure AWARD_BONUS:

CREATE OR REPLACE
 PROCEDURE award_bonus (
  emp_id NUMBER, sales_amt NUMBER) AS
  commission    REAL;
  comm_missing  EXCEPTION;
BEGIN
  SELECT commission_pct INTO commission
    FROM employees2
      WHERE employee_id = emp_id;
  IF commission IS NULL THEN
    RAISE comm_missing;
  ELSE
    UPDATE employees2
      SET salary = NVL(salary,0) + sales_amt*commission
        WHERE employee_id = emp_id;
  END IF;
END award_bonus;

I didn’t quite like the testing approach in SQL Developer unit testing tutorial – it was assuming that there is already specific data in employees2 table and was testing procedure using specific primary key values. As a result tests are not very readable as you cannot see all input data in the test case and tests could easily broke if initial data in table are different.

Therefore I created tests in Ruby using better approach that each test creates all necessary data that are needed for it and at the end of test there are no side effects which can influence other tests:

describe "Award bonus" do
  include CustomerFactory

  [ [1000,  1234.55,  0.10,   1123.46],
    [nil,   1234.56,  0.10,   123.46],
    [1000,  1234.54,  0.10,   1123.45]
  ].each do |salary, sales_amt, commission_pct, result|
    it "should calculate base salary #{salary.inspect} + sales amount #{sales_amt} * commission percentage #{commission_pct} = salary #{result.inspect}" do
      employee = create_employee(
        :commission_pct => commission_pct,
        :salary => salary
      )
      plsql.award_bonus(employee[:employee_id], sales_amt)
      get_employee(employee[:employee_id])[:salary].should == result
    end
  end
end

I am generating three different tests with three different sets of input values. When you run these tests you see result:

Award bonus
- should calculate base salary 1000 + sales amount 1234.55 * commission percentage 0.1 = salary 1123.46
- should calculate base salary NULL + sales amount 1234.56 * commission percentage 0.1 = salary 123.46
- should calculate base salary 1000 + sales amount 1234.54 * commission percentage 0.1 = salary 1123.45

In addition I am using factory pattern (create_customer method) for test data creation. When using factory pattern you create test data creation method which will create valid new record with default field values. If in your test you need some specific non-default values then you can pass just these values as parameters to factory method. Factory pattern also helps in the maintenance of tests. For example, if new mandatory columns will be added to employees table then it will be necessary to add new fields with default values in factory methods and nothing should be changed in individual tests.

Here is example of employee factory implementation:

module EmployeeFactory
  # Creates new employee with valid field values.
  # Pass in parameters only field values that you want to override.
  def create_employee(params)
    employee = {
      :employee_id => plsql.employees2_seq.nextval,
      :last_name => 'Last',
      :email => 'last@example.com',
      :hire_date => Date.today,
      :job_id => plsql.jobs.first[:job_id],
      :commission_pct => nil,
      :salary => nil
    }.merge(params)
    plsql.employees2.insert employee
    get_employee employee[:employee_id]
  end

  # Select employee by primary key
  def get_employee(employee_id)
    plsql.employees2.first :employee_id => employee_id
  end
end

And here is additional test for testing if procedure will raise exception if one input value is missing:

  it "should raise ORA-06510 exception if commission percentage is missing" do
    salary, sales_amt, commission_pct = 1000,  1234.55,  nil
    employee = create_employee(
      :commission_pct => commission_pct,
      :salary => salary
    )
    lambda do
      plsql.award_bonus(employee[:employee_id], sales_amt)
    end.should raise_error(Exception, /ORA-06510/)
  end

How to use it

I hope that if you are looking for PL/SQL unit testing tool then you will try this out You can get examples from this article together with necessary setup code and installation instructions at http://github.com/rsim/plsql-testing-examples.

If you have any feedback or questions or feature suggestions then please comment.

Create Function

create or replace function fu_add(p_in in number)
  return number
as
  v_out number;
begin
  v_out := p_in + 1;
  return v_out;
end;

exec dbms_output.put_line(fu_add(10));

select fu_add(10) from dual;

Create Procedure

Zum Anlegen oder Ändern einer Procedure wird das Recht “CREATE PROCEDURE” benötigt.

Anlegen:

create or replace procedure proc_ascii
as
  type t_ascii is varray(256) of char(1);
  a_ascii t_ascii;
begin null;
  a_ascii := t_ascii();
  a_ascii.extend(256);
  for i in 1 .. a_ascii.limit-1 loop
    a_ascii(i) := chr(i-1);
    dbms_output.put_line(i || ' ' || chr(i-1));
  end loop;
end;

Drop Procedure

Das Löschen einer Procedure erfolgt mit “DROP PROCEDURE -name-”.

Aufruf Procedure

Ausführen (1):

exec proc_acsii

Ausführen (2):

begin proc_acsii;
end;

Kompilerfehler

Wenn eine Fehlermeldung beim Anlegen kommt kann mit “show errors” die Meldung angezeigt werden.

Parameter

Parameter können innerhalb der Procedure nur lesend verwendet werden.

create or replace procedure proc_ascii(p_bis in number default 256)
as
  type t_ascii is table of char(1);
  a_ascii t_ascii;
begin null;
  a_ascii := t_ascii();
  a_ascii.extend(p_bis);
  for i in 1 .. p_bis loop
    a_ascii(i) := chr(i-1);
    dbms_output.put_line(i || ' ' || chr(i-1));
  end loop;
end;

Rückgaben

create or replace procedure proc_add(p_in in number, p_out out number)
as
begin null;
  p_out := p_in + 1;
end;

declare
  v_out number;
begin
  proc_add(10,v_out);
  dbms_output.put_line(v_out); /* 11 */
end;

declare
  v_out number;
begin
  proc_add(p_out=>v_out,p_in=>10);
  dbms_output.put_line(v_out); /* 11 */
end;

By-Reference:

create or replace procedure proc_add(p_inout in out number)
as
begin null;
  p_inout := p_inout + 1;
end;

declare
  v_inout number;
begin
  v_inout := 10;
  proc_add(v_inout);
  dbms_output.put_line(v_inout); /* 11 */
end;

PLSQL um in Oracle mehrere Zeilen “gleichzeitig” einzufügen:

declare
  type t_emp is table of emp%rowtype;
  a_emp t_emp;
begin
  select * bulk collect into a_emp from emp;
  dbms_output.put_line('emp.count ' || a_emp.count);
  -- Datensätze clonen
  for i in a_emp.first .. a_emp.last loop
    a_emp(i).empno := a_emp(i).empno + 1000;
    dbms_output.put_line('empno ' || a_emp(i).empno);
  end loop;
  -- Bulk insert
  forall i in a_emp.first .. a_emp.last
    insert into emp values a_emp(i);
end;

Mit PLSQL eine komplette Oracle Tabelle in ein Array einlesen:

declare
  type t_emp is table of emp%rowtype;
  a_emp t_emp;
begin
  select * bulk collect into a_emp from emp;
  dbms_output.put_line('emp.count ' || a_emp.count);
  for i in a_emp.first .. a_emp.last loop
    dbms_output.put_line('empno ' || a_emp(i).empno);
  end loop;
end;

PLSQL-Code für SQL*Plus oder SQL Developer

declare
  v_count number;
  v_owner all_tab_columns.owner%type;
  v_table_name all_tab_columns.table_name%type;
  v_column_name all_tab_columns.column_name%type;
  cursor c_all_tab_columns is
    select distinct owner, table_name
    from all_tab_columns
    where upper(column_name) like upper(v_column_name)
  ;
begin
  v_column_name := '&like_column_name';
  dbms_output.put_line('Suche Tabellen, die Spalte ' || v_column_name || ' verwenden');
  for r_all_tab_columns in c_all_tab_columns loop
    v_owner := r_all_tab_columns.owner;
    v_table_name := r_all_tab_columns.table_name;
    v_count := 0;
    begin
      execute immediate 'select count(*)
                         from ' || v_owner || '.' || v_table_name || '
                        ' into v_count;
    exception
      when others then
        case sqlcode
          when -1031 then
            dbms_output.put_line(rpad('ErrAccess',10,'.') || ' ' || v_owner || '.' || v_table_name || ' (ORA' || SQLCODE || ')');
          else
            dbms_output.put_line(rpad('ErrOthers',10,'.') || ' ' || v_owner || '.' || v_table_name || ' (' || SQLERRM || ')');
        end case;
    end;
    if v_count > 0 then
      dbms_output.put_line(lpad(v_count,10,'.') || ' ' || v_owner || '.' || v_table_name);
    end if;
  end loop;
end;

COLUMN_NAME LIKE ‘%TABLE_NAME%’

........29 OLAPSYS.ALL$OLAP_COLUMNS
.........1 OLAPSYS.ALL$OLAP_FOREIGN_KEYS
.........2 OLAPSYS.ALL$OLAP_KEYS
.........3 OLAPSYS.ALL$OLAP_KEY_COLUMN_USES
.........9 OLAPSYS.ALL$OLAP_TABLES
........97 SYS.ALL_ALL_TABLES
.....21690 SYS.ALL_CATALOG
.....15195 SYS.ALL_COL_COMMENTS
.......339 SYS.ALL_CONSTRAINTS
.......249 SYS.ALL_CONS_COLUMNS
........74 SYS.ALL_INDEXES
.......120 SYS.ALL_IND_COLUMNS
.........2 SYS.ALL_IND_STATISTICS
.......299 SYS.ALL_LOBS
........16 SYS.ALL_OBJECT_TABLES
.......565 SYS.ALL_OBJ_COLATTRS
........50 SYS.ALL_REFS
........17 SYS.ALL_STREAMS_UNSUPPORTED
.....20089 SYS.ALL_SYNONYMS
........81 SYS.ALL_TABLES
.....16139 SYS.ALL_TAB_COLS
.....15195 SYS.ALL_TAB_COLUMNS
.......266 SYS.ALL_TAB_COL_STATISTICS
......1611 SYS.ALL_TAB_COMMENTS
......3573 SYS.ALL_TAB_HISTOGRAMS
.........1 SYS.ALL_TAB_MODIFICATIONS
.....21100 SYS.ALL_TAB_PRIVS
.....21100 SYS.ALL_TAB_PRIVS_RECD
........85 SYS.ALL_TAB_STATISTICS
........32 SYS.ALL_TRIGGERS
.....15195 SYS.ALL_UPDATABLE_COLUMNS
.......283 SYS.ALL_VARRAYS
........15 SYS.ALL_XML_TABLES
.........2 SYS.ALL_XML_TAB_COLS
.......657 SYS.DICTIONARY
.....15702 SYS.DICT_COLUMNS
ErrAccess. SYS.FLASHBACK_TRANSACTION_QUERY (ORA-1031)
.......299 SYS.IMP_LOB_INFO
.....16139 SYS.LOADER_COL_FLAGS
......1055 SYS.LOADER_COL_TYPE
.......339 SYS.LOADER_CONSTRAINT_INFO
.......627 SYS.LOADER_FULL_ATTR_NAME
.....16139 SYS.LOADER_INTCOL_INFO
.......299 SYS.LOADER_LOB_FLAGS
.......120 SYS.LOADER_OID_INFO
........16 SYS.LOADER_REF_INFO
........32 SYS.LOADER_TRIGGER_INFO
.....20740 SYS.TABLE_PRIVILEGES
.........5 SYS.USER_ALL_TABLES
.........9 SYS.USER_CATALOG
........29 SYS.USER_COL_COMMENTS
.........3 SYS.USER_CONSTRAINTS
.........3 SYS.USER_CONS_COLUMNS
.........2 SYS.USER_INDEXES
.........2 SYS.USER_IND_COLUMNS
.........2 SYS.USER_IND_STATISTICS
.........5 SYS.USER_TABLES
........29 SYS.USER_TAB_COLS
........29 SYS.USER_TAB_COLUMNS
.........9 SYS.USER_TAB_COMMENTS
.........1 SYS.USER_TAB_MODIFICATIONS
.........9 SYS.USER_TAB_STATISTICS
........29 SYS.USER_UPDATABLE_COLUMNS
........17 SYS.USER_XML_COLUMN_NAMES
ErrOthers. SYS._ALL_FILE_GROUP_TABLES (ORA-00911: Ungültiges Zeichen)
ErrOthers. SYS._ALL_REPPARAMETER_COLUMN (ORA-00911: Ungültiges Zeichen)

COLUMN_NAME LIKE ‘%USER%’

........97 SYS.ALL_ALL_TABLES
.........2 SYS.ALL_DEQUEUE_QUEUES
........74 SYS.ALL_INDEXES
.........2 SYS.ALL_IND_STATISTICS
........16 SYS.ALL_OBJECT_TABLES
.........2 SYS.ALL_QUEUES
.........2 SYS.ALL_QUEUE_TABLES
........81 SYS.ALL_TABLES
.....16139 SYS.ALL_TAB_COLS
.....15195 SYS.ALL_TAB_COLUMNS
.......266 SYS.ALL_TAB_COL_STATISTICS
........85 SYS.ALL_TAB_STATISTICS
........22 SYS.ALL_USERS
.........1 SYS.EXU8USRU
ErrAccess. SYS.FLASHBACK_TRANSACTION_QUERY (ORA-1031)
.........1 SYS.GV_$AW_SESSION_INFO
.........1 SYS.IMP9USR
........30 SYS.KU$_PROCACT_SCHEMA_VIEW
.........8 SYS.KU$_SCHEMA_CALLOUT_VIEW
.........5 SYS.USER_ALL_TABLES
.........2 SYS.USER_INDEXES
.........2 SYS.USER_IND_STATISTICS
.........2 SYS.USER_ROLE_PRIVS
.........1 SYS.USER_SYS_PRIVS
.........5 SYS.USER_TABLES
........29 SYS.USER_TAB_COLS
........29 SYS.USER_TAB_COLUMNS
.........9 SYS.USER_TAB_STATISTICS
.........1 SYS.USER_USERS
.........1 SYS.V_$AW_SESSION_INFO
........28 SYS.V_$SESSION_CONNECT_INFO
.........1 WMSYS.ALL_WORKSPACES

I have just released ruby-plsql gem version 0.4.0 which provides many new features. You can read about initial versions of ruby-plsql in previous blog posts.

Oracle complex data type support

Initial versions of ruby-plsql supported just simple Oracle types like NUMBER, VARCHAR2, DATE, TIMESTAMP, CLOB, BLOB as PL/SQL procedure parameters. Now support for many more complex data types is added. See examples below how to call PL/SQL procedures with these complex data types.

PL/SQL Record

Let’s assume you have PL/SQL procedure with PL/SQL record type parameter (which most typically will be in table%ROWTYPE format):

CREATE TABLE test_employees (
          employee_id   NUMBER(15),
          first_name    VARCHAR2(50),
          last_name     VARCHAR2(50),
          hire_date     DATE
        );
CREATE OR REPLACE FUNCTION test_full_name (p_employee test_employees%ROWTYPE)
RETURN VARCHAR2 IS
BEGIN
  RETURN p_employee.first_name || ' ' || p_employee.last_name;
END;

Then you can create Ruby Hash with record field values (specifying field names as Symbols), e.g.:

p_employee = {
  :employee_id => 1,
  :first_name => 'First',
  :last_name => 'Last',
  :hire_date => Time.local(2000,01,31)
}

and pass this Hash as a parameter which will be translated to PL/SQL record parameter by ruby-plsql:

plsql.test_full_name(p_employee) #=> "First Last"
# or
plsql.test_full_name(:p_employee => p_employee) #=> "First Last"

In the same way you can get PL/SQL function return values or output parameter values as Hash values.

Object type

In similar way also object type parameters can be passed as Hash values. In this case also nested objects or nested collections of objects are supported:

CREATE OR REPLACE TYPE t_address AS OBJECT (
  street    VARCHAR2(50),
  city      VARCHAR2(50),
  country   VARCHAR2(50)
);
CREATE OR REPLACE TYPE t_phone AS OBJECT (
  type            VARCHAR2(10),
  phone_number    VARCHAR2(50)
);
CREATE OR REPLACE TYPE t_phones AS TABLE OF T_PHONE;
CREATE OR REPLACE TYPE t_employee AS OBJECT (
  employee_id   NUMBER(15),
  first_name    VARCHAR2(50),
  last_name     VARCHAR2(50),
  hire_date     DATE,
  address       t_address,
  phones        t_phones
);
CREATE OR REPLACE FUNCTION test_full_name (p_employee t_employee)
  RETURN VARCHAR2
IS
BEGIN
  RETURN p_employee.first_name || ' ' || p_employee.last_name;
END;

and from Ruby side you can call this PL/SQL function as:

p_employee = {
  :employee_id => 1,
  :first_name => 'First',
  :last_name => 'Last',
  :hire_date => Time.local(2000,01,31),
  :address => {:street => 'Main street 1', :city => 'Riga', :country => 'Latvia'},
  :phones => [{:type => 'mobile', :phone_number => '123456'}, {:type => 'home', :phone_number => '654321'}]
}
plsql.test_full_name(p_employee) #=> "First Last"
# or
plsql.test_full_name(:p_employee => p_employee) #=> "First Last"

And also object type return values and output parameters will be returned as Ruby Hash values (with nested Hashes or Arrays if necessary).

There is one limitation that these object types should be defined as database types and not just inside PL/SQL package definition. Unfortunately you cannot access type definitions inside packages from OCI or JDBC drivers and as a result cannot call such procedures from outside of PL/SQL.

TABLE and VARRAY collections

TABLE and VARRAY collection parameters can be passed as Array values:

CREATE OR REPLACE TYPE t_numbers AS TABLE OF NUMBER(15);
CREATE OR REPLACE FUNCTION test_sum (p_numbers IN t_numbers)
  RETURN NUMBER
IS
  l_sum   NUMBER(15) := 0;
BEGIN
  IF p_numbers.COUNT > 0 THEN
    FOR i IN p_numbers.FIRST..p_numbers.LAST LOOP
      IF p_numbers.EXISTS(i) THEN
        l_sum := l_sum + p_numbers(i);
      END IF;
    END LOOP;
    RETURN l_sum;
  ELSE
    RETURN NULL;
  END IF;
END;

And from Ruby side:

plsql.test_sum([1,2,3,4]) #=> 10

CURSOR

You can get also cursor return values from PL/SQL procedures:

CREATE OR REPLACE FUNCTION test_cursor
  RETURN SYS_REFCURSOR
IS
  l_cursor  SYS_REFCURSOR;
BEGIN
  OPEN l_cursor FOR
  SELECT * FROM test_employees ORDER BY employee_id;
  RETURN l_cursor;
END;

can be called from Ruby in the following way:

plsql.test_cursor do |cursor|
  cursor.fetch #=> first row from test_employees will be returned
end

It is important to pass block parameter in this case and do something with returned cursor within this block as after ruby-plsql finishes PL/SQL procedure call it will close all open cursors and therefore it will not be possible to do anything with returned cursor outside this block.

It is also possible to use returned cursor as input parameter for another PL/SQL procedure:

CREATE OR REPLACE FUNCTION test_cursor_fetch(p_cursor SYS_REFCURSOR)
  RETURN test_employees%ROWTYPE
IS
  l_record  test_employees%ROWTYPE;
BEGIN
  FETCH p_cursor INTO l_record;
  RETURN l_record;
END;

plsql.test_cursor do |cursor|
  plsql.test_cursor_fetch(cursor) #=> first record as Hash
end

Note: you can pass cursors as PL/SQL procedure input parameter just when using ruby-plsql on MRI 1.8/1.9 with ruby-oci8, unfortunately I have not found a way how to pass cursor as input parameter when using JRuby and JDBC.

BOOLEAN

And finally you can use also PL/SQL BOOLEAN type – it is quite tricky data type as it is supported just by PL/SQL but not supported as data type in Oracle tables. But now you can also use it with ruby-plsql:

CREATE OR REPLACE FUNCTION test_boolean
  ( p_boolean BOOLEAN )
  RETURN BOOLEAN
IS
BEGIN
  RETURN p_boolean;
END;

plsql.test_boolean(true) #=> true

You can find more PL/SQL procedure call usage examples in ruby-plsql RSpec tests.

Table and sequence operations

I have been using and promoting to others ruby-plsql as PL/SQL procedure unit testing tool. As current PL/SQL unit testing tools are not so advanced and easy to use as Ruby unit testing tools then I like better to use Ruby testing tools (like RSpec) together with ruby-plsql to write short and easy to understand PL/SQL unit tests.

In unit tests in setup and teardown methods you typically need some easy way how to create some sample data in necessary tables as well as to validate resulting data in tables after test execution.

If you are Ruby on Rails developer then you probably will use ActiveRecord (or DataMapper) for manipulation of table data. But if Ruby is used just for unit tests then probably ActiveRecord would be too complicated for this task.

Therefore I added some basic table operations to ruby-plsql which might be useful e.g. in unit tests. Some syntax ideas for these table operations are coming from Sequel Ruby library.

INSERT

# insert one record
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', ...)

# insert many records
employees = [employee1, employee2, ... ]  # array of many Hashes
plsql.employees.insert employees

If primary key values should be selected from sequence then you can get next sequence values with

plsql.employees_seq.nextval # SELECT employees_seq.NEXTVAL FROM dual
plsql.employees_seq.currval # SELECT employees_seq.CURRVAL FROM dual

SELECT

# select one record
plsql.employees.first # SELECT * FROM employees
                      # fetch first row => {:employee_id => ..., :first_name => '...', ...}
plsql.employees.first(:employee_id => 1)  # SELECT * FROM employees WHERE employee_id = 1
plsql.employees.first("WHERE employee_id = 1")
plsql.employees.first("WHERE employee_id = :employee_id", 1)
# select many records
plsql.employees.all                       # => [{...}, {...}, ...]
plsql.employees.all(:order_by => :employee_id)
plsql.employees.all("WHERE employee_id > :employee_id", 5)

# count records
plsql.employees.count                     # SELECT COUNT(*) FROM employees
plsql.employees.count("WHERE employee_id > :employee_id", 5)

UPDATE

# update records
plsql.employees.update(:first_name => 'Second', :where => {:employee_id => 1})
                      # UPDATE employees SET first_name = 'Second' WHERE employee_id = 1

DELETE

# delete records
plsql.employees.delete(:employee_id => 1) # DELETE FROM employees WHERE employee_id = 1

Other SQL statements

Any other SELECT statement can be executed with

plsql.select :first, "SELECT ..."
# or
plsql.select :all, "SELECT ..."

or any other non-SELECT SQL statement can be executed with

plsql.execute "..."

And also COMMIT or ROLLBACK could be executed simply with

plsql.commit
plsql.rollback

I plan to write a separate blog post about how I recommend to create PL/SQL unit tests using Ruby and ruby-plsql and RSpec.

Install

As always you can install latest version of ruby-plsql with

gem install ruby-plsql

Latest gem version is just on Gemcutter but now it should be available as default gem source for all Ruby installations.

And as always ruby-plsql is supported both on

• Ruby 1.8.6/1.8.7 or Ruby 1.9.1 with ruby-oci8 gem version 2.0.3 or later (some specific issues with complex data types will be fixed in later versions of ruby-oci8)
• JRuby 1.3/1.4 with Oracle JDBC driver (testing mainly with ojdbc14.jar but also ojdbc5.jar or ojdbc6.jar should be fine)

Please try it out and tell me if there are any issues with some particular data types or if there are still some unsupported PL/SQL data types that you would like to be supported in ruby-plsql. And also I encourage you to try ruby-plsql out for PL/SQL unit testing if you had no PL/SQL unit tests previously

Learn a new thing today, as always. That’s a classical hierarchical tree problem reprsented in relational database.

A table having nodeId and parentNodeId and thus the tree is set up. How do you get the org tree startting from anode going up till the root node level? A stored proc.

But two problems in the implementation.

1. If you want base your loop termination logic in a PL/SQL stored proc on the basis of rowcount on the select statement having where clause.  Then it doesn’t work. It is not considered unsuccessful, hence doesn’t result ZERO as rowcount as per PL/SQL rule.

2. If you want to have your loop termination logic on the basis of variable’s value obtained from the select. That too doesnt gonna work as it doesnt update the value with null on the basis of no row returend.

THE SOLUTION: have a prevParentNodeId and parentNodeId. Andrest you know. Check for the inequality/equality of those.

Tulisan ini menguraikan apa dan bagaimana cara membuat function menggunakan PL/pgSQL. Didalamnya terdapat panduan tahap demi tahap dalam membuat dan menggunakan function menggunakan PL/pgSQL. Setelah membaca tulisan ini, anda diharapkan dapat membuat dan menggunakan fungsi menggunakan PL/pgSQL.
Overview
PL/pgSQL adalah procedural language yang loadable (dapat langsung digunakan tanpa restart server) pada sistem database PostgreSQL. PL/pgSQL didesain dengan tujuan supaya kita dapat membuat sebuah procedural language yang:

• dapat dipakai untuk membuat function atau trigger
• dapat menambahkan sruktur kontrol pada bahasa SQL
• dapat melakukan komputasi kompleks
• semua type, function, dan operator yang didefinisikan user (buatan anda sendiri atau orang lain) dapat diturunkan (inherit)
• dapat dipercaya oleh server
• mudah digunakan

Function yang telah anda buat menggunakan PL/pgSQL dapat digunakan sebagaimana function bawaan yang sudah ada. Misalnya, anda dapat membuat fungsi komputasi kondisional yang kompleks, kemudian menggunakannya untuk membuat operator atau menggunakannya untuk membuat index.

Keuntungan menggunakan PL/pgSQL
SQL merupakan bahasa yang digunakan PostgreSQL, dan begitu pula sebagian besar sistem database relasional (RDBMS: Relational Dtabase Management System) juga menggunakanSQL sebagai bahasa query. Bahasa ini begitu portable (dapat dipakai dimana saja, dan tentu ada sedikit perbedaan antar RDBMS) dan mudah dipelajari.
Namun, setiap pernyataan SQL harus dijalankan secara terpisah oleh server database. Artinya, setiap aplikasi client anda harus mengirimkan setiap perintah SQL pada server satu per satu. Seletah mengirim 1 perintah SQL, client menunggu hasil prosesnya, kemudian menerima hasilnya dan memroses hasil tersebut. Client kemudian melakukan komputasi selanjutnya, dan kemudian mengirim pernyataan SQL berikutnya pada server. Begitu seterusnya. Hal ini tentu menimbulkan beban komunikasi antara server dan client, yang tentu akan menimbulkan beban jaringan, utamanya jika client dan server database anda terpisah.
Dengan menggunakan PL/pgSQL anda dapat mengelompokkan sebuah blok komputasi atau serangkaian query langsung didalam server, yang tentu saja anda memanfaatkan keunggulan procedural language dan kemudahan penggunaan SQL, sekaligus menghemat ongkos komunikasi dan beban jaringan.
beban komunikasi dari server ke client dan sebaliknya dihilangkan
client tidak perlu menerima hasil/data pada saat proses berlangsung, cukup menerima hasil akhir dari proses tersebut, dan siap digunakan untuk proses komputasi berikutnya
dapat mencegah pengiriman query dari client ke server berulang-ulang, karena function dijalankan di sisi server
Hal ini tentu saja meningkatkan performa aplikasi anda secara signifikan. Dalam membuat function menggunakan PL/pgSQL, anda dapat menggunakan tipe data, operator, dan function pada SQL.

Tipe data parameter dan hasil yang didukung
Function yang dibuat dari PL/pgSQL dapat menerima parameter dalam bentuk skalar apa saja (integrer, char, float, dsb) maupun array yang didukung server, dan dapat pula mengembalikan nilai/hasil dengan tipe data tersebut. Function ini juga dapat menerima parameter dan mengembalikan nilai dengan tipe data komposit (tipe row). Function ini juga dapat mengembalikan nilai berupa record yang kolomnya sesuai dengan query yang dijalankan. Function yang dibuat dari PL/pgSQL juga dapat menerima parameter dan mengembalikan nilai bertipe polymorphic (anyelement, anyarray, dsb).
Function dari PL/pgSQL juga dapat dideklarasikan untuk mengembalikan nilai berupa sebuah set atau tabel. Dengan demikian fungsi ini dapat memberikan hasil dengan menjalankan perintah RETURN NEXT untuk setiap elemen dalam 1 record hasil query, atau menggunakan RETURN QUERY untuk mendapatkan semua hasil query.
Function ini juga dapat dideklarasikan untuk menghasilkan nilai void jika anda menghendaki function ini tidak mengembalikan apa-apa.
Function ini juga memiliki kemampuan untuk menerima parameter dengan tipe data berupa output, sehingga anda tidak perlu memberi perintah secara eksplisit untuk mengembalikan sebuah nilai dari suatu function. Ini seringkali berguna jika anda ingin mengembalikan beberapa nilai sekaligus.
Function Anda yang Pertama
Pada bagian ini anda akan saya ajak untuk membuat function, tentu saja function anda yang pertama. Pertama anda harus memiliki software-software yang dibutuhkan. Jika anda meggunakan windows, ada cukup perlu master installer PostgreSQL yang didalamnya sudah memasukkan server PostgreSQL dan aplikasi (client) manajemen database PgAdmin. Jika anda menggunakan linux, gunakan server PostgreSQL dan PgAdmin sesuai dengan distribusi/distro yang anda gunakan. Saya menggunakan PostgreSQL 8.3 dan PgAdmin 1.8.
Buatlah sebuah database untuk mempraktekkan contoh-contoh yang akan saya tampilkan. Buat database baru dengan nama contohplsql. Kemudian jalankan script SQL yang dapat di-download disini, pada database tersebut. Jika sukses, database contohplsql akan memiliki 3 tabel (nama, alamat, negara) dan 2 function (uuid_generate_v4, get_uuid). Kedua function ini hanya digunakan untuk meng-generate primary key pada tiap-tiap record menggunakan algoritma UUID. Klik disini untuk informasi lebih lanjut tentang UUID.
Melalui PgAdmi, masuklah pada database contohplsql, kemudian buka window baru untuk menuliskan script SQL.
[gambar 1]
[gambar 2]
Kemudian tuliskan kode berikut:
CREATE FUNCTION somefunc() RETURNS integer AS $$
<< outerblock >>
DECLARE
quantity integer := 30;
BEGIN
RAISE NOTICE ‘Quantity here is %’, quantity; — mencetak 30
quantity := 50;

/* Create a subblock */

DECLARE
quantity integer := 80;
BEGIN
RAISE NOTICE ‘Quantity here is %’, quantity; — mencetak 80
RAISE NOTICE ‘Outer quantity here is %’, outerblock.quantity; — mencetak 50
END;

RAISE NOTICE ‘Quantity here is %’, quantity; — mencetak 50

RETURN quantity;
END outerblock;
$$ LANGUAGE plpgsql;

Jalankan kode tersebut, anda baru saja membuat function anda yang pertama, dengan nama somefunc. Kemudian panggillah function yang baru saja anda buat dengan menjalankan perintah berikut:
SELECT * FROM somefunc()
Maka anda akan mendapatkan hasil berupa return value bertipe integer bernilai 50. Selamat! Anda baru saja berhasil membuat function.
Struktur PL/pgSQL
PL/pgSQL merupakan bahasa yang dibangun dari blok-blok. Syntax lengkap untuk mendefinisikan sebuah function harus membentuk sebuah blok. Sebuah blok didefinisikan sebagai berikut:
[<>]
[DECLARE
declaration]
BEGIN
statement
END [label];
Pada function pertama yang sudah anda buat tedapat blok yang bernama outerblock. Karena dia didefinisikan dibagian atas, blok ini melingkupi seluruh function. Didalam blok outerblock terdapat blok yang tidak diberi nama (jadi block sebenarnya ditandai dari adanya BEGIN dan END). Setiap deklarasi dan setiap statement dalam sebuah blok harus diakhiri dengan titik koma (;). Sebuah blok yang berada dalam blok lain, tanda titik koma harus ada setelah END. Khusus untuk blok yang menandakan badan function (mencakup keseluruhan isi function) tidak perlu titik koma.
Label hanya diperlukan untuk menandai sebuah blok jika anda menggunakan statement EXIT, atau untuk menandai nama variable yang sifatnya lokal di dalam blok tersebut. Label yang diberikan harus cocok antara yang ada di bagian BEGIN dan END. Pada function contohplsql, block outerblock diakhiri dengan END outerblock;
Semua kata kunci (key word) dibedakan huruf besar/kecil. Identifier secara implisit dikonvesi menjadi huruf kecil, kecuali yang telah diberi petik ganda, sama seperti SQL pada umumnya.
Ada 2 cara untuk menuliskan komentar pada PL/pgSQL. Pertama menggunakan awalan double dash (–), kedua menggunakan awalan /* dan akhiran */.
Setiap statement dalam sesi statement pada sebuah blok dapat ditempatkan pada sebuah sub-blok. Pembuatan sub-blok bisa didasarkan pada logika pemrograman maupun untuk tujuan melokalisir variable. Namun, anda masih bisa mengakses varible diluar blok dengan jalan menggunakan nama label blok tersebut. Perhatikan function pertama yang sudah anda buat. Blok bagian luar bernama outerblock, sedangkan didalam blok ini terdapat sub-blok yang tidak diberi nama. Pada contoh ini, sub-blok digunakna untuk melokalisir varible. Didalam sub-blok ini terdapat variable quantity, dimana namanya sama dengan variable pada blok induknya. Namun karena posisinya berbeda blok, kedua variable ini berbeda. Untuk mengakses variable quantity pada sub-blok cukup menggunakan quantity saja, sementara untuk quantity yang berada pada blok induk harus menggunakan outerblock.quantity.
Catatan: Pada function pertama yang sudah anda buat sebenarnya tedapat blok diluar semua blok yang telah didefinisikan. Blok ini dibuat oleh server secara implisit dan mencakup semua bagian dari blok-blok yang telah anda buat. Blok ini memiliki nama yang sama dengan nama function. Jadi, sebenarnya pada blok inilah anda mendeklarasikan parameter function, begitu juga varible spesial lainnya seperti FOUND. Dengan demikian anda dapat mengakses nama parameter dan variable khusus lainnya menggunakan nama function ini.
Penting untuk memahami dan tidak bingung akan penggunaan BEGIN/END sebagai blok dan sebagai transaction. Pada PL/pgSQL pernyataan BEGIN/END hanya digunakan untuk pengelompokan saja, dia tidak bisa start/commit sebuah transaction. Namun, sebuah blok yang didalamnya terdapat klausa EXCEPTION akan membentuk susunan blok tertentu dimana sebuah rangkaian statement didalamnya dapat di-roll back tanpa mempengaruhi perintah-perintah di blok lain.

Declaration
Semua variable yang digunakan dalam blok harus dideklarasikan dalam bagian deklarasi pada blok tersebut. (Kecuali varible yang digunakan dalam iterasi LOOP, yang akan dideklarasikan secara otomatis sebagai integer). PL/pgSQL dapat memiliki tipe variable sebagaimana yang dimiliki SQL, seperti integer, char, maupun varchar.
Pada function somefunc dideklarasikan 1 variable bernama quantity pada outerblock, dan 1 variable bernama quantity pada sub-blok. Berikut adalah contoh deklarasi variable:
user_id integer;
quantity numeric(5);
url varchar;
myrow tablename%ROWTYPE;
myfield tablename.columnname%TYPE;
arow RECORD;
Syntax umum untuk mendeklarasikan variable adalah sebagai berikut:
name [ CONSTANT ] type [ NOT NULL ] [ { DEFAULT | := } expression ];
Jika dalam deklarasi varible terdapat klausa DEFAULT, maka value awal akan dimasukkan ke dalam variable tersebut. Namun, jika tidak ada klausa DEFAULT, nilaia awal yang dimasukkan dalam variable tersebut adalah SQL NULL. Klausa CONSTANT membuat nilai variable ini selalu tetap, sehingga jika terjadi perintah pengisian nilai pada variable ini akan terjadi error. Klausa NOT NULL membuat pengisian SQL NULL pada variable ini error. Oleh karena itu, jika terdapat salah satu saja dari kedua properti ini, maka sebuah variable harus memiliki klausa DEFAULT. Khusus untuk klausa NOT NULL, nilai awal yang dimasukkan tidak boleh NULL.
Klausa DEFAULT dijalankan setiap kali blok tersebut dijalankan, jadi tidak hanya saat function di-compile. Contoh, jika anda mendefinisikan varible bertipe DATE, kemudian diisi dengan nilai default NOW(), maka isi varible tersebut akan berubah setiap blok dijalankan, bukan hanya saat pertama kali function ini di-compile.
Contoh penggunaan klausa DEFAULT dan CONSTANT:
quantity integer DEFAULT 32;
url varchar := ‘http://mysite.com’;
user_id CONSTANT integer := 10;

Alias untuk Parameter Fungsi
Alias digunakan untuk memberikan nama pada parameter fungsi. Secara default nama parameter adalah angka yang urut sesuai definisi paramter fungsi. Perhatikan contoh berikut:
CREATE FUNCTION somefunc(integer, varchar) RETURNS integer AS $$
Pada contoh diatas, terdapat 2 parameter pada function somefunc, keduanya berturut-turut bertipe integer dan varchar. Secara default kedua parameter tersebut berturut-turut bernama $1 dan $2. Penamaan semacam ini, pada kasus tertentu, menyulitkan anda dalam membuat dan membaca kode function. Untuk itu diperlukan penamaan parameter yang mencerminkan penggunaan parameter tersebut. Proses penamaan ini disebut dengan alias.
Terdapat 2 cara membuat alias pada parameter function. Perhatikan 2 contoh berikut:
CREATE FUNCTION instr(varchar, integer) RETURNS integer AS $$
DECLARE
v_string ALIAS FOR $1;
index ALIAS FOR $2;
BEGIN
– some computations using v_string and index here
END;
$$ LANGUAGE plpgsql;

CREATE FUNCTION sales_tax(subtotal real, OUT tax real) AS $$
BEGIN
tax := subtotal * 0.06;
END;
$$ LANGUAGE plpgsql
Pada contoh pertama, alias dilaksanakan pada bagian deklarasi function. Sedangkan pada contoh kedua, alias dilaksanakan saat pendefinisian parameter. Kedua contoh diatas tidak sepenuhnya identik. Pada contoh kedua, kita dapat membuat referensi sales_tax.subtotal, sedangkan pada contoh pertama fitur ini tidak ada. Hal ini disebabkan karena PL/pgSQL akan membuatkan label khusus secara implisit yang melingkup semua isi function dengan nama label sama dengan nama function, sehingga sales_tax.total nampak pada label ini, sedangkan pada contoh kedua alias parameter berada pada label yang berbeda.
Pada kasus parameter dan return function yang bertipe polymorphic, PL/pgSQL akan secara otomatis membuat variable bernama $0 yang akan menjadi tipe data aktual dari return function tersebut. Ini dapat digunakan sebagai variable yang dapat menampung nilai return dari suatu function, meski kadang ini tidak diperlukan. Selanjutnya, variable ini dapat diberi alias seperti parameter, yang telah dijelaskan sebelumnya. Perhatikan contoh berikut:
CREATE FUNCTION add_three_values(v1 anyelement, v2 anyelement, v3 anyelement)
RETURNS anyelement AS $$
DECLARE
result ALIAS FOR $0;
BEGIN
result := v1 + v2 + v3;
RETURN result;
END;
$$ LANGUAGE plpgsql;

CREATE FUNCTION add_three_values(v1 anyelement, v2 anyelement, v3 anyelement,
OUT sum anyelement)
AS $$
BEGIN
sum := v1 + v2 + v3;
END;
$$ LANGUAGE plpgsql;
Pada contoh pertama, alias dilaksanakan pada bagian deklarasi function. Pada contoh kedua, alias dilaksanakan pada pendefinisian parameter.

Menyalin Tipe Data
variable%TYPE

Anda dapat mendefinisikan sebuah variable dengan tipe data yang dinamis, artinya tipe data variable tersebut dapat berubah saat function dijalankan (on the fly). Tipe data seperti ini banyak dibutuhkan jika anda ingin membuat variable yang menampung data dari sebuah kolom pada suatu tabel. %TYPE akan menyajikan tipe data atau tipe kolom pada sebuah tabel. Jika anda ingin membuat variable yang bernama user_id dan digunakan untuk menampung nilai kolom user_id pada tabel user, maka syntax yang digunakan adalah:
user_id user.user_id%TYPE;

Jika kolom user_id bertipe integer maka variable user_id juga beritipe integer. Jika dikemudian hari anda mengubah kolom ini sehingga bertipe float, maka variable user_id juga akan bertipe float, tanpa harus mengganti function ini.

Row Type
name tablename%ROWTYPE;
name composite_type_name;

Sebuah variable komposit adalah variable row (atau variable row-type). Sebuah variable row dapat menampung nilai dari seluruh kolom hasil perintah select. Setiap kolom dapat diakses menggunakan tanda dot (.), misalnya: variablerow.namafield.

En la etiqueta DECLARE colocamos el cursor y añadimos un parámetro, también agregamos la consulta sql, la cual proporcionará el resultado que almacenará el cursor dependiendo del parámetro dado.

En la etiqueta BEGIN-END agregamos un ciclo que nos permitirá desplegar la información que contiene el cursor.

A continuación un ejemplo de una tabla regiones que tiene dos atributos reg_codigo, reg_nombre:

DECLARE
   CURSOR cemp(r_codigo IN number) IS
   SELECT reg_codigo, reg_nombre
   FROM regiones
   WHERE reg_codigo = r_codigo;
   cepm_rec cemp%ROWTYPE;
   v_codigo number;
BEGIN
   v_codigo := codigo_region
   FOR cemp_rec IN cemp(v_codigo) LOOP
      :bloque1.mostrar_nombre := cemp_rec.reg_nombre;
   END LOOP;
END;

El código está en Oracle Forms lo cual muestra por pantalla el item “:bloque1.mostrar_nombre” entregando el nombre de la región según codigo_region.

Client is looking for a Perm Siebel Certified Technician/Configurator. Must be Green Card/ Citizens ONLY- Great Salary and Benefits. Easton, PA area.

Experience with Siebel CRM.
Experience with configuring Siebel Tools, eScript, Workflow and Assignment Manager.
Experience with EIM, EAI, Integration Objects, EBC, VBC, Business Services and Web Services.
Experience writing SQL, PL/SQL and SQL Loader.
Experience with installation and administration of Siebel servers.
Experience in estimating level of effort and complexity of requirements.
Experience with hands-on custom software development, code reviews and technical design.
Bachelor’s degree in an IT related area or equivalent work experience.
Siebel Certified
5+ years’ of Experience delivering quality Siebel CRM solutions.
Experience delivering two + full life cycle implementation.
Experience with Siebel Configuration; Business Components, Views, Applets, Roles & Responsibilities, Workflow, eScript, SmartScript.
Experience with event driven Configuration, such as Workflow Policies and Run-time Events.
Experience configuring VBCs and EBCs.
Experience integrating Siebel with other applications. Exposure to EAI, EIM, integration objects, integration error handling, and integration concepts (real-time, batch, sync/async).
Experience with web service configuration for both subscribing to external web services and exposing Siebel business layer objects as web services.
Experience gathering and documenting business and functional requirements.
Excellent Understanding of Siebel Development process, architecture, and data model.
 Working knowledge of db technologies and relational database concepts.

Below are the list of URLs, which I found to be very good. I have also provided a small abstract from the reference site. For more detail, please refer the URL.

First, I will thank and acknowledge all the authors and Gurus who have shared their knowledge through websites and blogs.

1. Defining Arrays in Oracle

   • Create a collection using the Associative Arrays i.e. <code>TYPE <type name> TABLE OF <like NUMBER> INDEX BY PLS_INTEGER </code>and then create another TABLE type based on the previous one. This creates a 2D Array of unlimited size.
     

2. Remove Characters using Translate Function

   • TRANSLATE ( <your_string> , ‘#’  ||  <characters_to_be_removed>, ‘#’)
   • Here, # was used by the author as a placeholder and which can be any character-set which should not be present in the <your_string>

3. Ref-Cursor variables

   • The Ref-cursor value can also be passed as an OUT parameter
   • PROCEDURE <yr_proc> (<in_var> OUT SYS_REFCURSOR), now within the procedure just OPEN the cursor OPEN <in_var> FOR <lv_query>

4. Best practices for changing headers and handling different WHERE clauses

6. Will add more…
   

Consider you’ve same tables (dummy_table) in two different users (assume user A & user B). You’re creating a procedure in user A to update the values of dummy_table. By granting the execute privilege on the procedure to insert into the dummy_table to user B, now you can define in a procedure to update it in either user A’s table or user B’s table.

Confusing..? Lets go into the practicals..

• In User A, create the following table.

CREATE TABLE dummy_tab(my_date DATE);

• Now, create a procedure in User A, to insert into the dummy_tab

CREATE OR REPLACE PROCEDURE update_dummy_tab AUTHID DEFINER AS
BEGIN
INSERT INTO dummy_tab VALUES(SYSDATE);
COMMIT;
END;
/

• Grant the execute privilege to user B to run the procedure.

GRANT EXECUTE ON update_dummy_tab TO userb;

• Now login as user B & create the dummy_tab table.

CREATE TABLE dummy_tab(my_date DATE);

• Run the procedure in user B which is created in user A as follows:

CALL usera.update_dummy_tab();

• If you select the values of dummy_tab in user A, it’s updated with sysdate..
  

       MY_DATE 
       11/6/2009 3:17:12 PM

Now lets try to update the user A’s procedure to update user B’s dummy table.

• Modify the procedure with AUTHID CURRENT_USER as follows:

CREATE OR REPLACE PROCEDURE update_dummy_tab AUTHID CURRENT_USER AS
BEGIN
INSERT INTO dummy_tab VALUES(SYSDATE);
COMMIT;
END;
/

• Run the procedure in user B again..

CALL usera.update_dummy_tab();

• Then select the user B’s dummy_tab table.. You’ll be surprised that it’s filled with the current sysdate.
  

        MY_DATE
        11/6/2009 3:27:40 PM

  So, by using AUTHID CURRENT_USER in the procedure, it takes the local tables of the user. If the table is not present, it’ll throw out the error.

  By default AUTHID DEFINER is implicitly specified in the procedure. Its not necessary to specify explicitly. Only for AUTHID CURRENT_USER it should be specified.

http://sirius.cs.ucdavis.edu/teaching/sqltutorial/tutorial.pdf

En oracle forms, cuando se tiene el escenario donde un bloque en particular no se permite guardar, es decir, los datos ingresados no son relevantes; se hace uso de paquete APP_SPECIAL

ejemplo:

en el bloque que se desea deshabilidar
usar el disparador “PRE-BLOCK” y introducir el código app_special.enable(‘SAVE’, PROPERTY_OFF);
ahora para que este botón se encuentre disponible en los demás bloques a nivel módulo en el mismo disparador (PRE-BLOCK)
introducir el código app_special.Enable(‘SAVE’, PROPERTY_ON);

I needed to spilt (tokenize) a string in Oracle SQL and I wanted do it simply and I found a really useful function:


function get_split(the_list varchar2,
the_index number,
delim varchar2 := '|' ) return varchar2
is
start_pos number;
end_pos number;
begin
if the_index = 1 then
start_pos := 1;
else
start_pos := instr(the_list, delim, 1, the_index - 1);
if start_pos = 0 then
return null;
else
start_pos := start_pos + length(delim);
end if;
end if;
end_pos := instr(the_list, delim, start_pos, 1);
if end_pos = 0 then
return substr(the_list, start_pos);
else
return substr(the_list, start_pos, end_pos - start_pos);
end if;
end get_split;

So now I could do a select :
select get_split('0|1|0',2) from dual; –> ‘1′

最近、pl/sqlのコードを書いてみたりしているが、ドキュメントの生成も欲しいところ、探すとPLDocというものがあったのでちょっと試した。

javadocと同じ感じで使用すると、ドキュメントをちゃんと生成してくれた。

この手のツールはあると非常に助かるが、pl/sqlのようなOracle社しかエンジン開発しないような言語は初めからOracle社として用意すべきではないだろうか？

いつかこの手のツールがOracleに標準装備されることを期待する。

Automatically Backuping Apex Applications

We can export our apex applications as an sql file in “Home>Application Builder>Application $ID>Export / Import>Export” menu. You can do this as manually, so if you want to backup your apex application(s) you should do this for each time for each application.

As you guess this operation runs a plsql command in background to export application.

“wwv_flow_utilities” public package of apex, includes “export_application_to_clob” function that returns clob variable that containts sql statements. These sql statements those are application metadata that will be imported your workspace. Spec part of function is below :

Application ID is a number that user specified or automatically got from apex. That is on right of f?p= parameter of url string. You should specify application id to export application. Another parameter is p_export_saved_reports is optional, if you want to export saved report you can set this as ‘Y’.

You can write a dbms_scheduler job that runs this plsql for every specified interval time. Or you can write a unix shell script that produces an sql file, put this shell script to crontab to run this backup operations for every specified interval time. Or anything else…

Also you can export only a page of an application, this function is under wwv_flow_utilities package too, spec part of this :

Example :

To backup your all of applications you can get application id from “select * from apex_applications”.

This example was tested on Oracle 11.1.0.6 and Apex 3.2.

I just wonder why ORACLE didn’t implement sum of interval day to second datatype.

CREATE OR REPLACE TYPE sum_interval AS OBJECT
(

/* type implements oracles data cartridge interface to compute sum of day to second interval values */

   duration INTERVAL DAY TO SECOND, --duration accumulator

   CONSTRUCTOR FUNCTION sum_interval RETURN SELF AS RESULT
      PARALLEL_ENABLE,

   STATIC FUNCTION odciaggregateinitialize(ctx IN OUT sum_interval) RETURN NUMBER,

   MEMBER FUNCTION odciaggregateiterate
   (
      SELF  IN OUT sum_interval,
      VALUE IN INTERVAL DAY TO SECOND
   ) RETURN NUMBER,

   MEMBER FUNCTION odciaggregatedelete
   (
      SELF  IN OUT sum_interval,
      VALUE IN INTERVAL DAY TO SECOND
   ) RETURN NUMBER,

   MEMBER FUNCTION odciaggregateterminate
   (
      SELF        IN sum_interval,
      returnvalue OUT INTERVAL DAY TO SECOND,
      flags       IN NUMBER
   ) RETURN NUMBER,

   MEMBER FUNCTION odciaggregatemerge
   (
      SELF IN OUT sum_interval,
      ctx  IN sum_interval
   ) RETURN NUMBER
)
;
/

CREATE OR REPLACE TYPE BODY sum_interval IS

   -------------------------------------------------------------------------------------------------
   CONSTRUCTOR FUNCTION sum_interval RETURN SELF AS RESULT
      PARALLEL_ENABLE IS
   BEGIN
      RETURN;
   END sum_interval;

   -------------------------------------------------------------------------------------------------
   STATIC FUNCTION odciaggregateinitialize(ctx IN OUT sum_interval) RETURN NUMBER IS
   BEGIN
      ctx := sum_interval();
      RETURN odciconst.success;
   END odciaggregateinitialize;

   -------------------------------------------------------------------------------------------------
   MEMBER FUNCTION odciaggregateiterate
   (
      SELF  IN OUT sum_interval,
      VALUE IN INTERVAL DAY TO SECOND
   ) RETURN NUMBER IS
   BEGIN
      IF SELF.duration IS NULL THEN
         SELF.duration := VALUE;
      ELSE
         SELF.duration := SELF.duration + VALUE;
      END IF;
      RETURN odciconst.success;
   END odciaggregateiterate;

   -------------------------------------------------------------------------------------------------
   MEMBER FUNCTION odciaggregateterminate
   (
      SELF        IN sum_interval,
      returnvalue OUT INTERVAL DAY TO SECOND,
      flags       IN NUMBER
   ) RETURN NUMBER IS
   BEGIN
      returnvalue := SELF.duration;
      RETURN odciconst.success;
   END odciaggregateterminate;

   -------------------------------------------------------------------------------------------------
   MEMBER FUNCTION odciaggregatedelete
   (
      SELF  IN OUT sum_interval,
      VALUE IN INTERVAL DAY TO SECOND
   ) RETURN NUMBER IS
   BEGIN
      SELF.duration := SELF.duration - VALUE;
      RETURN odciconst.success;
   END odciaggregatedelete;

   -------------------------------------------------------------------------------------------------
   MEMBER FUNCTION odciaggregatemerge
   (
      SELF IN OUT sum_interval,
      ctx  IN sum_interval
   ) RETURN NUMBER IS
   BEGIN
      IF ctx.duration IS NULL THEN
         NULL;
      ELSE
         SELF.duration := SELF.duration + ctx.duration;
      END IF;
      RETURN odciconst.success;
   END odciaggregatemerge;

END;
/

create or replace function fce_sum_interval(duration interval day to second) return interval day to second
  parallel_enable
  aggregate using sum_interval;
/

select fce_sum_interval(numtodsinterval(level, 'minute')) from dual connect by level <= 10;