Valoare implicită în Doctrina

<?php
/**
 * @Entity
 */
class myEntity {
    /**
     * @var string
     *
     * @ORM\Column(name="myColumn", type="integer", options={"default" : 0})
     */
    private $myColumn;
    ...
}

Rețineți că această utilizează SQL "DEFAULT", care nu este susținută de unele domenii, cum ar fi BLOB și "TEXT".

Baza de date valorile implicite nu sunt "portably" a sprijinit. Singura modalitate de a folosi baza de date valorile implicite este prin columnDefinition cartografiere atribut în cazul în care să specificați " SQL " fragment ("DEFAULT" că inclusive) pentru coloana domeniul este mapat la.

Puteți folosi:

<?php
/**
 * @Entity
 */
class myEntity {
    /**
     * @var string
     *
     * @Column(name="myColumn", type="string", length="50")
     */
    private $myColumn = 'myDefaultValue';
    ...
}

PHP-nivel valorile implicite sunt de preferat, deoarece acestea sunt, de asemenea, disponibile în mod corespunzător pe nou-create și a persistat obiecte (Doctrină nu va merge înapoi la baza de date după care persistă un nou obiect pentru a obține valorile implicite).

A înființat un constructor în entitate și setați valoarea implicită acolo.

Utilizare:

options={"default":"foo bar"}

și nu:

options={"default"="foo bar"}

De exemplu:

/**
* @ORM\Column(name="foo", type="smallint", options={"default":0})
*/
private $foo

Actualizare

Un motiv mai mult de ce citiți documentația pentru Symfony nu va iesi din trend. Există o soluție simplă pentru cazul meu specific și este să setați câmpul tip "opțiunea" empty_data` la o valoare implicită.

Din nou, această soluție este doar pentru scenariu în cazul în care un gol de intrare într-o formă de seturi DB domeniu de nul.

De fundal

Nici unul dintre răspunsurile anterioare m-a ajutat cu specific scenariu, dar am găsit o soluție.

Am avut un câmp de formular care trebuia să se comporte după cum urmează:

1. Nu este necesar, poate fi lăsat necompletat. (Folosit 'este necesar' => false)
2. Dacă este lăsat necompletat, ar trebui să implicit la o anumită valoare. Pentru o mai bună experiență de utilizator, nu am stabilit valoarea implicită de pe câmpul de intrare, ci mai degrabă folosit atributul html 'substituent' deoarece este mai puțin deranjantă.

Apoi am încercat toate recomandările indicate aici. Lasă-mă să le lista:

• Setați o valoare implicită, atunci când pentru o entitate de proprietate:

<?php
/**
 * @Entity
 */
class myEntity {
    /**
     * @var string
     *
     * @Column(name="myColumn", type="string", length="50")
     */
    private $myColumn = 'myDefaultValue';
    ...
}

• Utilizați opțiunile adnotare:

@ORM\Column(name="foo", options={"default":"foo bar"})

• Setați valoarea implicită pe constructor:

/**
 * @Entity
 */
class myEntity {
    ...
    public function __construct()
    {
        $this->myColumn = 'myDefaultValue';
    }
    ...
}

Nimic nu a lucrat și toate pentru că de cum Symfony foloseste clasă de Entități.

IMPORTANT

Symfony câmpuri de formular suprascrie valorile implicite stabilite pe clasă de Entități. Sensul, schema pentru DB poate avea o valoare implicită definit, dar dacă vă lăsați un non-câmp obligatoriu gol de la depunerea formularului, forma->handleRequest () i forma->isValid() metoda va trece peste aceste valori implicite pe "Entitate" de clasă și pune-le în câmpul de introducere a valorilor. Dacă câmpul de introducere valori sunt goale, atunci se va seta "Entitate" proprietatea de a null.

http://symfony.com/doc/current/book/forms.html#handling-form-submissions

Mea Soluție

Setați valoarea implicită de pe controlerul după formă->handleRequest () i`forma->isValid() metoda:

...
if ($myEntity->getMyColumn() === null) {
    $myEntity->setMyColumn('myDefaultValue');
}
...

Nu o soluție frumos, dar funcționează. Probabil că aș putea face o validare grup dar pot exista oameni care vad acest aspect ca pe o transformarea datelor decat validarea datelor te las pe tine să decizi.

Suprascrie Setter (Nu Funcționează)

Am încercat, de asemenea, pentru a trece peste "Entitate" setter în acest fel:

...
/**
 * Set myColumn
 *
 * @param string $myColumn
 *
 * @return myEntity
 */
public function setMyColumn($myColumn)
{
    $this->myColumn = ($myColumn === null || $myColumn === '') ? 'myDefaultValue' : $myColumn;

    return $this;
}
...

Asta, chiar dacă pare mai curat, nu't lucru. Motivul fiind că răul forma->handleRequest() metoda nu folosește Modelul's setter metode pentru a actualiza datele (sape în formă->setData () pentru mai multe detalii).

Soluție am folosit a fost un LifeCycleCallback. Încă în așteptare pentru a vedea dacă nu există nici mai mult "originar" metodă, de exemplu @Coloana(type="string", default="buna ziua valoare implicită").

/**
 * @Entity @Table(name="posts") @HasLifeCycleCallbacks
 */
class Post implements Node, \Zend_Acl_Resource_Interface {

...

/**
 * @PrePersist
 */
function onPrePersist() {
    // set default date
    $this->dtPosted = date('Y-m-d H:m:s');
}

Puteți face acest lucru folosind xml precum:

<field name="acmeOne" type="string" column="acmeOne" length="36">
    <options>
        <option name="comment">Your SQL field comment goes here.</option>
        <option name="default">Default Value</option>
    </options>
</field>

Aici este modul în care am rezolvat-o pentru mine. Mai jos este o Entitate exemplu, cu o valoare implicită pentru MySQL. Cu toate acestea, acest lucru necesită, de asemenea, de configurare a unui constructor în entitate, și pentru tine de a stabili valoarea implicită acolo.

Entity\Example:
  type: entity
  table: example
  fields:
    id:
      type: integer
      id: true
      generator:
        strategy: AUTO
    label:
      type: string
      columnDefinition: varchar(255) NOT NULL DEFAULT 'default_value' COMMENT 'This is column comment'

Pentru mine funcționează pe o bază de date mysql, de asemenea,:

Entity\Entity_name:
    type: entity
    table: table_name
    fields: 
        field_name:
            type: integer
            nullable: true
            options:
                default: 1

Nici unul dintre acest lucru a lucrat pentru mine. Am găsit niște documentare pe doctrina's site-ul care spune că pentru a seta valoarea direct pentru a seta o valoare implicită.

http://doctrine-orm.readthedocs.io/projects/doctrine-orm/en/latest/reference/faq.html

private $default = 0;

Aceasta introduce valoarea mi-am dorit.

Dacă utilizați yaml definiție pentru entitate, următoarele lucrări pentru mine pe o bază de date postgresql:

Entity\Entity_name:
    type: entity
    table: table_name
    fields: 
        field_name:
            type: boolean
            nullable: false
            options:
                default: false

Adăugând la @romanb răspuns genial.

Aceasta adaugă un pic de regie în domeniul migrației, pentru că, evident, nu poate crea un câmp cu constrângere not null și cu nici o valoare implicită.

// this up() migration is autogenerated, please modify it to your needs
$this->abortIf($this->connection->getDatabasePlatform()->getName() != "postgresql");

//lets add property without not null contraint        
$this->addSql("ALTER TABLE tablename ADD property BOOLEAN");

//get the default value for property       
$object = new Object();
$defaultValue = $menuItem->getProperty() ? "true":"false";

$this->addSql("UPDATE tablename SET property = {$defaultValue}");

//not you can add constraint
$this->addSql("ALTER TABLE tablename ALTER property SET NOT NULL");

Cu acest răspuns, am să vă încurajez să te gândești de ce ai nevoie valoarea implicită în baza de date, în primul rând? Și, de obicei, este de a permite crearea de obiecte cu constrângere not null.

M-am luptat cu aceeasi problema. Am vrut să aibă valoarea implicită din baza de date în entități (automat). Ghici ce, am facut-o :)

<?php
/**
 * Created by JetBrains PhpStorm.
 * User: Steffen
 * Date: 27-6-13
 * Time: 15:36
 * To change this template use File | Settings | File Templates.
 */

require_once 'bootstrap.php';

$em->getConfiguration()->setMetadataDriverImpl(
    new \Doctrine\ORM\Mapping\Driver\DatabaseDriver(
        $em->getConnection()->getSchemaManager()
    )
);

$driver = new \Doctrine\ORM\Mapping\Driver\DatabaseDriver($em->getConnection()->getSchemaManager());
$driver->setNamespace('Models\\');

$em->getConfiguration()->setMetadataDriverImpl($driver);

$cmf = new \Doctrine\ORM\Tools\DisconnectedClassMetadataFactory();
$cmf->setEntityManager($em);
$metadata = $cmf->getAllMetadata();

// Little hack to have default values for your entities...
foreach ($metadata as $k => $t)
{
    foreach ($t->getFieldNames() as $fieldName)
    {
        $correctFieldName = \Doctrine\Common\Util\Inflector::tableize($fieldName);

        $columns = $tan = $em->getConnection()->getSchemaManager()->listTableColumns($t->getTableName());
        foreach ($columns as $column)
        {
            if ($column->getName() == $correctFieldName)
            {
                // We skip DateTime, because this needs to be a DateTime object.
                if ($column->getType() != 'DateTime')
                {
                    $metadata[$k]->fieldMappings[$fieldName]['default'] = $column->getDefault();
                }
                break;
            }
        }
    }
}

// GENERATE PHP ENTITIES!
$entityGenerator = new \Doctrine\ORM\Tools\EntityGenerator();
$entityGenerator->setGenerateAnnotations(true);
$entityGenerator->setGenerateStubMethods(true);
$entityGenerator->setRegenerateEntityIfExists(true);
$entityGenerator->setUpdateEntityIfExists(false);
$entityGenerator->generate($metadata, __DIR__);

echo "Entities created";

În timp ce stabilirea valorii în constructorul va lucra, folosind Doctrina Ciclului de viață evenimente ar putea fi o soluție mai bună.

Prin folosirea `prePersist a Ciclului de viață a Evenimentului, puteți seta ca valoare implicită pe entității doar la inițială persistă.

Fiți atenți atunci când setarea valorilor implicite pe proprietate definiție! Face în constructorul în schimb, să-l țină fără probleme. Dacă-l definească pe proprietate definiție, apoi persista obiect în baza de date, apoi face o încărcare parțială, atunci nu a încărcat proprietăți va avea din nou valoarea implicită. Care este periculoasă dacă doriți să persiste obiect din nou.