Data Mapper
Available from Prado versions 3.1a onwards.
Data Mappers moves data between objects and a database while keeping them
independent of each other and the mapper itself. If you started with
Active Records, you may eventually
faced with more complex business
objects as your project progresses. When you build an object model with a
lot of business logic it's valuable to use these mechanisms to better organize
the data and the behavior that goes with it. Doing so leads to variant schemas;
that is, the object schema and the relational schema don't match up.
The Data Mapper separates the in-memory objects from the database. Its responsibility
is to transfer data between the two and also to isolate them from each other.
With Data Mapper the in-memory objects needn't know even that there's a database
present; they need no SQL interface code, and certainly no knowledge of the
database schema. (The database schema is always ignorant of the objects that use it.)
When to Use It
The primary occasion for using Data Mapper is when you want the database schema
and the object model to evolve independently. Data Mapper's primary benefit is
that when working on the business (or domain) objects you can ignore the database, both in
design and in the build and testing process. The domain objects have no idea
what the database structure is, because all the correspondence is done by the mappers.
This helps you in the code because you can understand and work with the domain objects
without having to understand how they're stored in the database. You can modify the
business models or the database without having to alter either. With complicated
mappings, particularly those involving existing databases, this is very valuable.
The price, of course, is the extra layer that you don't get with
Active Record,
so the test for using these patterns is the complexity of the business logic.
If you have fairly simple business logic, an Active Record
will probably work.
For more complicated logic a Data Mapper may be more suitable.
SqlMap Data Mapper
The SqlMap DataMapper framework makes it easier to use a database with a PHP application.
SqlMap DataMapper couples objects with stored procedures or SQL statements using
a XML descriptor. Simplicity is the biggest advantage of the SqlMap DataMapper over
object relational mapping tools. To use SqlMap DataMapper you rely on your own objects,
XML, and SQL. There is little to learn that you don't already know.
With SqlMap DataMapper you have the full power of both SQL and stored procedures at
your fingertip
Here's a high level description of the work flow illustrated in the figure above.
Provide a parameter, either as an object or a primitive type. The parameter can be
used to set runtime values in your SQL statement or stored procedure. If a runtime value
is not needed, the parameter can be omitted.
Execute the mapping by passing the parameter and the name you gave the statement or
procedure in your XML descriptor. This step is where the magic happens. The framework
will prepare the SQL statement or stored procedure, set any runtime values using your
parameter, execute the procedure or statement, and return the result.
In the case of an update, the number of rows affected is returned. In the case of a
query, a single object, or a collection of objects is returned. Like the parameter,
the result object, or collection of objects, can be a plain-old object or a primitive PHP type.
Setting up a database connection and initializing the SqlMap
A database connection for SqlMap can be set as follows.
See Establishing Database Connection for
futher details regarding creation of database connection in general.
//create a connection and give it to the SqlMap manager.
$dsn = 'pgsql:host=localhost;dbname=test'; //Postgres SQL
$conn = new TDbConnection($dsn, 'dbuser','dbpass');
$manager = new TSqlMapManager($conn);
$manager->configureXml('my-sqlmap.xml');
$sqlmap = $manager->getSqlMapGateway();
The TSqlMapManager is responsible for setting up the database connection
and configuring the SqlMap with given XML file(s). The configureXml()
method accepts a string that points to a SqlMap XML configuration file. Once
configured, call the getSqlMapGateway() method to obtain an instance
of the SqlMap gateway interface (use this object to insert/delete/find records).
SqlMap database connection can also be configured using a <module>
tag in the application.xml
or config.xml as follows.
<modules>
<module id="my-sqlmap" class="System.Data.SqlMap.TSqlMapConfig"
EnableCache="true" ConfigFile="my-sqlmap.xml" >
<database ConnectionString="pgsql:host=localhost;dbname=test"
Username="dbuser" Password="dbpass" />
</module>
</modules>
The ConfigFile attribute should point to a SqlMap configuration file
(to be detailed later) either using absolute path, relative path or the
Prado's namespace dot notation path (must omit the ".xml" extension).
Tip:
The
EnableCache attribute when set to "true" will cache the
parsed configuration. You must clear or disable the cache if you
make changes to your configuration file.
A
cache
module must also be defined for the cache to function.
To obtain the SqlMap gateway interface from the <module> configuration, simply
do, for example,
class MyPage extends TPage
{
public function onLoad($param)
{
parent::onLoad($param);
$sqlmap = $this->Application->Modules['my-sqlmap']->Client;
$sqlmap->queryForObject(...); //query for some object
}
}
A quick example
Let us
consider the following "users" table that contains two columns named "username" and "email",
where "username" is also the primary key.
CREATE TABLE users
(
username VARCHAR( 20 ) NOT NULL ,
email VARCHAR( 200 ) ,
PRIMARY KEY ( username )
);
Next we define our plain User class as follows. Notice that
the User is very simple.
class User
{
public $username;
public $email;
}
Next, we need to define a SqlMap XMl configuration file, lets name
the file as my-sqlmap.xml
<?xml version="1.0" encoding="utf-8" ?>
<sqlMapConfig>
<select id="SelectUsers" resultClass="User">
SELECT username, email FROM users
</select>
</sqlMapConfig>
The <select> tag returns defines an SQL statement. The id
attribute will be used as the identifier for the query. The resultClass
attribute value is the name of the class the the objects to be returned.
We can now query the objects as follows:
//assume that $sqlmap is an TSqlMapGateway instance
$userList = $sqlmap->queryForList("SelectUsers");
//Or just one, if that's all you need:
$user = $sqlmap->queryForObject("SelectUsers");
The above example shows demonstrates only a fraction of the capabilities
of the SqlMap Data Mapper. Further details can be found in the
SqlMap Manual.
Combining SqlMap with Active Records
The above example may seem trival and it also seems that there is
alot work just to retrieve some data. However, notice that the User
class is totally unware of been stored in the database, and the database is
unware of the User class.
One of advantages of SqlMap is the
ability to map complex object relationship, collections from an existing
database. On the other hand, Active Record
provide a very simple way
to interact with the underlying database but unable to do more complicated
relationship or collections. A good compromise is to use SqlMap to retrieve
complicated relationships and collections as Active Record objects and then using
these Active Records to do the updates, inserts and deletes.
Continuing with the previous example, we change the definition of the
User class to become an Active Record.
class UserRecord extends TActiveRecord
{
const TABLE='users'; //table name
public $username; //the column named "username" in the "users" table
public $email;
/**
* @return TActiveRecord active record finder instance
*/
public static function finder($className=__CLASS__)
{
return parent::finder($className);
}
}
We also need to change the definition of the SqlMap XML configuration. We
just need to change the value of resultClass attribute to UserRecord.
<?xml version="1.0" encoding="utf-8" ?>
<sqlMapConfig>
<select id="SelectUsers" resultClass="UserRecord">
SELECT username, email FROM users
</select>
</sqlMapConfig>
The PHP code for retrieving the users remains the same, but SqlMap
returns Active Records instead, and we can take advantage of the Active Record methods.
//assume that $sqlmap is an TSqlMapGateway instance
$user = $sqlmap->queryForObject("SelectUsers");
$user->email = 'test@example.com'; //change data
$user->save(); //save it using Active Record
References
- Fowler et. al. Patterns of Enterprise Application Architecture,
Addison Wesley, 2002.
- iBatis Team. iBatis Data Mapper,
http://ibatis.apache.org.