jQuery – Simple & Powerful

jQuery seems the new player as far the client side manipulation is the issue. I had always thanked JavaScript for allowing us to do the dirty job on the client side starting from validation to amazing animations and magics – as it was seen on the Google earth, we should due credit.
Then comes Ajax, yup I have loved and played with it and it is so logical. Why do I have to submit the whole page while the intension is to submit only, say, a single value like an email for subscription. Of course it has done even more than that.
And now, jQuery which is a bundle of the two nice tools. JQuery is collection of JavaScript libraries that would make coding easy, fast navigation experience and almost a shortcut to Ajax.
The functions in the jQuery are human friendly and easy to remember.
It is possible to access an element only, or a group of elements or elements under the same class in easier way. Above all uses nicely callback functions – cooool.
All one has to do to start jQuery is to download the library from http://docs.jquery.com/Downloading_jQuery and locate it like any other JavaScript code:
Following this, be ready to plough. The main character in play would be the jquery object itself. Accessing it could be done either by directly calling it or using its alias($) – which is the custom to go. How it does is: first it would select single or group of elements and then apply tasks like editing, hide/show, replacing, assigning new style and many more. Let us use the following simpe XHTML code for illustration

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<title> Sample jQuery </title>
<script src="JQuery/jquery-1.3.2.min.js" type="text/javascript" ></script>
<style type="text/css">
background-color: palegreen;
font-family: verdana;
color: black;
font-size: 12px;
width: 300px;
text-weight: bold;
border: solid 1px blue;
width: 300px;


<p id="description" class="highlight">This is for the illustration purpose</p>
<p id="attention" class="emphasis">give attention for this</P>
<a href="http://www.devx.com/codemag/Article/40923/0/page/1">More examples</a>
<input type="button" id="toggler" value="toggle" />

Basic jQuery statement would have the following format:

<script type="text/javascript">
       $(document).ready( function(){
               logic goes here;

Here the ‘$’ is an alias for the jQuery object, document is the representation of documents as in DOM. The ready method makes sure if the page is ok to proceed or not.
function() inside the ready() method is the callback function. The beauty begins here, we can define any function of our own as we like.
Lets remove the highlight style from description and assign it emphais
The first part “p#description” would select the paragraph with id description. Had it been “p”, it would select all paragraphs.
In this particular case it is also possible to say (“#description”).
removeClass and addClass are self-explanatory.
The chaining is possible as a dot operated methods because each selection would return an object.
Remember how to toggle in JavaScript? Had to use if .. how about in jQuery.
Lets make a click on the first paragraph to hide and show the second paragraph.

        $("#description").click( function(event){

That is all. A single line would keep our fingers from being tired.

Here, the click method would accept the callback function. This call back function is specific to the call only. Say if I have used (“p”), then when I click on a particular <p>, the click method would be applicable only to the clicked paragraph element.


The above snippet shows only one paragraph at a time. But it shows them alternatively.

This is just to give a very highlight about jQuery. There are a lot of things especially on the selection area.

The following are are good sources of jQuery tutorial and references

Knowing Accessibility of Methods Using Reflection

While programming, one inquiry would be to know the if the methods from the given class could be accessible or not from any object, from derived class, from assembly or from derived & assembly…
Knowing ahead for time these factors would reduce the error theater from running.
Say a class with the following definition is given:

class Person{
     private void privateMethod(){}
     public void publicMethod(){}
     protected void protectedMethod(){}
     internal void internalMehtod(){}
     public static void staticMethod(){}
     public virtual void virtualMethod(){}
     protected internal void internalProtectedMethod(){}

So, while trying to access the methods of the Person class and wanted to know accessibility – no problem..
Dot Net has provided the following methods for this specific usage under the implementation of reflection

.Name - tells the name of the method
.IsPublic - checks if the method in the class is public or not (public)
.IsStatic - checks if the method is static (static)
.IsVirtual - checks if the method is virtual (virtual)
.IsAssembly - answers if it can be accessed from assembly (internal)
.IsFamily - answers if it can be accessed from derived class (protected)
.IsFamilyOrAssembly - from derived or assebmbly (protected internal)
.IsFamilyAndAssembly - from derived and assembly 

Look @
http://msdn.microsoft.com/en-us/library/system.reflection.methodbase.isfamily.aspx For example and application

Stored Procedure in MySQL

Using MySQL had one setback – lack of stored procedures. But, we had celebrated the farewell of this hindrance after welcoming MySQL 5.0.
Stored procedure is a collection of valid SQL statements residing in the data server. It may or may not return value based on our need.
Stored procedure should be our first choice when we have a choice to play with them – because:

  • Our application would be fast due to decreased use of network
  • Logics can be used more than once
  • Maintenance is simple – just edit at one place… and even more

I will try to use simple example to demonstrate how to use stored procedure in MySQL. I will use MySQL CLI for the illustration.

Syntax: CREATE PROCEDURE procname(parameters)
logic goes here

Example:  simple procedure to collect rows of a table:

Lets create a table first:
USE dbTest;
CREATE TABLE member (Id int not null auto_increment primary key, first_name nvarchar(12), last_name nvarchar(12) );

Say we want to collect all rows from the above table using stored procedure:
SELECT * FROM member;
The above snippet would create a stored procedure named selectAll() on the dbTest database.
DELIMITER ** would change the default delimiter of the CLI which is ‘;’ to **. I have to change the delimiter from ‘;’ to ‘**’ or any other character except ”. Otherwise, when the execution gets ‘;’ in the middle of execution, it will halt – and finally we would return the default delimiter at the end.
Using the stored procedure would be:
CALL selectAll(); or CALL selectAll; –> which will list all the rows of the table.
What about when we have parameters?

Listing Databases and Tables in MySQL

To list databases from terminal
1. Go to terminal and type mysql -uroot -proot –> taking user name as root and password as root to log as administrator
2. type show databases; –> this will list all databases in the server.

To list tables in the given database:
1. First move to the database by typing: use databasename where databasename is the name of the database whose tables would be listed
2. type show tables;
To see the make up of the table:
1. First move to the database
2. Type describe tablename or desc tablename

Using Checks

One of the handy tools regarding the constraint in SQL Server is check.
This simple, but powerful, tool allows us to use column based constraints on the data.
Say you have a table with age column. If you want to add constraint on age for values less than or equal to zero and above 100 – thinking we would live 100 years…
ALTER TABLE tbl ADD CONSTRAINT age_constraint CHECK(age < 100);
That is all.
If I try to run a query like this..
INSERT INTO tbl (age,..) VALUES (-12);
Then the engine would tell me that this cannot happen.

Encapsulating Queries in Object

Here is some more pattern for you. I have provided how to implement singleton pattern for database.
The idea is:
Why don’t we encapsulate our queries to the database in an object?
What we need is to execute a query whether it is update query – like delete, update and insert or retrieval query like select. In both cases, the the accomplishment would be one – executing – with different query parameters.
Which means we need only a single interface per application for that would simply execute our queries independent of the query string.
The encapsulating class for queries (acting as command) shall contain the implementation of method executeQuery().

Query class: implementing the basic tasks of query
Author: Kaleb B. Woldearegay
Date: 18.Apr.2009

Open for any kind of modification and use.
Please let me know when you use and modify it as I will learn from that 
	class Query{
		protected $sql;
		protected $db; /*any database implementing IDatabase */
		/*Method executeQuery would accept query string 
and executes it using the database's execute query method */
		public function __construct($database){
			$this->db = $database;
		protected function executeQuery($sql){
			return $this->db->executeQuery($sql);

Another point here would be, since we have two major tasks to perform against database – namely update queries and retrieval queries – we need two query commands which would be the derived classes of Query class

	/* This class would perform non resulted queries - 
like update, insert and delete
-- Query.php--
	class UpdateQuery extends Query{
		/* constructor would pass the database for query class */
		public function __construct($db){
		/* execution of queries would goes here */
		public function executeQuery($sql){
			return parent::executeQuery($sql);		

	/* This class would perform resulted queries - like select */
	class ResultQuery extends Query{
		/* constructor would pass the database for query class */
		private $result; /* result object that would be created from database */
		public function __construct($db){
		/* constructor would pass the database for query class */
		public function executeQuery($sql){
                        /* Assigning the object */
			$this->result =  parent::executeQuery($sql); 
			return $this; //return the result query;
		/* Collect the row from the collected result */
		public function getRow(){
			/*using associative array for the rows*/
		       if ( $row=mysql_fetch_array($this->result,MYSQL_ASSOC) ) {

            			return $row;

        		} else if ( $this->size() > 0 ) {


            			return false;

        		} else {

            			return false;


		/* Size of the collected result */
    		public function size () {

        		return mysql_num_rows($this->result);


The hot-to-go part is simple. Any query should be executed! But the type of query is different – some require result set and other don’t. Which is a kind of topping we want on our query pizza. UpdateQuery and ResultQuery would provide the different type of flavors.
So, the client would encapsulate its request in either of the commands and would call an execute method.
But, this has some problem. We would need to know specifically of which type the query is. But what if we have an interface which would accept any command object and invoke its execute method – this seems neat..

Query class: implementing the basic tasks of query
Author: Kaleb B. Woldearegay
Date: 18.Apr.2009

An invoker class would implement the 'command' pattern over 
the database applicaion
the invoker would be called by any client who needs a service 
from database either update or non-update

	class QueryInvoker{
		private $query_obj; /*any query object inheriting 
from Query class */
		public function __construct($query_obj){

		public function setQuery($query_obj){
		/*the invoker would accept object [ which could be 
either update query object or non update query object ] which it 
has no any idea, and would invoke its  execute method */
		public function execute($query_obj,$sql){
			return $query_obj->executeQuery($sql);

An example showing the interaction would be:

/*this example assumes you would put all your classes in the 
folder named classes - which is a practice of course.
	$obj_invoker=new QueryInvoker();
	$objUpdate=new ResultQuery($objDb);
	$sql="select * from tbl";
	$result = $obj_invoker->execute($objUpdate,$sql);
        while($row = $result->getRow()){do stuff}

You can get Mysql class in the singleton pattern part of my article.

How to change password in ubuntu

Here is how you would change password in ubuntu

1. Go to preferences->about me
2. On the right top corner of the form you would see the Change Password..
3. Follow the wizard.

Free FTP tool on Ubuntu

Do you want to upload files to your web server and are you on Ubuntu OS? If yes then you might want to have one cute FTP tool for free. That is named FILEZILLA
Just do this>
1. Go to Applications->Accessories->Terminal
2. sudo apt-get install filezilla
YUP! you are done.
Now go to Applicatoins->internet->Filezilla
Enter your host, username and password then uploading/downloading would be yours.

Singleton in PHP

One of the commonly utilized part in programming is database access. Accessing a database in PHP is by far tied with his beloved one: MySQL.

While connecting and working with database, we have to limit the number of connections to database. Especially in a single database environment, the program shall utilize one object efficiently for all of its actions. Resource management and efficiency would be increased in doing so.

I have tried to apply the singleton pattern on the database class and share it here.
I have an interface with the following signature:

/* An interface for database.  
Author: http://gullele.com
Open for any modification and usage
Date: 18.Apr.2009
	interface IDatabase{
		/* method for connection */
		public function connect();
		/* method for opening the database */
		public function open();
		/* method for closing */
		public function close();
		/* method for query that returns result - common for other kind of databases like SQL Server */
		public function executeQuery($query);
		/* method for query that does not return result */	
		public function executeNonQuery($query);
		public static function getInstance(); /*function to return a static instance of a class*/

This interface would assure all the implementers would have the same functions all over.
If we have this, later, if we change the database – those methods who have been using the database class would remain unaffected.

Here is the mysql database which implements the interface and the logic of singleton pattern is applied.

Author: http://gullele.com
Open for modification and any use - please let me know when you use/modify it as I might learn from your modification. 
Date: 18.Apr.2009
class Mysql implements IDatabase{
		private $host; 
		private $username;
		private $password;
		private $db_name;
                private $connection_error;
		private static $instance = null; /*an instance of the class*/
		/* Connection object to be assigned for the database selected */
		private $connection; 
		/* Make the constructor private or protected to prevent the object from being instantiated directly - this is how to make it singleton pattern being applied*/
		private function __construct(){
			$this->host = 'localhost';		
			$this->username = 'root';
			$this->password = 'root';
			$this->db_name = 'intramicro';
		/* Connecting to the database it also opens the database */
		public function connect(){

        		if (!$this->connection = @mysql_connect($this->host,

                            $this->username,$this->password)) {
	    			echo "Connection error";

            			trigger_error('Error Connection to database');


        		/* Assing to the database for initial use - can be changed later if needed */

        		} else if ( !@mysql_select_db($this->db_name,$this->connection) ) {

            		trigger_error('Database selection error');


		/* Implementation is not needed for this method as mysql would open the database when it connects to it */
		public function open(){
		/* Closing the database - used for non-persistent connection*/
		public function close(){
		/* A method to accept query object, execute it and return resource object */
		public function executeQuery($query){
			if (!$query_resource=mysql_query($query,$this->connection))

            			trigger_error ('Query failed: '.mysql_error($this->connection).' SQL: '.$query);	
			return $query_resource;
		/* Non query method is not needed in the MySQL database as it can be done with my_sql()*/
		public function executeNonQuery($query){}
		public static function getInstance(){
				self::$instance=new self();
			return self::$instance;

It is necessary to make the constructor of the implementing class private or protected to inhibit the direct instantiation of the object from the clients.
The clients shall know enjoying the object of MySQL class would only through the static getInstance() method of the class.

Here is an example

require(‘…MySQL.Database.php’); //include the file here
$objDb=Mysql::getInstance(); //get instance here
Once it is instantiated, a single object would serve for many clients.
You may want to check the security, error handling and some additional things by your own.
Cool.. Continue reading Singleton in PHP

Table read only – update error in mysql

When you move a database from other server and tried to update it, it might generate an error saying: Table tbl is read only
The very likely case for this is mysql is not able to access the tables due to ownership.
Here is a workaround for it:
1. Go to Terminal – Application->Accessories->Terminal
2. Change the the ownership to mysql using this command
sudo chown mysql:mysql -R /var/lib/mysql/your_db_name
This command will change the owner (chown) of the db to mysql