teknicallyspeaking

Multiple commands execution via runtime.exec() in Java

2009-09-18T20:56:00.004+05:30

The situation insists you to issue more than one command (native or external) through Java Runtime Environment via (Runtime.getRuntime().exec("Cmd")).

Ideally speaking, there has to be a way to separate/distinguish the commands from one another.

Few search results in Google suggested to use a semicolon in between the commands as 'cmd1;cmd2' in exec() method.

I tried the same way but it did NOT work out. During my trial-and-effort, the white space character did the trick :)

Runtime.getRuntime.exec("pwd date");

But it did work in Unix flavours but NOT in windows :( and i am still finding out a way to resolve.

Hope to get it resolved soon..

Cheers...

java.io.UnsupportedEncodingException: Cp850

2008-11-06T16:59:00.003+05:30

Wow.. A nice exception with which I learnt and found a new thing yesterday.

As being asked my one of my colleagues as she was facing this error soon after she launched the application in IE (the browser, Internet Explorer). It was a Struts based application and We digged around all the possibilities by looking at the flow to find out where the encoding has been specified.

I was sure that it has to deal with the encoding settings at the client side (obviously thats what the meaningful Exception says! lol..). The research continued with applicationResources.properties of struts, other application specific properties file, web.xml (to specify the encoding if any) etc., But no luck!!

The entire stack trace is below (fyi).

java.io.UnsupportedEncodingException: Cp850
sun.io.Converters.getConverterClass(Unknown Source)
sun.io.Converters.newConverter(Unknown Source)
sun.io.ByteToCharConverter.getConverter(Unknown Source)
java.lang.StringCoding.decode(Unknown Source)
java.lang.String.(Unknown Source)
java.lang.String.(Unknown Source)
...... [here the application specific code goes -- PRIVACY and CONFIDENTIALITY :)]

Well, she found out the solution with the googling that the "Issue was with the browser (IE 7) " and it was a bug in it. She got the application up and running in IE 6 :) Cool.

Thought of posting it here so that it may be useful for others whoever faces this issue :).

Editing the shell script in Windows OS

2008-09-08T22:04:00.004+05:30

Are you one among them who happened to edit the shell script in Windows OS? You may have various reasons to do that.

You should have got the script working very well in the appropriate linux (or any other flavour) box. But just before doing the final operation (be it checking it into CVS (version control system) or sending to the client waiting at onsite) you might have thought of giving a final/finishing touch like adding some documentation etc.,

Are you asking, "wats up?" or "what's a big deal.. huh?". Wait a minute. All is fine until you execute the script back in the linux box again.

Boooom.. The linux OS spits out an error message saying that "/bin/bash^M: bad interpreter: no such file or directory". What had happened? Wondering..? Surprised? Shocked rather??

Well, here it goes. The way the Windows OS deals with the file saving option is quite different than that of Linux OS. Once you are done with the so called final/finishing touch and when you save the file, some control characters are getting added to the shellscript (.sh file). That's what the culprit is and hence the error when executing it again in linux. The Bash Shell is unable to deal with such special character ('Control M' -- is referred as "^M").

It is assumed that Bash is the default and widely used Shell. The shell being used and the actual error message might vary as per your system's default shell and the way it is customized.

What and Where is the rescue?

There has to be a way. Isn't it? Yes, of course. There are two options.

(1) You can open the file in Linux OS (using your favorite editor like vi, emacs etc.,) and can delete such characters what you find at the end. I am not very sure of this as to what extent those characters are explicitly visible to the end user.

(2) But the other excellent alternative is to use the 'dos2unix' command wherein the usage goes as follows.

'dos2unix ' [eg., dos2unix myShellScript.sh]

This do2unix command converts the file in the DOS (for Microsoft environment) to the Unix properitary format. While doing so, it removes the special/control characters and it ultimately cleans the file to be used in Linux versions :).

Note/Word of Caution: Never edit the Linux related files in non-linux OS (Windows)! :)

Hope this helps to solve the tactics and saves you from the critical moment!

dealing with windows services in java

2008-03-09T17:44:00.005+05:30

&&tWell, had been thinking to get the control of windows services in a Java application so that programatically I can manage them (start/stop etc).

My main intention to start off this was basically to check the status of the service whether it is up and running. If not, start it before you accomplish the relevant task. The triggering factor was to check the 'MySQL' service as i sometimes keep certain services as of type 'Manual' instead of 'Automatic' so that these services may not take up considerable amount of time when the Windows OS gets booted up.

At times, when running a J2EE web application used to get the SQLException saying that 'could not obtain a connection', used to panic all of a sudden. Then recollecting our duty as having forgotten to start the particular service :)

As such, i am able to get the service up and bring it down through the application. Yet to get to know the status of a particular service and conditionally run the service :)

First, i remember i can get the external process running inside a Java appliation is via Runtime class (java.lang.Runtime) and its 'exec()' method which takes a String argument which says the OS process to run. A couple of years back i have invoked the IE browser via the same and recollected those stuff.

I tried executing the same as

Runtime runtime = new Runtime().exec("iexplore.exe www.javaranch.com");

The second argument is the actual argument to the application/process to be executed.

It was giving a different error saying that "java.io.IOException: CreateProcess iexplore.exe www.javaranch.com error=2". Had searched a bit in JavaDoc of the Java API in Process, Runtime classes, but really could not get anything.

Beforehand, i wanted to try with some other executables like Notepad etc., to my surprise it was working fine. for example the below command

runtime.exec("Notepad.exe C:\path.txt");

perfectly works fine and opens the path.txt inside the notepad application. Have checked the same with "Calc.exe" as well.

I have concluded to certain extent that the way we invoke this particular executable is errenous. I have tested the same by invoking the executable in the command prompt. It gave the infamous error

'iexplore.exe' is not recognized as an internal or external command,

Found out that the path was missing to this executable. That means, the location to the 'iexplore.exe' was not added into the path. Though i checked the same by adding the location to IE.exe in PATH and it worked fine, but it won't be appropriate to do so just for this testing purpose. So reverted back and tried executing the following:

runtime.exec("C:\\Program Files\\Internet Explorer\\iexplore.exe www.javaranch.com");

What a surprise? It worked fine!

Then i moved on to my required, 'services.msc' stuff in the same way. I got the same error but with different error code even when i gave it with full path :(. For the invocation of

runtime.exec("C:\\WINDOWS\\system32\\services.msc");

the error what i got was, "java.io.IOException: CreateProcess: C:\WINDOWS\system32\services.msc error=193". I am sure that the path to 'System32' was not mandatory at all. This error made me get into google and some good links helped me out in finding a way of what this error 193 means, 'this is not a valid Win32 application'. Also could get some other invocations and out of which what i tried was successful. It is below.

runtime.exec("cmd.exe /c services.msc");

Actually, you have to invoke the Command Prompt (cmd.exe) first and then pass the actual service/exectuable to be invoked as an argument to command prompt. The middle argument '/c' is for 'carrying out the command and terminates". And i thought it would work even if it is not present, but it failed :(. Need a clarification here. :). But it holds good when you type it in 'Run prompt'. The other option to verify it is '/K' which stands for 'carries out the command specified by the string but remains'.

The next question was, how to get the particular service up? I tried by passing the name of the service as an argument as follows.

runtime.exec("cmd.exe /c services.msc MySQL");

but it dint give any fruitful results :(. After a while, though why don't i directly execute the particular executable which the service is made run. Of course, the services is also a shortcut or link pointing to the executable placed elsewhere. Tried it out. it worked but with two drawbacks..

1. The java executable was getting hung. :(

2. Was not having a way to stop the executable rather than killing the process!

Finally when continued searching in google, somewhere i read about the way to start a service. That's through 'NET START '. Here is the link. Got succeeded as well :)

runtime.exec("net start MySQL");

runtime.exec("net stop MySQL");

Obviously these are invoking the MySQL Service in the services.msc only. As of now i am able enuf to do till this phase. Let me complete the rest and post it here..

to set the color of the windows cmd prompt

2008-03-09T16:08:00.005+05:30

Basically I too fall in that 'customizing-freak' category to customize certain features of the OS apart from the specific applications we work on.

One among them is, to have the preferred font, foreground and background colors in the Comman Prompt and with a shortcut to the command prompt on the Quick Launch bar.

Just today when i was searching for a help command for another utility (services.msc), got to know about this favorite-and-regular routine of mine.

Windows has a command utility named Color with an argument to set the foreground and background colors for the window being opened.

I bet no one can beat the Microsoft's help/documentation. so for your info, just copy-pasting the information available in the help!

Command : color help

Sets the default console foreground and background colors.

COLOR [attr]

attr Specifies color attribute of console output

Color attributes are specified by TWO hex digits -- the first

corresponds to the background; the second the foreground. Each digit

can be any of the following values:

0 = Black 8 = Gray

1 = Blue 9 = Light Blue

2 = Green A = Light Green

3 = Aqua B = Light Aqua

4 = Red C = Light Red

5 = Purple D = Light Purple

6 = Yellow E = Light Yellow

7 = White F = Bright White

If no argument is given, this command restores the color to what it was

when CMD.EXE started. This value either comes from the current console

window, the /T command line switch or from the DefaultColor registry

value.

The COLOR command sets ERRORLEVEL to 1 if an attempt is made to execute

the COLOR command with a foreground and background color that are the

same.

Example: "COLOR fc" produces light red on bright white.

My preference goes as : "Color 0a" :P

Note: It just sets the colour for the current window being opened! :)

Another Info about the 'DefaultColor' registry value: it is present in the HKEY_USERS/.DEFAULT/Software/Microsoft/CommandProcessor directory in 'regedit' (Registry Editor).

Getters and Setters for better encapsulation

2008-01-21T14:48:00.000+05:30

This is an interesting topic in the beginner's level. Well, at the end of this discussion you would have an answer for these questions.

What are Getters and Setters?

What way they are beneficial?

Are they the means of achieving Encapsulation?

Summary of this encapsulation

Let's take you have a Person object and whose size object is what you are trying to access or set.

The plain version of the class would look like as follows:



class Person
{
   


   public int age;
   public String name;

   


   public static void main(String[] args)
   {
      Person obj1 = new Person();
      obj1.age = 5;
      obj1.name = "Raghavan";
      System.out.println("obj1.age="+obj1.age);
      System.out.println("obj1.name="+obj1.name);
   }
}

The following program produces the output as:


obj1.age=5
obj1.name=Raghavan

By looking at the above code, you don't seem to get anything strange! Yes so do I :).

Let's have a different scenario on the same class.



class Person
{
   


   public int age;
   public String name;

   


   public static void main(String[] args)
   {
      Person obj1 = new Person();
      obj1.age = -5;
      obj1.name = "";
      System.out.println("obj1.age="+obj1.age);
      System.out.println("obj1.name="+obj1.name);
   }
}

Now did you see something strange?

If not, look at the two lines carefully.


      obj1.age = -5;
      obj1.name = "";

They are perfectly valid and legal to the compiler and runtime, they are syntactically correct! But logically?

Can any person have a negative age?

Can a person's name be empty?

Why these occurred? Because the variables were of public during declaration.

That's why they are allowed outside and any legal value is allowed in the program without any harm.

How we go ahead in preventing this scenario?

Before the setters/getters were in picture or came into existence, the variables were declared public and given outside access without any harms.

In that case,


class Person
{
   public int age;
   



   public static void main(String[] args) 
   {

     Person myObj = new Person();
     myObj.age = 5;
     System.out.println("myObj.age : "+myObj.age);
     



     Person myObj2 = new Person();
     /* Check here! */
     myObj.age = -2; //Ouch! a syntactically correct but logically incorrect value
     System.out.println("myObj2.age : "+myObj2.age);
   }
}

Just to have a better control on this value being accessed, there came a rescue in the form of Getters and Setters. As the name indicates, Getter is used to get/obtain a value and Setter is to set a value back. They are also called as Accessor and Mutators.

What if you allowed the access through a method and NOT directly?

For which you need to have two things.

First "protect" your variable from outside access. Means, declare them to be of private.

Then provide getter and setter for your private variable. As the variable is pricate, the getter and setters should be public.

Following the same, the code will initially look like


class Person
{
   private int age; 
   



   /* Getter Method */
   



   public int getAge() {
     return this.age;
   }
   



   /* Setter Method */
   



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


   public static void main(String[] args) 
   {
      Person myObj = new Person();
      //myObj.age = 5; // can't access directly!
      myObj.setAge(5);
      System.out.println("myObj.age : "+myObj.getAge());
      



      Person myObj2 = new Person();
      /* Check here! */
      myObj.SetAge(-2); //Ouch! a syntactically correct but logically incorrect value
      System.out.println("myObj2.age : "+myObj2.getAge());
   }
}

But had you been exposing your code through this way, it would be very easy in a later point when you realize that setting a negative value is a sin! you should NOT allow that, you have an easy way to get rid of it.

Just modify/update the setter method as below :


...
public void setAge(int newAge) {
    


   /* introducing a new check for Age */
   



   if(newAge <=0){ /*definitely age should NOT be zero! */
     System.err.println("Invalid age!");
     return;
   }
  


   this.age = newAge;

}

This way, you really don't break the existing code. As such the users would still continue using your setAge() method to set an age.

Here dealing with the invalid values and the condition to confirm the same may definitely based on the user and requirement. You can either set a default value or throw an exception or just let the user know about invalid value and continue the program normally.

A Quick Summary of encapsulation goes:

Encapsulation reduces coupling between classes, allowing it to make changes to classes without having to change its clients (whoever invokes the methods of this class). This makes maintenance and extension of a software system much easier and less costly.

Remember that for most systems, much more effort is put into maintenance than into initial development, so proper management of code dependencies pays manyfold.

/* 2-arg Constructor */
public Person(int age,String name)
{
this.age = age;
this.name = name;
}

/*Overridden toString() for our Person class*/
public String toString()
{
return "[Person] : age="+this.age+", name="+this.name;
}

tasklist - cmd in windows similar to ps cmd in linux

2007-11-19T18:05:00.001+05:30

The people who have worked in Unix and its flavours, would have definitely come across a command called 'ps' (which stands for 'process status'). As such the 'ps' command gives you the list of processes running and the pid (process id) etc.,

There is a command to achieve the same in Windows OS too. That is 'tasklist'. Just execute in the command prompt. Here it gives the "Image Name", "PID", "Session name", "Session#", "Mem Usage".

Image Name -> the name of the process running
PID -> as you know, the process id (unique id which the OS refers to)
Session name -> it shows 'Console' but have to check what it really means
Session # -> should be a session id and for console it gives '0'.
Mem usage -> the amount of memory each task/process occupies.

Here is the sample screenshot of the same.

It looks like the CUI version of the 'task manager' :)

NOTE: It may not work in all versions of Windows. As such i have tested in Windows XP. I believe it must definitely work in 2000 also. Not sure about the previous versions of 98,95 etc., will check and update later.

Pass by Reference for object references holds good really?

2007-09-13T13:42:00.000+05:30

Pre-requisite: Well, If you want to refreshwith the concepts of "Pass-by-value Vs Pass-by-reference", you may please refer this previous entry in this blog.

With respect to Java, it "passes everything by value". I repeat, "everything" by value only.

Generally, we may think that passing by values will hold good only for primitive types and values but not for the object references.

This everything includes even the references to objects.

Lets say, you have a method which takes an object as a parameter as follows

public void doChange(MyClass myClassObj)
{
//do something..
}

And you call that method from some other piece of code as follows

//calling method
public void method1()
{
MyClass myClassObj = new MyClass();
doChange(myClassObj);
}

The reference variable myClassObj is being assigned to an object of class MyClass in Heap. Just like primitive variables holding bit patterns to represent a value, reference variables also store the bit patterns to reach an object.

Once you call the method doChange() by passing the reference variable "myClassObj" to it, the value of the bit patterns held by "myClassObj" is being copied and passed into the called method doChange(). In the called method doChange(), the copied-and-sent bit pattern is received in the same name as that of the original reference variable "myClassObj". But the compiler treats that as a different one just like primitives.

Lets say the received reference variable as "myClassObjLocal" for easy understanding. In this stage, both the original refernece variable "myClassObj" and the received reference variable inside the doChange() method "myClassObjLocal" (to compiler) point to the same object in Heap.

Now if you change the state of the object being pointed by, it will reflect to both the reference variables because both of them point to the same object in Heap. Whereas,if you change the received reference variable "myClassObjLocal" to point to a new object (reassign a different object), it does NOT reflect back to the original object because the bit pattern to the "myClassObjLocal" alone gets changed!

If you are clear with the above paragraphs, lets go to an example to make it more clear.

Lets take a small example.

class TestObjRef
{
int intValue;

public TestObjRef()
{
intValue = 1;
}

public static void changeStateOfObject(TestObjRef obj)
{
obj.intValue = 2;
}

public static void changeReference(TestObjRef obj)
{
obj = new TestObjRef();
obj.intValue = 9;
}

public static void main(String[] args)
{
TestObjRef obj1 = new TestObjRef();
System.out.println("obj1.intValue (1) = "+obj1.intValue);
changeStateOfObject(obj1);
System.out.println("obj1.intValue (2) = "+obj1.intValue);
changeReference(obj1);
System.out.println("obj1.intValue (3) = "+obj1.intValue);
}
}

Running the above code produces the following output:

Output:
obj1.intValue (1) = 1
obj1.intValue (2) = 2
obj1.intValue (3) = 2

changeStateOfObject Method

This is because, changeStateOfObject() method just changes the value of the variable "intValue" which definitely constitutes the state of object. And as such, both the "obj1" in main() method and "obj" in changeStateOfObject() method point to the same object. Means, they both hold the same bit patterns to reach a single object of TestObjRef class in heap.

That's why the output in the second line shows the changed state of object "2" as the value of "intValue" property.

changeReference() Method

If you look at the changeReference() method, by the time of receiving the argument, both the "obj1" reference variable in main() method and received reference variable "obj" in changeReference() method both hold the same bit patterns to reach the same and single TestObjRef class in Heap.

But inside the method, the received "obj" reference variable is reassigned to a newly created object of TestObjRef class. In this case, only the bit pattern of the "obj" reference variable inside the changeReference() method is changed and the change is NOT reflected back to the originally sent reference variable "obj1".

That's why the third line in the output still shows the value of "intValue" as "2" since the changed value "9" is only reflected in the received local reference variable "obj" in changeReference() method.

Note :
The received argument (object reference variable) is treated local to the method. That means, the scope of the variable is only local to the called method just like primitives and the variable cannot be accessed outside the method.

Pass by value Vs Pass by Reference

2007-09-13T11:41:00.000+05:30

We all would have read the two terms "pass-by-value" and "pass-by-reference" especially when you deal with methods (which are also called as functions).

Let's just have a quick glance at both the terms with a small example.

The definition of these terms goes as follows.

Pass-by-value: A copy of the value is being passed from the calling method to the called method.

What exactly do you mean by copy of the value? In general, we tend to pass the variable for the value to be passed. In such case, whatever the value the variable holds is being copied and passed across. That means, you are taking a xerox of the o riginal value and pass the xeroxed copy to the called method.

What are the effects?
Since you have only passed the xeroxed copy and NOT the original value, whatever changes you do in the called method, the change is not reflected back to the original variable.

A Sample program for pass-by-value:

void changeValue(int a)
{
int b = ++a;
printf("changeValue -> a, b contain: %d,%d",a,b);
}

int changeAndReturn(int a)
{
int b = ++a;
printf("changeAndReturn -> a,b contain : %d,%d",a,b);
return b;
}

int main()
{
int i = 1;
changeValue(i);
j = i;
printf("\ni and j is : %d,%d\n",i,j);
printf("\ncalling changeAndReturn()..");
changeAndReturn(i);
j = i;
printf("\nNow i and j contain: %d,%d",i,j);
}

Output:
changeValue-> a, b contain: 2 2
i and j is: 1,1
calling changeAndReturn()..
changeAndReturn -> a,b contain: 2 2
Now i and j contain: 1 2

Explanation:
Let's see how exactly the values are dealt. In the main() method, you are calling changeValue() method as

changeValue(i);

At this time, the value of i (which is 1) is being copied (Remember! xeroxed) and the xeroxed copy is what getting passed to the changeValue() method. Inside the changeValue() method, you get (receive) the passed value in the variable name "a". Note: Even if you have received the passed argument as the same name "i" in the function, the compiler would treat both of them differently!

Soon after you take a xerox copy of the value of the variable and use it for calling functions, the connection between the copied value and the original value is cut. There is no relation between those two values and /or variables.

Inside the method changeValue(), we do the following steps:

(i) receive the value passed in the variable whose name is 'a' (implicit)
(ii) declare an int variable named 'b'
(iii) increment the received value in its variable 'a' and assign the incremented value to 'b'

Since because the original value ('i' in main) does NOT hold any relationship with its xeroxcopy ('a' here), the changes you do in the called function (incrementing the value in changeValue()) does NOT reflect back.

That's why in the main after the function call returned, the printf statement prints the value both i and j contain 0. Once the function call is returned, the present focus is in main() function and now we are assigning the value of 'i' to 'j' which is 0 only. This clearly shows that there is NO effect on the variable 'i' even after calling the function changeValue() which does some change to it actually.

Just to have an effect, we have one more method called changeAndReturn() which changes the value and returns it. In the calling function (main()), we get the returned value and assign it to 'j'. That's why the second set of output shows the incremented value '2' for both 'i' and 'j'.

Pass-by-reference: The memory address of the variable is being passed instead of making a copy of the value. This holds good for C, C++ languages (as far as i know as such).

What are the effects?
Since you pass the memory address itself to the function and you obtain the value from the received memory address inside the called function, you get the full control over the value. That means, whatever change you do, it will be reflecting in the original variable in the calling function eventhough you do NOT return either the memory address or value back.

It is because, you have played around with the memory directly instead of values and in both the calling and called functions, the values are obtained and manipulated with respect to memory only. So the change is reflected back.

Let's see a sample program for pass-by-reference:

Sample Program for pass-by-reference:

void changeValue(int *int_ptr)
{
//doing an increment operation on the 'dereferenced' pointer
int b = ++(*int_ptr);
printf("changeValue -> a, b contain: %d,%d",a,b);
}

int main()
{
int i = 1;
int *int_ptr = &i;
printf("\ncalling changeValue()..");
//Note: we are passing the pointer to the function! (the 'address')
changeValue(int_ptr);
//assigning the value of 'i' to 'j'
int j = i;
printf("\ni and j is : %d,%d\n",i,j);
}

Output:
changeValue-> a, b contain: 2 2
calling changeValue()..
i and j is: 2,2

Explanation:

If you carefully look at the implementation and way of calling the function changeValue(), it actually receives a pointer to an integer! that means, we are passing the 'memory address' of an integer variable.

Inside the function, we do the following steps:

(i) receive the address of the integer variable in the name 'int_ptr' (the same name as in the calling function, here main(). But remember! for the compiler, they both are different!)
(ii) we declare an integer variable 'b'
(iii) we dereference the pointer variable ('dereferencing' means obtaining the value present in the location where the pointer is pointing to)
(iv) we increment the value being obtained by the dereferencing operation
Note: here the value is incremented directly in the memory location
(v) and assign the incremented value to the variable 'b'

One important thing is that, we do NOT return any value back to the calling function. But the changes happend in the memory location directly in the called function (changeValue()). Once the control comes back to the calling function (main()), we are still accessing the value in the same memory location through the original variable 'i' and assigning to 'j'.

That's why we see both i and j having the value '2'.

How to get the list of files in a directory and save it in a file

2007-04-04T12:27:00.000+05:30

You may need to get the list of files inside a folder with the appropriate structures being maintained.

This tip will help you to get the complete list of filenames within a directory structure in Windows OS.

(1) Go to Command Prompt
(2) Navigate to any directory of your interest
(3) Type dir /b /s "Root-directory" > "filename.extension"

whereas

/b -> use bare format (no heading information or summary)
{summary is the date time info, size , file or directory attribute etc.}

/s -> displays file in specified directory and all subdirectories.

Root-directory -> is the directory from which you want the file list info
{if Root-directory is omitted it will process from the current directory}

> -> Redirection Operator or Symbol.
{the output of the command on its left would be sent to its right}

fileName.extension -> any file name with extension you want
{example. directory-structure.txt}

Make it Automated in a Batch File

You can even write a batch file with another line to open it in the
appropriate application.

dir /b /s "Root-directory" > "filename.extension"
notepad "filename.extension"

Save these two lines in a batchfile as ".bat" and run this batch file from command prompt. It would automatically save it in the file and gets opened in Notepad. You could use any other convenient applications to open as you wish.

Hope you may need not take screenshots for directory structure {if at all you had been doing so} ;-).

Tip to increase the efficiency while deleting huge volume of rows

2007-02-23T21:26:00.000+05:30

This tip would be very much useful when you have enormous rows in a table and you are trying to delete/remove the rows using the usual, "DELETE FROM <tableName>;" statement.

You may ask whats the consequences of using the DELETE statement and thats what its purpose is. But, not just deletion, for that matter any DML statement will make use of something called TRANSACTION LOG which is nothing but the buffer/temporary storage where all the data would be kept until there is an explicit COMMIT or ROLLBACK.

Once a Commit is issued, the data kept in the Transaction Log is written into the database files in its own appropriate format (.dat for data files, .inx for index files in IBM DB2 database - which may vary in Oracle, MySQL, SQL Server etc..).

When a rollback is issued, the data in the temporary Transaction Log is removed and thereby no state change happens to the data files.

Moreover, its gonna be time consuming wherein the time is directly proportional to the dense of data.

When you deal with large number of data to be dealt with, be it inserting, updating or deleting, you might end up in something called, "The Transaction Log is FULL" while doing the operation. Most of us might not have encountered this situtation as we do just deal with 100s or max 1000s of data. People who are dealing with lakhs, millions of rows might have been aware of this. Say, who are in Data Warehousing, Business Objects etc.

When we encountered the situation, one of my teammates in my client place (Yadati Ravishankar) had come up with a query what he found out in googling. This query does the magic by just clearing up the table with very very less time compared to that of plain old DELETE statement.

Here you go...

"ALTER TABLE [<SchemaName>.]<tablename> ACTIVATE NOT LOGGED INITIALLY WITH EMPTY TABLE;"

This query does alter the table with empty rows but while doing the same it requests the db engine not to activate the Logging. Thereby it is able to get the request serviced within seconds!!

Try with huge data buddies..then only you can make out the difference!!

Good luck!

Java #Q1: What would be the output?

2007-01-16T17:27:00.000+05:30

public class Test
{
     public void method1(Object o)
     {
          System.out.print("object");
     }
    public void method1(String s)
    {
          System.out.print("string");
    }
    public static void main(String[] args)
    {
           Test t = new Test();
           t.method1(null);
    }
}

When running the program, the output would be
(a) object
(b) string
(c) objectstring
(d) stringobject

Answer:
(b) string

Explanation:
It is the hierarchy of objects being searched for a match, which is quite similar to the exception objects of catch blocks. The search process is done in the bottom-up manner wherein the object of class of least node is searched first and its continued upwards to the super/parent classes till the end is reached.

jsfffffff

2006-05-02T15:53:00.000+05:30

Java Server Faces Notes
=====================
- M Raghavan alias Saravanan, 13Jan2006 Friday 5:25 PM

--> JSF - is mainly used to develop the custom UI Parts in any application in a neutral manner.
(*)to create a standard framework for user interface components for web applications
(*)JSF lets you build web applications that run on a Java server and render the user interface back to the client
(*)provides web application lifecycle management through a controller servlet, and a rich component model with event handling and component rendering
--> Though it also follows MVC 2 pattern (separation of presentation logic and business logic) its focus is fully into the VIEW tier, where as
--> Struts is concentrating mainly on the Controller tier. But still there are some overlaps are there between these two frameworks.
--> Integration of these two frameworks is in progress. See Apache site for the same.

MINIMUM REQUIREMENT:
-----------------------------
--> Works with the Servlet 2.3 or more and JSP 1.2 or more

Two Main Components of JSF:
~~~~~~~~~~~~~~~~~~~~~~~~~
(1) Java APIs to represent UI Components, manage state, handle events, and validate Input. (Internationalization and accessibilty!)
(2) Two JSP Custom tag libraries for expressing user interfaces (UI) components within a JSP page and for writing components to server-side objects. Page authors can easily add UI components to their pages.

The UI parts are rendered on the Server and then the rendered output (HTML Of course as most of the clients - browsers are relying on HTML as the Least Common Denominator) is sent to the client on the first.

Browser---->(request for a jsp page for ex) ----> form.jsp ----> UI ===> Form rendered with the components

Guidelines/Rules to Use
****************************
--> In order to user JSF tags, you need to include the taglib directives to the "html" and "core" tag libraries that refer to the standard HTML renderkit library and the JSF core tag library, respectively
--> A page containing JSF tags is represented by a tree of components whose root is the "UIViewRoot", which is represented by the "view" tag. All component tags MUST BE ENCLOSED in the "view" tag. Other content such as HTML and other JSP pages can be enclosed within that tag.
--> A typical JSP page includes a form, which is submitted when a button is clicked. The tags representing the form components (such as textfields and buttons) MUST BE NESTED inside the "form" tag.

POINTS TO PONDER:
################
(1) Value-binding expressions (syntax: #{bean-managed-property}, eg: value="#{UserNumberBean.minimum}")
(*) minimum is the attribute in the bean class UserNumberBean
Method-binding expressions (syntax: #{method-name-of-the-bean-to-validate}, eg: validator="#{UserNumberBean.validate}")
(*) validate is the method in the bean class UserNumberBean

The Model Object
----------------------
--> A typical JSF application uses a bean with each page in the application.
--> The bean defines the properties and methods associated with the UI components used on the page.
--> A bean can also define a set of methods that perform functions, such as validating the component's data, for the component.
--> The model object bean is like any other JavaBeans component: it has a set of accessor methods.

Application Configuration Resource File
------------------------------------------------
An application configuration resource file, "faces-config.xml", is used to define your managed beans, validators, converters, and navigation rules

Faces Servlet
============
(*) has to be configured in web.xml (similar to ActionServlet in Struts)

--> in order to use the JSF framework in your web applications, you need to define the "FaceServlet and its mapping" in your deployment descript file, web.xml.
--> This servlet "acts as the FRONT CONTROLLER" and handles "all JSF-related requests"

JSF Components are organized into categories
********************************************************
--> Added Components: JSF components you have written or acquired elsewhere and imported into the Java Studio Creator development environment
--> JSF Standard Components: The basic set of components including form fields, hyperlinks, labels and text. The JSF components are organized into logical groups by function.
--> JSF Validators/Converters: Components that modify or validate data in other components but are not themselves displayed
--> Advanced: JSP tags for advanced JSF features. These tags generally do not have a visual appearance and are only useful if you are familiar with both the JSP and JSF technologies.

Conclusion
###########
(*) JavaServer Faces (JSF) is a user interface framework for building web applications that run on the server side and render the user interface back to the client.
(*) It lets you develop tools that simplify coding web-based Java applications

(*) JSF requires little more effort than an ordinary JSP configuration -- but with many more benefits

just test in teknical stuff

2006-04-29T12:52:00.000+05:30

hi folks,
this just a test post in this teknical stuff..

Free java e-books, visit http://www.jvsoft.org/index.html

Raghs.