Symfony2 and Doctrine2 Integration

Symfony and Doctrine
What’s new in the Symfony and Doctrine Integration

Doctrine 2 www.doctrine-project.org www.sensiolabs.com

Updated DoctrineBundle
• Doctrine2 features fully integrated
– Database Abstraction Layer
– Object Relational Mapper


DoctrineMongoDBBundle
• MongoDB Object Document Mapper
– Transparent persistence to MongoDB
– Same architecture as ORM
– Map a class as an entity and document


DoctrineMigrationsBundle
• Integration with the database migrations
project.

• Easily manage and deploy different versions
of your database.

• Generate migrations when you change your
schema mapping information


DBAL
• To use just the DBAL you must conﬁgure it:

doctrine.dbal:
dbname: Symfony
user: root
password: ~


DBAL
• If you need to specify multiple connections
you can use the following syntax:
doctrine.dbal:
default_connection: default
connections:
default:
driver: PDOSqlite
dbname: Symfony
user: root
password: null
host: localhost
port: ~
path: %kernel.data_dir%/symfony.sqlite
event_manager_class: DoctrineCommonEventManager
configuration_class: DoctrineDBALConfiguration
wrapper_class: ~
options: []

DBAL Console Commands
• Create all configured databases
$ php console doctrine:database:create

• Create a specific database
$ php console doctrine:database:create --connection=default

• Drop all configured databases
$ php console doctrine:database:drop

• Drop a specific database
$ php console doctrine:database:drop --connection=default


DBAL Console Commands
• Execute SQL queries
$ php console doctrine:query:sql “SELECT * FROM user”

• Specify connection
$ php console doctrine:query:sql “...” --connection=default


DBAL
• Get the default conﬁgured database
connection:
class MyController extends DoctrineController
{
public function indexAction()
{
$conn = $this->getDatabaseConnection();

// ...
}
}


DBAL
• Get a conﬁgured database connection service
by its name:
{
{
$conn = $this->getDatabaseConnection('default');

// ...
}
}


ORM
• The EntityManager
• Central place for persisting and retrieving entities
• Multiple instances allowed
• One EntityManager per database connection
$config = new DoctrineORMConfiguration();
$config->setMetadataCacheImpl(new DoctrineCommonCacheArrayCache);
$driverImpl = $config->newDefaultAnnotationDriver(array(__DIR__."/Entities"));
$config->setMetadataDriverImpl($driverImpl);

$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('Proxies');

$connectionOptions = array(
'driver' => 'pdo_sqlite',
'path' => 'database.sqlite'
);

$em = DoctrineORMEntityManager::create($connectionOptions, $config);

• Dependency Injection handles the creation and
management of entity manager services

ORM
• What is an Entity? It is a regular PHP object
that has been mapped to the Doctrine2 ORM:
/** @Entity */
class User
{
/**
* @Id @Column(type="integer")
* @GeneratedValue
*/
private $id;

/** @Column(type="string", length=255) */
private $name;

public function getId()
{
return $this->id;
}

public function getName()
{
return $this->name;
}

public function setName($name)
{
$this->name = $name;
}
}


ORM
• No more magic in your domain
• Clean and testable
• Fast!
• Only limited by what you can do with PHP OO
to design your domain
• Inheritance
• Use __construct() without any problems
• Entities are persisted transparently by the
EntityManager


ORM
• Conﬁgure an entity manager to start using
the ORM:

doctrine.orm:
default_entity_manager: default
cache_driver: apc # array, apc, memcache, xcache
entity_managers:
default:
connection: default


ORM
• Console commands implemented for
improved developer workﬂow:


ORM
• Console commands implemented for
improved developer workflow:
• Ensure production settings
• Clear metadata, query and result cache
• Load data fixtures
• Create and drop configured databases
• Generate entities from mapping information
• Generate new skeleton entities
• Generate skeleton entity repository classes
• Convert mapping information between formats
• Convert a Doctrine1 schema
• Import mapping information from an existing database
• Execute DQL and SQL queries
• Create, drop and update database schema from mapping information


ORM
• Get the default conﬁgured entity manager
service:

{
{
$em = $this->getEntityManager();

// ...
}
}


ORM
• Get a conﬁgured entity manager service by its
name:

{
{
$em = $this->getEntityManager('default');

// ...
}
}


ORM
• Persisting entities is as simple as creating the
object and telling Doctrine to persist it:
{
public function createAction()
{

$user = new User();
$user->setName('Jonathan H. Wage');
$em->persist($user);
$em->flush();

// ...
}
}


ORM
• Creating Query instances and issue DQL
queries to retrieve objects:
{
{
$query = $em->createQuery('select u from MyBundle:User u');

$users = $query->execute();

// ...
}
}


ORM
• Creating QueryBuilder instances to
programatically build DQL queries through a
ﬂuent interface:
{
{
$qb = $em->createQueryBuilder()
->select('u')
->from('MyBundle:User', 'u');

$query = $qb->getQuery();

// ...
}
}


ORM
• Update your database schema during
development as your domain model evolves

• Add a new column to our User entity
/** @Entity */
class User
{
// ...

/** @Column(type="string", length=255) */
private $email;
}


ORM
• Run update command to update your
database schema from mapping information

$ php console doctrine:schema:update

• The above compares your current database
schema to your new mapping information and
executes the necessary queries to bring your
database up-to-date.


Object Document Mapper
• New Doctrine Project for persisting objects to
MongoDB

• Same architecture as ORM

• Transparently persist PHP5 objects to
MongoDB


MongoDB ODM
• The DocumentManager
• Central place for persisting and retrieving documents
• Multiple instances allowed
$config = new Configuration();

$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('Proxies');
$config->setDefaultDB('doctrine_odm_sandbox');

$reader = new AnnotationReader();
$reader->setDefaultAnnotationNamespace('DoctrineODMMongoDBMapping');
$config->setMetadataDriverImpl(new AnnotationDriver($reader, __DIR__ . '/Documents'));

$dm = DocumentManager::create(new Mongo(), $config);

• Dependency Injection handles the creation and
management of document manager services


MongoDB ODM
• To use the MongoDB ODM you must conﬁgure
it:

doctrine_odm.mongodb:
default_document_manager: default
cache_driver: array
document_managers:
default:
connection: mongodb
connections:
mongodb:
server: localhost/somedatabase


MongoDB ODM
• If the defaults are good enough for you then
you can omit all the previous options:

doctrine_odm.mongodb: ~


MongoDB ODM
• What is a Document? It is a regular PHP object
that has been mapped to the MongoDB ODM:
/** @Document */
class User
{
/**
* @Id
*/
private $id;

/** @String */
private $name;

public function getId()
{
return $this->id;
}

public function getName()
{
return $this->name;
}

public function setName($name)
{
$this->name = $name;
}
}


MongoDB ODM
• Get the default conﬁgured document
manager:

{
{
$dm = $this->getDocumentManager();

// ...
}
}


MongoDB ODM
• Get a conﬁgured document manager by its
name:

{
{
$dm = $this->getDocumentManager('default');

// ...
}
}


MongoDB ODM
• Just like the ORM persisting documents is
easy:
{
public function createAction()
{

$user = new User();
$user->setName('Jonathan H. Wage');
$dm->persist($user);
$dm->flush();

// ...
}
}


MongoDB ODM
• Change tracking
– All objects are tracked in an identity map
– Changesets are calculated on ﬂush
– Changesets are used to perform updates using
the atomic operators
• The following code results in an efficient mongo update
with only the properties that need updated:

Array
(
$user->setName('new name');
->
[$set] => Array
(
$dm->flush(); [name] => new name
)
)


MongoDB ODM
• Traditional MongoDB ﬁnd() and ﬁndOne()

$users = $dm->find('User', $criteria);

$query = $dm->findOne('User',
array('username' => 'jwage')
);
$user = $query->getSingleResult();


MongoDB ODM
• Query API for building MongoDB queries
through a ﬂuent OO interface:

{
{
$query = $dm->createQuery('MyBundle:User');


// ...
}
}


MongoDB ODM
• Using Query builder API
{
{
$query = $dm->createQuery('User')
->where('username', 'jwage');

$user = $query->getSingleResult();

// ...
}
}

• where(), whereIn(), whereMod(), whereNot(),
etc.


MongoDB ODM
• Fluent Query interface generates and
executes find() and findOne() methods
internally

• Query information is collected via fluent oo
interface and executed later


MongoDB ODM
• Document Query Language (DQL)
– SQL like grammar for querying MongoDB

• Query types supported
– Find
– Insert
– Update
– Remove


MongoDB ODM
• Find query

$query = $dm->query('find all User');


MongoDB ODM
• Selecting ﬁelds

$query = $dm->query('find username, password User');


MongoDB ODM
• $slice operator for paging embedded
collections
$query = $dm->query('find comments skip 20 limit 10 Post');

Array
(
[comments] => Array
(
[$slice] => Array
(
[0] => 20
[1] => 10
)

)

)


MongoDB ODM
• Use atomic operators
$query = $dm->query("update User set password =
'changeme' where username = 'jwage'");

Array
(
[$set] => Array
(
[password] => changeme
)

)


MongoDB ODM
• Complex update
$query = $dm->query("update User inc count = 1, inc
views = 2, set username = 'jwage'");

Array
(
[$inc] => Array
(
[count] => 1
[views] => 2
)

[$set] => Array
(
[username] => jwage
)

)


MongoDB ODM
• Document Query Language (DQL)
– atomic operators
– skip and limit main results
– skip and limit embedded documents
– use dot notation for querying embedded
documents
– embed JSON values in your DQL syntax

$query = $dm->query("update User pushAll groups = '[1, 2, 3]'");


Database Migrations
• New DoctrineMigrationsBundle contains
integration with the Doctrine Database
Migrations project

• Migrations have been completely re-written
from Doctrine1 and are an extension of the
database abstraction layer

http://www.doctrine-project.org/projects/migrations


Database Migrations
• Migration classes:

class Version20100416130401 extends AbstractMigration
{
public function up(Schema $schema)
{

}

public function down(Schema $schema)
{

}
}


Database Migrations
• Manually execute SQL for migrations:

{
{
$this->_addSql('CREATE TABLE addresses (id INT NOT NULL, street
VARCHAR(255) NOT NULL, PRIMARY KEY(id)) ENGINE = InnoDB');
}

{
$this->_addSql('DROP TABLE addresses');
}
}


Database Migrations
• Use API of Schema objects to perform
migration:

{
{
$table = $schema->createTable('users');
$table->addColumn('username', 'string');
$table->addColumn('password', 'string');
}

{
$schema->dropTable('users');
}
}


Database Migrations
• Check migrations status:

$ ./doctrine migrations:status

== Configuration

>> Name: Doctrine Sandbox Migrations
>> Configuration Source: /Users/jwage/Sites/doctrine2git/tools/sandbox/migrations.xml
>> Version Table Name: doctrine_migration_versions
>> Migrations Namespace: DoctrineMigrations
>> Migrations Directory: /Users/jwage/Sites/doctrine2git/tools/sandbox/DoctrineMigrations
>> Current Version: 2010-04-16 13:04:22 (20100416130422)
>> Latest Version: 2010-04-16 13:04:22 (20100416130422)
>> Executed Migrations: 0
>> Available Migrations: 1
>> New Migrations: 1

== Migration Versions

>> 2010-04-16 13:04:01 (20100416130401) not migrated


Database Migrations
• Execute migration dry runs:
$ ./doctrine migrations:migrate --dry-run
Are you sure you wish to continue?
y
Executing dry run of migration up to 20100416130452 from 0

>> migrating 20100416130452

-> CREATE TABLE users (username VARCHAR(255) NOT NULL, password VARCHAR(255) NOT NULL) ENGINE = InnoDB

• Omit --dry-run to execute migration.


Database Migrations
• Specify a version number to revert to or 0 to
revert all migrations:
$ ./doctrine migrations:migrate 0
Are you sure you wish to continue?
y
Migrating down to 0 from 20100416130401

-- reverting 20100416130401

-> DROP TABLE users

-- reverted


Database Migrations
• Write migration SQL ﬁle instead of executing:
$ ./doctrine migrations:migrate --write-sql
Executing dry run of migration up to 20100416130401 from 0

>> migrating 20100416130401

-> CREATE TABLE users (username VARCHAR(255) NOT NULL, password VARCHAR(255) NOT NULL) ENGINE = InnoDB

Writing migration file to "/path/to/sandbox/doctrine_migration_20100416130405.sql"

• It would produce a ﬁle like:
# Doctrine Migration File Generated on 2010-04-16 13:04:05
# Migrating from 0 to 20100416130422

# Version 20100416130401
CREATE TABLE users (username VARCHAR(255) NOT NULL, password VARCHAR(255) NOT NULL) ENGINE = InnoDB;


Database Migrations
• Integration with ORM for generating
migrations when you change your mapping
information. Add a new property to your
Entity: /** @Entity @Table(name="users") */
class User
{
/**
* @var string $test
*/
private $test;

// ...
}

• Run the migrations diff command:
$ ./doctrine migrations:diff
Generated new migration class to "/path/to/migrations/DoctrineMigrations/Version20100416130459.php" from schema differences.


Database Migrations
• The generated migration class looks like:
{
{
$this->_addSql('ALTER TABLE users ADD test VARCHAR(255) NOT NULL');
}

{
$this->_addSql('ALTER TABLE users DROP test');
}
}

• It contains the SQL statements required to
update your database with the schema
changes.


Database Migrations
• Run migrate command to execute the
generated migration:
$ ./doctrine migrations:migrate

• Now your database is up to date and contains
the new column named test.


Questions?
Jonathan H. Wage
jonathan.wage@sensio.com

sensiolabs.com | doctrine-project.org | sympalphp.org | jwage.com

You should follow me on http://www.twitter.com/jwage for updates about Symfony,
Doctrine and related developments.

You can contact Jonathan about Doctrine and Open-Source or for
training, consulting, application development, or business related
questions at jonathan.wage@sensio.com


Symfony2 and Doctrine2 Integration

More Related Content

What's hot

Viewers also liked

Similar to Symfony2 and Doctrine2 Integration

More from Jonathan Wage

Symfony2 and Doctrine2 Integration