Effective RDBMS Interface for Pega!

Pega Rules Process commandar is a workflow engine that helps to develop Business Process Management application.

In recent project, we had an challenge in data intensive application design as Pega does not support distributed transaction with external databases.

After trying out several designs, we found an excellent solution which not only requires very less coding, but scalable, robust and more over fits perfectly given the nature of Pega Architecture and most of the RDBMS.

The one-line solution is XML!

Yes, since pega internally stores anything and everything as XML, we have an easy job when we can pass the complete work object (pega-terminalogy equivalent to object in java) in XML format to Database, where DB can parse the input, process and send back the reponse in same way.


PROCEDURE FRED_SERVICE (
p_header IN CLOB,
p_request IN CLOB,
p_response OUT VARCHAR2,
p_err_code OUT NUMBER
)
IS
/* XML Parsing local variables */

l_doc DBMS_XMLDOM.DOMDocument;
l_element DBMS_XMLDOM.DOMElement;
l_attr DBMS_XMLDOM.DOMAttr;
l_node DBMS_XMLDOM.DOMNode;
l_node_list DBMS_XMLDOM.DOMNodeList;

l_pxResults_list DBMS_XMLDOM.DOMNodeList;
l_rowdata_list DBMS_XMLDOM.DOMNodeList;
l_rowdata_child_list DBMS_XMLDOM.DOMNodeList;


l_node_value VARCHAR2(1000);
l_tag_name VARCHAR2(1000);
l_pxResults_size NUMBER;
l_rowdata_size NUMBER;
l_rowdata_child_size NUMBER;
l_rowdata_column FRED_UTIL.FRED_ELEMENT := FRED_UTIL.FRED_ELEMENT('ELEMENT1',
'ELEMENT2',
'ELEMENT3',
'ELEMENT4',
'ELEMENT5');
l_rowdata_map FRED_UTIL.FRED_ELEMENT_MAP;

/* Transaction Unit local variables*/
ELEMENT1 NUMBER;
ELEMENT2 NUMBER;
ELEMENT3 NUMBER;
ELEMENT4 DATE;
ELEMENT5 VARCHAR2(3);

/* Trace */
l_file UTL_FILE.file_type;
l_log_file_name VARCHAR2 (100) := 'fredService.log';
l_log_dir VARCHAR2 (100) := '/tmp';
l_log_msg VARCHAR2 (1000) := 'fredService';


BEGIN
p_err_code :=0;
p_response :=NULL;
l_log_msg := TO_CHAR (SYSDATE, 'MM/DD/YY HH24:MI:SS')||'**** fred_service STARTED****';
l_log_msg := l_log_msg||chr(10);
DBMS_OUTPUT.put_line (l_log_msg);
l_file := UTL_FILE.fopen (l_log_dir,l_log_file_name,'W');
UTL_FILE.put_line (l_file,l_log_msg);

IF p_request IS NULL
THEN
p_err_code := 999;
p_response := 'INPUTNULL';
UTL_FILE.put_line (l_file,p_response);
ELSE

l_doc := DBMS_XMLDOM.newdomdocument (p_request);
l_pxResults_list := DBMS_XMLDOM.getelementsbytagname (l_doc, 'pxResults');
l_rowdata_list := DBMS_XMLDOM.getChildrenByTagName(DBMS_XMLDOM.makeElement(DBMS_XMLDOM.item(l_pxResults_list,0)),'rowdata');
l_rowdata_size := DBMS_XMLDOM.getlength (l_rowdata_list);

FOR rowCounter in 0..l_rowdata_size-1 LOOP

FOR colCounter in 1..l_rowdata_column.count LOOP

l_rowdata_child_list := DBMS_XMLDOM.getChildrenByTagName(DBMS_XMLDOM.makeElement(DBMS_XMLDOM.item(l_rowdata_list,rowCounter)),l_rowdata_column(colCounter));
l_node := DBMS_XMLDOM.item(l_rowdata_child_list,0);
l_rowdata_map(l_rowdata_column(colCounter)) := DBMS_XMLDOM.getNodeValue(DBMS_XMLDOM.getFirstChild(l_node));

END LOOP;

ELEMENT1 :=TO_NUMBER(l_rowdata_map('ELEMENT1'));
ELEMENT2 :=TO_NUMBER(l_rowdata_map('ELEMENT2'));
ELEMENT3 :=TO_NUMBER(l_rowdata_map('ELEMENT3'));
ELEMENT4 :=TO_DATE(SUBSTR(l_rowdata_map('ELEMENT4'),1,8),'YYYYMMDD');
ELEMENT5 :=l_rowdata_map('ELEMENT5');


l_log_msg := l_log_msg||'
'
||'Calling Business Transaction with following parameters'||'
'
||'ELEMENT1: '||ELEMENT1||'
'
||'ELEMENT2: '||ELEMENT2||'
'
||'ELEMENT3: '||ELEMENT3||'
'
||'ELEMENT4: '||ELEMENT4||'
'
||'ELEMENT5: '||ELEMENT5||'
';

END LOOP;

END IF;
l_log_msg := l_log_msg ||'
'||TO_CHAR (SYSDATE, 'MM/DD/YY HH24:MI:SS')||'**** fred_service completed****';
p_response := l_log_msg;
UTL_FILE.put_line (l_file,l_log_msg);
UTL_FILE.fclose (l_file);

EXCEPTION WHEN OTHERS THEN
p_err_code := SQLCODE;
p_response := SQLERRM;
END FRED_SERVICE;





Autonomous Transaction

Feature from oracle 8i.

The commit/rollback does not affect the surrounding transaction.

Can be used if we want to log some message irrespective of state of the transaction.


PROCEDURE TEST_PRC IS
PRAGMA AUTONOMOUS_TRANSACTION;
BEGIN
NULL;
END;


Vector / ArrayList - Size increment

ArrayList and Vector are internally implemented with Object[] with dynamically expands as we add more objects. But its interesting to know why people stress on using arrays if at all possible in the place these utilities.

These dynamic arrays increases the memory in folds.

ArrayList - default capacity 10

int newCapacity = (oldCapacity * 3)/2 + 1;


Vecor - default capacity

int newCapacity = (capacityIncrement > 0) ?
(oldCapacity + capacityIncrement) : (oldCapacity * 2);



So its better to initialize these objects with proper initial capacity to avoid performance issues.

Keywords not used in Java

• goto
• const

The keywords const and goto are reserved, even though they are not currently used. true, false, and null might seem like keywords, but they are actually literals; you cannot use them as identifiers in your programs.

Newly added keyword in Java 5 - enum

Refer

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html

How to prevent subclassing!

1. By declaring class as final

public final class Parent{
}


2. By having only private constructors. Super class constructors should be visible in order to subclass.

private Parent(){
}


How to call blocks from other classes?

Non static blocks & Static blocks are executed one by one by the order of their defintion before any constructor is being executed.

Static blocks can also be invoked without creating instance of the Class(without actually calling constructors) by simply loading the Class.


Class.forName("ClassThatContainsStaticBlock");


---


class ExOne{

//Static block
static{
System.out.println("This is static block of ExOne");
}

//Non static block
{
System.out.println("This is non-static block of ExOne");
}

public ExOne(){
System.out.println("This is Constructor block of ExOne");

}
}

public class ExOneTest{

public static void main(String[] args) {
try {
// Static blocks can be called either by creating
// new instance or loading the class
new ExOne();
Class.forName("ExOne");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}


How to make a class immutable?

1)All of its fields are final
2)The class is declared final
3)The this reference is not allowed to escape during construction
4)Any fields that contain references to mutable objects, such as arrays, collections, or mutable classes like Date:
-Are private
-Are never returned or otherwise exposed to callers
-Are the only reference to the objects that they reference
-Do not change the state of the referenced objects after construction

Refer java.lang.String

How to redirect standard output/err to a file?



PrintStream err=null;
PrintStream out=null;
String outputFile="C://output.txt";
String errorFile="C://error.txt";

err=new PrintStream(new FileOutputStream(errorFile));
System.setErr(err);

//append all outputs
out=new PrintStream(new FileOutputStream(outputFile,true));
System.setOut(out);

System.err.print("This is error written to file");
System.out.print("This is output written to file");



Singleton pattern in Java

Simplest way to create a singleton instance is to use - static member/members, final class and private constructor.



class final Singleton{

private Singleton(){

}

static public doSomething(){
//do stuff here
}

}

class Client{

public static void main(String[] a){

Singleton.doSomething();

}

}



So wats wrong here?

a. Since Singleton class is final - cant subclass
b. Since Singleton class can effectively have only static members- it cannot implement any interface -very bad
c. all clients should access the Singleton with classname- hard binding
d. modifying existing pojo as singleton is nightmare of changing all over the places

Wat to do then?

Decouple the singleton functionality from singleton class with wrapper class.



class final SingletonWrapper{

static private Singleton instance_;

static synchronized public Singleton getInstance(){

if (instance_==null){
instance_=new Singleton();

}

return instance_;
}

}



Good article, why static singleton can't be a complete solution


http://radio.weblogs.com/0122027/stories/2003/10/20/implementingTheSingletonPatternInJava.html

Some more better models


/*
* Simple Traditional Way An instance is available whether used or not thread
* safe
*/
class AClass {

private final static AClass instance_ = new AClass();

private AClass() {
}

static AClass getInstance() {
return instance_;
}

void doStuff() {

}
}

/*
* New Java 5 way - use of volatile Instance is created with thread safe way
* when the fist getInstance is called
*/

class BClass {

private static volatile BClass instance_;

private BClass() {

}

static BClass getInstance() {

if (instance_ == null) {

synchronized (BClass.class) {

if (instance_ == null) {
instance_ = new BClass();
}
}
}

return instance_;
}

}

/*
* Better way to make use of Wrapper/Holder Lazy loaded when getInstance is
* called Thread safe
*/

class CClass {

private CClass() {

}

private static class CClassHolder {
private static final CClass instance = new CClass();
}

static CClass getInstance() {
return CClassHolder.instance;
}
}




Identify Duplicate Records


SELECT *
FROM my_org a
WHERE (SELECT COUNT (*)
FROM my_org b
WHERE a.legal_name=b.legal_name
and a.org_id <> b.org_id) > 1