PHP: How to retrieve data from database & format as XML

Retrieving Data

This tutorial will show you how to connect to a MySQL database, retrieve some data and finally how to format and display that data in XML format. The code will be written in OOP format, which in this case means creating a number of re-usable classes.

An outline of the steps:

See demo:

XML Demo

Step 1: Connecting to the database.

As mentioned previously, the code is going to be written in an object oriented fashion. Let us begin with the connection class. To establish the connection the class will use PDO, you can read more about PDO and the following class using the link below:

http://weebtutorials.com/2012/03/pdo-connection-class-using-singleton-pattern/

Moving on, Create a new file called ‘db_conn.class.php’ and add the following code.

<?php

//db connection class using singleton pattern
class dbConn{

//variable to hold connection object.
protected static $db;

//private construct - class cannot be instantiated externally.
private function __construct() {

try {
// assign PDO object to db variable
self::$db = new PDO( 'mysql:host=localhost;dbname=DBNAME', 'USERNAME', 'PASSWORD' );
setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
}
catch (PDOException $e) {
//Output error - would normally log this to error file rather than output to user.
echo "Connection Error: " . $e->getMessage();
}

}

// get connection function. Static method - accessible without instantiation
public static function getConnection() {

//Guarantees single instance, if no connection object exists then create one.
if (!self::$db) {
//new connection object.
new dbConn();
}

//return connection.
return self::$db;
}

}//end class

?>

First of all, the class is using the singleton pattern. If you don’t know what this is you can find out more using the link provided previously. Just for clarity though, the pattern is used when global access is desirable and only one instance of the class is required. You will notice that the ‘__construct’ method is set to private. This prevents the class from be instantiated externally.

The ‘getConnection’ method is set to ‘public static’ which means it is accessible externally, and can be called without ever instantiating the class. The method checks to see if a database connection object exists, if not it creates one and then returns it.

Using this class it is possible to connect to the database, you can do so by using the following code:

$conn = dbConn::getConnection();

Step 2: Create class to query database.

With the database connection class complete, let us move on to the database query class. The class below is an abstract class and is used to provide a base set of methods & properties for any children which extend it.

Although using an abstract class isn’t actually necessary in this scenario, it makes it possible to easily extend the functionality at a later date if needs be. For example, you could easily create another child class, lets say ‘getRecordSet’ which could then be used to return data in the usual format, rather than XML.

As a final note, abstract classes cannot be instantiated – so you will not be using this class directly. Instead you will create a further class which extends it.

Take a look at the code below, then see the explanation beneath it for further clarification. First of all though, create a new document called ‘getRecordSet.class’ and add in the code.

//include db connection class
require_once( 'db_conn.class.php' );

// abstract class used as base class to store functionality/data required by children.
abstract class get_RecordSet {

//properties.
protected $db;
protected $stmt;

//constructor
function __construct()
{
//store db connection in class property.
$this->db = dbConn::getConnection();
}

//standard function to retrieve database info using PDO.
public function getRecordSet ($sql)
{
$this->stmt = $this->db->query($sql);
return $this->stmt;
}

}

So, first of all the connection class is ‘imported’ using the ‘require_once’ function. The class is now available for use. The class is then declared with the abstract access modifier (cannot be used directly, must inherit from the class first).

Inside the class we declare two properties, with the protected access modifier. This means the properties can only be used INSIDE the class, or inside child classes. The ‘db’ property will hold the database connection object, the ‘stmt’ property will hold the SQL statement.

Inside the constructor the connection class is used to establish a database connection, and finally is a function used to query the database and return the result.

Step 3: Create a child class to format sql query results as XML.

The following class is a child of the previous class and is used to set the xml headers, format the sql results and finally to display them. The comments explain the process fairly well, but it seems necessary to a least give an overview first.

The class has a method named ‘getRecordSet’, the same as its parent. Inside this method,  the necessary headers are set for XML, the ‘getRecordSet’ method of the parent is called (runs query and returns data) and a new variable is created to store the results.

At this point the function loops through the data set, storing the data into structured XML nodes. XML nodes work in a similar way to HTML elements, they have an opening tag, a closing tag and can also have attributes, the only difference being you can name them as you wish.

In this example, by using an associative array (‘fetch(PDO::FETCH_ASSOC)’), the name of the database column will be saved to the array key. This key is then used to name the XML nodes, so our XML nodes will be named the same as the database columns. Take a look at the demo to get an idea of how this looks.

Quick note: You will notice that the ‘getRecordSet’ method accepts another parameter, this is the name used for the custom XML elements

//class to return record set in xml format
class XMLRecordSet extends get_RecordSet {

//overiding base class. Two parameters, first is sql statement, second is option and is
//the name to be used for xml.
public function getRecordSet($sql, $elementName = 'element')
{

//Set headers to XML.
header("Content-Type: text/xml");

try {
//execute parent function to run query & retrieve data.
$stmt = parent::getRecordSet($sql);

//var to store values
$returnValue = "";
//xml header info
$returnValue .= "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n";
//xml parent node, or wrapper to be named according to 'element' parameter
$returnValue .= "<{$elementName}s>\n";
// fetch each record as an associative array
while ($book = $stmt->fetch(PDO::FETCH_ASSOC)) {
//child node element name
$returnValue .= "\t<$elementName>\n";
// iterate through each field in the associative array,
foreach ($book as $key => $value) {
// Store values as xml elements, using key as element name.
$returnValue .= "\t\t<$key>" . htmlspecialchars($value) ."</$key>\n";
}
//close each single element.
$returnValue .= "\t</$elementName>\n";
}
//close xml wrapper element.
$returnValue .= "</{$elementName}s>\n";

//return data in xml format.
return $returnValue;

}
catch (PDOException $e) {
//catch and display error
echo "Connection Error: " . $e->getMessage();
}
}
}

The post PHP: How to retrieve data from database & format as XML appeared first on Weebtutorials.