Database and Doctrine ORM

You can also generate getters and setters for all known entities in a bundle or an entity namespace (any PHP class containing Doctrine mapping information):

# generates all entities in the AppBundle# 生成AppBundle下的全部entities$  php bin/console doctrine:generate:entities AppBundle
# generates all entities of bundles in the Acme namespace
# 生成Acme命名空间下的bundles的全部entities
$  php bin/console doctrine:generate:entities Acme

Create data table/Schema ¶

Now you have a working Product class that contains the mapping information, so Doctrine knows exactly how to persist it. Of course, you don't have the corresponding product data table in the library yet. Fortunately, Doctrine can create all data tables automatically. To do this, run the following command:

$  php bin/console doctrine:schema:update --force

You now have a fully functional product table in your database with columns that match the metadata you specified.

Persistent object to database ¶

Now you have a Product entity and the product database table mapped to it. You can persist data into a database. Inside a Controller it's very simple. Add the following method to the bundle's DefaultController.

Now that you have mapped the Product entity to the corresponding product table, you are ready to persist the Product object to in the database. Inside the controller, this is extremely simple. Add the following method to bundle's DefaultController:

// src/AppBundle/Controller/DefaultController.php // ...use AppBundle\Entity\Product;use Symfony\Component\HttpFoundation\Response; // ...public function createAction(){
    $product = new Product();
    $product->setName('Keyboard');
    $product->setPrice(19.99);
    $product->setDescription('Ergonomic and stylish!');     $em = $this->getDoctrine()->getManager();     // tells Doctrine you want to (eventually) save the Product (no queries yet)
    // 告诉Doctrine你希望（最终）存储Product对象（还没有语句执行）
    $em->persist($product);     // actually executes the queries (i.e. the INSERT query)
    // 真正执行语句（如，INSERT 查询）
    $em->flush();     return new Response('Saved new product with id '.$product->getId());}

A closer look at the previous example:

• Lines 10-13 is instantiated here and behaves like any other regular PHP object Use the $product object the same way.
• Line 15 This line takes out the entity manager object of Doctrine, which is responsible for handling the persistence (Annotation: writing) of the database and the process of taking out the object.
• Line 18 persist($product) is called to tell Doctrine to "manage" the $product object. It didn't trigger a request to the database.
• Line 21 When the flush() method is called, Doctrine will traverse all the objects it manages to determine whether they need to be persisted to the database. In this example, the data of the $product object does not exist in the database, so the entity manager needs to execute the INSERT request to create a new row in the product table .

The workflow is the same when creating and updating objects. In the next section you'll see how Doctrine cleverly automatically issues an Update statement if the record already exists in the database.

Getting objects from the database ¶

Getting objects from the database is even simpler. For example, if you configure a Routing, based on the product's id to display a specific Product object:

public function showAction($productId){
    $product = $this->getDoctrine()
        ->getRepository('AppBundle:Product')
        ->find($productId);     if (!$product) {
        throw $this->createNotFoundException(
            'No product found for id '.$productId
        );
    }     // ... do something, like pass the $product object into a template
    // ... 做一些事，比如把 $product 对象传入模板}

When you want to query a specific type of object, you always use its "respository". You can think of a Respository as a PHP class whose only job is to help you get entities out of that particular class. For an entity class, to access its treasure house, pass:

$repository = $this->getDoctrine()
    ->getRepository('AppBundle:Product');

Once you have a Repository object, you can access all of its useful methods.

$repository = $this->getDoctrine()->getRepository('AppBundle:Product');
// query for a single product by its primary key (usually "id")// 通过主键（通常是id）查询一件产品
$product = $repository->find($productId); // dynamic method names to find a single product based on a column value// 动态方法名称，基于字段的值来找到一件产品$product = $repository->findOneById($productId);$product = $repository->findOneByName('Keyboard');
// dynamic method names to find a group of products based on a column value
// 动态方法名称，基于字段值来找出一组产品$products = $repository->findByPrice(19.99); 
// find *all* products / 查出 *全部* 产品$products = $repository->findAll();

You can also make effective use of the findBy and findOneBy methods to easily obtain objects based on multiple conditions:

$repository = $this->getDoctrine()->getRepository('AppBundle:Product'); // query for a single product matching the given name and price// 查询一件产品，要匹配给定的名称和价格$product = $repository->findOneBy(
    array('name' => 'Keyboard', 'price' => 19.99)); // query for multiple products matching the given name, ordered by price// 查询多件产品，要匹配给定的名称和价格$products = $repository->findBy(
    array('name' => 'Keyboard'),
    array('price' => 'ASC'));

Object Update ¶

Once you have obtained an object from Doctrine, updating it is easy. Suppose you have a route that maps a product id to the controller's update action:

public function updateAction($productId){
    $em = $this->getDoctrine()->getManager();
    $product = $em->getRepository('AppBundle:Product')->find($productId);     if (!$product) {
        throw $this->createNotFoundException(
            'No product found for id '.$productId
        );
    }     $product->setName('New product name!');
    $em->flush();     return $this->redirectToRoute('homepage');}

Updating an object involves three steps:

1. Get the object from Doctrine;
2. Modify the object;
3. Call the flush() method of the entity manager.

Note that calling $em->persist($product) is unnecessary. Recall that this method just tells Doctrine to manage or "observe" the $product object. Here, because you have already obtained the $product object, it has already been managed.

Deleting an object ¶

Deleting an object is very similar, but you need to call remove() from the entity manager. Method:

$em->remove($product);$em->flush();

As you might have expected, the remove() method notifies Doctrine that you want to remove the specified entity from the database. The real DELETE query will not be actually executed until the flush() method is called.

Object Query ¶

You have seen how the repository object allows you to perform some basic queries without having to do any work:

$repository = $this->getDoctrine()->getRepository('AppBundle:Product'); $product = $repository->find($productId);$product = $repository->findOneByName('Keyboard');

Of course, Doctrine also allows you to use Doctrine Query Language (DQL) to write some complex queries. DQL is similar to SQL, except that it is used to query one or more entity class objects (such as product) , while SQL queries rows in a data table (such as product).

When querying in Doctrine, you have two main options: write pure Doctrine queries (DQL) or use Doctrine's Query Builder.

Using DQL for object query ¶

Suppose you want to query products with a price higher than 19.99, and sort them from low to high. You can use DQL, a syntax similar to native SQL in Doctrine, to construct a query for this scenario:

$em = $this->getDoctrine()->getManager();$query = $em->createQuery(
    'SELECT p
    FROM AppBundle:Product p
    WHERE p.price > :price
    ORDER BY p.price ASC')->setParameter('price', 19.99); $products = $query->getResult();

If you are used to writing SQL, then DQL will also be very natural. The biggest difference between them is that you need to think in terms of "select PHP objects", not rows of a data table. Because of this, you start with AppBundle:Product the entity (optional shortcut for a AppBundle\Entity\Product class ) to select, and then give the entity an alias of p.

getResult() The method returns a result array. To get a result, you can use getSingleResult() (this method will throw an exception when there is no result) or getOneOrNullResult():

$product = $query->setMaxResults(1)->getOneOrNullResult();

DQL syntax is powerful Incredibly, it allows easy joins between entities (relations will be covered later), groups, etc. Refer to the Doctrine Query Language documentation to learn more.

Use Doctrine's Query Builder for object query ¶

Instead of writing a large string in DQL, you can use a very useful QueryBuilder object to build that string . This is useful when your query depends on dynamic conditions, because as your connection string keeps growing, the DQL code becomes increasingly difficult to read:

$repository = $this->getDoctrine()
    ->getRepository('AppBundle:Product'); // createQueryBuilder() automatically selects FROM AppBundle:Product// and aliases it to "p"// createQueryBuilder() 自动从 AppBundle:Product 进行 select 并赋予 p 假名$query = $repository->createQueryBuilder('p')
    ->where('p.price > :price')
    ->setParameter('price', '19.99')
    ->orderBy('p.price', 'ASC')
    ->getQuery(); $products = $query->getResult();// to get just one result: / 要得到一个结果：// $product = $query->setMaxResults(1)->getOneOrNullResult();

The QueryBuilder object contains all the Necessary method. By calling the getQuery() method, the query builder will return a standard Query object that can be used to obtain the requested result set.

Query BuilderFor more information, refer to Doctrine's Query Builder documentation.

Organize custom queries into the Repository class ¶

All the previous queries are written directly in your controller. But for program organization, Doctrine provides a dedicated repository class that allows you to save all query logic to a central location.

Reference How to Create a Custom Repository Class to learn more.

Configuration ¶

Doctrine is highly configurable, although you may never care about those options. For Doctrine configuration information, see the config reference.

Doctrine Field Type Reference ¶

Doctrine comes with a large number of available field types. Each can map PHP data types to specific field types, no matter what database you use. For each field type, Column can be further configured to set length, nullable behavior, name or other options. For a list of available field types, see the Mapping Types documentation.

Associations and Relations ¶

Doctrine provides all the functionality you need to manage database relationships (also known as associations). For more information, see How to use Doctrine Associations/Relations.

Summary ¶

With Doctrine, you can focus on your object and how to apply it to the program, while database persistence comes second. This is because Doctrine allows you to use any PHP object to save your data, and relies on "metadata mapping" information to map an object's data to a specific data table.

Doctrine has many powerful features waiting for you to learn, such as relationships, complex queries and event monitoring.