Oracle

PL/SQL – Retrieving current milliseconds

The function to_char with sysdate is the most known way to retrieve current time in PL/SQL. The way:

select to_char(sysdate,'dd/MM/yyyy HH24:mi:ss') date from dual;

You get this:

DATE
------------------------------
14/08/2012 13:24:32

But, if need get milliseconds also, we should to use systimestamp and the characters ‘FFn‘, where ‘n’ will be number of digits. The milliseconds are the goal, then ’4′ is the number.

select to_char(systimestamp,'dd/MM/yyyy HH24:mi:ss.FF4') date from dual;

And results:

DATE
------------------------------
14/08/2012 13:24:33.2110

If you wants only milliseconds, jus keep ‘FF4’ and remove the others characters:

select to_char(systimestamp,'FF4') millis from dual;

Now you will get:

MILLIS
------------------------------
2110

Good coding!


Oracle – Escaping character ‘_’ in LIKE clause

How should you know, underline(‘_’), in LIKE, is considered a wildcard that means “any character”. Query will replace underline by any other character where ‘_’ is.

Following table bellow:

+---------+
|  WORD   |
+---------+
| COLUMN  |
+---------+
| BEE     |
| SEE     |
| FEE     |
| SHE     |
| _EE     |
+---------+

And running

select column from word where column LIKE '_EE';

Results

+---------+
| COLUMN  |
+---------+
| BEE     |
| SEE     |
| FEE     |
| _EE     |
+---------+

Besides “_EE“, expected initially, “BEE“, “SEE” and “FEE” has been returned.

We have to use escape after LIKE to include ‘_’ at the search. Escape needs a character to transform it in a wildcard that ignores the next one, thus, the new wildcard should be added before ‘_’, like this.

select column from word where column LIKE '\_EE' escape '\';

Now, the result will be:

+---------+
| COLUMN  |
+---------+
| _EE     |
+---------+

I hope this helps some one else! 🙂


A easy way to compile many objects in Oracle database

When compiles an object that is referenced by many others, they stay invalidated until Oracle compile they again and sometimes it fails.

So, here’s a tip to compile several invalid packages, procedures and/or functions and fix this.

There is a command to compile all invalid objects under an user, the command is:

exec dbms_ultility.compile_schema(<USER>)

Replace  <USER> for user, or for user name where invalid objects are.

This command is slow and not compiles objects invalidated by coding error. To find which are invalid you need runs the query below:

select object_name
from all_objects
where status = 'INVALID'

Invalid objects will be listed.


Retrieving an Oracle cursor in Java

Many people come here looking for one way to retrieve cursors of Oracle procedures in Java. To them, I’ve here are a tutorial showing how to do this.

To retrieve the cursor you should declare him how a REF CURSOR in Package spec.

  --Creating the REF CURSOR type
  type g_cursor is ref cursor;

In both, spec and body, you need declare an out REF CURSOR variable in procedure signature, how cited above.

  procedure PRO_RETURN_CARS(
    i_id     in     tbl_car.car_id%type,
    o_cursor in out g_cursor);

The cursor must be opened in procedure’s body to return, this way:

open o_cursor for
          select car_id, company, model, color, hp, price
          from tbl_car
          where car_id = i_id;

The complete Package:

create or replace package PAC_CURSOR is
  --Creating REF CURSOR type
  type g_cursor is ref cursor;

  --Procedure that return the cursor
  procedure PRO_RETURN_CARS(
    i_id     in     tbl_car.car_id%type,
    o_cursor in out g_cursor); -- Our cursor

end PAC_CURSOR;
/

create or replace package body PAC_CURSOR is
  procedure PRO_RETURN_CARS(
    i_id     in     tbl_car.car_id%type,
    o_cursor in out g_cursor) is

       begin
        --Opening the cursor to return matched rows
        open o_cursor for
          select car_id, company, model, color, hp, price
          from tbl_car
          where car_id = i_id;

  end PRO_RETURN_CARS;

end PAC_CURSOR;

We have Oracle side ready, now we need create Java call

How the cursors are being returned by a procedure, we’ll used a java.sql.CallableStatement instance.

CallableStatement cs = conn.prepareCall("{call PAC_CURSOR.PRO_RETURN_CARS(?,?)}");

The registerOutParameter will obtain oracle.jdbc.OracleTypes.CURSOR type and return a java.sql.ResultSet instance. We can iterate the ResultSet like a common Iterator.
Each row column returned by SELECT will be represented how a map, using correspondent getter. For example, we will call getString(<column name>) method when value of column is a varchar, getDate(<column name>) when is a date and etc.

The complete code will be like this:

//Calling Oracle procedure
CallableStatement cs = conn.prepareCall("{call PAC_CURSOR.PRO_RETURN_CARS(?,?)}");

//Defining type of return
cs.registerOutParameter("o_cursor", OracleTypes.CURSOR);
cs.setLong("i_id", id);

cs.execute();//Running the call

//Retrieving the cursor as ResultSet
ResultSet rs = (ResultSet)cs.getObject("o_cursor");

//Iterating the returned rows
while(rs.next()){
	//Getting column values
	System.out.println("ID: " + rs.getLong("car_id"));
	System.out.println("Manufacturer: " + rs.getString("company"));
	System.out.println("Model: " + rs.getString("model"));
	System.out.println("Color: " + rs.getString("color"));
	System.out.println("HP: " + rs.getString("hp"));
	System.out.println("Price: " + rs.getFloat("price"));
}

In the end you will get any value returned in a SELECT clause.

See ya!


Retrieving objects collection from Oracle procedure

As I’ve promised in post “Learn to pass a Java Object as Oracle Procedure parameter“, I’ll show how retrieve object that have a collection of objects as attribute through of an Oracle procedure. Is highly recommended to read previous post.

For this tutorial, we’ll need create the table TBL_CLASS and add your primary key as foreign key in TBL_USER table.

--num class is PK and desc_class description
create table TBL_CLASS (num_class number, desc_class varchar(100));
alter table TBL_CLASS add primary key(num_class);

alter table TBL_USER add num_class number;
alter table TBL_USER add constraint FK_CLASS foreign key(num_class) references tbl_class(num_class);

Now we need to include the new types:

create or replace type class_type as object (num_class number, desc_class varchar2(100), users arr_users);
/
create or replace type arr_class as table of class_type;
/

The class_type type will be the Java Object. Notice that in your signature was included the arr_users type, that will be our collection of user_type (read previous post for more information), the arr_class type will be the class_type collection.

Now we’ll include the procedure that returns our class_type collection.

procedure pro_select_class(clas in class_type, class_return in out arr_class)is
  class_ref_cur ref_cur;
  --class_type array
  classes arr_class := arr_class();

  begin
    open class_ref_cur for
      select cast(
                multiset(
                  select num_class,
                         desc_class,
                         (select cast(
                                  multiset(
                                    select user_name,
                                           height,
                                           b_date
                                    from tbl_user
                                    --JOIN with TBL_USER
                                    where tbl_user.num_class = tbl_class.num_class
                                  ) as arr_users)
                          from dual) users
                  from tbl_class
                  --Using num_class attribute of in parameter
                  where num_class = clas.num_class) as arr_class
      ) classes
    from dual;

    --including the return in array
    fetch class_ref_cur into classes;
    --transferring arrar to variable out
    class_return := classes;
end pro_select_class;

Notice that procedure receive class_type as parameter in and returns arr_class type.

Separating code charge back and set up our objects, we have:

--Mount return
select cast(
        multiset(

          --Will returns the objects class_type and your attributes
          select num_class,
                 desc_class,

                 --Populate user_type collection
                 (select cast(
                          multiset(
                            select user_name,
                                   height,
                                   b_date
                            from tbl_user
                            where tbl_user.num_class = tbl_class.num_class
                          ) as arr_users)

                  from dual) users

          from tbl_class
          where num_class = clas.num_class) as arr_class
) classes
from dual;

Oracle objects done, now the Java code!

We’ll create the object that will be interpreted by the Oracle. Called TypeClass:

public class TypeClass implements SQLData{
	public static final String ORACLE_OBJECT_NAME = "CLASS_TYPE"; //Type name in Oracle
	public static final String ORACLE_CLASS_ARRAY_NAME = "ARR_CLASS"; //Array name in Oracle
	
        //Attibutes of TBL_CLASS table
	private Long number;
	private String desc;
	private Array users; //This will be user_type collection (or TypeUser in Java)
	
	public String getSQLTypeName() throws SQLException {
		return ORACLE_OBJECT_NAME;
	}
	
	public void readSQL(SQLInput stream, String typeName) throws SQLException {
		setNumber(stream.readLong());
		setDesc(stream.readString());
		setUsers(stream.readArray());//Used by JDBC driver to read the collection
	}

	public void writeSQL(SQLOutput stream) throws SQLException {
		stream.writeLong(getNumber());
		stream.writeString(getDesc());
		stream.writeArray(getUsers());//Used by JDBC driver to write the collection
	}
	//Getters and setters omitted
}

We need to map types interpreted in request, this way:

Map> typeMaps = connection.getTypeMap(); 
typeMaps.put(TypeUser.ORACLE_OBJECT_NAME, TypeUser.class);
typeMaps.put(TypeClass.ORACLE_OBJECT_NAME, TypeClass.class);

We need to map the arrays too:

typeMaps.put(TypeClass.ORACLE_CLASS_ARRAY_NAME, TypeClass[].class);//returned by procedure
typeMaps.put(TypeUser.ORACLE_USER_ARRAY_NAME, TypeUser[].class);//returned by class_type collection

For request, we do:

cs = conn.prepareCall("{call PAC_BEAN.PRO_SELECT_CLASS(?,?)}");
//registering out type, that will be a TypeClass array
cs.registerOutParameter("class_return", OracleTypes.ARRAY, TypeClass.ORACLE_CLASS_ARRAY_NAME);

//passing parameter object
cs.setObject("clas", classQry);

cs.execute();
//retrieving and looping the TypeClass array
Object[] array = (Object[])cs.getArray("class_return").getArray();

for(Object obj : array){
	TypeClass objClass = ((TypeClass)obj);
	
	System.out.println("Description: "+objClass.getDesc());
	
        //Here we obtains user_type(TypeUser) array returned by query.
	Object[] userArray = (Object[])objClass.getUsers().getArray();
	for(Object user : userArray){
		System.out.println("\tName: " + ((TypeUser)user).getName());
		System.out.println("\tHeight: " + ((TypeUser)user).getHeight());
		System.out.println("\tBirth: " + sdf.format(((TypeUser)user).getBirth())+ "\r\n");
	}
}

In the end you’ll have a java.sql.Array of TypeUser in getUsers() attribute of TypeClass.

Here I fulfilled my promise. Download the source code of this sample (with previous post sample too) here.

Until next time!


  • Advertisement

  • Advertisement

  • Copyright © 1996-2010 André L. S.. All rights reserved.
    iDream theme by Templates Next | Powered by WordPress