What are those three?
————————————
1) Functionality  of the query.
2) Driver Table.
3) Row Source.

Explaining them in detail
————————————–
1)   Functionality of the query :  (Functionality of the query is tightly coupled with the performance)
              You should be  able to write the functional behaviour of the query in plain English.By writing this in plain  english  you have solved 50% of the problem. Now from that understanding of the query think in your own way how the query should be evaluated which is the first table,second table and so on.

 
2) Driver Table :  (The first table that optimizer chooses)              
————————————————————————–
   After understanding the  functional behaviour of the query think of the first  table that we should evaluate.This first table is called the driver table.Once again the first table which the optimizer chooses in evaluating the query is called DRIVER TABLE.
In the below explain Plan (at the end) the DRIVER TABLE is  JTF_RS_SALESREPS .
Why it matters ?
The output of the first table will be piped with the rest of the tables in getting the output of the query.we want the output of the first table should be as minimum as possible
Why?
   WHen it is minimum, the number of rows that are evaluated in the next stages of the explain plan is also minimum there by minimizing the total time.When it is very large the number of rows that are evaluated in the next stages of the explain plan are also very large there by maximizing the total time.
Once again : By only understanding the functional behaviour of the query you will get the Driver table of the query.

3) Row Source : (Number of rows that  optimizer has fetched at every stage of the query)
—————————————————————————————————————
  Examine the below explain plan ROWS column it indicates the number of rows that  optimizer has fetched  at each and every stage.This is called the RowSource of the query.
1) The problematic part of the plan can be figured out by examining the ROWSOURCE of the query. If the row source for a particular stage is high then that stage is problematic.
2)  If there is large difference between the access predicate fetched rows (Ex: ID 8  (8th row) in below EXPLAIN PLAN) and filter predicate resultant rows (See : ID  7  (7th row)  in below EXPLAIN PLAN) we need to push strong filters predicates into the Access  filter predicates for better performance.
Access Predicates and Filter Predicates (you need to figure it our for more better understanding)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  Access Predicates : the columns that are used in accessing the rows (usually indexed columns)
                      (Ex See Row where Column ID values is 8 in below explain plan)                               
  Filter Predicates : Filter predicates are being applied once the rows are being fetched  using access predicates.
    (usually non indexed columns)
                       (Ex See Row where Column ID values is 7 in below explain plan)
by examining all the above aspects you will find the problem in the query.Once the problem is found you need to provide solution to the problem by  rewriting the query,adding hints,changing the indexes,and so on………………..

One final Note
———————–
if you could not able to tune a query think of an alternative query ( with different tables) which provides the same functional behaviour as the earlier one.

Execution Plan

Order	ID	Operations	Cost	Rows	A	F
18	0	SELECT STATEMENT	152	554
17	1	.HASH JOIN	152	554
15	2	..HASH JOIN OUTER	25	545
10	3	…MERGE JOIN CARTESIAN	18	545
7	4	..:.NESTED LOOPS	12	1
4	5	..:..NESTED LOOPS	8	4
1	6	..:…TABLE ACCESS FULL JTF_RS_SALESREPS	4	4
3	7	..:…TABLE ACCESS BY INDEX ROWID JTF_RS_RESOURCE_EXTNS	1	1
2	8	..:….INDEX UNIQUE SCAN JTF_RS_RESOURCE_EXTNS_U1 [RESOURCE_ID ]	0	1
6	9	..:..TABLE ACCESS BY INDEX ROWID JTF_RS_RESOURCE_EXTNS_TL	1	1
5	10	..:…INDEX UNIQUE SCAN JTF_RS_EXTNS_U1 [RESOURCE_ID,LANGUAGE,CATEGORY ]	0	1
9	11	..:.BUFFER SORT	17	896
8	12	..:..TABLE ACCESS FULL HZ_CUST_ACCOUNTS	6	896
14	13	…VIEW  ORG_FREIGHT_VL	6	445
13	14	..:.NESTED LOOPS	6	445
11	15	..:..TABLE ACCESS FULL ORG_FREIGHT_TL	6	445
12	16	..:..INDEX UNIQUE SCAN MTL_PARAMETERS_U1 [ORGANIZATION_ID ]	0	1
16	17	..TABLE ACCESS FULL HZ_PARTIES	125	22643

]]> http://developerinsight.wordpress.com/2008/11/19/three-main-things-that-you-should-consider-when-improving-the-performance-of-a-sql-query-in-oracle-or-mysql/feed/ 1 Rama clip_image001 clip_image001[1] clip_image001[2] clip_image001[3] clip_image001[4] clip_image001[5] clip_image001[6] clip_image001[7] clip_image001[8] http://developerinsight.wordpress.com/2008/11/19/handling-utf-8-characters-in-java/ http://developerinsight.wordpress.com/2008/11/19/handling-utf-8-characters-in-java/#comments Wed, 19 Nov 2008 11:11:00 +0000 Rama http://developerinsight.wordpress.com/2008/11/19/handling-utf-8-characters-in-java/ ]]> Are you facing the below problem in java?

Sample string in another language

: 认清世界 读懂中国: 老百姓将杨佳案矛头指向沪政法书记吴志明

Are you getting all question marks  (?????????) instead of language specific characters (认清世界 读懂中国: 老百姓) when you are trying to read language specific strings in java program and display it ?

Then below are steps that you should follow to avoid such problems.

Problem :
The characters which are in the string are UTF-8 encoded characters , where as by default the tomcat server assume that all the characters are encoded in ISO-8859-1
as the result Tomcat is trying to read the characters in the string (which are UTF-8 encoded) in ISO-8859-1 encoded format because of which it could not able to print the international character’s.

How to resolve?
~~~~~~~~~~~~~~~
we need to say to the java servlet that those characters are UTF-8 and are not the default ISO encoded

How to say?
~~~~~~~~~~
Please observe the below bold line the second argument of InputStreamReader constructor ………………..it is UTF-8
which says to the servlet that characters retrieved from the URL/file  are UTF-8 Encoded and are not encoded in the default ISO format

(please not here iam reading the contents from an URL if you are reading from file instead of httpconnection you need to specify file path or File Object)

InputStreamReader defaultReader = new InputStreamReader(httpConnection.getInputStream(),"UTF-8");

That’s it. in adddition to that you need to take care of the below things.

1) mysql connection should be as below
jdbc:mysql://localhost/databasename?useEncoding=true&characterEncoding=UTF-8
instead of
jdbc:mysql://localhost/databasename

2) in mysql database , each table , each text/varchar column should be of UTF-8-general-ci
3) if you are using log4j and want ot see the UTF-8 characters in the log messages you should add the below param to each appender
<param name="Encoding" value="UTF-8"/> (i don’t know even after setting this i couldnot able to see the characters properly in log file/console)
4 ) important links which talks about this problem and solution:
http://java.sun.com/developer/technicalArticles/Intl/HTTPCharset/ (excellent article which clearly helps us to understand what the problem is and how to resolve)
http://blogs.warwick.ac.uk/kieranshaw/entry/utf-8_internationalisation_with
http://stackoverflow.com/questions/138948/how-to-get-utf-8-working-in-java-webapps

Similarly

To identify any language characters (say arabic, hindi etc……….)

we need to know the unicode block name for that language and need to apply the similar condition as shown above.

See the below link for more details
http://forums.sun.com/thread.jspa?forumID=31&threadID=5341202

http://developer.yahoo.net/blog/archives/2007/05/high_performanc_2.html

if you are using TOmcat the below is the way to add expiry date to the  js,images and css files that i figured out.
1)you need to create a filter for the above files to add an expiry date.
At the below link you will get code illustration of how we should do it
————————————————————
http://www.jguru.com/faq/view.jsp?EID=1311010

2) How to make sure that the expiry date is added properly to those files?
———————————————————–

I did a lot of investigation on the above problem. you can use the following tools

1) Yslow itself to check which components has expiry header and which components do not have.But it is some what buggy is not correctly reporting the expiry date of components.

2) http://www.webpagetest.org
AOL’s Page test tools you can download the desktop version and for accurate picture you can check the optimization report to know which components have expiry header which components do not have.This tool also some gives different problems.

3) The best way that i figured out is
The number of http requests that will go to the server is equal to the number of components (js,img,css) present in the webpage.What you need to do is…….
Step1) write some debug messages( i.e printing requested url and filename) in the filter that you have written for adding expiry date.

Step2)clear cache and download the page from the browser now check whether filter has modified any response by looking at the debug messages.
The number of debug messages = number of components requested.By debug messages you can know to which component we have added expiry header.

Step3) Load the page again (please don’t refresh as per my understanding refresh will invalidates all components of the browser cache and brings fresh components from the server) by copying the url and pasting in another browser window.
Now at server you can observe that no debug messages has been printed from the filter which means that those component have not been requested from browser because they are present in the browser cache which means our expiry date is working properly.

i hope you understood the above.

please let me know in comments if you need any clarifications.

pattern 1)  Following sequence may cause unexpected problems

step1) ClientA opened a session with the Server .Assume that session id = “23″

step2)Now you restarted the server the previous session with the id 23 is deleted on the server

step3)The same client made a request , as the cookie information is still with client client carries a old session id23.

step4)The server examines this 23 finds that it is deleted and creates a new session with the same session id 23 in this process  all the previous attributes which are there in the session will not present now.

step5)Very Important: During the 4 step the server will not call  the session listener some how and session attributes are all null.Due to this state some problems may arise.

pattern 2)

step1)Once after this  step 2)  Suppose  suppose you opened another browser (there is small issue with browser too ) window  (Client B) and opened the same web application 

Step2) WEb application creates a new session with id = 32

Step3) In Mozilla (look below what happens in IE)Now if the old client A makes any request it will be stamped with 32 rather that 23.

Very important thing you should note is

1) In Mozilla if old client A sends a request it is stamped withs session id  32.

2) IN Internet Explorer if old client A sends a request it is stamped with 27.

Although the possibility of such issues in the production is very rare because server will not be restarted as usually as we do while developing an web application.But while you are in the process of developing an application the above pattern may occur will cause some unexpected problems.

if you have not heard of DRUID.Then here is the introduction.Druid is a Database Manager means it is a front end tool from which we can control /develop various things related to various databases.Some of the advantages are

1) Automation of creating tables for your schema with a single click in any database (oracle,mysql,DB2 and others)

2) Maintaining the database also becomes easier.

2) There many  many many advantages Please see this page http://druid.sourceforge.net/

To learn more see the following page http://druid.sourceforge.net/   For tutorials and reference documentation just download the druid zip and extract it, inside the docs folder you will find various documentation and tutorials to proceed further.

SOme of the key things you should note while working with DRUID:

1)For mysql 5.0. Field attribute Unsigned should be next to primary key Field attribute .If not it will give some error.

2)If a primary key of a table is unsigned BIG INT then the foreign keys which references this primary key also should by unsigned BIG INT. Even if it is BIG INT it will give some error.

Please note the above point when working with MYSQL database.

Note:Good tutorials are inside the  Druid downloaded Zip so if you want to read good tutorials just download the DRUID from http://druid.sourceforge.net/

Download the DWR library and copy it to the ‘lib’ directory of the project.

Open the web.xml of the project and add the following lines to it.

<servlet>
    <servlet-name>dwr-invoker</servlet-name>
    <servlet-class> org.directwebremoting.servlet.DwrServlet</servlet-class>
    <init-param>
        <param-name>debug</param-name>
        <param-value>true</param-value>
    </init-param>
</servlet>
<servlet-mapping>
    <servlet-name>dwr-invoker</servlet-name>
    <url-pattern>/dwr/*</url-pattern>
</servlet-mapping>

What did we do? We declared a servlet and mapped it to the URL pattern /dwr/*. The servlet we declared, org.directwebremoting.servlet.DwrServlet, is the one which handles all the DWR requests. The init parameter ‘debug’ sets the debugging mode. Turn on debugging mode to check if the classes declared are getting exposed properly. But do not forget to turn it off when moving the project to production.

Now if the URL ‘http://localhost/DWRSpring/dwr’, assuming DWRSpring is the project name, is opened, it should a page showing ‘Classes known to DWR:’. However, the list will be empty as we haven’t exposed any classes yet.

Suppose that you wanna expose a bean, named ‘loginValidator’, using DWR. Create a file named ‘dwr.xml’ under WEB-INF folder of the project and add the following code to it.

<!DOCTYPE dwr PUBLIC
    “-//GetAhead Limited//DTD Direct Web Remoting 1.0//EN”
    “http://www.getahead.ltd.uk/dwr/dwr10.dtd”>

<dwr>
  <allow>
    <create creator=”spring” javascript=”UserValidator” scope=”session”>
      <param name=”beanName” value=”loginvalidator”/>
    </create>
  </allow>
</dwr>

What did we do? We exposed the bean ‘loginValidator’ as Javascript class ‘UserValidator’. The value ‘spring’ for the attribute ‘creator’ of the ‘create’ tag specifies that Spring framework should be used to instantiate this bean and the init parameter ‘beanName’ specifies the which bean to be instantiated. DWR provides many other creators. Most common one is ‘new’, which is used to instantiate the Java class using new operator. The javascript attribute of the ‘create’ tag specifies the JavaScript class name to be created.

Note that the bean to be exposed should be available in the application context.

To check if the bean has got exposed properly, open the URL ‘http://localhost/DWRSpring/dwr’. It should list the bean exposed. This page also allows to call the methods exposed.

To use the JavaScript class exposed by DWR, include the following lines in the HTML page.

<script src=’/DWRSping/dwr/interface/UserValidator.js’></script>
<script src=’/DWRSpring/dwr/engine.js’></script>

The script ‘UserValidator.js’ contains the definition of the class exposed by the DWR.

To call any methods of the JavaScript class exposed, use the following code:

UserValidator.validateID( id, callbackMethod );

Here validateID is one of the public methods of bean we exposed. ‘id’ is the parameter it takes. DWR runtime makes a call to the Java bean exposed on the server asynchronously. It takes care of marshalling and unmarshalling the parameters. The parameter ‘callbackMethod’ is the method to be called when the asynchronous request is complete.

function callbackMethod( data ) {
    window.alert( data );
}

The parameter ‘data’ contains the return value of the method we called.

Hibernate Tools :

  We use Hibernate Tools to  automatically generate  POJO (plain old java objects) and  sqlmaps  for the Objects/Tables  from the database.(there are variety of other things also that  these tools will do make sure that these tools will not do that particular task when you are about to hard code)

During this  reverse engineering process we can control the various names (i.e) names of the classes,names of the properties ,names of the collections  using an xml file,Which we give  during the code generation in the reverse.xml text box.

Sample XML file:

<hibernate-reverse-engineering>

<table  catalog=”catalogname”  name=”tablename”   class=”packagename”>
  <foreign-key  constraint-name=”constrain_name”
           foreign-catalog=”catalogname”
           foreign-schema=”schemaname”
           foreign-table=”tablewhichthe above constraint is pointing to”>
           <many-to-one property=”yourpreferredname”/>                
           <set  property=”yourpreferredname”/>
</foreign-key>

</table>

</hibernate-reverse-engineering>

As every table maps to a class we specify all the configuration details in the <table> element.

For every foreign key of a table (assume we are following bidirectional association mappings) which participates in the one-to-many relationship on one end we have a SET collection and on another end we just have POJO (plain old java object) we control the SET Collection name and POJO name.

The example XML files illustrates the above said theory

   1) write down your foreign key constraint and other details as shown above.Please note that without the foreign-schema some errors may come. 

  2) <set propertyname=” |  here you mention the name you want your collection should take.

3)   <many-to-one =” | here you mention the name you want your POJO to take.

Thats it.

There are other levels of configuration too you can able to do such as

1) we can mention class name for the table.        

2)we can Mention the property name and types that corresponds to the table column .

3) we can mention primary key details too.

Please note this is not written by Expert in Hibernate.We too are in the learning phase.They may be mistakes in the article .

java.sql.Date
————-
sql.Date is the convinient class to wrap the above java.util.Date into a format that is familiar to Databases.(i.e into the format yyyy-mm–dd) .Note that java.sql.Date will not store the timecomponent.

java.sql.Timestamp will store the Time Component along with the nanoseconds.