ZenTut

PDO Inserting Data into Tables

Zentut Founder — Mon, 06 May 2013 04:24:55 +0000

Summary: in this tutorial, we will show you how to insert data into database table using PDO API.

The following are steps of how to insert data into a table using PDO:

Create a connection to the database by create a new PDO object.
Use a SQL INSERT statement to insert the data into the table.
Call the exec() method of the PDO object to execute the INSERT statement. The exec() method returns the number of rows that were affected on success or return false on failure.

PDO Inserting data into a table example

We will insert a new department into the departments table of the empdb sample database.

First, we create a form for creating a new department. The form consists of one text field that accepts department name and a submit button.

Second, when we enter a department name and click the Create Department button, the we need to:

Validate the input by using the filter_var() function. Check it out the PHP HTML form tutorial to learn how to use the filter_var() function to validate form’s data.
Check the input department name to see if it already exists by querying data from the departments table. If the department already exists, we display an error message. Otherwise we insert the new department and display a success message.

To insert a new department into the departments table, we construct an INSERT statement and call the exec() method of the PDO object.

PDO Inserting data into table script

We put the following code at the beginning of the script file:

getMessage();
	}
}
else{
	// display insert form
	display_form();
}

If the form is not submitted, we display it. If it is submitted, we perform the logic as described above. The following are the functions for the each step:

Validate department function:

/**
 * validate department
 * @return department name on success or false on failure
 */
function validate_dept(){
	global $msg;

	$dept_name = $_POST['department'];

	if($dept_name != ''){
		$dept_name = filter_var($dept_name,FILTER_SANITIZE_STRING);
		return $dept_name;
	}else{
		$msg =  'Please enter the department name';
		return false;
	}
}

Check department exists function:

/**
 * Check if a department exists
 * @param string $dept_name department name
 * @return NULL|boolean return true if department exists, false
 *         if it does not exist, and NULL on failure
 */
function dept_exist($dept_name){
	global $msg, $dbh;

	$sql_select = "SELECT department_no
		       FROM departments
		       WHERE name = " . $dbh->quote($dept_name) . "
		       LIMIT 1";

	$stmt = $dbh->query($sql_select);

	if($stmt === false){
		$msg = 'Error querying departments table';
		return NULL;
	}

	$r = $stmt->fetch(PDO::FETCH_ASSOC);

	if($r !== false){
		$msg = "Department with name $dept_name already exists.";
		return true;
	}else
		return false;

}

Insert a new department function:

/**
 * insert a new department table
 * @param string $dept_name department name
 * @return boolean return true on success or false on failure
 */
function insert_dept($dept_name){
	global $dbh, $msg;
	// construct SQL insert statement
	$sql_insert = "INSERT INTO departments(name)
				   VALUES(" . $dbh->quote($dept_name) .")";

	if($dbh->exec($sql_insert) === false){
		$msg = 'Error inserting the department.';
		return false;
	}else{
		$msg = "The new department $dept_name is created";
		return true;
	}
}

Create new department function that includes the logic of validating, checking for existence and inserting :

/**
 * insert new department
 * @param string $msg message 
 * @return boolean return true on success, false on failure
 */
function create_dept(){
	// validate department
	$dept_name = validate_dept();

	if($dept_name){
		// check if the department exists
		if(!dept_exist($dept_name)){
			// insert the department
			return insert_dept($dept_name);
		}		
	}
	return false;
}

Display error or success message function:

/**
 * display message based on message type
 * @param string $msg message to display
 * @param boolean $type true: success message, 
 * 			false: failed message
  */
function display_msg($msg,$type){
	 $type === true ? $cssClass = "alert-success" :
	 		  $cssClass = "alert-error";
	 if($msg != ''){
	 	?>
	 		
				
			
	 	Display form function:
/**
 * display the create new department form
 */
function display_form(){
	global $msg, $result;
	?>



Create Department



	
	
		

		
			Department:
			
				
			
		
		
			
				
			
				

	
	


	Testing the form:
Insert Sales Department
Failed to insert Sales department because it already exists
Insert Legal Department
Legal department created successfully
In this tutorial, we have shown you step by step how to insert data into a database table using PHP PDO.
The post PDO Inserting Data into Tables appeared first on ZenTut.

PL/SQL GOTO

Zentut Founder — Fri, 03 May 2013 07:06:37 +0000

Summary: in this tutorial, you will learn how to use PL/SQL GOTO statement to jump unconditionally to another executable statement in a same PL/SQL block.

Introduction to PL/SQL GOTO statement

PL/SQL GOTO statement allows you to jump to a specific executable statement in the same execution section of a PL/SQL block.

The syntax of the PL/SQL GOTO statement is as follows:

GOTO label_name

Where label_name is a label that defines the target statement. In program, you define a label as follows:

<>

The label name is enclosed in double angle brackets ( <<>>).

PL/SQL GOTO restrictions

There are some restrictions of using the PL/SQL GOTO statement that you should be aware of before using it.

First, the PL/SQL GOTO statement cannot jump to an IF statement, CASE statement, LOOP statement, or child-block.

The only way to branch into an IF statement is through its condition check. This is also applied for the CASE statement. In the following example, the GOTO statement tries to jump to inside an IF statement, which is not allowed. As a result, PL/SQL issues an error message.

BEGIN 
    GOTO goto_inside_if;
    IF v_status = 'COMPLETED'.
      <>
      ...
    ENDIF.
END;

The GOTO statement cannot branch to middle of a loop:

BEGIN
  GOTO goto_inside_loop;
  FOR n_day IN 1 .. 7
  LOOP
     <>
     ...
  END LOOP; 
END;

The only way to enter the child-block is through its BEGIN statement. The following example does not comply with this rule, hence causes an error.

BEGIN
  GOTO inside_child_block;
  ...
  BEGIN
    ...
    <>
    ...
  END;
END;

Second, you cannot use a GOTO statement to branch from an exception handling section back into the current block. The following example does not comply with this rule, hence it causes an error.

BEGIN
  --...
  <>
  --...
  EXCEPTION.
    --...
    WHEN SOMETHING_WRONG_HAPPENED.
        GOTO back_to_exec;
    --...
END;

Third, you cannot use a GOTO statement to jump out of a subprogram. To end a subprogram, you jump to the end of subprogram using the GOTO statement or use a RETURN statement instead.

Fourth, you cannot use a GOTO statement to branch from one IF clause to another, or from one WHEN clause of a CASE statement to another.

Fifth, there must be at least one executable statement appears after the target label. If you just want to branch to a target label without doing anything, you use a NULL statement.

PL/SQL GOTO examples

The following example demonstrates how to use PL/SQL GOTO statement:

SET SERVEROUTPUT ON SIZE 1000000;
BEGIN 
  GOTO label_1;
  DBMS_OUTPUT.PUT_LINE('Right after the GOTO statement');
  <>
  DBMS_OUTPUT.PUT_LINE('It is here!');
END;
/

The output of the script is:

It is here!

When PL/SQL reaches the GOTO statement, it skips everything and immediately jumps to the target label i.e. label_1 and it displays the message It is here

The PL/SQL GOTO statement has a bad reputation because it makes the code hard to understand and difficult to debug. In general, the PL/SQL GOTO statement should be avoided and replaced by other statements such as IF or CASE statement.

However, there are some cases that using the GOTO statement can make the program more efficient. See the following example:

BEGIN
   IF ... THEN
         FOR rec_emp IN cur_emp LOOP
            -- By pass all using GOTO
            GOTO <>
         END LOOP;
         -- a lot of code here
   END IF;
   -- target label
   <> 
   NULL;
END;

In the above example, instead of going through a lot of code after the first FOR loop statement, we used the GOTO statement to jump to the end of the block that make the code very efficient.

In this tutorial, you have learned how to use the PL/SQL GOTO statement to branch unconditionally to a target label in the same block.

The post PL/SQL GOTO appeared first on ZenTut.

What is PL/SQL

Zentut Founder — Thu, 02 May 2013 07:38:29 +0000

Summary: in this tutorial, we introduce you to PL/SQL language. We will discuss about PL/SQL history, the language elements and the advantages that PL/SQL brings to the Oracle development.

PL/SQL is a Procedural Language (PL) that extends the Structured Query Language (SQL). If you have been programming Pascal or Ada, you will find much familiar syntax in PL/SQL.

It is difficult to write applications using SQL only because each SQL statement runs independently and has little or no effect on each other. To overcome this limitation, you often have to use other programming languages such as C/C++, Perl, PHP, Java, etc., by using standard database interfaces. Oracle supports this approach when you want to develop applications that interact with Oracle databases.

In addition, Oracle also encourages you to use PL/SQL to work with Oracle databases because PL/SQL brings many advantages.

PL/SQL history

Oracle introduced PL/SQL (version 1.0) in its Oracle Database product version 6.0 as the scripting language in SQL*Plus and programming language in SQL*Forms 3.

Since version 7, Oracle did a major upgrade for PL/SQL (version 2.0) that provides more features such as procedures, functions, packages, records, collections, and some package extensions.

Since then many features have been added to PL/SQL such as XML support, preprocessor, file I/O, object-orientation, new statements such as CONTINUE, GOTO, etc. to make it one of the most highly structure programming languages .

PL/SQL Advantages

PL/SQL is a highly structured language

PL/SQL provides a very expressive syntax that makes it easy for anyone who wants to learn PL/SQL. If you are programming in other languages, you can get familiar with PL/SQL very quickly and understand the intent of the code without difficulty.

PL/SQL language features include the following elements:

Variables
Block structure, nested block structure
Conditional and sequential statements: IF, CASE, GOTO, CONTINUE and NULL
Loop statements: WHILE loop, FOR loop
Exception and error handling
Data types: string, numbers, date & timestamp, boolean and LOB
Record
Collection
Cursor
Procedures, functions, packages
Object-orientation features
Dynamic SQL and dynamic PL/SQL

PL/SQL is a portable and standard language for Oracle development

Once you develop a PL/SQL program in an Oracle Database, you can move it to the other Oracle Databases without changes, with the assumption that the versions of Oracle database are compatible.

PL/SQL is an embedded language

PL/SQL programs such as functions and procedures are stored in Oracle database in compiled form. This allows applications or users to share the same functionality stored in Oracle database.

PL/SQL also allows you to define triggers that can be invoked automatically to response to particular events in associated tables.

PL/SQL is a high-performance language inside Oracle Databases

Oracle adds many enhancements to the PL/SQL to make it more efficient to interact with Oracle databases.

The post What is PL/SQL appeared first on ZenTut.

PL/SQL Setting Up a Development Environment

Zentut Founder — Thu, 02 May 2013 04:56:18 +0000

Summary: in this tutorial, we will show you step by step how to download and install Oracle Database for learning and practicing PL/SQL programming in your system.

Download and install Oracle Database

First, you need go to the Oracle office website and download the Oracle Database. We are going to download Oracle Database 11g Release 2 on Microsoft Windows (x64).

Second, unzip the downloaded files into a folder e.g., C:\setup\Oracle as follows:

Third, double click the setup.exe file to start installing Oracle database. You need to follows the steps as described in the following section:

Step 1.

In this step, you can provide your email to get the updated information on security issues from Oracle.

Step 2.

There are three options in this step as shown in the screenshot. Choose the first one to create and configure database and click Next button.

Step 3.

If you are installing Oracle database in your laptop or desktop, choose the first option, otherwise choose the second one and click the Next button.

Step 4.

This step allows you to enter full database installation folders. You can change the Oracle base folder e.g., c:\app\zentut, other folders be changed accordingly. After that click Next button to go to the next step.

Step 5.

In this step, Oracle will perform prerequisite checks before installing Oracle database component.

Step 6.

This steps shows you summary information of the previous steps. Click the finish button to start installing Oracle database.

Step 7.

This step copies the files to the corresponding folder and install the Oracle components and services. It takes few minutes to finish so please be patient.

After complete, the installer displays a database Configuration Assistant dialog, click on the Password Management… button to setup the passwords for different users.

We need to unlock the SYS, SYSTEM and HR users and set the their corresponding passwords.

Step 8.

Once the installation process is done, you can click the button to close the installer.

Verify the installation

If everything is fine, you will see the Oracle folder as follows:

First, launch the SQL Plus that is a command line interface tool which you can use to interact with Oracle databases.

Second, enter user name and password that you have set in the installation process. we enter HR user and its corresponding password.

Third, enter the following statement:

SELECT * FROM dual;

If you see the output as shown in the following screenshot, it means you have installed Oracle database successfully and start learning PL/SQL programming.

In this tutorial, we have shown you step by step how to install Oracle database and verify the installation using SQL Plus. We hope that you got everything right at the first time. If this is not the case, please review each step one more time and make the appropriate correction if necessary.

The post PL/SQL Setting Up a Development Environment appeared first on ZenTut.

PDO Querying Data

Zentut Founder — Fri, 26 Apr 2013 09:18:24 +0000

Summary: in this tutorial, you will learn how to query data from tables using PDOStatement object with different fetch modes.

In order to query data from database table, you have to perform the following steps:

Create a connection to the database by initiating an instance of the PDO class.
Pass a SQL statement to the query() method of the PDO object. This query() method returns a PDOStatement object that allows you to traverse the returned result set. If an error occurred during executing the SQL statement, the query() method return false.

For example, if you want to query all data from the departments table in the employees database ( empdb), you can use the following script:

query($sql_get_depts);

	if($stmt === false){
		die("Error executing the query: $sql_get_depts");
	}

}catch (PDOException $e){
	echo $e->getMessage();
}
?>



Departments



	Departments
	fetch(PDO::FETCH_ASSOC)) : ?>
			
		
			
				No.
				Name

How it works.

First, we included the dbconfig.php file, which is a database configuration file that contains database parameters including host, database name, username and password. These parameters are used to create a connection to the employees database.
Second, we created a connection to the employees database by initiating an instance of the PDO class.
Third, we called the query() method of the PDO object and passed the SELECT statement that gets all data from the departments table.
Fourth, in the body of the HTML document, we called the fetch() method of the PDOStatement object with the FETCH_ASSOC fetch mode and displayed the column’s value of each record.

The following is the output of the script:

When we use PDO::FETCH_ASSOC fetch mode, the PDOStatement returns an array indexed by column name.

PDO provides several fetch modes. We will discuss the most commonly used ones in this section.

If you don’t pass a fetch mode to the fetch() method, it will use a default fetch mode which is PDO::FETCH_BOTH that instructs the fetch() method to returns an array indexed by both column name and integer index. For example, if you use PDO::FETCH_BOTH fetch mode, you can access the department column by using not only:

$row['department_no']

but also

$row[0]

The PDO::FETCH_NUM allows the fetch() method to return an array indexed by integer index. Therefore the FETCH_BOTH mode is the combination of FETCH_ASSOC and FETCH_NUM modes.

You can set fetch mode before calling the fetch() method by calling the setFetchMode() method of the PDOStatement object.

See the following example:

$stmt->setFetchMode(PDO::FETCH_BOTH);
while($r = $stmt->fetch()){
   //..
}

The PDO::FETCH_COLUMN instructs PDO to return a specified column of every row. In this case, the fetch() method return a scalar value:

// only get the department name column
$stmt->setFetchMode(PDO::FETCH_COLUMN,1);
// $r is a string 
while($r = $stmt->fetch()){
	echo $r . '
';
}

The PDO statement allows you to query multiple times however before querying a new result set you have to call the closeCursor() method. The following example shows the department with number 1 and employees who belong to department 1.

query($sql_get_depts);

	if($stmt === false){
		die("Error executing the query: $sql_get_depts");
	}

}catch (PDOException $e){
	echo $e->getMessage();
}
?>



Departments



	Departments
	fetch(PDO::FETCH_ASSOC)) : ?>
			
		
			
				No.
				Name
			
		
		
			
				
				
			
			
		
	

	closeCursor();
		// get employees of department no 1
		$sql_get_emps_by_dept = "SELECT * FROM employees
					 WHERE department_no = 1
 					 ORDER BY last_name";
		$stmt = $dbh->query($sql_get_emps_by_dept);

		if($stmt === false){
			die("Error executing the query: $sql_get_emps_by_dept");
		}
	?>
	Employees
	fetch(PDO::FETCH_ASSOC)) : ?>
			
		
			
				No.
				First Name
				Last Name
				Gender
				Birth Date
				Hire Date

The following is the output of the script:

In this tutorial, we have shown you how to query data from the database tables using the PDOStatement object with different fetch modes.

The post PDO Querying Data appeared first on ZenTut.

PDO Creating New Tables

Zentut Founder — Thu, 25 Apr 2013 12:47:41 +0000

Summary: in this tutorial, we will introduce you to employees data model that we will use through our PDO tutorial series and show you how to create new tables using PDO API.

Introducing the Employees data model

We are going to use the employees database through our PDO tutorial series. The following database diagram illustrates the employees data model:

There are two tables in the Employees database:

departments: stores the department data including department number and department name. Each department has one or more employees.
employees: stores employees data including employee number, first name, last name, birth date, gender, hire date and department which the employee belongs to.

Notice that we make the employees data model as simple as possible for the demonstration purpose only. We will use MySQL as the database management system for the PDO tutorial series.

If you don’t know anything about SQL or you want to refresh you SQL knowledge, you can check it out the SQL tutorial section in our website.

To create a new table in a database you use the CREATE TABLE statement. The following SQL statement creates the departments table:

CREATE TABLE departments (
  department_no int(11) NOT NULL AUTO_INCREMENT,
  name varchar(255) DEFAULT NULL,
  PRIMARY KEY (department_no)
) ENGINE=InnoDB;

And to create the employees table, you use the following SQL statement:

CREATE TABLE employees (
  employee_no int(11) NOT NULL AUTO_INCREMENT,
  first_name varchar(40) NOT NULL,
  last_name varchar(40) NOT NULL,
  birth_date date NOT NULL,
  gender varchar(1) NOT NULL,
  hire_date date DEFAULT NULL,
  department_no int(11) DEFAULT NULL,
  PRIMARY KEY (employee_no),
  KEY emp_dept (department_no),
  CONSTRAINT emp_dept FOREIGN KEY (department_no) 
  REFERENCES departments (department_no)
) ENGINE=InnoDB;

We execute these SQL statements to create departments and employees tables via MySQL command line tool or GUI tool like MySQL Workbench. However, we will use PDO API to create tables from the PHP script.

Using PDO to create new tables

First, we need to create a new database in MySQL named empdb to store the employee data using the CREATE DATABASE statement as follows:

CREATE DATABASE empdb;

Second, we need to create a new database configuration file dbconfig.php to store the database parameters including hosts, database name, username and password as follows:

Third, we develop a script file that creates new tables in the   empdb database. We will include the dbconfig.php in this script file to access the database configurations.
exec($sql_create_dept_tbl);

	if($r !== false){

		$r = $dbh->exec($sql_create_emp_tbl);

		if($r !== false){
			$msg =  "Tables are created successfully!
";
		}else{
			$msg =  "Error creating the employees table.
";
		}

	}else{
		$msg =  "Error creating the departments table.
";
	}

	// display the message
	if($msg != '')
		echo $msg;

}catch (PDOException $e){
	echo $e->getMessage();
}
How it works.
First, we created a connection to the MySQL database by instantiating an instance of the PDO class and passing the $dsn argument to its constructor.
Second, we specify the SQL statements that creates the departments and employees tables and put them into string variables:   $sql_create_dept_tbl and  $sql_create_emp_tbl
 
Third, we call the exec() method of the PDO class to execute the SQL statements in sequence. The exec() method returns the number of affected rows, including 0, on success and false on failure, therefore we had to use the !== operator to compare its returned value with false.
After executing the script file, you can check the database to see if the departments and employees tables were created.
In this tutorial, you have learned about the employees data model and how to create new tables in the employees database using PDO API.
The post PDO Creating New Tables appeared first on ZenTut.

PDO Connecting to PostgreSQL

Zentut Founder — Thu, 25 Apr 2013 10:20:15 +0000

Summary: this tutorial shows you how to connect to a PostgreSQL database server using PHP PDO.

Prerequisites

Before connecting to the PostgreSQL database server using PHP PDO, you need to have:

A PostgreSQL database server, a sample database and account with username and password that can access the database.
PHP PDO PostgreSQL driver enabled in your web server.

For example, we have a local PostgreSQL database server that has pagila sample database and an account with postgres username and postgres password which can access the pagila database. We can create a new database configuration file named dbconfig.php and put these database parameters into the file as shown below:

Later on, we will use the dbconfig.php configuration file in other script files that need to access this configuration parameters by using the require_once() function.

To check if the PDO PostgreSQL driver is enabled, you open the php.ini file and check if the following line is un-commented. If it is not, you can remove the semicolon ( ;) in front of the entry.

extension=php_pdo_pgsql.dll

PostgreSQL data source name

The data source name or DSN conveys the database parameters that allow you to connect to a database system. PDO defines different DSN for different database system. The data source name of the PostgreSQL is composed of the following parameters:

DNS prefix: pgsql:
host: the database server’s host name where the PostgreSQL database locates.
port: the port which PostgreSQL database is running, the default port is 5432.
dbname: database name.
user: The name of user that connects to the database dbname. You can specify the user name in either DSN or in constructor of the PDO class.
password: The password of the user name. You can specify the password in either the DSN or the PDO constructor.

Notice that PDO ignores the username and password in the PDO constructor if you put them in the data source name (DSN). The following is the DSN that allows us to connect to pagila database in the local PostgreSQL database server.

pgsql:host=localhost;port=5432;dbname=pagila;user=postgres;password=postgres

Connecting to PostgreSQL

The following code illustrates how to connect to the pagila database in PostgreSQL database server:

$db database successfully!";
	}
}catch (PDOException $e){
	// report error message
	echo $e->getMessage();
}

How the script works.

To connect to a PostgreSQL database, you just need to create a new connection object, which is an instance of the PDO class. When you create a new connection object, you pass the DSN as an argument to its parameter.
The try catch statement is used to catch any exception that may occur during connecting to the PostgreSQL database. In the catch block, we display the error message if there is anything wrong with the connection.

If you have everything setup correctly, you will see the following message:

Connected to the pagila database successfully!

If you are using WAMP server, after enabling the POD PostgreSQL driver, it is still not working and you got the following error message:

could not find driver

You can put the following line:

LoadFile "c:/wamp/bin/php/php5.4.3/libpq.dll"

At the end of the httpd.conf file in the C:\wamp\bin\apache\apache2.2.22\conf folder.

In this tutorial, we have shown you step by step how to connect to the PostgreSQL database server using PHP PDO.

The post PDO Connecting to PostgreSQL appeared first on ZenTut.

PDO Connecting to MySQL

Zentut Founder — Thu, 25 Apr 2013 08:41:35 +0000

Summary: this tutorial shows you step by step how to connect to MySQL database using PHP PDO.

Prerequisites

Before creating a connection to a MySQL database server, you must have:

A MySQL database server installed in your local system or in a remote server.
A sample database in the MySQL database server.
A MySQL account with username and password that can access the sample database.

Suppose we have a local MySQL database server that contains the pdodemo sample database and an account with root username and blank password, we can put these parameters into a database configuration file named dbconfig.php as shown below:

We will include the dbconfig.php configuration file by using the require_once() function in other script files that need to access this configuration information. Check it out how to include a file in other files in the PHP include file tutorial.

To check whether the PDO MySQL driver is enabled, you need to open the php.ini file and uncomment the following line by removing the semicolon ( ;) at the front of the entry:

extension=php_pdo_mysql.dll

MySQL data source name

PDO uses a data source name (DSN), which contains the database server name, database name, and other parameters, that helps create a connection to a database server. Different database system requires different data source name. To connect to MySQL, you use the following data source name:

mysql:host=host_name;dbname=db_name

The MySQL data source name contains the host name and database name which you want to connect to. We can define the DSN for our sample database as follows:

$dsn = "mysql:host=$host;dbname=$db";

Connecting to MySQL

The following index.php script illustrates how to connect to the pdodemo database in MySQL database server with the root account:

$db database successfully!";
        }
}catch (PDOException $e){
	// report error message
	echo $e->getMessage();
}

How it works.

To connect to MySQL database server, you need to create a new connection object with the data source name, user name and password. The connection object is an instance of the PDO class.
If something went wrong while establishing a connection to the MySQL server, an error message will display. The try catch block is used to catch any exceptions that occurs during creating the database connection.

If you have everything setup correctly, you will see the following message:

Connected to the pdodemo database successfully!

There are some common issues when you connect to the MySQL database as indicated below:

If the MySQL driver is not enabled in the php.ini file, you will get the error message:

could not find driver

If you provide incorrect database account, you get the following error message:

SQLSTATE[HY000] [1045] Access denied for user ‘root’@'localhost’ (using password: YES)

If you provide an invalid database name or the database name does not exist in the MySQL database server, you get the following error message:

SQLSTATE[HY000] [1049] Unknown database 'pdodemo'

If you provide an invalid database host name, the following error message will display:

SQLSTATE[HY000] [2002] php_network_getaddresses: getaddrinfo failed: No such host is known.

In this tutorial, you have learned how to connect to the MySQL database server using PHP PDO.

The post PDO Connecting to MySQL appeared first on ZenTut.

PHP PDO

Zentut Founder — Wed, 24 Apr 2013 02:23:19 +0000

PHP PDO tutorial introduces you to one of the most important PHP extensions called PHP Data Objects or PDO, which was available since PHP version 5.0.

PHP Data Objects or PDO is a PHP5 extension that provides a lightweight relational database management system (RDMBS) connection abstract library. PDO provides a unified interface for working with various RDBMS including creating database connection, performing queries, handling error, etc.

PDO relies on database specific drivers e.g., PDO_MYSQL for MySQL, PDO_PGSQL for PostgreSQL, PDO_OCI for Oracle, etc., to function properly so to use PDO for a specific database, you need to have the corresponding database driver available.

There are several libraries that provide the same functionality as PDO such as PEAR DB package and ADOdb library. However, those libraries were written in PHP, while PDO was developed in C/C++ that makes it perform faster.

In addition, PDO does not require you to include script files in your application like other libraries, which helps distribute and install the application easier and faster.

PDO Quick Start

This section shows you step by step how to connect to some relational database management systems including MySQL, PostgreSQL and Oracle.

Connecting to MySQL – guides you step-by-step how to connect to MySQL database using PDO.
Connecting to PostgreSQL – shows you how to connect to PostgreSQL database using PDO.
Connecting to Oracle – connects to Oracle database using PDO.

PDO Basic Operations

This section illustrates some common operations that you often work with databases including:

Creating new tables – shows you how to use PDO API to create tables for the employees sample database.
Querying data with different fetch modes – guides you how to query data from database tables with different fetch modes.
Inserting data into tables – walks you through the steps of inserting data into database tables.
Updating data – shows you how to update data in the database tables using PDO API.
Deleting data – guides you how to delete data in the database table using PDO API.

PDO Prepared Statements

In this section, we’ll introduce you to prepared statement and show you the advantages of PDO prepared statements. We also show how to use the prepared statements to make your application more secure e.g., to avoid SQL injection.

Positional and named holders.
Prepared statements and bound values.
CRUD using prepared statements.
Working with BLOBs.

PDO & Stored Procedures

This section shows you some examples of dealing with stored procedures including:

Calling stored procedures.
Getting values returned from the stored procedures.

PDO Transaction

PDO gives you some handy methods including PDO::beginTransaction(), PDO::commit() and PDO::rollBack() that handles transactions effectively. This section gives you an example of handling transactions in your web application.

PDO handling transaction.

PDO Reference

http://www.php.net/manual/en/book.pdo.php – PHP Data Objects

The post PHP PDO appeared first on ZenTut.

C Binary Search Tree

Zentut Founder — Thu, 18 Apr 2013 11:39:17 +0000

Summary: this tutorial introduces you to binary search tree data structure and how to implement it in C.

Introduction to binary search tree

Binary Search Tree

A binary search tree or BST is a binary tree in symmetric order.

A binary search tree can:

Be empty
Have a key and not more than two other subtrees, which are called left subtree and right subtree.

A binary search tree is in symmetric order, it means:

Each node contains a key.
Each node’s key is smaller than all node’s keys in the right subtree and bigger than all node’s keys in the left subtree.

A binary search tree is also known as sorted or ordered binary tree.

Binary search tree operations

There are some common operations on the binary search tree:

Insert – inserts a new node into the tree
Delete – removes an existing node from the tree
Traverse – traverse the tree in pre-order, in-order and post-order. For the binary search tree, only in-order traversal makes sense
Search – search for a given node’s key in the tree

All binary search tree operations are O(H), where H is the depth of the tree. The minimum height of a binary search tree is H = log₂N, where N is the number of the tree’s nodes. Therefore the complexity of a binary search tree operation in the best case is O(logN); and in the worst case, its complexity is O(N).

The worst case happens when the binary search tree is unbalanced. Many algorithms have been invented to keep a binary search tree balanced such as height-balanced tree or AVL trees of Adelson-Velskii and Landis, B-trees, and Splay trees.

C binary search tree implementation

We can use a structure to model the binary search tree node a follows:

typedef struct node
{
    int data;
    struct node* left;
    struct node* right;
} node;

The node structure has three members:

data: stores node’s key, which is an integer. You can store a string, a pointer to a structure or (void*). For the sake of simplicity, we will use a binary search tree of integers.
left: points to the left subtree.
right: points to the right subtree.

To create a new node, we use the malloc() function to allocate memory dynamically as follows:

/*
    create a new node
*/
node* create_node(int data)
{
    node *new_node = (node*)malloc(sizeof(node));
    if(new_node == NULL)
    {
        fprintf (stderr, "Out of memory!!! (create_node)\n");
        exit(1);
    }
    new_node->data = data;
    new_node->left = NULL;
    new_node->right = NULL;
    return new_node;
}

To compare the data of two nodes, we can compare two integers. However to make it more extensible, we can pass a callback to any function that has comparison between two keys of nodes. The callback for comparing two nodes is defined as follows:

typedef int (*comparer)(int, int);

Later on you may change the type of data to string, float, or even void*, and change the comparer callback accordingly.

Insert a new node into the binary search tree

If the binary search tree is empty, we just create a new node, otherwise we start from the root node:

We find the proper position for the new node by comparing the new node’s key with the root node’s key. If the key of the new node less than the root node’s key, we go to the left subtree. If the key of the new node is greater than the root node’s key, we go to the right subtree. We do this step recursively until we find the correct position in the tree to insert the new node.

The following illustrates the insert_node function:

/*
    insert a new node into the BST
*/
node* insert_node(node *root, comparer compare, int data)
{

    if(root == NULL)
    {
        root = create_node(data);
    }
    else
    {
        int is_left  = 0;
        int r        = 0;
        node* cursor = root;
        node* prev   = NULL;

        while(cursor != NULL)
        {
            r = compare(data,cursor->data);
            prev = cursor;
            if(r < 0)
            {
                is_left = 1;
                cursor = cursor->left;
            }
            else if(r > 0)
            {
                is_left = 0;
                cursor = cursor->right;
            }

        }
        if(is_left)
            prev->left = create_node(data);
        else
            prev->right = create_node(data);

    }
    return root;
}

Delete a node from the binary search tree

Deleting an existing node in the binary search tree is little more complicated. There are three cases that we should consider:

Case 1. Delete a leaf node i.e., node that has no children. We just need to remove it. The following example illustrates how to remove the leaf node e.g., 13

C Binary Search Tree – Remove Leaf Node

Case 2. Remove a node that has 1 child node, we replace it with its child node and remove it e.g., to remove node 10 in the following picture.

C Binary Search Tree – Remove Node with 1 Child

Case 3. To remove a node that has two child nodes or two children, we find its in-order successor node, which is the next node in in-order traversal of the tree, and replace it with the in-order success node.

For example, to remove node 3, we find its in-order successor node, which is 4, and replace the node 3 by 4 as illustrated in the following picture.

Binary Search Tree – Remove Node with Two Children

The following is the delete node function that uses recursive function in C:

/*
    delete a node in the binary search tree
*/
node* delete_node(node* root, int data,comparer compare)
{
    if(root == NULL)
        return NULL;

    node *cursor;
    int r = compare(data,root->data);
    if( r < 0)
        root->left = delete_node( root->left, data,compare);
    else if( r > 0 )
        root->right = delete_node(root->right,data,compare);
    else
    {
        if (root->left == NULL)
        {
            cursor = root->right;
            free(root);
            root = cursor;
        }
        else if (root->right == NULL)
        {
            cursor = root->left;
            free(root);
            root = cursor;
        }
        else    //2 children
        {
            cursor = root->right;
            node *parent = NULL;

            while(cursor->left != NULL)
            {
                parent = cursor;
                cursor = cursor->left;
            }
            root->data = cursor->data;
            if (parent != NULL)
                parent->left = delete_node(parent->left, parent->left->data,compare);
            else
                root->right = delete_node(root->right, root->right->data,compare);
        }
    }
    return root;
}

Search for a specific key in the binary search tree

To search for a specific key in the binary search tree, we start from the root node. If the tree is empty, the key does not exist. Otherwise, if the root node’s key is equal to the key, the search is successful, we terminate the search. If the key is less than the root node’s key, we search the left subtree. Likewise, if the key is greater than the root node’s key, we search the right subtree. We repeat this step recursively until the key is found or subtree is NULL.

/*
    search for a specific key
*/
node* search(node *root,const int data,comparer compare)
{
    if(root == NULL)
        return NULL;

    int r;
    node* cursor = root;
    while(cursor != NULL)
    {
        r = compare(data,cursor->data);
        if(r < 0)
            cursor = cursor->left;
        else if(r > 0)
            cursor = cursor->right;
        else
            return cursor;
    }
    return cursor;

}

Traverse the binary search tree

We can traverse the binary search tree once it is created by traversing recursively to the left subtree of the root node, accessing the root node’s data, and then recursively traversing to the right subtree of the root node. This is called in-order traversal of a binary tree.

Because of the rules of the nodes’ keys in the binary search tree, this in-order traversal always creates a sorted list of nodes.

The following is the in-order traversal function of the binary search tree:

/*
    in order traversal the binary search tree
*/
void traverse(node *root,callback cb)
{
    node *cursor, *pre;

    if(root == NULL)
        return;

    cursor = root;

    while(cursor != NULL)
    {
        if(cursor->left != NULL)
        {
            cb(cursor);
            cursor = cursor->right;
        }
        else
        {
            pre = cursor->left;

            while(pre->right != NULL && pre->right != cursor)
                pre = pre->right;

            if (pre->right != NULL)
            {
                pre->right = cursor;
                cursor = cursor->left;
            }
            else
            {
                pre->right = NULL;
                cb(cursor);
                cursor = cursor->right;
            }
        }
    }
}

Notice that we pass a callback to the traverse function so that we can manipulate the node dynamically. The callback is defined as follows:

typedef void (*callback)(node*);

Remove all nodes

We must deallocate memory allocated for all the nodes in the binary search tree. We can create a function named dispose() to do this:

/*
    recursively remove all nodes of the tree
*/
void dispose(node* root)
{
    if(root != NULL)
    {
        dispose(root->left);
        dispose(root->right);
        free(root);
    }
}

C binary search tree program

Before creating a program to test our binary search tree, we need to create some functions for:

Comparing two integers:

/*
    compare two integers
*/
int compare(int left,int right)
{
    if(left > right)
        return 1;
    if(left < right)
        return -1;
    return 0;
}

Displaying a node:

/*
    display a node's key
*/
void display(node* nd)
{
    if(nd != NULL)
        printf("%d ",nd->data);
}

And a function for displaying the whole tree:

/*
    Recursively display tree or subtree
*/
void display_tree(node* nd)
{
    if (nd == NULL)
        return;
    /* display node data */
    printf("%d",nd->data);
    if(nd->left != NULL)
        printf("(L:%d)",nd->left->data);
    if(nd->right != NULL)
        printf("(R:%d)",nd->right->data);
    printf("\n");

    display_tree(nd->left);
    display_tree(nd->right);
}

Now it’s time to play with the binary search tree:

#include 
#include 

#include "bst.h"

#define SIZE 9

int main()
{
    node* root = NULL;
    comparer int_comp = compare;
    callback f = display;

    /* insert data into the tree */
    int a[SIZE] = {8,3,10,1,6,14,4,7,13};
    int i;
    printf("--- C Binary Search Tree ---- \n\n");
    printf("Insert: ");
    for(i = 0; i < SIZE; i++)
    {
        printf("%d ",a[i]);
        root = insert_node(root,int_comp,a[i]);
    }
    printf(" into the tree.\n\n");

    /* display the tree */
    display_tree(root);

    /* remove element */
    int r;
    do
    {
        printf("Enter data to remove, (-1 to exit):");
        scanf("%d",&r);
        if(r == -1)
            break;
        root = delete_node(root,r,int_comp);
        /* display the tree */
        if(root != NULL)
            display_tree(root);
        else
            break;
    }
    while(root != NULL);

    /* search for a node */
    int key = 0;
    node *s;
    while(key != -1)
    {
        printf("Enter data to search (-1 to exit):");
        scanf("%d",&key);

        s = search(root,key,int_comp);
        if(s != NULL)
        {
            printf("Found it %d",s->data);
            if(s->left != NULL)
                printf("(L: %d)",s->left->data);
            if(s->right != NULL)
                printf("(R: %d)",s->right->data);
            printf("\n");
        }
        else
        {
            printf("node %d not found\n",key);
        }
    }

    /* remove the whole tree */
    dispose(root);
    return 0;
}

The following is the output of the binary search tree program in C:

--- C Binary Search Tree ----

Insert: 8 3 10 1 6 14 4 7 13  into the tree.

8(L:3)(R:10)
3(L:1)(R:6)
1
6(L:4)(R:7)
4
7
10(R:14)
14(L:13)
13
Enter data to remove, (-1 to exit):13
8(L:3)(R:10)
3(L:1)(R:6)
1
6(L:4)(R:7)
4
7
10(R:14)
14
Enter data to remove, (-1 to exit):10
8(L:3)(R:14)
3(L:1)(R:6)
1
6(L:4)(R:7)
4
7
14
Enter data to remove, (-1 to exit):3
8(L:4)(R:14)
4(L:1)(R:6)
1
6(R:7)
7
14
Enter data to remove, (-1 to exit):-1
Enter data to search (-1 to exit):6
Found it 6(R: 7)
Enter data to search (-1 to exit):13
node 13 not found
Enter data to search (-1 to exit):-1
node -1 not found

In this tutorial, you have learned how to implement the binary search tree in C.

The post C Binary Search Tree appeared first on ZenTut.