Oracle - Print Column values in Rows

Many times, we wonder how to print all the column values of a single record in row form which will be most widely used for analysis or studies

Here is an utility PL/SQL block which can print all column valus in a rows in tab limitied form (can be easily converted to Spreadsheets)


/**
* Author : Nambi Adhimoolam
* Date : 9/17/2008
* Revision : 1.0
*/

DECLARE
CURSOR c1 (v_table_name VARCHAR2)
IS
SELECT column_name
FROM all_tab_cols
WHERE table_name = v_table_name;

l_sql VARCHAR2 (100);
l_val VARCHAR2 (32000);
BEGIN
FOR k IN c1 ('MY_TABLE')
LOOP
l_sql :=
'SELECT ''''||'|| k.column_name
||' FROM MY_TABLE WHERE rownum < 2';

EXECUTE IMMEDIATE l_sql INTO l_val;

DBMS_OUTPUT.put_line (k.column_name||chr(9)||l_val);
END LOOP;
EXCEPTION
WHEN OTHERS
THEN
DBMS_OUTPUT.put_line (SQLERRM || SQLCODE);
END;



Disable Substitution variables in SQL* Plus

For example, if we need to execute a following sql, in SQL*Plus


INSERT INTO USER(ID,NAME) VALUES(12,'ABC & CO');


While executing this, SQL*Plus will promt the user to input value 'CO' as its prefixed with subsititution character &. However in this scenarios, its should not act as substitution variable but rather &hersand.

To overcome this issues, we can disable the subsititution variabels with


SET DEFINE OFF


For selective disabling and other options, refer
http://www.orafaq.com/wiki/SQL*Plus_FAQ

Frequent Use of VBScript Confirm Box

In an user friendly internet applications, one of the most used feature is prompts. Since Java script doesnot offer much flexibility, most of us turn to VB Script. Here the crux of wat we look normally for prompts.


retVal = makeMsgBox("Hi","how are you?",32,1,256,4096);


You can change the numbers to create alerts, confirms or any type of popup using the numbers / arguments below.

The alert and confirm boxes take 4 arguments

Argument one : The Icon 0 = none
16 = X
32 = ?
48 = !
64 = i

Argument two : The buttons 0 = OK # standard alert
1 = OK CANCEL
2 = ABORT RETRY IGNORE
3 = YES NO CANCEL
4 = YES NO
5 = RETRY CANCEL

Argument three : 0 = First
In your popup, which 256 = Second
button should be selected 512 = Thrid
by default?

Argument four : 0 = Browser stalls
The system command will 4096 = All apps stall
stall either the browser
or the whole system until
the user responds
(either submits or cancels)


A value is returned
depending on which button
was pressed. So you could say

if(retVal == 3){do this}
else {do this}

Here are the return values OK = 1
Cancel = 2
Abort = 3
Retry = 4
Ignore = 5
Yes = 6
No = 7

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



Open Source Gateway Initiative[OSGi] - A Middleware Revolution!

Finally,world realizes the true purpose of Object Orientation - the Re-Usability and today any software development largely consists of adapting existing functionality to perform in a new environment,since large number of standard, well-tested building blocks have become readily available from various vendors.

Now, the core problem is, integration of many different libraries-(building blocks)as these libraries have become complex and require their own libraries to function --even if that functionality is never needed for the product.

This propels the need for tools/frameworks/specifications that standardize the integration aspects of software so that reusing existing components becomes reliable, robust and cheap.

There comes our OSGi!!!!!!!!!!!!!!

So what is OSGi?

A nonprofit organization-founded in March 1999- comprises of IBM,Ericsson,Nortel,Sybase,Sun,France Telecom,Motorola and Phillips that promotes an open dynamic component platform.

The objective of this Alliance is : "How to let applications from different vendors work reliably together and share resources in an embedded/network computer"

OSGi specifies JVM - (now only Java)- based service platform - so that software components/applications/modules/bundles can be remotely installed, started, stopped, updated and uninstalled without requiring a reboot;

Why JVM as Platform
Without any doubts, JVM is evovling as unanimous platform going forward for multi-layered, multi-faceted enterprise applications. Not only Java,but there are many other languages evovling on JVM [Current JVM Languages - PHP,Scala,Groovy,Ruby,Python]and certainly the list is growing day-by-day.

Speficiation - Overview

OSGi technology is the dynamic module system for Java™. The OSGi Service Platform provides functionality to Java that makes Java the premier environment for software integration and thus for development. Java provides the portability that is required to support products on many different platforms. The OSGi technology provides the standardized primitives that allow applications to be constructed from small, reusable and collaborative components. These components can be composed into an application and deployed.

The OSGi Service Platform provides the functions to change the composition dynamically on the device of a variety of networks, without requiring restarts. To minimize the coupling, as well as make these couplings managed, the OSGi technology provides a service-oriented architecture that enables these components to dynamically discover each other for collaboration. The OSGi Alliance has developed many standard component interfaces for common functions like HTTP servers, configuration, logging, security, user administration, XML and many more. Plug-compatible implementations of these components can be obtained from different vendors with different optimizations and costs. However, service interfaces can also be developed on a proprietary basis.

OSGi technology adopters benefit from improved time-to-market and reduced development costs because OSGi technology provides for the integration of pre-built and pre-tested component subsystems. The technology also reduces maintenance costs and enables unique new aftermarket opportunities because components can be dynamically delivered to devices in the field.

Framework

The core component of the OSGi Specifications is the OSGi Framework. The Framework provides a standardized environment to applications (called bundles). The Framework is divided in a number of layers.

L0: Execution Environment
L1: Modules
L2: Life Cycle Management
L3: Service Registry A ubiquitous security system is deeply intertwined with all the layers.

The L0 Execution environment is the specification of the Java environment. Java 2 Configurations and Profiles, like J2SE, CDC, CLDC, MIDP etc. are all valid execution environments. The OSGi platform has also standardized an execution environment based on Foundation Profile and a smaller variation that specifies the minimum requirements on an execution environment to be useful for OSGi bundles.

The L1 Modules layer defines the class loading policies. The OSGi Framework is a powerful and rigidly specified class-loading model. It is based on top of Java but adds modularization. In Java, there is normally a single classpath that contains all the classes and resources. The OSGi Modules layer adds private classes for a module as well as controlled linking between modules. The module layer is fully integrated with the security architecture, enabling the option to deploy closed systems, walled gardens, or completely user managed systems at the discretion of the manufacturer.

The L2 Life Cycle layer adds bundles that can be dynamically installed, started, stopped, updated and uninstalled. Bundles rely on the module layer for class loading but add an API to manage the modules in run time. The lifecycle layer introduces dynamics that are normally not part of an application. Extensive dependency mechanisms are used to assure the correct operation of the environment. Life cycle operations are fully protected with the security architecture, making it virtually impossible to be attacked by viruses.

The L3 layer adds a Service Registry. The service registry provides a cooperation model for bundles that takes the dynamics into account. Bundles can cooperate via traditional class sharing but class sharing is not very compatible with dynamically installing and uninstalling code. The service registry provides a comprehensive model to share objects between bundles. A number of events are defined to handle the coming and going of services. Services are just Java objects that can represent anything. Many services are server-like objects, like an HTTP server, while other services represent an object in the real world, for example a Bluetooth phone that is nearby. The service model is fully security instrumented. The service security model provides an elegant way to secure the communication between bundles passes.

Security
Security is based on Java and the Java 2 security model. The language by design limits many possible constructs. For example, buffer overflows used in viruses are impossible. Access modifiers in the language restrict the visibility of the code to other programmers. The OSGi platform extends this model by allowing private classes, a mechanism that is not available in a standard way in Java. The Java 2 security model provides a comprehensive model to check access by code to resources. The OSGi platform adds full dynamic management of the permissions, simplifying the life of operators and system administrators.

It Is SOA!
On top of the Framework, the OSGi Alliance has specified many services. Services are specified by a Java interface. Bundles can implement this interface and register the service with the Service Registry. Clients of the service can find it in the registry, or react to it when it appears or disappears.

This is similar to the service-oriented architecture made popular with web services. The key difference between web services and OSGi services is that web services always require some transport layer, which makes it thousands times slower than OSGi services that use direct method invocations. Also, OSGi components can directly react on the appearance and disappearance of services.

Examples:

Http Service
The Http Service is, among other things, a servlet runner. Bundles can provide servlets, which becomes available over the Http protocol. The dynamic update facility of the OSGi Service Platform makes the Http Service a very attractive web server that can be updated with new servlets, remotely if necessary, without requiring a restart.


Active participants:
Apache iFelix, iPojo, Spring - OSGi, Eclipse - Equinox


Whats new on OSGi-Release 4:

Powerful new modularization capabilities providing enhanced encapsulation of networked services that can share a single VM.

Modularized class sharing and hiding of implementation details.
Advanced handling of multiple versions of the same classes so old and new applications can execute within the same VM.

Localization of OSGi bundle manifests enabling service deployment anywhere.

Enhancements in security and policies: The new Conditional Permission Admin service provides an elegant and simple way to manage networked services securely. It also supports dynamic policies that can depend on external (custom) conditions. Combined with R4 support for digital signatures, this provides a central security solution to large deployments of products using the OSGi Service Platform.

A Declarative Services specification that addresses memory footprint issues that can prevent small embedded devices from using a service oriented architecture to support multiple applications. Additionally, it significantly simplifies the service-oriented programming model by declaratively handling the dynamics of services.

Compatibility with Release 3, requiring no changes for existing OSGi bundles, applications, or services.

Future is here...
The OSGi specifications are so widely applicable because the platform is a small layer that allows multiple Java™ based components to efficiently cooperate in a single Java Virtual Machine (JVM). It provides an extensive security model so that components can run in a shielded environment. However, with the proper permissions, components can reuse and cooperate, unlike other Java application environments. The OSGi Framework provides an extensive array of mechanisms to make this cooperation possible and secure.

The presence of OSGi technology-based middleware in many different industries creates a large software market for OSGi software components. The rigid definition of the OSGi Service Platform enables components that can run on a variety of devices, from very small to very big.

Adoption of the OSGi specifications can therefore reduce software development costs as well as provide new business opportunities.


Courtesy : ACM Queue Jan-Feb 2008 , Wiki

Whats Hot on J2EE design?

Below link describes the best architecure available for J2EE systems today

http://cwiki.apache.org/S2WIKI/struts-2-spring-2-jpa-ajax.html

Design Patterns - FAQ

http://en.wikipedia.org/wiki/Design_Patterns

As per GOF (Gang of Four),the total is :23 and they are classified as below. Classification :Creational(5),Structural(7),Behavioral(11)

Creational Patterns
--- Abstract Factory
--- Builder
--- Factory Method
--- Prototype
--- Singleton
Structural Patterns
--- Adapter
--- Bridge
--- Composite
--- Decorator
--- Façade
--- Flyweight
--- Proxy
Behavioral Patterns
--- Chain of Responsibility
--- Command
--- Interpreter
--- Iterator
--- Mediator
--- Memento
--- Observer
--- State
--- Strategy
--- Template Method
--- Visitor
J2EE Patterns
--- MVC
--- Business Delegate
--- Composite Entity
--- Data Access Object
--- Front Controller
--- Intercepting Filter
--- Service Locator
--- Transfer Object
Misc
--- typesafe enum

Connection Pool - Life Cycle

Lot of folks often ask something or other doubts on connection pooling, either with respect to transaction failures or performance issues. Found a good material and thought of sharing.. Here it is.

A ManagedConnection object is always in one of three states:
DoesNotExist, InFreePool, or fInUse.

Before a connection is created, it must be in the DoesNotExist state. After a connection is created, it can be in either the InUse or the InFreePool state, depending on whether it is allocated to an application.

Between these three states are transitions. These transitions are controlled by guarding conditions. A guarding condition is one in which true indicates when you can take the transition into another legal state. For example, you can make the transition from the InFreePool to InUse state only if:
- the application has called the data source or connection factory .getConnection method (getConnection)
- a free connection is available in the pool with matching properties (freeConnectionAvailable)
and one of the two following conditions are true:
- the getConnection request is on behalf of a resource reference that is marked unsharable
- the getConnection request is on behalf of a resource reference that is marked shareable but no shareable connection in use has the same properties.

This transition description follows:
InFreePool > InUse:
getConnection AND
freeConnectionAvailable AND
NOT(shareableConnectionAvailable)

Here is a list of guarding conditions and descriptions.
Condition Description
ageTimeoutExpired - Connection is older then its ageTimeout value.
close - Application calls close method on the Connection object.
fatalErrorNotification - A connection has just experienced a fatal error.
freeConnectionAvailable - A connection with matching properties is available in the free pool.
getConnection -Application calls getConnection method on DataSource or ConnectionFactory object.
markedStale-Connection is marked as stale, typically in response to a FatalErrorNotification.
noOtherReferences-There is only one connection handle to the ManagedConnection, and the Transaction Service is not holding a reference to the ManagedConnection.
noTx -No transaction is in force.
poolSizeGTMin-Connection pool size is greater than the minimum pool size (minimum number of connections)
poolSizeLTMax-Pool size is less than the maximum pool size (maximum number of connections)
shareableConnectionAvailable-The getConnection request was for a shareable connection and one with matching properties is in use and available to share.
TxEnds-The transaction has ended.
unshareableConnectionRequest-The getConnection request is for an unshareable connection.
unusedTimeoutExpired-Connection is in the free pool and not in use past its unused timeout value.
Getting connections
The first set of transitions covered are those in which the application requests a connection from either a data source or a connection factory. In some of these scenarios, a new connection to the database results. In others, the connection might be retrieved from the connection pool or shared with another request for a connection.
DoesNotExist
Every connection begins its life cycle in the DoesNotExist state. When an application server starts, the connection pool does not exist. Therefore, there are no connections. The first connection is not created until an application requests its first connection. Additional connections are created as needed, according to the guarding condition.

getConnection AND
NOT(freeConnectionAvailable) AND
poolSizeLTMax AND
(NOT(shareableConnectionAvailable) OR
unshareableConnectionRequest)

This transition specifies that a Connection object is not created unless the following conditions occur:

The application calls the getConnection() method on the data source or connection factory
No connections are available in the free pool (NOT(freeConnectionAvailable))
The pool size is less than the maximum pool size (poolSizeLTMax)
If the request is for a sharable connection and there is no sharable connection already in use with the same sharing properties (NOT(shareableConnectionAvailable)) OR the request is for an unsharable connection (unshareableConnectionRequest)

All connections begin in the DoesNotExist state and are only created when the application requests a connection. The pool grows from 0 to the maximum number of connections as applications request new connections. The pool is not created with the minimum number of connections when the server starts.
If the request is for a sharable connection and a connection with the same sharing properties is already in use by the application, the connection is shared by two or more requests for a connection. In this case, a new connection is not created. For users of the JDBC API these sharing properties are most often userid/password and transaction context; for users of the Resource Adapter Common Client Interface (CCI) they are typically ConnectionSpec, Subject, and transaction context.

InFreePool

The transition from the InFreePool state to the InUse state is the most common transition when the application requests a connection from the pool.

InFreePool>InUse:
getConnection AND
freeConnectionAvailable AND
(unshareableConnectionRequest OR
NOT(shareableConnectionAvailable))

This transition states that a connection is placed in use from the free pool if:
the application has issued a getConnection() call
a connection is available for use in the connection pool (freeConnectionAvailable),
and one of the following is true:

the request is for an unsharable connection (unsharableConnectionRequest)
no connection with the same sharing properties is already in use in the transaction. (NOT(sharableConnectionAvailable)).

Any connection request that a connection from the free pool can fulfill does not result in a new connection to the database. Therefore, if there is never more than one connection used at a time from the pool by any number of applications, the pool never grows beyond a size of one. This number can be less than the minimum number of connections specified for the pool. One way that a pool grows to the minimum number of connections is if the application has multiple concurrent requests for connections that must result in a newly created connection.

InUse

The idea of connection sharing is seen in the transition on the InUse state.

InUse>InUse:
getConnection AND
ShareableConnectionAvailable
This transition states that if an application requests a shareable connection (getConnection) with the same sharing properties as a connection that is already in use (ShareableConnectionAvailable), the existing connection is shared.
The same user (user name and password, or subject, depending on authentication choice) can share connections but only within the same transaction and only when all of the sharing properties match. For JDBC connections, these properties include the isolationLevel which is configurable on the resource-reference (IBM WebSphere extension) to data source default. For a resource adapter factory connection, these properties include those specified on the ConnectionSpec. Because a transaction is normally associated with a single thread, you should never share connections across threads.

Note: It is possible to see the same connection on multiple threads at the same time, but this situation is an error state usually caused by an application programming error.


Returning connections
All of the transitions so far have covered getting a connection for application use. From this point, the transitions result in a connection closing and either returning to the free pool or being destroyed. Applications should explicitly close connections (note: the connection that the user gets back is really a connection handle) by calling close() on the Connection object. In most cases, this action results in the following transition:

InUse>InFreePool:
(close AND
noOtherReferences AND
NoTx AND
UnshareableConnection)
OR
(ShareableConnection AND
TxEnds)

Conditions that cause the transition from the InUse state are:
If the application (or the container) calls close() (close) and there are no references (noOtherReferences) either by the application (application sharing) or by the transaction manager (NoTx - who holds a reference when the connection is enlisted in a transaction), the Connection object returns to the free pool.
If the connection was enlisted in a transaction but the transaction manager ends the transaction (txEnds), and the connection was a shareable connection (ShareableConnection), the connection closes and returns to the pool.
When the application calls close() on a connection, it is returning the connection to the pool of free connections; it is not closing the connection to the data store. When the application calls close() on a currently shared connection, the connection is not returned to the free pool. Only after the application drops the last reference to the connection, and the transaction is over, is the connection returned to the pool. Applications using unsharable connections must take care to close connections in a timely manner. Failure to do so can starve out the connection pool making it impossible for any application running on the server to get a connection.

When the application calls close() on a connection enlisted in a transaction, the connection is not returned to the free pool. Because the transaction manager must also hold a reference to the connection object, the connection cannot return to the free pool until the transaction ends. Once a connection is enlisted in a transaction, you cannot use it in any other transaction by any other application until after the transaction is complete.

There is a case where an application calling close() can result in the connection to the data store closing and bypassing the connection return to the pool. This situation happens if one of the connections in the pool is considered stale. A connection is considered stale if you can no longer use it to contact the data store. For example, a connection is marked stale if the data store server is shut down. When a connection is marked as stale, the entire pool is cleaned out by default because it is very likely that all of the connections are stale for the same reason (or you can set your configuration to clean just the failing connection). This cleansing includes marking all of the currently InUse connections as stale so they are destroyed upon closing. The following transition states the behavior on a call to close() when the connection is marked as stale:

InUse>DoesNotExist:
close AND
markedStale AND
NoTx AND
noOtherReferences

This transition states that if the application calls close() on the connection and the connection is marked as stale during the pool cleansing step (markedStale), the connection object closes to the data store and is not returned to the pool.
Finally, you can close connections to the data store and remove them from the pool.
This transition states that there are three cases in which a connection is removed from the free pool and destroyed.

If a fatal error notification is received from the resource adapter (or data source). A fatal error notification (FatalErrorNotification) is received from the resource adaptor when something happens to the connection to make it unusable. All connections currently in the free pool are destroyed.

If the connection is in the free pool for longer than the unused timeout period (UnusedTimeoutExpired) and the pool size is greater than the minimum number of connections (poolSizeGTMin), the connection is removed from the free pool and destroyed. This mechanism enables the pool to shrink back to its minimum size when the demand for connections decreases.

If an age timeout is configured and a given connection is older than the timeout. This mechanism provides a way to recycle connections based on age.

Migrate Struts App to Websphere Portal

Simple steps to migrate already developed struts application to host on websphere portal server

http://www.ibm.com/developerworks/websphere/techjournal/0403_yu/0403_yu.html

Developing new portal struts app:
http://www.ibm.com/developerworks/websphere/library/techarticles/0401_hanis/hanis.html

http://www-128.ibm.com/developerworks/websphere/library/techarticles/0601_patil/0601_patil.html

http://www-128.ibm.com/developerworks/websphere/library/techarticles/0601_patil2/0601_patil2.html

RIA with Flex - Part 1

Most of the present day Rich Internet Applications, especially on public arena are built with some or other Flash components. The embedded support of flash player for IE and other prominent browsers provided the edge of reach.

The reach can be understood with the well known day-2-day use application YouTube.

Evolution

Macromedia was a US graphics and Web development software company producing such products as Adobe Flash. The line of Macromedia products is now controlled by its former rival, Adobe Systems which acquired Macromedia on December 3, 2005.

Almost all prominent prgramming languages are gearing up to support this integration, ex- JavaFx. Among them Flex-promoted by Adobe can be considered as pioneer.

So, What is Flex?

Flex is a development and run-time environment that you use to create rich Internet applications that use Adobe® Flash® Player 9 to deliver more intuitive and interactive online experiences.

The flex applications are developed with MXML and Action Scripts.

MXML - Macromedia XML

Every Flex application contains at least one MXML file, known as the main application file. MXML is a markup language, an implementation of XML that was designed specifically for creating Flex applications, and you use it to declaratively define the structure of your application using tags.

Action Script

You add dynamic behavior to your applications using ActionScript 3.0, which is an implementation of ECMAScript and is similar to JavaScript. You can add ActionScript to Flex applications directly in the MXML file as script blocks or you can create separate files of ActionScript functions and import them into your MXML files.

Architecure

A Flex application is compiled into a SWF file, which runs in Flash Player. When the source code is compiled into a Flex application it is converted to ActionScript classes and is then merged into the SWF file along with graphics and other assets. At run time, the Flex application SWF file interacts with external libraries, services, and data sources as needed.

Standard Flex applications do not require server-side Flex services. Therefore, you compile them locally on your computer and typically deploy them to your users from an HTML page on a web server. As all browsers supports playing flash contents, you can code java script to play swf file on browser flash player.


Data Services

The major advantage of Flex addressed when it started supporting data services.

To provide data to your application, Adobe Flex includes components designed specifically for interacting with HTTP servers, web services, or remote object services (Java objects). These components are called remote procedure call (RPC) service components.

Unlike web applications built with Adobe ColdFusion, PHP, or similar server technologies, Flex applications cannot connect directly to a database. They interact with data using services. For example, you can insert an HTTP service in a Flex file to interact with a ColdFusion file that retrieves data from a MySQL database, converts it to XML, and then feeds it to your Flex application.

First Look on how you embed 'flash component - test.swf' on html page

<object width="425" height="373">
<param name="movie" value="test.swf"></param>
<param name="wmode" value="transparent"></param>
<embed src="test.swf"
type="application/x-shockwave-flash"
wmode="transparent"
width="425" height="373"></embed>
</object>


Evolution of Remote Procedure Calls - RPC

A remote procedure call is a request to a server application at another location to perform operations and return information.This is one of very common requirements for any enterprise world.From time to time, there are so many technological advances made on this arena.This article meant for Java evangelists who would like to understand the evolution of RPC with current context.

Remote method invocation - RMI

Enterprise Java Beans - EJB

XML over HTTP - Webservices

XML - RPC

Simple Object Access Protocol-SOAP



Evolution of Remote Procedure Calls - RPC

A remote procedure call is a request to a server application at another location
to perform operations and return information.This is one of very common requirements
for any enterprise world.From time to time, there are so many technological
advances made on this arena.This article meant for Java evangelists who would like
to understand the evolution of RPC with current context.

Microsoft's Distributed Common Object Model - DCOM

Common Object Request Broker Architecture - CORBA

Remote method invocation - RMI

Enterprise Java Beans - EJB


XML over HTTP - Webservices

XML - RPC

XML-RPC is a simple, stable, and well-understood specification. It’s not a
moving target like so many other Web service specifications. It also has
longevity, because the only things that it depends on are technologies such as
HTTP and XML, and basic programming constructs such as arrays, structures, and
scalars. None of those things is going away any time soon. And since everything
related to XML-RPC is freely available and downloadable, you can have a Web
service up and running in a single afternoon.

Simple Object Access Protocol-SOAP

XML-RPC is a simple protocol that
allows software running in different environments to make remote procedure calls
over the Internet. XML-RPC uses two industry standards: XML (extensible markup
language) for encoding messages, and HTTP (hypertext transfer protocol) for
transporting them. A properly formatted XML-RPC message is an HTTP POST request
whose body is in XML. The specified remote server executes the requested call
and returns any requested data in XML format.

XML-RPC recognizes procedure parameters by position. Parameters and return
values can be simple types such as numbers, strings, and dates, or more complex
types such as structures and arrays. To learn more about XML-RPC messages, see
the XML-RPC specification at http://www.xmlrpc.com/spec.

SOAP (Simple Object Access Protocol) is an RPC protocol designed for a
distributed environment, where a server may consist of a hierarchy of objects
whose methods can be called over the Internet. A goal of SOAP is to establish a
standard protocol that will serve both web service providers and service users.
As with other remote procedure call protocols, SOAP uses XML to encode messages
and HTTP to transport them. A SOAP request contains a header and an envelope;
the envelope in turn contains the body of the request.

One key difference between the SOAP and XML-RPC protocols is that with SOAP,
parameters are notational (a request must encode the method parameter names
within its XML), rather than positional (recognized by position). To learn more
about SOAP messages, see the SOAP specification at http://www.w3.org/TR/.

Remote procedure calls provide a powerful tool for accessing services over the
Internet. For example, there are already a variety of web-based servers that can
check spelling, translate text between languages, provide stock prices, supply
weather and traffic information, and more. You can find available services at
sites such as XMethods at http://www.xmethods.net/. There you can also find
information you’ll need to make remote procedure calls to these services.





The biggest conceptual difference between SOAP and XML-RPC is that XML-RPC
exchanges a limited number of parameters of six fixed types, plus structs and
arrays. However, SOAP allows you to send the server arbitrary XML elements. This
is a much more flexible approach.


Remote procedure call systems have been around since around 1984 when they were
first proposed (A.D. Birrell and B.J. Nelson, 1984). During the intervening 15
years, numerous evolutionary improvements have occurred in the basic RPC system,
leading to improved systems-such as NCS (T.H. Dineen et al., 1987)-that offer
programmers more functionality or greater simplicity. The Common Object Request
Broker Architecture from the Object Management Group and Microsoft's Distributed
Common Object Model are this evolutionary process's latest outgrowths. With the
introduction of Java Developer's Kit release 1.1, a third alternative for
creating distributed applications has emerged. The Java Remote Method Invocation
system has many of the same features of other RPC systems, letting an object
running in one Java virtual machine make a method call on an object running in
another, perhaps on a different physical machine. On the surface, the RMI system
is just another RPC mechanism, much like Corba and DCOM. But on closer
inspection, RMI represents a very different evolutionary progression, one that
results in a system that differs not just in detail but in the very set of
assumptions made about the distributed systems in which it operates. These
differences lead to differences in the programming model, capabilities, and the
way the mechanisms interact with the code that implements and built the
distributed systems

Oracle - Diff between CHAR,VARCHAR and VARCHAR2

Coming soon...

Refer as of now
http://www.orafaq.com/faq/what_is_the_difference_between_varchar_varchar2_and_char_data_types

File Operations with Oracle

How to read a file using PL/SQL


declare
input_buffer varchar2(4000);
successful_output_file utl_file.file_type;
begin
successful_output_file := utl_file.fopen ('/tmp','mytest.txt', 'W');
input_buffer := 'ask'||'|'||'nava';
DBMS_OUTPUT.PUT_LINE(input_buffer);
utl_file.put_line(successful_output_file,input_buffer);
utl_file.fclose(successful_output_file);
end;


How to write to file using PL/SQL


declare
input_buffer varchar2(4000);
input_file utl_file.file_type;
begin
input_file := utl_file.fopen ('/tmp','mytest.txt', 'R');
utl_file.get_line(input_file,input_buffer);
DBMS_OUTPUT.PUT_LINE(input_buffer);
utl_file.fclose(input_file);
end;


Powerful SQL with Excel

Known for their integrity, VB scripts works great for any operations with MS-Excel spreadsheets.

Following simple funtion, can Query/Process the records from excel sheet. You can do most of the operations that you may want to do through table data just from a spreadsheet.

Assume, your excel file is C:\Book2.xls and the Work Sheet name is Sheet1


strConnectString ="Driver={Driver do Microsoft Excel(*.xls)};DBQ=C:\Book2.xls"
strSQL = "select * from [Sheet1$]"
Set objEnv = UDF_GetRecordset1(strConnectString,strSQL)
If Not objEnv.EOF Then
'msgBox('DataArray = objEnv.GetRows(objEnv.Recordcount)')
DataArray = objEnv.GetRows()
For row=0 To (objEnv.recordCount-1)
MsgBox "RowNum:"&row+1
For col=0 To (objEnv.Fields.count-1)
' MsgBox DataArray(col,row)
Next
Next
End If



Public Function UDF_GetRecordset1(strConnection,strSQL)
Dim objConn,objRec ' Variable declaration
Set UDF_GetRecordset1 = Nothing
Err.Clear
Set objConn = CreateObject("ADODB.Connection")
objConn.Open strConnection
If Err <> 0 Then
Set objConn = Nothing
Exit Function
End If
Set objRec = CreateObject("ADODB.Recordset")
objRec.CursorType = 1
objRec.Open strSQL,objConn
If Err <> 0 Then
strSQL
'MsgBox('step31')
Set objRec=Nothing
Set objConn = Nothing
Exit Function
End If
Set UDF_GetRecordset1 = objRec
Set objRec=Nothing
Set objConn=Nothing
End Function




This script can be tested with any VB Script editors- EditPlus.

Known issues:
Numeric field overflow
http://support.microsoft.com/kb/815277

XML Serialization

Classic Defintion:
The reversible process of encoding a data structure as a sequence of bytes

Marshall & Unmarshall:
Marshalling is the process of generating XML document from the instance of Java Class(or any other language in context) and as unmarshalling is interpreting java object from xml document.

Usage:
Wherever xml <--> java occurs heavily. For example, SOAP clients or any other XML intensive processing in java

Frameworks:
Breeze XML Binder, a tool produced by Breeze Factor
http://www.breezefactor.com/.
JAXB Reference Implementation, created by SUN
http://java.sun.com/xml/jaxb/.
Castor:an open source project under ExoLab
http://www.castor.org/spring-xml-intro.html
http://www.ibm.com/developerworks/xml/library/x-xjavacastor2/
XML Beans: Apache Open Source
http://www.onjava.com/pub/a/onjava/2004/07/28/XMLBeans.html

Comparision:
http://www.xml.com/pub/a/2003/09/03/binding.html
http://dev2dev.bea.com/pub/a/2004/05/ryan_xml.html


Known Issues:

1. The language of XML Schema is much richer than the object model of Java,
2. Not all XML names can be turned into Java identifiers, xsd:enumeration declarations cannot be nicely mapped into Java types (even since Java 5),
3. Some Java types are by nature explicitly unportable.
4. XML is a hierarchical data structure, and can only describe trees or lists of data, while Java classes almost invariably refer to other objects, oftencreating cyclic graphs of references.
5. Each node in an XML message can have a separate namespace, which cannot be expressed in Java.

O/X Mapping:
The upcoming improvements are to provide a way to map Object to XML document to overcome most of the known issues

Java Portal/Portlet Specification - JSR 168 (1.0) JSR 286 (2.0)

JSR-168 is a collection of Java APIs for portlet developers. There are a number of reasons to design JSR-168 portlets that adhere to the specification. Portability is an obvious benefit. Code written according to the specification will be easier to move to among portal servers. The majority of Java-based portal servers support JSR-168 portlets.

Another benefit is easier federation. Exposing JSR-168 Portlets via Web Services for Remote Portlets (WSRP) producers is easier when portlets adhere to the JSR-168 specification. WSRP provides a standard to federate portlet content via Web services. JSR-168 and WSRP 1.0 portlet capabilities are tightly coupled. JSR-168 to WSRP portlet bridges utilize JSR-168's URL rewriting APIs. This article illustrates best practices for developing JSR-168 portlets for portability.

---

JSR 286 is a futuristic view of portlet specification 2.0 and the major working areas for JSR 286:

Coordination (Events support, Sharing session beyond portlet application, Sharing render parameters across portlets)
WSRP 2.0 alignment
Better support for Web Frameworks (JSF, Struts, Spring, WebWork)
AJAX Support

This aligns with J2EE 1.4, integrate other new JSRs relevant for the portlet, and align with the WSRP specification V 2.0


More : http://jcp.org/en/jsr/all

XML Schema Languages

1.DTD Data Type Definition

Basic.

2.XML Schemas (XSD)
Widely used

3.RELAX NG
RELAX NG is a schema language for XML. The key features of RELAX NG are that it:

is simple
is easy to learn
has both an XML syntax and a compact non-XML syntax
does not change the information set of an XML document
supports XML namespacezs
treats attributes uniformly with elements so far as possible
has unrestricted support for unordered content
has unrestricted support for mixed content
has a solid theoretical basis
can partner with a separate datatyping language (such W3C XML Schema Datatypes)


4.Schematron
The Schematron differs in basic concept from other schema languages in that it not based on grammars but on finding tree patterns in the parsed document. This approach allows many kinds of structures to be represented which are inconvenient and difficult in grammar-based schema languages. If you know XPath or the XSLT expression language, you can start to use The Schematron immediately.

Webservice development Styles

Webservices can be developed in any of following two ways.

1. Contract-First
The artifacts of external world - WSDL (web service description language) and other schema references are created first and these config definitions are implemented in any of the programming languages (java,.net etc) afterwards.


2. Contract-Last
Here actual services are coded in any of the programming languages and the XML artifacts(wsdl) are created based on the prgrammed services.

Example
For example, Spring web service supports Contract First style whereas web service development from any of IDEs (RAD etc) encourages coding first and generates contract based on the programmed services.

Which is good?
Lets assume the webservices are implemented in Java, the basic difference between these two styles are whether XML is generated from java or Java is genereated from XML.

There is a fundamental difference between hierarchial languages such as XML and object oriented language as Java. Following factors advocates Contract-First better than of Contract-Last atleast from java perspective.

1. Unportable Types:
Few Java types such as TreeMap cannot be converted directly to XML.
2. Cyclic Graph:
Class A refers B and B refers back A. Its difficult to handle these scenarios in XML whereas its very common in java which makes Contract-Last (java->xml) tougher.
3. Reusability:
The XML configurations can be defined in individual XSD files and can be imported to WSDL so that these individual XSD configurations can be reused if required in any other WSDL files.

Javascript Text Parsing


var inputText='this is testin\r\ng of the enivonem of NSHOWKAT@1STNA\r\nTIONALMERCHANT.COM \r\nNSHOWKAT@1STNATIONALMERCHANT.COM';

var ans=inputText.replace(/\r\n/g,"");



Blogger Help - How to create scrollbars for your blogs

Use following style in div tag style="width:420px;height:270px;overflow:scroll;white-space: nowrap;"

WebSphere webservice deployment!

How to configure/deploy servlet based webservices on WebSphere?

Any application on WebSphere is deployed as EAR.

Lets assume The enterprise archive (EAR) is NeoServiceEAR.ear

This has following entries:

NeoServiceEAR/META-INF
NeoServiceEAR/META-INF/application.xml
NeoServiceEAR/NeoService.war

The application.xml has just one web module(NeoService.war)configuration on it.

The web (war) module can have default META-INF and the WEB-INF should contain following files.

NeoService/
NeoService/META-INF/
NeoService/META-INF/Manifest.mf
NeoService/WEB-INF/
NeoService/WEB-INF/classes (directory to have all classes required)
NeoService/WEB-INF/lib(directory to have all runtime libraries)
NeoService/WEB-INF/wsdl (directory - contains webServiceInterfaceClassName.wsdl )
NeoService/WEB-INF/wsdl/webServiceInterfaceClassName.wsdl
NeoService/WEB-INF/web.xml
NeoService/WEB-INF/webservices.xml
NeoService/WEB-INF/webServiceInterfaceClassName_mapping.xml
NeoService/WEB-INF/ibm-webservices-bnd.xmi
NeoService/WEB-INF/ibm-webservices-ext.xmi

JSR 94 - Java Rule Engine API

Introduction:

"The api prescribes a set of fundamental rule engine operations. The set of operations is based upon the assumption that most clients will need to be able to execute a basic multi-step rule engine cycle, which consists of parsing rules, adding objects to an engine, firing rules and getting resultant objects from the engine. The set of operations also supports variations of the basic cycle, particularly variations that would occur in J2EE server deployments."


Goals:


Facilitate adding rule engine technology to Java applications.

Increase communication and standardization between rule engine vendors.

Make Java applications more portable from one rule engine vendor to another.

Provide implementation patterns for rules-based applications for the J2SE
platform.

Support rule engine vendors by offering a harmonized API that meets the needs
of their existing customers and is easily implemented.

Architecture:


The interfaces and classes defined by the specification are in the javax.rules and
javax.rules.admin packages. The javax.rules package contains classes and
interfaces that are aimed at runtime clients of the rule engine. The runtime client API
exposes methods to acquire a rule session for a registered rule execution set and
interact with the rule session. The administrator API-javax.rules.admin exposes methods to load an execution set from these external resources: URI, InputStream, XML Element,
binary abstract syntax tree, or Reader. The administrator API also provides methods
to register and unregister rule execution sets. Only registered rule execution sets are accessible through the runtime client API.

Major Rule Engine Vendors:
JBoss Business Process management suite - jBPM
PagaRULES - PegaRULES Process Commander


Following code illustrates how a Java application can use this API to integrate with any JSR-94 implemented Rule Engine


import javax.rules.RuleServiceProviderManager;
import javax.rules.StatefulRuleSession;
import javax.rules.StatelessRuleSession;
import javax.rules.admin.RuleAdministrator;
import javax.rules.admin.RuleExecutionSet;

// external imports
import org.jcp.jsr94.tck.model.Customer;
import org.jcp.jsr94.tck.model.Invoice;

/**
* This class implement a simple example using a rule execution set
* from the Test Compatibility Kit.
*
* See for the TCK for more information on the object model and the
* rule execution set.
*
* This example requires the following jar file to be present on your
* classpath:
* jsr94.jar
* jsr94-ri.jar
* jsr94-tck.jar
* xerces.jar
* jess.jar (The reference implementation)
*
* To run this example execute the following command in the lib
* directory of the jsr94 distribution:
* java -jar jsr94-example.jar
*/
public class Example
{
// The rule service provider uri as defined by the reference
// implementation.
private static final String RULE_SERVICE_PROVIDER = "org.jcp.jsr94.jess";

/**
* Main entry point.
*/
public static void main( String[] args )
{
try
{
// Load the rule service provider of the reference
// implementation.
// Loading this class will automatically register this
// provider with the provider manager.
Class.forName( "org.jcp.jsr94.jess.RuleServiceProviderImpl" );

// Get the rule service provider from the provider manager.
RuleServiceProvider serviceProvider = RuleServiceProviderManager.getRuleServiceProvider( RULE_SERVICE_PROVIDER );

// get the RuleAdministrator
RuleAdministrator ruleAdministrator = serviceProvider.getRuleAdministrator();
System.out.println("\nAdministration API\n");
System.out.println( "Acquired RuleAdministrator: " +
ruleAdministrator );

// get an input stream to a test XML ruleset
// This rule execution set is part of the TCK.
InputStream inStream = org.jcp.jsr94.tck.model.Customer.class.getResourceAsStream( "/org/jcp/jsr94/tck/tck_res_1.xml" );
System.out.println("Acquired InputStream to RI tck_res_1.xml: " +
inStream );

// parse the ruleset from the XML document
RuleExecutionSet res1 = ruleAdministrator.getLocalRuleExecutionSetProvider( null ).createRuleExecutionSet( inStream, null );
inStream.close();
System.out.println( "Loaded RuleExecutionSet: " + res1);

// register the RuleExecutionSet
String uri = res1.getName();
ruleAdministrator.registerRuleExecutionSet(uri, res1, null );
System.out.println( "Bound RuleExecutionSet to URI: " + uri);



// Get a RuleRuntime and invoke the rule engine.
System.out.println( "\nRuntime API\n" );

RuleRuntime ruleRuntime = serviceProvider.getRuleRuntime();
System.out.println( "Acquired RuleRuntime: " + ruleRuntime );

// create a StatelessRuleSession
StatelessRuleSession statelessRuleSession =
(StatelessRuleSession) ruleRuntime.createRuleSession(uri,
new HashMap(), RuleRuntime.STATELESS_SESSION_TYPE);

System.out.println( "Got Stateless Rule Session: " +
statelessRuleSession );

// call executeRules with some input objects

// Create a Customer as specified by the TCK documentation.
Customer inputCustomer = new Customer("test");
inputCustomer.setCreditLimit(5000);

// Create an Invoice as specified by the TCK documentation.
Invoice inputInvoice = new Invoice("Invoice 1");
inputInvoice.setAmount(2000);

// Create a input list.
List input = new ArrayList();
input.add(inputCustomer);
input.add(inputInvoice);

// Print the input.
System.out.println("Calling rule session with the following data");
System.out.println("Customer credit limit input: " +
inputCustomer.getCreditLimit());
System.out.println(inputInvoice.getDescription() +
" amount: " + inputInvoice.getAmount() +
" status: " + inputInvoice.getStatus());

// Execute the rules without a filter.
List results = statelessRuleSession.executeRules(input);

System.out.println( "Called executeRules on Stateless Rule Session: " + statelessRuleSession );

System.out.println( "Result of calling executeRules: " +
results.size() + " results." );

// Loop over the results.
Iterator itr = results.iterator();
while(itr.hasNext()) {
Object obj = itr.next();
if (obj instanceof Customer)
System.out.println("Customer credit limit result: " +
((Customer) obj).getCreditLimit());
if (obj instanceof Invoice)
System.out.println(((Invoice) obj).getDescription() +
" amount: " + ((Invoice) obj).getAmount() +
" status: " + ((Invoice) obj).getStatus());
}

// Release the session.
statelessRuleSession.release();
System.out.println( "Released Stateless Rule Session." );
System.out.println();

// create a StatefulRuleSession
StatefulRuleSession statefulRuleSession =
(StatefulRuleSession) ruleRuntime.createRuleSession( uri,
new HashMap(),
RuleRuntime.STATEFUL_SESSION_TYPE );

System.out.println( "Got Stateful Rule Session: " + statefulRuleSession );
// Add another Invoice.
Invoice inputInvoice2 = new Invoice("Invoice 2");
inputInvoice2.setAmount(1750);
input.add(inputInvoice2);
System.out.println("Calling rule session with the following data");
System.out.println("Customer credit limit input: " +
inputCustomer.getCreditLimit());
System.out.println(inputInvoice.getDescription() +
" amount: " + inputInvoice.getAmount() +
" status: " + inputInvoice.getStatus());
System.out.println(inputInvoice2.getDescription() +
" amount: " + inputInvoice2.getAmount() +
" status: " + inputInvoice2.getStatus());

// add an Object to the statefulRuleSession
statefulRuleSession.addObjects( input );
System.out.println( "Called addObject on Stateful Rule Session: "
+ statefulRuleSession );

statefulRuleSession.executeRules();
System.out.println( "Called executeRules" );

// extract the Objects from the statefulRuleSession
results = statefulRuleSession.getObjects();

System.out.println( "Result of calling getObjects: " +
results.size() + " results." );


// Loop over the results.
itr = results.iterator();
while(itr.hasNext()) {
Object obj = itr.next();
if (obj instanceof Customer)
System.out.println("Customer credit limit result: " +
((Customer) obj).getCreditLimit());
if (obj instanceof Invoice)
System.out.println(((Invoice) obj).getDescription() +
" amount: " + ((Invoice) obj).getAmount() +
" status: " + ((Invoice) obj).getStatus());
}

// release the statefulRuleSession
statefulRuleSession.release();
System.out.println( "Released Stateful Rule Session." );
System.out.println();

}
catch (NoClassDefFoundError e)
{
if (e.getMessage().indexOf("JessException") != -1)
{
System.err.println("Error: The reference implementation Jess could not be found.");
}
else
{
System.err.println("Error: " + e.getMessage());
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
}


More info:
http://jcp.org/aboutJava/communityprocess/first/jsr094/index.html

Thread-Safe - volatile, synchronized & atomic

The usual way of ensuring thread safety is though locking mechanism via synchronized blocks/methods
Example:

public class MySync {
private int value;

public int getValue(){
return value;
}
//Sync Method
public synchronized void setValue(int v){
value=v;
}

public void performCriticalTask(){
String task="KILL";
//Sync Block
synchronized(this){
//TODO: perform critical task with locking 'this'
}

}
}

Though this is a proven method,too much of locking can be a overhead for the system performance.

There are other alternatives which can be explored and carefully used along with locking for better thread-safe systems.

1. Use of volatile variables
2. Use of new JDK 5 feature java.util.concurrent.atomic

volatile:

Marking a variable as volatile means that the current value is always referred irrespective of state of the object. This means that threads will automatically see the most up-to-date value for volatile variables thus facilitating simpler way of thread safety.However this can be used only under following restricted set of circumstances.

1. Writes to the variable do not depend on its current value.
2. The variable does not participate in invariants with other variables.

Basically, these conditions state that the set of valid values that can be written to a volatile variable is independent of any other program state, including the variable's current state.

So, where can we use volatile safely.

status flags

Perhaps the canonical use of volatile variables is simple boolean status flags, indicating that an important one-time life-cycle event has happened, such as initialization has completed or shutdown has been requested.

Many applications include a control construct of the form, "While we're not ready to shut down, do more work," as shown following example:

Using a volatile variable as a status flag

volatile boolean shutdownRequested;

...

public void shutdown() { shutdownRequested = true; }

public void doWork() {
while (!shutdownRequested) {
// do stuff
}
}

It is likely that the shutdown() method is going to be called from somewhere outside the loop -- in another thread -- and as such, some form of synchronization is required to ensure the proper visibility of the shutdownRequested variable. (It might be called from a JMX listener, an action listener in the GUI event thread, through RMI, through a Web service, and so on.) However, coding the loop with synchronized blocks would be much more cumbersome than coding it with a volatile status flag as in Listing 2. Because volatile simplifies the coding, and the status flag does not depend on any other state in the program, this is a good use for volatile.

One common characteristic of status flags of this type is that there is typically only one state transition; the shutdownRequested flag goes from false to true and then the program shuts down. This pattern can be extended to state flags that can change back and forth, but only if it is acceptable for a transition cycle (from false to true to false) to go undetected. Otherwise, some sort of atomic state transition mechanism is needed, such as atomic variables.

the "volatile bean" pattern

The volatile bean pattern is applicable in frameworks that use JavaBeans as "glorified structs." In the volatile bean pattern, a JavaBean is used as a container for a group of independent properties with getters and/or setters. The rationale for the volatile bean pattern is that many frameworks provide containers for mutable data holders (for instance, HttpSession), but the objects placed in those containers must be thread safe.

In the volatile bean pattern, all the data members of the JavaBean are volatile, and the getters and setters must be trivial -- they must contain no logic other than getting or setting the appropriate property. Further, for data members that are object references, the referred-to objects must be effectively immutable. (This prohibits having array-valued properties, as when an array reference is declared volatile, only the reference, not the elements themselves, have volatile semantics.) As with any volatile variable, there may be no invariants or constraints involving the properties of the JavaBean. An example of a JavaBean obeying the volatile bean pattern is shown in following example.

A Person object obeying the volatile bean pattern

@ThreadSafe
public class Person {
private volatile String firstName;
private volatile String lastName;
private volatile int age;

public String getFirstName() { return firstName; }
public String getLastName() { return lastName; }
public int getAge() { return age; }

public void setFirstName(String firstName) {
this.firstName = firstName;
}

public void setLastName(String lastName) {
this.lastName = lastName;
}

public void setAge(int age) {
this.age = age;
}
}

Volatile variables are a simpler -- but weaker -- form of synchronization than locking, which in some cases offers better performance or scalability than intrinsic locking. If you follow the conditions for using volatile safely -- that the variable is truly independent of both other variables and its own prior values -- you can sometimes simplify code by using volatile instead of synchronized. However, code using volatile is often more fragile than code using locking. The patterns offered here cover the most common cases where volatile is a sensible alternative to synchronized. Following these patterns -- taking care not to push them beyond their limits -- should help you safely cover the majority of cases where volatile variables are a win.

Java 5 Atomicity

The volatile cannot be used for thread-safe counters due to the fact that "Volatile can write to the variable do not depend on its current value". While the increment operation (x++) may look like a single operation, it is really a compound read-modify-write sequence of operations that must execute atomically -- and volatile does not provide the necessary atomicity. Correct operation would require that the value of x stay unchanged for the duration of the operation, which cannot be achieved using volatile variables.

JDK 5 enables this by providing new package java.util.concurrent.atomic.This is a small toolkit of classes that support lock-free thread-safe programming on single variables.

This package comprises of classes -AtomicInteger; AtomicLong; AtomicReference; AtomicBoolean; array forms of atomic integer; long; reference; and atomic marked reference and stamped reference classes, which atomically update a pair of values.

Following example illustrates how to use AtomicInteger for any CAS operations

package org.nava.jfive.concurrent;

import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomicOperation {
private AtomicInteger value;

public static void main(String[] args) {
MyAtomicOperation myOp=new MyAtomicOperation();
myOp.setValue(new AtomicInteger(10));
TestThread tt1=new TestThread(myOp);
TestThread tt2=new TestThread(myOp);
tt1.start();
tt2.start();
}


public AtomicInteger getValue() {
return value;
}

public void setValue(AtomicInteger value) {
this.value = value;
}

}

class TestThread extends Thread {

MyAtomicOperation myOp;

public void run(){
int test=myOp.getValue().incrementAndGet();
System.out.println(Thread.currentThread().getName()+"|"+test);
}
public TestThread(MyAtomicOperation myOp) {
super();
this.myOp = myOp;
}

}


InfoQ

http://www.infoq.com/

Tracking change and innovation in the enterprise software development community

New thoughts on Build Mechanism!

ANT looks like default choice for any java project build. However we do see couple of disadvantages of using XML based scripting tool. The XML scripts have error-prone syntaxes as well as the declarative nature is not as sweet as any traditional programming languages.

So, what are the other alternatives available today?

1. Maven
Apache project. Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project's build, reporting and documentation from a central piece of information.

http://maven.apache.org/

2. Rake
Rake is task based (similar to ANT) build mechanism using Ruby. Though it does not have many pre-defined task as that of Ant, the people who already using ruby would find it more comfortable. Above all it provides plain english-like scripting syntaxes

3. Raven
This is infact based on Rake and uses Ruby scripting. To make the life of Java developers easier, Raven adds a set of predefined tasks that implement the most common needs for a Java build system, like compiling or resolving jar dependencies. Just like a library, but instead of being a set of classes and methods, it's a set of reusable tasks that are well-suited for Java builds.

Infact, Raven packaged with JRuby (a Ruby interpreter written in Java),

http://raven.rubyforge.org/

4. Antwrap

Invoking existing Ant tasks(defined in XML) along with Raven (ruby build scripts)

Antwrap is a Ruby library that can be used to invoke Ant tasks.Antwrap runs on both the native Ruby and the JRuby interpreters. Antwrap is compatible with Ant versions 1.5.4, 1.6.5 and 1.7.0. It lets you reuse all existing Ant tasks that have already been created, but with a much nicer syntax than XML. So, you could use Raven for everything that's already included and Antwrap when an existing Ant task does what you're looking for, all within the same script.

http://antwrap.rubyforge.org/


5. Buildr
Buildr is a build system for Java applications.It's an Apache Incubator project and completely overlaps with Raven and thus based on Ruby Rake.(on Ruby scripting)

Fast; Reliable; Full of Ruby; Easier Dependency Injection-build only what is changed; All Unit Test support;Library tasks equivalent to Ant- Anything you do with Ant can do with Buildr.

http://incubator.apache.org/buildr/

Is Buildr future of Java Builds?

Confluence - Enterprise Wiki

Confluence is enterprise-class WIKI solution.

A wiki is a simple, practical web application
that makes it easy for you and your
teammates to collaborate and manage
knowledge. With a wiki, your team can:
• share, manage, and comment on
information
• easily make edits that update instantly
• track every change or rollback to a
previous version
• access content securely anytime from
anywhere through a browser
• find information quickly, unlike emails.

Developed and promoted by Atlassian and costs around $1200 for minmum license

Features:

Pages: Easy to create, easy to edit, easy to organise.
Spaces: Discrete areas for different groups or projects.
News: Share timely information in notices, bulletins, and blogs.
Mail: Archive and index team email conversations.
Attachments: Attach, track and search all file types.
Comments: Turn any page into a team discussion.
Organisation: Flexible page structures, cross reference, index,
search…hierarchify!
Search: Everything is searchable. Pages, attachments,
comments…everything.
Images: Display images, diagrams, mind maps and more.
Links: Connect, cross-reference.
Administration: Powerful, simple admin. No geniuses required.
Security: Enterprise-grade permissioning and control.
Openness: Plays well with others via SOAP and XML-RPC.
Integration: From daily workflow tools to enterprise systems,
customise and fit your needs.
RSS: Produce and consume RSS newsfeeds.
Plugins: Just a wiki? No, an application platform.
Polish: Not just a pretty face. It works well. It feels right.

Pega Rules Process Commander - PRPC

www.pega.com

Byte Circle

Interesting math operations on byte to illustrate the binary computation


byte x=64;
byte y=3;
byte z= (byte)(x*y);
System.out.print(z);

Output:
if y=1,z -> 64
y=2, z-> -128
y=3, z-> -64
y=4, z -> 0
y=5, z-> 64



Check the following bit circle for more ...

When does static block executed?

The static blocks are executed as soon as the class is loaded whereas the instance blocks are executed when the object is instantiated(just before the constructor)


public class Jan2b {
static int i;
static {
out.println("The static i value@static block:"+i);
}
{
out.println("The static i value@instance block:"+i);
}

Jan2b(){
out.println("The static i value@constructor block:"+i);
}

public static void main(String[] args) {
out.println("The static i value@main:"+i);
Jan2b j=new Jan2b();
}
}

Output:

The static i value@static block:0
The static i value@main:0
The static i value@instance block:0
The static i value@constructor block:0



String.intern()

There have been lots of posts regarding String literals and String objects.Yet another one to reveal some more depth.

We knew the String literals first lookup to String constant pool if it exists, before actually creating a new instance whereas string object creation with "new" always creates a new String and add that to the string constant pool.

So, how can we force the String objects created with "new" to lookup to Constant pool before actually creating new instance?

There comes the native method intern

The source comment says...


/**
* Searches an internal table of strings for a string equal to this String.
* If the string is not in the table, it is added. Answers the string contained
* in the table which is equal to this String. The same string object is always
* answered for strings which are equal.
*
* @return the interned string equal to this String
*/

public native String intern();



This can be illustrated via following example,

String s="TEST";
String t="TEST";
String k=new String("TEST").intern();
String p=new String("TEST");
if(s==t)
out.println("s=t");
if(s==k && k==t)
out.println("s=k & k=t");
if(s==p || t==p)
out.println("s=p Or t=p");

if(p==k)
out.println("p=k");

Output:
s=t
s=k & k=t


This shows, the String objects created with explicit "new" does not lookup the String constant pool unless specified as intern!

String Literal (String a="string") & String Object (String a=new String("string"))

Are both String literal & String Object eligible for garbage collection.

Check the below class operating both on String literal and String object.


class GC{
public static void main(String args[]) {
String str1 = "abc";
String str2 = new String("abc");

str1=str2=null;
}
}

Only one Object is eligible for GC.
Reason:
In the above code,
1. String1 is the String literal. (this is also object )
2.String2 is the Object.

3. When ever you create a String by using
String str1 = "abc";
Str1 is going to store in Heap Memory.
Str1 is referencing to the String Constant pool.

4. String str2 = new String("abc") is not referencing to the String constant pool.

5. so, when ever we make that strings as null, then
str1=str2=null;

6. Both the string will be null.
7. String2 is eligible to GC, because String1 is still has a reference in String constant pool
8. So, what ever may be the string which has a reference to String constant pool, is
not eligible for GC.

Thus String literals are not eligible for GC.