|
1
|
|
|
<?php |
|
2
|
|
|
|
|
3
|
|
|
namespace Doctrine\Tests\ORM\Mapping; |
|
4
|
|
|
|
|
5
|
|
|
use Doctrine\Common\Persistence\Mapping\RuntimeReflectionService; |
|
6
|
|
|
use Doctrine\ORM\EntityManager; |
|
7
|
|
|
use Doctrine\ORM\Events; |
|
8
|
|
|
use Doctrine\ORM\Mapping\ClassMetadata; |
|
9
|
|
|
use Doctrine\ORM\Mapping\ClassMetadataFactory; |
|
10
|
|
|
use Doctrine\ORM\Mapping\ClassMetadataInfo; |
|
11
|
|
|
use Doctrine\ORM\Mapping\DefaultNamingStrategy; |
|
12
|
|
|
use Doctrine\ORM\Mapping\DiscriminatorColumn; |
|
13
|
|
|
use Doctrine\ORM\Mapping\Id; |
|
14
|
|
|
use Doctrine\ORM\Mapping\MappingException; |
|
15
|
|
|
use Doctrine\ORM\Mapping\UnderscoreNamingStrategy; |
|
16
|
|
|
use Doctrine\Tests\Models\Cache\City; |
|
17
|
|
|
use Doctrine\Tests\Models\CaseSensitiveDiscriminatorMap\Shape; |
|
18
|
|
|
use Doctrine\Tests\Models\CMS\CmsAddress; |
|
19
|
|
|
use Doctrine\Tests\Models\CMS\CmsAddressListener; |
|
20
|
|
|
use Doctrine\Tests\Models\CMS\CmsUser; |
|
21
|
|
|
use Doctrine\Tests\Models\Company\CompanyContract; |
|
22
|
|
|
use Doctrine\Tests\Models\Company\CompanyContractListener; |
|
23
|
|
|
use Doctrine\Tests\Models\Company\CompanyFixContract; |
|
24
|
|
|
use Doctrine\Tests\Models\Company\CompanyFlexContract; |
|
25
|
|
|
use Doctrine\Tests\Models\Company\CompanyFlexUltraContract; |
|
26
|
|
|
use Doctrine\Tests\Models\Company\CompanyFlexUltraContractListener; |
|
27
|
|
|
use Doctrine\Tests\Models\Company\CompanyPerson; |
|
28
|
|
|
use Doctrine\Tests\Models\DDC1476\DDC1476EntityWithDefaultFieldType; |
|
29
|
|
|
use Doctrine\Tests\Models\DDC2825\ExplicitSchemaAndTable; |
|
30
|
|
|
use Doctrine\Tests\Models\DDC2825\SchemaAndTableInTableName; |
|
31
|
|
|
use Doctrine\Tests\Models\DDC3579\DDC3579Admin; |
|
32
|
|
|
use Doctrine\Tests\Models\DDC5934\DDC5934Contract; |
|
33
|
|
|
use Doctrine\Tests\Models\DDC869\DDC869ChequePayment; |
|
34
|
|
|
use Doctrine\Tests\Models\DDC869\DDC869CreditCardPayment; |
|
35
|
|
|
use Doctrine\Tests\Models\DDC869\DDC869PaymentRepository; |
|
36
|
|
|
use Doctrine\Tests\Models\DDC889\DDC889Class; |
|
37
|
|
|
use Doctrine\Tests\Models\DDC889\DDC889Entity; |
|
38
|
|
|
use Doctrine\Tests\Models\DDC964\DDC964Admin; |
|
39
|
|
|
use Doctrine\Tests\Models\DDC964\DDC964Guest; |
|
40
|
|
|
use Doctrine\Tests\OrmTestCase; |
|
41
|
|
|
|
|
42
|
|
|
abstract class AbstractMappingDriverTest extends OrmTestCase |
|
43
|
|
|
{ |
|
44
|
|
|
abstract protected function _loadDriver(); |
|
45
|
|
|
|
|
46
|
|
|
public function createClassMetadata($entityClassName) |
|
47
|
|
|
{ |
|
48
|
|
|
$mappingDriver = $this->_loadDriver(); |
|
49
|
|
|
|
|
50
|
|
|
$class = new ClassMetadata($entityClassName); |
|
51
|
|
|
$class->initializeReflection(new RuntimeReflectionService()); |
|
52
|
|
|
$mappingDriver->loadMetadataForClass($entityClassName, $class); |
|
53
|
|
|
|
|
54
|
|
|
return $class; |
|
55
|
|
|
} |
|
56
|
|
|
|
|
57
|
|
|
/** |
|
58
|
|
|
* @param \Doctrine\ORM\EntityManager $entityClassName |
|
59
|
|
|
* @return \Doctrine\ORM\Mapping\ClassMetadataFactory |
|
60
|
|
|
*/ |
|
61
|
|
|
protected function createClassMetadataFactory(EntityManager $em = null) |
|
62
|
|
|
{ |
|
63
|
|
|
$driver = $this->_loadDriver(); |
|
64
|
|
|
$em = $em ?: $this->_getTestEntityManager(); |
|
65
|
|
|
$factory = new ClassMetadataFactory(); |
|
66
|
|
|
$em->getConfiguration()->setMetadataDriverImpl($driver); |
|
67
|
|
|
$factory->setEntityManager($em); |
|
68
|
|
|
|
|
69
|
|
|
return $factory; |
|
70
|
|
|
} |
|
71
|
|
|
|
|
72
|
|
|
public function testEntityTableNameAndInheritance() |
|
73
|
|
|
{ |
|
74
|
|
|
$class = $this->createClassMetadata(User::class); |
|
75
|
|
|
|
|
76
|
|
|
$this->assertEquals('cms_users', $class->getTableName()); |
|
77
|
|
|
$this->assertEquals(ClassMetadata::INHERITANCE_TYPE_NONE, $class->inheritanceType); |
|
78
|
|
|
|
|
79
|
|
|
return $class; |
|
80
|
|
|
} |
|
81
|
|
|
|
|
82
|
|
|
/** |
|
83
|
|
|
* @depends testEntityTableNameAndInheritance |
|
84
|
|
|
* @param ClassMetadata $class |
|
85
|
|
|
*/ |
|
86
|
|
|
public function testEntityIndexes($class) |
|
87
|
|
|
{ |
|
88
|
|
|
$this->assertArrayHasKey('indexes', $class->table, 'ClassMetadata should have indexes key in table property.'); |
|
89
|
|
|
$this->assertEquals( |
|
90
|
|
|
[ |
|
91
|
|
|
'name_idx' => ['columns' => ['name']], |
|
92
|
|
|
0 => ['columns' => ['user_email']] |
|
93
|
|
|
], $class->table['indexes']); |
|
94
|
|
|
|
|
95
|
|
|
return $class; |
|
96
|
|
|
} |
|
97
|
|
|
|
|
98
|
|
|
public function testEntityIndexFlagsAndPartialIndexes() |
|
99
|
|
|
{ |
|
100
|
|
|
$class = $this->createClassMetadata(Comment::class); |
|
101
|
|
|
|
|
102
|
|
|
$this->assertEquals( |
|
103
|
|
|
[ |
|
104
|
|
|
0 => [ |
|
105
|
|
|
'columns' => ['content'], |
|
106
|
|
|
'flags' => ['fulltext'], |
|
107
|
|
|
'options' => ['where' => 'content IS NOT NULL'], |
|
108
|
|
|
] |
|
109
|
|
|
], $class->table['indexes']); |
|
110
|
|
|
} |
|
111
|
|
|
|
|
112
|
|
|
/** |
|
113
|
|
|
* @depends testEntityTableNameAndInheritance |
|
114
|
|
|
* @param ClassMetadata $class |
|
115
|
|
|
*/ |
|
116
|
|
|
public function testEntityUniqueConstraints($class) |
|
117
|
|
|
{ |
|
118
|
|
|
$this->assertArrayHasKey('uniqueConstraints', $class->table, |
|
119
|
|
|
'ClassMetadata should have uniqueConstraints key in table property when Unique Constraints are set.'); |
|
120
|
|
|
|
|
121
|
|
|
$this->assertEquals( |
|
122
|
|
|
[ |
|
123
|
|
|
"search_idx" => ["columns" => ["name", "user_email"], 'options' => ['where' => 'name IS NOT NULL']] |
|
124
|
|
|
], $class->table['uniqueConstraints']); |
|
125
|
|
|
|
|
126
|
|
|
return $class; |
|
127
|
|
|
} |
|
128
|
|
|
|
|
129
|
|
|
/** |
|
130
|
|
|
* @depends testEntityTableNameAndInheritance |
|
131
|
|
|
* @param ClassMetadata $class |
|
132
|
|
|
*/ |
|
133
|
|
|
public function testEntityOptions($class) |
|
134
|
|
|
{ |
|
135
|
|
|
$this->assertArrayHasKey('options', $class->table, 'ClassMetadata should have options key in table property.'); |
|
136
|
|
|
|
|
137
|
|
|
$this->assertEquals( |
|
138
|
|
|
[ |
|
139
|
|
|
'foo' => 'bar', 'baz' => ['key' => 'val'] |
|
140
|
|
|
], $class->table['options']); |
|
141
|
|
|
|
|
142
|
|
|
return $class; |
|
143
|
|
|
} |
|
144
|
|
|
|
|
145
|
|
|
/** |
|
146
|
|
|
* @depends testEntityOptions |
|
147
|
|
|
* @param ClassMetadata $class |
|
148
|
|
|
*/ |
|
149
|
|
|
public function testEntitySequence($class) |
|
150
|
|
|
{ |
|
151
|
|
|
$this->assertInternalType('array', $class->sequenceGeneratorDefinition, 'No Sequence Definition set on this driver.'); |
|
|
|
|
|
|
152
|
|
|
$this->assertEquals( |
|
153
|
|
|
[ |
|
154
|
|
|
'sequenceName' => 'tablename_seq', |
|
155
|
|
|
'allocationSize' => 100, |
|
156
|
|
|
'initialValue' => 1, |
|
157
|
|
|
], |
|
158
|
|
|
$class->sequenceGeneratorDefinition |
|
159
|
|
|
); |
|
160
|
|
|
} |
|
161
|
|
|
|
|
162
|
|
|
public function testEntityCustomGenerator() |
|
163
|
|
|
{ |
|
164
|
|
|
$class = $this->createClassMetadata(Animal::class); |
|
165
|
|
|
|
|
166
|
|
|
$this->assertEquals(ClassMetadata::GENERATOR_TYPE_CUSTOM, |
|
167
|
|
|
$class->generatorType, "Generator Type"); |
|
168
|
|
|
$this->assertEquals( |
|
169
|
|
|
["class" => "stdClass"], |
|
170
|
|
|
$class->customGeneratorDefinition, |
|
171
|
|
|
"Custom Generator Definition"); |
|
172
|
|
|
} |
|
173
|
|
|
|
|
174
|
|
|
|
|
175
|
|
|
/** |
|
176
|
|
|
* @depends testEntityTableNameAndInheritance |
|
177
|
|
|
* @param ClassMetadata $class |
|
178
|
|
|
*/ |
|
179
|
|
|
public function testFieldMappings($class) |
|
180
|
|
|
{ |
|
181
|
|
|
$this->assertEquals(4, count($class->fieldMappings)); |
|
182
|
|
|
$this->assertTrue(isset($class->fieldMappings['id'])); |
|
183
|
|
|
$this->assertTrue(isset($class->fieldMappings['name'])); |
|
184
|
|
|
$this->assertTrue(isset($class->fieldMappings['email'])); |
|
185
|
|
|
$this->assertTrue(isset($class->fieldMappings['version'])); |
|
186
|
|
|
|
|
187
|
|
|
return $class; |
|
188
|
|
|
} |
|
189
|
|
|
|
|
190
|
|
|
/** |
|
191
|
|
|
* @depends testFieldMappings |
|
192
|
|
|
* @param ClassMetadata $class |
|
193
|
|
|
*/ |
|
194
|
|
|
public function testVersionedField($class) |
|
195
|
|
|
{ |
|
196
|
|
|
$this->assertTrue($class->isVersioned); |
|
197
|
|
|
$this->assertEquals("version", $class->versionField); |
|
198
|
|
|
|
|
199
|
|
|
$this->assertFalse(isset($class->fieldMappings['version']['version'])); |
|
200
|
|
|
} |
|
201
|
|
|
|
|
202
|
|
|
/** |
|
203
|
|
|
* @depends testEntityTableNameAndInheritance |
|
204
|
|
|
* @param ClassMetadata $class |
|
205
|
|
|
*/ |
|
206
|
|
|
public function testFieldMappingsColumnNames($class) |
|
207
|
|
|
{ |
|
208
|
|
|
$this->assertEquals("id", $class->fieldMappings['id']['columnName']); |
|
209
|
|
|
$this->assertEquals("name", $class->fieldMappings['name']['columnName']); |
|
210
|
|
|
$this->assertEquals("user_email", $class->fieldMappings['email']['columnName']); |
|
211
|
|
|
|
|
212
|
|
|
return $class; |
|
213
|
|
|
} |
|
214
|
|
|
|
|
215
|
|
|
/** |
|
216
|
|
|
* @depends testEntityTableNameAndInheritance |
|
217
|
|
|
* @param ClassMetadata $class |
|
218
|
|
|
*/ |
|
219
|
|
|
public function testStringFieldMappings($class) |
|
220
|
|
|
{ |
|
221
|
|
|
$this->assertEquals('string', $class->fieldMappings['name']['type']); |
|
222
|
|
|
$this->assertEquals(50, $class->fieldMappings['name']['length']); |
|
223
|
|
|
$this->assertTrue($class->fieldMappings['name']['nullable']); |
|
224
|
|
|
$this->assertTrue($class->fieldMappings['name']['unique']); |
|
225
|
|
|
|
|
226
|
|
|
return $class; |
|
227
|
|
|
} |
|
228
|
|
|
|
|
229
|
|
|
/** |
|
230
|
|
|
* @depends testEntityTableNameAndInheritance |
|
231
|
|
|
* |
|
232
|
|
|
* @param ClassMetadata $class |
|
233
|
|
|
* |
|
234
|
|
|
* @return ClassMetadata |
|
235
|
|
|
*/ |
|
236
|
|
|
public function testFieldOptions(ClassMetadata $class) |
|
237
|
|
|
{ |
|
238
|
|
|
$expected = ['foo' => 'bar', 'baz' => ['key' => 'val'], 'fixed' => false]; |
|
239
|
|
|
$this->assertEquals($expected, $class->fieldMappings['name']['options']); |
|
240
|
|
|
|
|
241
|
|
|
return $class; |
|
242
|
|
|
} |
|
243
|
|
|
|
|
244
|
|
|
/** |
|
245
|
|
|
* @depends testEntityTableNameAndInheritance |
|
246
|
|
|
* @param ClassMetadata $class |
|
247
|
|
|
*/ |
|
248
|
|
|
public function testIdFieldOptions($class) |
|
249
|
|
|
{ |
|
250
|
|
|
$this->assertEquals(['foo' => 'bar', 'unsigned' => false], $class->fieldMappings['id']['options']); |
|
251
|
|
|
|
|
252
|
|
|
return $class; |
|
253
|
|
|
} |
|
254
|
|
|
|
|
255
|
|
|
/** |
|
256
|
|
|
* @depends testFieldMappings |
|
257
|
|
|
* @param ClassMetadata $class |
|
258
|
|
|
*/ |
|
259
|
|
|
public function testIdentifier($class) |
|
260
|
|
|
{ |
|
261
|
|
|
$this->assertEquals(['id'], $class->identifier); |
|
262
|
|
|
$this->assertEquals('integer', $class->fieldMappings['id']['type']); |
|
263
|
|
|
$this->assertEquals(ClassMetadata::GENERATOR_TYPE_AUTO, $class->generatorType, "ID-Generator is not ClassMetadata::GENERATOR_TYPE_AUTO"); |
|
264
|
|
|
|
|
265
|
|
|
return $class; |
|
266
|
|
|
} |
|
267
|
|
|
|
|
268
|
|
|
/** |
|
269
|
|
|
* @group #6129 |
|
270
|
|
|
* |
|
271
|
|
|
* @return ClassMetadata |
|
272
|
|
|
*/ |
|
273
|
|
|
public function testBooleanValuesForOptionIsSetCorrectly() |
|
274
|
|
|
{ |
|
275
|
|
|
$class = $this->createClassMetadata(User::class); |
|
276
|
|
|
|
|
277
|
|
|
$this->assertInternalType('bool', $class->fieldMappings['id']['options']['unsigned']); |
|
|
|
|
|
|
278
|
|
|
$this->assertFalse($class->fieldMappings['id']['options']['unsigned']); |
|
279
|
|
|
|
|
280
|
|
|
$this->assertInternalType('bool', $class->fieldMappings['name']['options']['fixed']); |
|
|
|
|
|
|
281
|
|
|
$this->assertFalse($class->fieldMappings['name']['options']['fixed']); |
|
282
|
|
|
|
|
283
|
|
|
return $class; |
|
284
|
|
|
} |
|
285
|
|
|
|
|
286
|
|
|
/** |
|
287
|
|
|
* @depends testIdentifier |
|
288
|
|
|
* @param ClassMetadata $class |
|
289
|
|
|
*/ |
|
290
|
|
|
public function testAssociations($class) |
|
291
|
|
|
{ |
|
292
|
|
|
$this->assertEquals(3, count($class->associationMappings)); |
|
293
|
|
|
|
|
294
|
|
|
return $class; |
|
295
|
|
|
} |
|
296
|
|
|
|
|
297
|
|
|
/** |
|
298
|
|
|
* @depends testAssociations |
|
299
|
|
|
* @param ClassMetadata $class |
|
300
|
|
|
*/ |
|
301
|
|
|
public function testOwningOneToOneAssociation($class) |
|
302
|
|
|
{ |
|
303
|
|
|
$this->assertTrue(isset($class->associationMappings['address'])); |
|
304
|
|
|
$this->assertTrue($class->associationMappings['address']['isOwningSide']); |
|
305
|
|
|
$this->assertEquals('user', $class->associationMappings['address']['inversedBy']); |
|
306
|
|
|
// Check cascading |
|
307
|
|
|
$this->assertTrue($class->associationMappings['address']['isCascadeRemove']); |
|
308
|
|
|
$this->assertFalse($class->associationMappings['address']['isCascadePersist']); |
|
309
|
|
|
$this->assertFalse($class->associationMappings['address']['isCascadeRefresh']); |
|
310
|
|
|
$this->assertFalse($class->associationMappings['address']['isCascadeDetach']); |
|
311
|
|
|
$this->assertFalse($class->associationMappings['address']['isCascadeMerge']); |
|
312
|
|
|
|
|
313
|
|
|
return $class; |
|
314
|
|
|
} |
|
315
|
|
|
|
|
316
|
|
|
/** |
|
317
|
|
|
* @depends testOwningOneToOneAssociation |
|
318
|
|
|
* @param ClassMetadata $class |
|
319
|
|
|
*/ |
|
320
|
|
|
public function testInverseOneToManyAssociation($class) |
|
321
|
|
|
{ |
|
322
|
|
|
$this->assertTrue(isset($class->associationMappings['phonenumbers'])); |
|
323
|
|
|
$this->assertFalse($class->associationMappings['phonenumbers']['isOwningSide']); |
|
324
|
|
|
$this->assertTrue($class->associationMappings['phonenumbers']['isCascadePersist']); |
|
325
|
|
|
$this->assertTrue($class->associationMappings['phonenumbers']['isCascadeRemove']); |
|
326
|
|
|
$this->assertFalse($class->associationMappings['phonenumbers']['isCascadeRefresh']); |
|
327
|
|
|
$this->assertFalse($class->associationMappings['phonenumbers']['isCascadeDetach']); |
|
328
|
|
|
$this->assertFalse($class->associationMappings['phonenumbers']['isCascadeMerge']); |
|
329
|
|
|
$this->assertTrue($class->associationMappings['phonenumbers']['orphanRemoval']); |
|
330
|
|
|
|
|
331
|
|
|
// Test Order By |
|
332
|
|
|
$this->assertEquals(['number' => 'ASC'], $class->associationMappings['phonenumbers']['orderBy']); |
|
333
|
|
|
|
|
334
|
|
|
return $class; |
|
335
|
|
|
} |
|
336
|
|
|
|
|
337
|
|
|
/** |
|
338
|
|
|
* @depends testInverseOneToManyAssociation |
|
339
|
|
|
* @param ClassMetadata $class |
|
340
|
|
|
*/ |
|
341
|
|
|
public function testManyToManyAssociationWithCascadeAll($class) |
|
342
|
|
|
{ |
|
343
|
|
|
$this->assertTrue(isset($class->associationMappings['groups'])); |
|
344
|
|
|
$this->assertTrue($class->associationMappings['groups']['isOwningSide']); |
|
345
|
|
|
// Make sure that cascade-all works as expected |
|
346
|
|
|
$this->assertTrue($class->associationMappings['groups']['isCascadeRemove']); |
|
347
|
|
|
$this->assertTrue($class->associationMappings['groups']['isCascadePersist']); |
|
348
|
|
|
$this->assertTrue($class->associationMappings['groups']['isCascadeRefresh']); |
|
349
|
|
|
$this->assertTrue($class->associationMappings['groups']['isCascadeDetach']); |
|
350
|
|
|
$this->assertTrue($class->associationMappings['groups']['isCascadeMerge']); |
|
351
|
|
|
|
|
352
|
|
|
$this->assertFalse(isset($class->associationMappings['groups']['orderBy'])); |
|
353
|
|
|
|
|
354
|
|
|
return $class; |
|
355
|
|
|
} |
|
356
|
|
|
|
|
357
|
|
|
/** |
|
358
|
|
|
* @depends testManyToManyAssociationWithCascadeAll |
|
359
|
|
|
* @param ClassMetadata $class |
|
360
|
|
|
*/ |
|
361
|
|
|
public function testLifecycleCallbacks($class) |
|
362
|
|
|
{ |
|
363
|
|
|
$this->assertEquals(count($class->lifecycleCallbacks), 2); |
|
364
|
|
|
$this->assertEquals($class->lifecycleCallbacks['prePersist'][0], 'doStuffOnPrePersist'); |
|
365
|
|
|
$this->assertEquals($class->lifecycleCallbacks['postPersist'][0], 'doStuffOnPostPersist'); |
|
366
|
|
|
|
|
367
|
|
|
return $class; |
|
368
|
|
|
} |
|
369
|
|
|
|
|
370
|
|
|
/** |
|
371
|
|
|
* @depends testManyToManyAssociationWithCascadeAll |
|
372
|
|
|
* @param ClassMetadata $class |
|
373
|
|
|
*/ |
|
374
|
|
|
public function testLifecycleCallbacksSupportMultipleMethodNames($class) |
|
375
|
|
|
{ |
|
376
|
|
|
$this->assertEquals(count($class->lifecycleCallbacks['prePersist']), 2); |
|
377
|
|
|
$this->assertEquals($class->lifecycleCallbacks['prePersist'][1], 'doOtherStuffOnPrePersistToo'); |
|
378
|
|
|
|
|
379
|
|
|
return $class; |
|
380
|
|
|
} |
|
381
|
|
|
|
|
382
|
|
|
/** |
|
383
|
|
|
* @depends testLifecycleCallbacksSupportMultipleMethodNames |
|
384
|
|
|
* @param ClassMetadata $class |
|
385
|
|
|
*/ |
|
386
|
|
|
public function testJoinColumnUniqueAndNullable($class) |
|
387
|
|
|
{ |
|
388
|
|
|
// Non-Nullability of Join Column |
|
389
|
|
|
$this->assertFalse($class->associationMappings['groups']['joinTable']['joinColumns'][0]['nullable']); |
|
390
|
|
|
$this->assertFalse($class->associationMappings['groups']['joinTable']['joinColumns'][0]['unique']); |
|
391
|
|
|
|
|
392
|
|
|
return $class; |
|
393
|
|
|
} |
|
394
|
|
|
|
|
395
|
|
|
/** |
|
396
|
|
|
* @depends testJoinColumnUniqueAndNullable |
|
397
|
|
|
* @param ClassMetadata $class |
|
398
|
|
|
*/ |
|
399
|
|
|
public function testColumnDefinition($class) |
|
400
|
|
|
{ |
|
401
|
|
|
$this->assertEquals("CHAR(32) NOT NULL", $class->fieldMappings['email']['columnDefinition']); |
|
402
|
|
|
$this->assertEquals("INT NULL", $class->associationMappings['groups']['joinTable']['inverseJoinColumns'][0]['columnDefinition']); |
|
403
|
|
|
|
|
404
|
|
|
return $class; |
|
405
|
|
|
} |
|
406
|
|
|
|
|
407
|
|
|
/** |
|
408
|
|
|
* @depends testColumnDefinition |
|
409
|
|
|
* @param ClassMetadata $class |
|
410
|
|
|
*/ |
|
411
|
|
|
public function testJoinColumnOnDelete($class) |
|
412
|
|
|
{ |
|
413
|
|
|
$this->assertEquals('CASCADE', $class->associationMappings['address']['joinColumns'][0]['onDelete']); |
|
414
|
|
|
|
|
415
|
|
|
return $class; |
|
416
|
|
|
} |
|
417
|
|
|
|
|
418
|
|
|
/** |
|
419
|
|
|
* @group DDC-514 |
|
420
|
|
|
*/ |
|
421
|
|
|
public function testDiscriminatorColumnDefaults() |
|
422
|
|
|
{ |
|
423
|
|
|
if (strpos(get_class($this), 'PHPMappingDriver') !== false) { |
|
424
|
|
|
$this->markTestSkipped('PHP Mapping Drivers have no defaults.'); |
|
425
|
|
|
} |
|
426
|
|
|
|
|
427
|
|
|
$class = $this->createClassMetadata(Animal::class); |
|
428
|
|
|
|
|
429
|
|
|
$this->assertEquals( |
|
430
|
|
|
['name' => 'discr', 'type' => 'string', 'length' => '32', 'fieldName' => 'discr', 'columnDefinition' => null], |
|
431
|
|
|
$class->discriminatorColumn |
|
432
|
|
|
); |
|
433
|
|
|
} |
|
434
|
|
|
|
|
435
|
|
|
/** |
|
436
|
|
|
* @group DDC-869 |
|
437
|
|
|
*/ |
|
438
|
|
|
public function testMappedSuperclassWithRepository() |
|
439
|
|
|
{ |
|
440
|
|
|
$em = $this->_getTestEntityManager(); |
|
441
|
|
|
$factory = $this->createClassMetadataFactory($em); |
|
442
|
|
|
|
|
443
|
|
|
|
|
444
|
|
|
$class = $factory->getMetadataFor(DDC869CreditCardPayment::class); |
|
445
|
|
|
|
|
446
|
|
|
$this->assertTrue(isset($class->fieldMappings['id'])); |
|
|
|
|
|
|
447
|
|
|
$this->assertTrue(isset($class->fieldMappings['value'])); |
|
448
|
|
|
$this->assertTrue(isset($class->fieldMappings['creditCardNumber'])); |
|
449
|
|
|
$this->assertEquals($class->customRepositoryClassName, DDC869PaymentRepository::class); |
|
|
|
|
|
|
450
|
|
|
$this->assertInstanceOf(DDC869PaymentRepository::class, $em->getRepository(DDC869CreditCardPayment::class)); |
|
451
|
|
|
$this->assertTrue($em->getRepository(DDC869ChequePayment::class)->isTrue()); |
|
452
|
|
|
|
|
453
|
|
|
|
|
454
|
|
|
|
|
455
|
|
|
$class = $factory->getMetadataFor(DDC869ChequePayment::class); |
|
456
|
|
|
|
|
457
|
|
|
$this->assertTrue(isset($class->fieldMappings['id'])); |
|
458
|
|
|
$this->assertTrue(isset($class->fieldMappings['value'])); |
|
459
|
|
|
$this->assertTrue(isset($class->fieldMappings['serialNumber'])); |
|
460
|
|
|
$this->assertEquals($class->customRepositoryClassName, DDC869PaymentRepository::class); |
|
461
|
|
|
$this->assertInstanceOf(DDC869PaymentRepository::class, $em->getRepository(DDC869ChequePayment::class)); |
|
462
|
|
|
$this->assertTrue($em->getRepository(DDC869ChequePayment::class)->isTrue()); |
|
463
|
|
|
} |
|
464
|
|
|
|
|
465
|
|
|
/** |
|
466
|
|
|
* @group DDC-1476 |
|
467
|
|
|
*/ |
|
468
|
|
|
public function testDefaultFieldType() |
|
469
|
|
|
{ |
|
470
|
|
|
$factory = $this->createClassMetadataFactory(); |
|
471
|
|
|
$class = $factory->getMetadataFor(DDC1476EntityWithDefaultFieldType::class); |
|
472
|
|
|
|
|
473
|
|
|
|
|
474
|
|
|
$this->assertArrayHasKey('id', $class->fieldMappings); |
|
|
|
|
|
|
475
|
|
|
$this->assertArrayHasKey('name', $class->fieldMappings); |
|
476
|
|
|
|
|
477
|
|
|
|
|
478
|
|
|
$this->assertArrayHasKey('type', $class->fieldMappings['id']); |
|
479
|
|
|
$this->assertArrayHasKey('type', $class->fieldMappings['name']); |
|
480
|
|
|
|
|
481
|
|
|
$this->assertEquals('string', $class->fieldMappings['id']['type']); |
|
482
|
|
|
$this->assertEquals('string', $class->fieldMappings['name']['type']); |
|
483
|
|
|
|
|
484
|
|
|
|
|
485
|
|
|
|
|
486
|
|
|
$this->assertArrayHasKey('fieldName', $class->fieldMappings['id']); |
|
487
|
|
|
$this->assertArrayHasKey('fieldName', $class->fieldMappings['name']); |
|
488
|
|
|
|
|
489
|
|
|
$this->assertEquals('id', $class->fieldMappings['id']['fieldName']); |
|
490
|
|
|
$this->assertEquals('name', $class->fieldMappings['name']['fieldName']); |
|
491
|
|
|
|
|
492
|
|
|
|
|
493
|
|
|
|
|
494
|
|
|
$this->assertArrayHasKey('columnName', $class->fieldMappings['id']); |
|
495
|
|
|
$this->assertArrayHasKey('columnName', $class->fieldMappings['name']); |
|
496
|
|
|
|
|
497
|
|
|
$this->assertEquals('id', $class->fieldMappings['id']['columnName']); |
|
498
|
|
|
$this->assertEquals('name', $class->fieldMappings['name']['columnName']); |
|
499
|
|
|
|
|
500
|
|
|
$this->assertEquals(ClassMetadataInfo::GENERATOR_TYPE_NONE, $class->generatorType); |
|
|
|
|
|
|
501
|
|
|
} |
|
502
|
|
|
|
|
503
|
|
|
/** |
|
504
|
|
|
* @group DDC-1170 |
|
505
|
|
|
*/ |
|
506
|
|
|
public function testIdentifierColumnDefinition() |
|
507
|
|
|
{ |
|
508
|
|
|
$class = $this->createClassMetadata(DDC1170Entity::class); |
|
509
|
|
|
|
|
510
|
|
|
|
|
511
|
|
|
$this->assertArrayHasKey('id', $class->fieldMappings); |
|
512
|
|
|
$this->assertArrayHasKey('value', $class->fieldMappings); |
|
513
|
|
|
|
|
514
|
|
|
$this->assertArrayHasKey('columnDefinition', $class->fieldMappings['id']); |
|
515
|
|
|
$this->assertArrayHasKey('columnDefinition', $class->fieldMappings['value']); |
|
516
|
|
|
|
|
517
|
|
|
$this->assertEquals("INT unsigned NOT NULL", $class->fieldMappings['id']['columnDefinition']); |
|
518
|
|
|
$this->assertEquals("VARCHAR(255) NOT NULL", $class->fieldMappings['value']['columnDefinition']); |
|
519
|
|
|
} |
|
520
|
|
|
|
|
521
|
|
|
/** |
|
522
|
|
|
* @group DDC-559 |
|
523
|
|
|
*/ |
|
524
|
|
|
public function testNamingStrategy() |
|
525
|
|
|
{ |
|
526
|
|
|
$em = $this->_getTestEntityManager(); |
|
527
|
|
|
$factory = $this->createClassMetadataFactory($em); |
|
528
|
|
|
|
|
529
|
|
|
|
|
530
|
|
|
$this->assertInstanceOf(DefaultNamingStrategy::class, $em->getConfiguration()->getNamingStrategy()); |
|
531
|
|
|
$em->getConfiguration()->setNamingStrategy(new UnderscoreNamingStrategy(CASE_UPPER)); |
|
532
|
|
|
$this->assertInstanceOf(UnderscoreNamingStrategy::class, $em->getConfiguration()->getNamingStrategy()); |
|
533
|
|
|
|
|
534
|
|
|
$class = $factory->getMetadataFor(DDC1476EntityWithDefaultFieldType::class); |
|
535
|
|
|
|
|
536
|
|
|
$this->assertEquals('ID', $class->getColumnName('id')); |
|
537
|
|
|
$this->assertEquals('NAME', $class->getColumnName('name')); |
|
538
|
|
|
$this->assertEquals('DDC1476ENTITY_WITH_DEFAULT_FIELD_TYPE', $class->table['name']); |
|
|
|
|
|
|
539
|
|
|
} |
|
540
|
|
|
|
|
541
|
|
|
/** |
|
542
|
|
|
* @group DDC-807 |
|
543
|
|
|
* @group DDC-553 |
|
544
|
|
|
*/ |
|
545
|
|
|
public function testDiscriminatorColumnDefinition() |
|
546
|
|
|
{ |
|
547
|
|
|
$class = $this->createClassMetadata(DDC807Entity::class); |
|
548
|
|
|
|
|
549
|
|
|
$this->assertArrayHasKey('columnDefinition', $class->discriminatorColumn); |
|
550
|
|
|
$this->assertArrayHasKey('name', $class->discriminatorColumn); |
|
551
|
|
|
|
|
552
|
|
|
$this->assertEquals("ENUM('ONE','TWO')", $class->discriminatorColumn['columnDefinition']); |
|
553
|
|
|
$this->assertEquals("dtype", $class->discriminatorColumn['name']); |
|
554
|
|
|
} |
|
555
|
|
|
|
|
556
|
|
|
/** |
|
557
|
|
|
* @group DDC-889 |
|
558
|
|
|
*/ |
|
559
|
|
|
public function testInvalidEntityOrMappedSuperClassShouldMentionParentClasses() |
|
560
|
|
|
{ |
|
561
|
|
|
$this->expectException(MappingException::class); |
|
562
|
|
|
$this->expectExceptionMessage('Class "Doctrine\Tests\Models\DDC889\DDC889Class" sub class of "Doctrine\Tests\Models\DDC889\DDC889SuperClass" is not a valid entity or mapped super class.'); |
|
563
|
|
|
|
|
564
|
|
|
$this->createClassMetadata(DDC889Class::class); |
|
565
|
|
|
} |
|
566
|
|
|
|
|
567
|
|
|
/** |
|
568
|
|
|
* @group DDC-889 |
|
569
|
|
|
*/ |
|
570
|
|
|
public function testIdentifierRequiredShouldMentionParentClasses() |
|
571
|
|
|
{ |
|
572
|
|
|
$factory = $this->createClassMetadataFactory(); |
|
573
|
|
|
|
|
574
|
|
|
$this->expectException(MappingException::class); |
|
575
|
|
|
$this->expectExceptionMessage('No identifier/primary key specified for Entity "Doctrine\Tests\Models\DDC889\DDC889Entity" sub class of "Doctrine\Tests\Models\DDC889\DDC889SuperClass". Every Entity must have an identifier/primary key.'); |
|
576
|
|
|
|
|
577
|
|
|
$factory->getMetadataFor(DDC889Entity::class); |
|
578
|
|
|
} |
|
579
|
|
|
|
|
580
|
|
|
public function testNamedQuery() |
|
581
|
|
|
{ |
|
582
|
|
|
$driver = $this->_loadDriver(); |
|
583
|
|
|
$class = $this->createClassMetadata(User::class); |
|
584
|
|
|
|
|
585
|
|
|
$this->assertCount(1, $class->getNamedQueries(), sprintf("Named queries not processed correctly by driver %s", get_class($driver))); |
|
586
|
|
|
} |
|
587
|
|
|
|
|
588
|
|
|
/** |
|
589
|
|
|
* @group DDC-1663 |
|
590
|
|
|
*/ |
|
591
|
|
|
public function testNamedNativeQuery() |
|
592
|
|
|
{ |
|
593
|
|
|
|
|
594
|
|
|
$class = $this->createClassMetadata(CmsAddress::class); |
|
595
|
|
|
|
|
596
|
|
|
//named native query |
|
597
|
|
|
$this->assertCount(3, $class->namedNativeQueries); |
|
598
|
|
|
$this->assertArrayHasKey('find-all', $class->namedNativeQueries); |
|
599
|
|
|
$this->assertArrayHasKey('find-by-id', $class->namedNativeQueries); |
|
600
|
|
|
|
|
601
|
|
|
|
|
602
|
|
|
$findAllQuery = $class->getNamedNativeQuery('find-all'); |
|
603
|
|
|
$this->assertEquals('find-all', $findAllQuery['name']); |
|
604
|
|
|
$this->assertEquals('mapping-find-all', $findAllQuery['resultSetMapping']); |
|
605
|
|
|
$this->assertEquals('SELECT id, country, city FROM cms_addresses', $findAllQuery['query']); |
|
606
|
|
|
|
|
607
|
|
|
$findByIdQuery = $class->getNamedNativeQuery('find-by-id'); |
|
608
|
|
|
$this->assertEquals('find-by-id', $findByIdQuery['name']); |
|
609
|
|
|
$this->assertEquals(CmsAddress::class,$findByIdQuery['resultClass']); |
|
610
|
|
|
$this->assertEquals('SELECT * FROM cms_addresses WHERE id = ?', $findByIdQuery['query']); |
|
611
|
|
|
|
|
612
|
|
|
$countQuery = $class->getNamedNativeQuery('count'); |
|
613
|
|
|
$this->assertEquals('count', $countQuery['name']); |
|
614
|
|
|
$this->assertEquals('mapping-count', $countQuery['resultSetMapping']); |
|
615
|
|
|
$this->assertEquals('SELECT COUNT(*) AS count FROM cms_addresses', $countQuery['query']); |
|
616
|
|
|
|
|
617
|
|
|
// result set mapping |
|
618
|
|
|
$this->assertCount(3, $class->sqlResultSetMappings); |
|
619
|
|
|
$this->assertArrayHasKey('mapping-count', $class->sqlResultSetMappings); |
|
620
|
|
|
$this->assertArrayHasKey('mapping-find-all', $class->sqlResultSetMappings); |
|
621
|
|
|
$this->assertArrayHasKey('mapping-without-fields', $class->sqlResultSetMappings); |
|
622
|
|
|
|
|
623
|
|
|
$findAllMapping = $class->getSqlResultSetMapping('mapping-find-all'); |
|
624
|
|
|
$this->assertEquals('mapping-find-all', $findAllMapping['name']); |
|
625
|
|
|
$this->assertEquals(CmsAddress::class, $findAllMapping['entities'][0]['entityClass']); |
|
626
|
|
|
$this->assertEquals(['name'=>'id','column'=>'id'], $findAllMapping['entities'][0]['fields'][0]); |
|
627
|
|
|
$this->assertEquals(['name'=>'city','column'=>'city'], $findAllMapping['entities'][0]['fields'][1]); |
|
628
|
|
|
$this->assertEquals(['name'=>'country','column'=>'country'], $findAllMapping['entities'][0]['fields'][2]); |
|
629
|
|
|
|
|
630
|
|
|
$withoutFieldsMapping = $class->getSqlResultSetMapping('mapping-without-fields'); |
|
631
|
|
|
$this->assertEquals('mapping-without-fields', $withoutFieldsMapping['name']); |
|
632
|
|
|
$this->assertEquals(CmsAddress::class, $withoutFieldsMapping['entities'][0]['entityClass']); |
|
633
|
|
|
$this->assertEquals([], $withoutFieldsMapping['entities'][0]['fields']); |
|
634
|
|
|
|
|
635
|
|
|
$countMapping = $class->getSqlResultSetMapping('mapping-count'); |
|
636
|
|
|
$this->assertEquals('mapping-count', $countMapping['name']); |
|
637
|
|
|
$this->assertEquals(['name'=>'count'], $countMapping['columns'][0]); |
|
638
|
|
|
|
|
639
|
|
|
} |
|
640
|
|
|
|
|
641
|
|
|
/** |
|
642
|
|
|
* @group DDC-1663 |
|
643
|
|
|
*/ |
|
644
|
|
|
public function testSqlResultSetMapping() |
|
645
|
|
|
{ |
|
646
|
|
|
|
|
647
|
|
|
$userMetadata = $this->createClassMetadata(CmsUser::class); |
|
648
|
|
|
$personMetadata = $this->createClassMetadata(CompanyPerson::class); |
|
649
|
|
|
|
|
650
|
|
|
// user asserts |
|
651
|
|
|
$this->assertCount(4, $userMetadata->getSqlResultSetMappings()); |
|
652
|
|
|
|
|
653
|
|
|
$mapping = $userMetadata->getSqlResultSetMapping('mappingJoinedAddress'); |
|
654
|
|
|
$this->assertEquals([],$mapping['columns']); |
|
655
|
|
|
$this->assertEquals('mappingJoinedAddress', $mapping['name']); |
|
656
|
|
|
$this->assertNull($mapping['entities'][0]['discriminatorColumn']); |
|
657
|
|
|
$this->assertEquals(['name'=>'id','column'=>'id'], $mapping['entities'][0]['fields'][0]); |
|
658
|
|
|
$this->assertEquals(['name'=>'name','column'=>'name'], $mapping['entities'][0]['fields'][1]); |
|
659
|
|
|
$this->assertEquals(['name'=>'status','column'=>'status'], $mapping['entities'][0]['fields'][2]); |
|
660
|
|
|
$this->assertEquals(['name'=>'address.zip','column'=>'zip'], $mapping['entities'][0]['fields'][3]); |
|
661
|
|
|
$this->assertEquals(['name'=>'address.city','column'=>'city'], $mapping['entities'][0]['fields'][4]); |
|
662
|
|
|
$this->assertEquals(['name'=>'address.country','column'=>'country'], $mapping['entities'][0]['fields'][5]); |
|
663
|
|
|
$this->assertEquals(['name'=>'address.id','column'=>'a_id'], $mapping['entities'][0]['fields'][6]); |
|
664
|
|
|
$this->assertEquals($userMetadata->name, $mapping['entities'][0]['entityClass']); |
|
665
|
|
|
|
|
666
|
|
|
|
|
667
|
|
|
$mapping = $userMetadata->getSqlResultSetMapping('mappingJoinedPhonenumber'); |
|
668
|
|
|
$this->assertEquals([],$mapping['columns']); |
|
669
|
|
|
$this->assertEquals('mappingJoinedPhonenumber', $mapping['name']); |
|
670
|
|
|
$this->assertNull($mapping['entities'][0]['discriminatorColumn']); |
|
671
|
|
|
$this->assertEquals(['name'=>'id','column'=>'id'], $mapping['entities'][0]['fields'][0]); |
|
672
|
|
|
$this->assertEquals(['name'=>'name','column'=>'name'], $mapping['entities'][0]['fields'][1]); |
|
673
|
|
|
$this->assertEquals(['name'=>'status','column'=>'status'], $mapping['entities'][0]['fields'][2]); |
|
674
|
|
|
$this->assertEquals(['name'=>'phonenumbers.phonenumber','column'=>'number'], $mapping['entities'][0]['fields'][3]); |
|
675
|
|
|
$this->assertEquals($userMetadata->name, $mapping['entities'][0]['entityClass']); |
|
676
|
|
|
|
|
677
|
|
|
$mapping = $userMetadata->getSqlResultSetMapping('mappingUserPhonenumberCount'); |
|
678
|
|
|
$this->assertEquals(['name'=>'numphones'],$mapping['columns'][0]); |
|
679
|
|
|
$this->assertEquals('mappingUserPhonenumberCount', $mapping['name']); |
|
680
|
|
|
$this->assertNull($mapping['entities'][0]['discriminatorColumn']); |
|
681
|
|
|
$this->assertEquals(['name'=>'id','column'=>'id'], $mapping['entities'][0]['fields'][0]); |
|
682
|
|
|
$this->assertEquals(['name'=>'name','column'=>'name'], $mapping['entities'][0]['fields'][1]); |
|
683
|
|
|
$this->assertEquals(['name'=>'status','column'=>'status'], $mapping['entities'][0]['fields'][2]); |
|
684
|
|
|
$this->assertEquals($userMetadata->name, $mapping['entities'][0]['entityClass']); |
|
685
|
|
|
|
|
686
|
|
|
$mapping = $userMetadata->getSqlResultSetMapping('mappingMultipleJoinsEntityResults'); |
|
687
|
|
|
$this->assertEquals(['name'=>'numphones'],$mapping['columns'][0]); |
|
688
|
|
|
$this->assertEquals('mappingMultipleJoinsEntityResults', $mapping['name']); |
|
689
|
|
|
$this->assertNull($mapping['entities'][0]['discriminatorColumn']); |
|
690
|
|
|
$this->assertEquals(['name'=>'id','column'=>'u_id'], $mapping['entities'][0]['fields'][0]); |
|
691
|
|
|
$this->assertEquals(['name'=>'name','column'=>'u_name'], $mapping['entities'][0]['fields'][1]); |
|
692
|
|
|
$this->assertEquals(['name'=>'status','column'=>'u_status'], $mapping['entities'][0]['fields'][2]); |
|
693
|
|
|
$this->assertEquals($userMetadata->name, $mapping['entities'][0]['entityClass']); |
|
694
|
|
|
$this->assertNull($mapping['entities'][1]['discriminatorColumn']); |
|
695
|
|
|
$this->assertEquals(['name'=>'id','column'=>'a_id'], $mapping['entities'][1]['fields'][0]); |
|
696
|
|
|
$this->assertEquals(['name'=>'zip','column'=>'a_zip'], $mapping['entities'][1]['fields'][1]); |
|
697
|
|
|
$this->assertEquals(['name'=>'country','column'=>'a_country'], $mapping['entities'][1]['fields'][2]); |
|
698
|
|
|
$this->assertEquals(CmsAddress::class, $mapping['entities'][1]['entityClass']); |
|
699
|
|
|
|
|
700
|
|
|
//person asserts |
|
701
|
|
|
$this->assertCount(1, $personMetadata->getSqlResultSetMappings()); |
|
702
|
|
|
|
|
703
|
|
|
$mapping = $personMetadata->getSqlResultSetMapping('mappingFetchAll'); |
|
704
|
|
|
$this->assertEquals([],$mapping['columns']); |
|
705
|
|
|
$this->assertEquals('mappingFetchAll', $mapping['name']); |
|
706
|
|
|
$this->assertEquals('discriminator', $mapping['entities'][0]['discriminatorColumn']); |
|
707
|
|
|
$this->assertEquals(['name'=>'id','column'=>'id'], $mapping['entities'][0]['fields'][0]); |
|
708
|
|
|
$this->assertEquals(['name'=>'name','column'=>'name'], $mapping['entities'][0]['fields'][1]); |
|
709
|
|
|
$this->assertEquals($personMetadata->name, $mapping['entities'][0]['entityClass']); |
|
710
|
|
|
} |
|
711
|
|
|
|
|
712
|
|
|
/* |
|
713
|
|
|
* @group DDC-964 |
|
714
|
|
|
*/ |
|
715
|
|
|
public function testAssociationOverridesMapping() |
|
716
|
|
|
{ |
|
717
|
|
|
|
|
718
|
|
|
$factory = $this->createClassMetadataFactory(); |
|
719
|
|
|
$adminMetadata = $factory->getMetadataFor(DDC964Admin::class); |
|
720
|
|
|
$guestMetadata = $factory->getMetadataFor(DDC964Guest::class); |
|
721
|
|
|
|
|
722
|
|
|
|
|
723
|
|
|
// assert groups association mappings |
|
724
|
|
|
$this->assertArrayHasKey('groups', $guestMetadata->associationMappings); |
|
|
|
|
|
|
725
|
|
|
$this->assertArrayHasKey('groups', $adminMetadata->associationMappings); |
|
726
|
|
|
|
|
727
|
|
|
$guestGroups = $guestMetadata->associationMappings['groups']; |
|
728
|
|
|
$adminGroups = $adminMetadata->associationMappings['groups']; |
|
729
|
|
|
|
|
730
|
|
|
// assert not override attributes |
|
731
|
|
|
$this->assertEquals($guestGroups['fieldName'], $adminGroups['fieldName']); |
|
732
|
|
|
$this->assertEquals($guestGroups['type'], $adminGroups['type']); |
|
733
|
|
|
$this->assertEquals($guestGroups['mappedBy'], $adminGroups['mappedBy']); |
|
734
|
|
|
$this->assertEquals($guestGroups['inversedBy'], $adminGroups['inversedBy']); |
|
735
|
|
|
$this->assertEquals($guestGroups['isOwningSide'], $adminGroups['isOwningSide']); |
|
736
|
|
|
$this->assertEquals($guestGroups['fetch'], $adminGroups['fetch']); |
|
737
|
|
|
$this->assertEquals($guestGroups['isCascadeRemove'], $adminGroups['isCascadeRemove']); |
|
738
|
|
|
$this->assertEquals($guestGroups['isCascadePersist'], $adminGroups['isCascadePersist']); |
|
739
|
|
|
$this->assertEquals($guestGroups['isCascadeRefresh'], $adminGroups['isCascadeRefresh']); |
|
740
|
|
|
$this->assertEquals($guestGroups['isCascadeMerge'], $adminGroups['isCascadeMerge']); |
|
741
|
|
|
$this->assertEquals($guestGroups['isCascadeDetach'], $adminGroups['isCascadeDetach']); |
|
742
|
|
|
|
|
743
|
|
|
// assert not override attributes |
|
744
|
|
|
$this->assertEquals('ddc964_users_groups', $guestGroups['joinTable']['name']); |
|
745
|
|
|
$this->assertEquals('user_id', $guestGroups['joinTable']['joinColumns'][0]['name']); |
|
746
|
|
|
$this->assertEquals('group_id', $guestGroups['joinTable']['inverseJoinColumns'][0]['name']); |
|
747
|
|
|
|
|
748
|
|
|
$this->assertEquals(['user_id'=>'id'], $guestGroups['relationToSourceKeyColumns']); |
|
749
|
|
|
$this->assertEquals(['group_id'=>'id'], $guestGroups['relationToTargetKeyColumns']); |
|
750
|
|
|
$this->assertEquals(['user_id','group_id'], $guestGroups['joinTableColumns']); |
|
751
|
|
|
|
|
752
|
|
|
|
|
753
|
|
|
$this->assertEquals('ddc964_users_admingroups', $adminGroups['joinTable']['name']); |
|
754
|
|
|
$this->assertEquals('adminuser_id', $adminGroups['joinTable']['joinColumns'][0]['name']); |
|
755
|
|
|
$this->assertEquals('admingroup_id', $adminGroups['joinTable']['inverseJoinColumns'][0]['name']); |
|
756
|
|
|
|
|
757
|
|
|
$this->assertEquals(['adminuser_id'=>'id'], $adminGroups['relationToSourceKeyColumns']); |
|
758
|
|
|
$this->assertEquals(['admingroup_id'=>'id'], $adminGroups['relationToTargetKeyColumns']); |
|
759
|
|
|
$this->assertEquals(['adminuser_id','admingroup_id'], $adminGroups['joinTableColumns']); |
|
760
|
|
|
|
|
761
|
|
|
|
|
762
|
|
|
// assert address association mappings |
|
763
|
|
|
$this->assertArrayHasKey('address', $guestMetadata->associationMappings); |
|
764
|
|
|
$this->assertArrayHasKey('address', $adminMetadata->associationMappings); |
|
765
|
|
|
|
|
766
|
|
|
$guestAddress = $guestMetadata->associationMappings['address']; |
|
767
|
|
|
$adminAddress = $adminMetadata->associationMappings['address']; |
|
768
|
|
|
|
|
769
|
|
|
// assert not override attributes |
|
770
|
|
|
$this->assertEquals($guestAddress['fieldName'], $adminAddress['fieldName']); |
|
771
|
|
|
$this->assertEquals($guestAddress['type'], $adminAddress['type']); |
|
772
|
|
|
$this->assertEquals($guestAddress['mappedBy'], $adminAddress['mappedBy']); |
|
773
|
|
|
$this->assertEquals($guestAddress['inversedBy'], $adminAddress['inversedBy']); |
|
774
|
|
|
$this->assertEquals($guestAddress['isOwningSide'], $adminAddress['isOwningSide']); |
|
775
|
|
|
$this->assertEquals($guestAddress['fetch'], $adminAddress['fetch']); |
|
776
|
|
|
$this->assertEquals($guestAddress['isCascadeRemove'], $adminAddress['isCascadeRemove']); |
|
777
|
|
|
$this->assertEquals($guestAddress['isCascadePersist'], $adminAddress['isCascadePersist']); |
|
778
|
|
|
$this->assertEquals($guestAddress['isCascadeRefresh'], $adminAddress['isCascadeRefresh']); |
|
779
|
|
|
$this->assertEquals($guestAddress['isCascadeMerge'], $adminAddress['isCascadeMerge']); |
|
780
|
|
|
$this->assertEquals($guestAddress['isCascadeDetach'], $adminAddress['isCascadeDetach']); |
|
781
|
|
|
|
|
782
|
|
|
// assert override |
|
783
|
|
|
$this->assertEquals('address_id', $guestAddress['joinColumns'][0]['name']); |
|
784
|
|
|
$this->assertEquals(['address_id'=>'id'], $guestAddress['sourceToTargetKeyColumns']); |
|
785
|
|
|
$this->assertEquals(['address_id'=>'address_id'], $guestAddress['joinColumnFieldNames']); |
|
786
|
|
|
$this->assertEquals(['id'=>'address_id'], $guestAddress['targetToSourceKeyColumns']); |
|
787
|
|
|
|
|
788
|
|
|
|
|
789
|
|
|
$this->assertEquals('adminaddress_id', $adminAddress['joinColumns'][0]['name']); |
|
790
|
|
|
$this->assertEquals(['adminaddress_id'=>'id'], $adminAddress['sourceToTargetKeyColumns']); |
|
791
|
|
|
$this->assertEquals(['adminaddress_id'=>'adminaddress_id'], $adminAddress['joinColumnFieldNames']); |
|
792
|
|
|
$this->assertEquals(['id'=>'adminaddress_id'], $adminAddress['targetToSourceKeyColumns']); |
|
793
|
|
|
} |
|
794
|
|
|
|
|
795
|
|
|
/* |
|
796
|
|
|
* @group DDC-3579 |
|
797
|
|
|
*/ |
|
798
|
|
|
public function testInversedByOverrideMapping() |
|
799
|
|
|
{ |
|
800
|
|
|
|
|
801
|
|
|
$factory = $this->createClassMetadataFactory(); |
|
802
|
|
|
$adminMetadata = $factory->getMetadataFor(DDC3579Admin::class); |
|
803
|
|
|
|
|
804
|
|
|
// assert groups association mappings |
|
805
|
|
|
$this->assertArrayHasKey('groups', $adminMetadata->associationMappings); |
|
|
|
|
|
|
806
|
|
|
$adminGroups = $adminMetadata->associationMappings['groups']; |
|
807
|
|
|
|
|
808
|
|
|
// assert override |
|
809
|
|
|
$this->assertEquals('admins', $adminGroups['inversedBy']); |
|
810
|
|
|
} |
|
811
|
|
|
|
|
812
|
|
|
/** |
|
813
|
|
|
* @group DDC-5934 |
|
814
|
|
|
*/ |
|
815
|
|
|
public function testFetchOverrideMapping() |
|
816
|
|
|
{ |
|
817
|
|
|
// check override metadata |
|
818
|
|
|
$contractMetadata = $this->createClassMetadataFactory()->getMetadataFor(DDC5934Contract::class); |
|
819
|
|
|
|
|
820
|
|
|
$this->assertArrayHasKey('members', $contractMetadata->associationMappings); |
|
|
|
|
|
|
821
|
|
|
$this->assertSame(ClassMetadata::FETCH_EXTRA_LAZY, $contractMetadata->associationMappings['members']['fetch']); |
|
822
|
|
|
} |
|
823
|
|
|
|
|
824
|
|
|
/** |
|
825
|
|
|
* @group DDC-964 |
|
826
|
|
|
*/ |
|
827
|
|
|
public function testAttributeOverridesMapping() |
|
828
|
|
|
{ |
|
829
|
|
|
|
|
830
|
|
|
$factory = $this->createClassMetadataFactory(); |
|
831
|
|
|
$guestMetadata = $factory->getMetadataFor(DDC964Guest::class); |
|
832
|
|
|
$adminMetadata = $factory->getMetadataFor(DDC964Admin::class); |
|
833
|
|
|
|
|
834
|
|
|
$this->assertTrue($adminMetadata->fieldMappings['id']['id']); |
|
|
|
|
|
|
835
|
|
|
$this->assertEquals('id', $adminMetadata->fieldMappings['id']['fieldName']); |
|
836
|
|
|
$this->assertEquals('user_id', $adminMetadata->fieldMappings['id']['columnName']); |
|
837
|
|
|
$this->assertEquals(['user_id'=>'id','user_name'=>'name'], $adminMetadata->fieldNames); |
|
|
|
|
|
|
838
|
|
|
$this->assertEquals(['id'=>'user_id','name'=>'user_name'], $adminMetadata->columnNames); |
|
|
|
|
|
|
839
|
|
|
$this->assertEquals(150, $adminMetadata->fieldMappings['id']['length']); |
|
840
|
|
|
|
|
841
|
|
|
|
|
842
|
|
|
$this->assertEquals('name', $adminMetadata->fieldMappings['name']['fieldName']); |
|
843
|
|
|
$this->assertEquals('user_name', $adminMetadata->fieldMappings['name']['columnName']); |
|
844
|
|
|
$this->assertEquals(250, $adminMetadata->fieldMappings['name']['length']); |
|
845
|
|
|
$this->assertTrue($adminMetadata->fieldMappings['name']['nullable']); |
|
846
|
|
|
$this->assertFalse($adminMetadata->fieldMappings['name']['unique']); |
|
847
|
|
|
|
|
848
|
|
|
|
|
849
|
|
|
$this->assertTrue($guestMetadata->fieldMappings['id']['id']); |
|
850
|
|
|
$this->assertEquals('guest_id', $guestMetadata->fieldMappings['id']['columnName']); |
|
851
|
|
|
$this->assertEquals('id', $guestMetadata->fieldMappings['id']['fieldName']); |
|
852
|
|
|
$this->assertEquals(['guest_id'=>'id','guest_name'=>'name'], $guestMetadata->fieldNames); |
|
853
|
|
|
$this->assertEquals(['id'=>'guest_id','name'=>'guest_name'], $guestMetadata->columnNames); |
|
854
|
|
|
$this->assertEquals(140, $guestMetadata->fieldMappings['id']['length']); |
|
855
|
|
|
|
|
856
|
|
|
$this->assertEquals('name', $guestMetadata->fieldMappings['name']['fieldName']); |
|
857
|
|
|
$this->assertEquals('guest_name', $guestMetadata->fieldMappings['name']['columnName']); |
|
858
|
|
|
$this->assertEquals(240, $guestMetadata->fieldMappings['name']['length']); |
|
859
|
|
|
$this->assertFalse($guestMetadata->fieldMappings['name']['nullable']); |
|
860
|
|
|
$this->assertTrue($guestMetadata->fieldMappings['name']['unique']); |
|
861
|
|
|
} |
|
862
|
|
|
|
|
863
|
|
|
/** |
|
864
|
|
|
* @group DDC-1955 |
|
865
|
|
|
*/ |
|
866
|
|
|
public function testEntityListeners() |
|
867
|
|
|
{ |
|
868
|
|
|
$em = $this->_getTestEntityManager(); |
|
869
|
|
|
$factory = $this->createClassMetadataFactory($em); |
|
870
|
|
|
$superClass = $factory->getMetadataFor(CompanyContract::class); |
|
871
|
|
|
$flexClass = $factory->getMetadataFor(CompanyFixContract::class); |
|
872
|
|
|
$fixClass = $factory->getMetadataFor(CompanyFlexContract::class); |
|
873
|
|
|
$ultraClass = $factory->getMetadataFor(CompanyFlexUltraContract::class); |
|
|
|
|
|
|
874
|
|
|
|
|
875
|
|
|
$this->assertArrayHasKey(Events::prePersist, $superClass->entityListeners); |
|
|
|
|
|
|
876
|
|
|
$this->assertArrayHasKey(Events::postPersist, $superClass->entityListeners); |
|
877
|
|
|
|
|
878
|
|
|
$this->assertCount(1, $superClass->entityListeners[Events::prePersist]); |
|
879
|
|
|
$this->assertCount(1, $superClass->entityListeners[Events::postPersist]); |
|
880
|
|
|
|
|
881
|
|
|
$postPersist = $superClass->entityListeners[Events::postPersist][0]; |
|
882
|
|
|
$prePersist = $superClass->entityListeners[Events::prePersist][0]; |
|
883
|
|
|
|
|
884
|
|
|
$this->assertEquals(CompanyContractListener::class, $postPersist['class']); |
|
885
|
|
|
$this->assertEquals(CompanyContractListener::class, $prePersist['class']); |
|
886
|
|
|
$this->assertEquals('postPersistHandler', $postPersist['method']); |
|
887
|
|
|
$this->assertEquals('prePersistHandler', $prePersist['method']); |
|
888
|
|
|
|
|
889
|
|
|
//Inherited listeners |
|
890
|
|
|
$this->assertEquals($fixClass->entityListeners, $superClass->entityListeners); |
|
891
|
|
|
$this->assertEquals($flexClass->entityListeners, $superClass->entityListeners); |
|
892
|
|
|
} |
|
893
|
|
|
|
|
894
|
|
|
/** |
|
895
|
|
|
* @group DDC-1955 |
|
896
|
|
|
*/ |
|
897
|
|
|
public function testEntityListenersOverride() |
|
898
|
|
|
{ |
|
899
|
|
|
$em = $this->_getTestEntityManager(); |
|
900
|
|
|
$factory = $this->createClassMetadataFactory($em); |
|
901
|
|
|
$ultraClass = $factory->getMetadataFor(CompanyFlexUltraContract::class); |
|
902
|
|
|
|
|
903
|
|
|
//overridden listeners |
|
904
|
|
|
$this->assertArrayHasKey(Events::postPersist, $ultraClass->entityListeners); |
|
|
|
|
|
|
905
|
|
|
$this->assertArrayHasKey(Events::prePersist, $ultraClass->entityListeners); |
|
906
|
|
|
|
|
907
|
|
|
$this->assertCount(1, $ultraClass->entityListeners[Events::postPersist]); |
|
908
|
|
|
$this->assertCount(3, $ultraClass->entityListeners[Events::prePersist]); |
|
909
|
|
|
|
|
910
|
|
|
$postPersist = $ultraClass->entityListeners[Events::postPersist][0]; |
|
911
|
|
|
$prePersist = $ultraClass->entityListeners[Events::prePersist][0]; |
|
912
|
|
|
|
|
913
|
|
|
$this->assertEquals(CompanyContractListener::class, $postPersist['class']); |
|
914
|
|
|
$this->assertEquals(CompanyContractListener::class, $prePersist['class']); |
|
915
|
|
|
$this->assertEquals('postPersistHandler', $postPersist['method']); |
|
916
|
|
|
$this->assertEquals('prePersistHandler', $prePersist['method']); |
|
917
|
|
|
|
|
918
|
|
|
$prePersist = $ultraClass->entityListeners[Events::prePersist][1]; |
|
919
|
|
|
$this->assertEquals(CompanyFlexUltraContractListener::class, $prePersist['class']); |
|
920
|
|
|
$this->assertEquals('prePersistHandler1', $prePersist['method']); |
|
921
|
|
|
|
|
922
|
|
|
$prePersist = $ultraClass->entityListeners[Events::prePersist][2]; |
|
923
|
|
|
$this->assertEquals(CompanyFlexUltraContractListener::class, $prePersist['class']); |
|
924
|
|
|
$this->assertEquals('prePersistHandler2', $prePersist['method']); |
|
925
|
|
|
} |
|
926
|
|
|
|
|
927
|
|
|
|
|
928
|
|
|
/** |
|
929
|
|
|
* @group DDC-1955 |
|
930
|
|
|
*/ |
|
931
|
|
|
public function testEntityListenersNamingConvention() |
|
932
|
|
|
{ |
|
933
|
|
|
$em = $this->_getTestEntityManager(); |
|
934
|
|
|
$factory = $this->createClassMetadataFactory($em); |
|
935
|
|
|
$metadata = $factory->getMetadataFor(CmsAddress::class); |
|
936
|
|
|
|
|
937
|
|
|
$this->assertArrayHasKey(Events::postPersist, $metadata->entityListeners); |
|
|
|
|
|
|
938
|
|
|
$this->assertArrayHasKey(Events::prePersist, $metadata->entityListeners); |
|
939
|
|
|
$this->assertArrayHasKey(Events::postUpdate, $metadata->entityListeners); |
|
940
|
|
|
$this->assertArrayHasKey(Events::preUpdate, $metadata->entityListeners); |
|
941
|
|
|
$this->assertArrayHasKey(Events::postRemove, $metadata->entityListeners); |
|
942
|
|
|
$this->assertArrayHasKey(Events::preRemove, $metadata->entityListeners); |
|
943
|
|
|
$this->assertArrayHasKey(Events::postLoad, $metadata->entityListeners); |
|
944
|
|
|
$this->assertArrayHasKey(Events::preFlush, $metadata->entityListeners); |
|
945
|
|
|
|
|
946
|
|
|
$this->assertCount(1, $metadata->entityListeners[Events::postPersist]); |
|
947
|
|
|
$this->assertCount(1, $metadata->entityListeners[Events::prePersist]); |
|
948
|
|
|
$this->assertCount(1, $metadata->entityListeners[Events::postUpdate]); |
|
949
|
|
|
$this->assertCount(1, $metadata->entityListeners[Events::preUpdate]); |
|
950
|
|
|
$this->assertCount(1, $metadata->entityListeners[Events::postRemove]); |
|
951
|
|
|
$this->assertCount(1, $metadata->entityListeners[Events::preRemove]); |
|
952
|
|
|
$this->assertCount(1, $metadata->entityListeners[Events::postLoad]); |
|
953
|
|
|
$this->assertCount(1, $metadata->entityListeners[Events::preFlush]); |
|
954
|
|
|
|
|
955
|
|
|
$postPersist = $metadata->entityListeners[Events::postPersist][0]; |
|
956
|
|
|
$prePersist = $metadata->entityListeners[Events::prePersist][0]; |
|
957
|
|
|
$postUpdate = $metadata->entityListeners[Events::postUpdate][0]; |
|
958
|
|
|
$preUpdate = $metadata->entityListeners[Events::preUpdate][0]; |
|
959
|
|
|
$postRemove = $metadata->entityListeners[Events::postRemove][0]; |
|
960
|
|
|
$preRemove = $metadata->entityListeners[Events::preRemove][0]; |
|
961
|
|
|
$postLoad = $metadata->entityListeners[Events::postLoad][0]; |
|
962
|
|
|
$preFlush = $metadata->entityListeners[Events::preFlush][0]; |
|
963
|
|
|
|
|
964
|
|
|
|
|
965
|
|
|
$this->assertEquals(CmsAddressListener::class, $postPersist['class']); |
|
966
|
|
|
$this->assertEquals(CmsAddressListener::class, $prePersist['class']); |
|
967
|
|
|
$this->assertEquals(CmsAddressListener::class, $postUpdate['class']); |
|
968
|
|
|
$this->assertEquals(CmsAddressListener::class, $preUpdate['class']); |
|
969
|
|
|
$this->assertEquals(CmsAddressListener::class, $postRemove['class']); |
|
970
|
|
|
$this->assertEquals(CmsAddressListener::class, $preRemove['class']); |
|
971
|
|
|
$this->assertEquals(CmsAddressListener::class, $postLoad['class']); |
|
972
|
|
|
$this->assertEquals(CmsAddressListener::class, $preFlush['class']); |
|
973
|
|
|
|
|
974
|
|
|
$this->assertEquals(Events::postPersist, $postPersist['method']); |
|
975
|
|
|
$this->assertEquals(Events::prePersist, $prePersist['method']); |
|
976
|
|
|
$this->assertEquals(Events::postUpdate, $postUpdate['method']); |
|
977
|
|
|
$this->assertEquals(Events::preUpdate, $preUpdate['method']); |
|
978
|
|
|
$this->assertEquals(Events::postRemove, $postRemove['method']); |
|
979
|
|
|
$this->assertEquals(Events::preRemove, $preRemove['method']); |
|
980
|
|
|
$this->assertEquals(Events::postLoad, $postLoad['method']); |
|
981
|
|
|
$this->assertEquals(Events::preFlush, $preFlush['method']); |
|
982
|
|
|
} |
|
983
|
|
|
|
|
984
|
|
|
/** |
|
985
|
|
|
* @group DDC-2183 |
|
986
|
|
|
*/ |
|
987
|
|
|
public function testSecondLevelCacheMapping() |
|
988
|
|
|
{ |
|
989
|
|
|
$em = $this->_getTestEntityManager(); |
|
990
|
|
|
$factory = $this->createClassMetadataFactory($em); |
|
991
|
|
|
$class = $factory->getMetadataFor(City::class); |
|
992
|
|
|
$this->assertArrayHasKey('usage', $class->cache); |
|
|
|
|
|
|
993
|
|
|
$this->assertArrayHasKey('region', $class->cache); |
|
994
|
|
|
$this->assertEquals(ClassMetadata::CACHE_USAGE_READ_ONLY, $class->cache['usage']); |
|
995
|
|
|
$this->assertEquals('doctrine_tests_models_cache_city', $class->cache['region']); |
|
996
|
|
|
|
|
997
|
|
|
$this->assertArrayHasKey('state', $class->associationMappings); |
|
|
|
|
|
|
998
|
|
|
$this->assertArrayHasKey('cache', $class->associationMappings['state']); |
|
999
|
|
|
$this->assertArrayHasKey('usage', $class->associationMappings['state']['cache']); |
|
1000
|
|
|
$this->assertArrayHasKey('region', $class->associationMappings['state']['cache']); |
|
1001
|
|
|
$this->assertEquals(ClassMetadata::CACHE_USAGE_READ_ONLY, $class->associationMappings['state']['cache']['usage']); |
|
1002
|
|
|
$this->assertEquals('doctrine_tests_models_cache_city__state', $class->associationMappings['state']['cache']['region']); |
|
1003
|
|
|
|
|
1004
|
|
|
$this->assertArrayHasKey('attractions', $class->associationMappings); |
|
1005
|
|
|
$this->assertArrayHasKey('cache', $class->associationMappings['attractions']); |
|
1006
|
|
|
$this->assertArrayHasKey('usage', $class->associationMappings['attractions']['cache']); |
|
1007
|
|
|
$this->assertArrayHasKey('region', $class->associationMappings['attractions']['cache']); |
|
1008
|
|
|
$this->assertEquals(ClassMetadata::CACHE_USAGE_READ_ONLY, $class->associationMappings['attractions']['cache']['usage']); |
|
1009
|
|
|
$this->assertEquals('doctrine_tests_models_cache_city__attractions', $class->associationMappings['attractions']['cache']['region']); |
|
1010
|
|
|
} |
|
1011
|
|
|
|
|
1012
|
|
|
/** |
|
1013
|
|
|
* @group DDC-2825 |
|
1014
|
|
|
* @group 881 |
|
1015
|
|
|
*/ |
|
1016
|
|
|
public function testSchemaDefinitionViaExplicitTableSchemaAnnotationProperty() |
|
1017
|
|
|
{ |
|
1018
|
|
|
/* @var $metadata \Doctrine\ORM\Mapping\ClassMetadata */ |
|
1019
|
|
|
$metadata = $this->createClassMetadataFactory()->getMetadataFor(ExplicitSchemaAndTable::class); |
|
1020
|
|
|
|
|
1021
|
|
|
$this->assertSame('explicit_schema', $metadata->getSchemaName()); |
|
1022
|
|
|
$this->assertSame('explicit_table', $metadata->getTableName()); |
|
1023
|
|
|
} |
|
1024
|
|
|
|
|
1025
|
|
|
/** |
|
1026
|
|
|
* @group DDC-2825 |
|
1027
|
|
|
* @group 881 |
|
1028
|
|
|
*/ |
|
1029
|
|
|
public function testSchemaDefinitionViaSchemaDefinedInTableNameInTableAnnotationProperty() |
|
1030
|
|
|
{ |
|
1031
|
|
|
/* @var $metadata \Doctrine\ORM\Mapping\ClassMetadata */ |
|
1032
|
|
|
$metadata = $this->createClassMetadataFactory()->getMetadataFor(SchemaAndTableInTableName::class); |
|
1033
|
|
|
|
|
1034
|
|
|
$this->assertSame('implicit_schema', $metadata->getSchemaName()); |
|
1035
|
|
|
$this->assertSame('implicit_table', $metadata->getTableName()); |
|
1036
|
|
|
} |
|
1037
|
|
|
|
|
1038
|
|
|
/** |
|
1039
|
|
|
* @group DDC-514 |
|
1040
|
|
|
* @group DDC-1015 |
|
1041
|
|
|
*/ |
|
1042
|
|
|
public function testDiscriminatorColumnDefaultLength() |
|
1043
|
|
|
{ |
|
1044
|
|
|
if (strpos(get_class($this), 'PHPMappingDriver') !== false) { |
|
1045
|
|
|
$this->markTestSkipped('PHP Mapping Drivers have no defaults.'); |
|
1046
|
|
|
} |
|
1047
|
|
|
$class = $this->createClassMetadata(SingleTableEntityNoDiscriminatorColumnMapping::class); |
|
1048
|
|
|
$this->assertEquals(255, $class->discriminatorColumn['length']); |
|
1049
|
|
|
$class = $this->createClassMetadata(SingleTableEntityIncompleteDiscriminatorColumnMapping::class); |
|
1050
|
|
|
$this->assertEquals(255, $class->discriminatorColumn['length']); |
|
1051
|
|
|
} |
|
1052
|
|
|
|
|
1053
|
|
|
/** |
|
1054
|
|
|
* @group DDC-514 |
|
1055
|
|
|
* @group DDC-1015 |
|
1056
|
|
|
*/ |
|
1057
|
|
|
public function testDiscriminatorColumnDefaultType() |
|
1058
|
|
|
{ |
|
1059
|
|
|
if (strpos(get_class($this), 'PHPMappingDriver') !== false) { |
|
1060
|
|
|
$this->markTestSkipped('PHP Mapping Drivers have no defaults.'); |
|
1061
|
|
|
} |
|
1062
|
|
|
$class = $this->createClassMetadata(SingleTableEntityNoDiscriminatorColumnMapping::class); |
|
1063
|
|
|
$this->assertEquals('string', $class->discriminatorColumn['type']); |
|
1064
|
|
|
$class = $this->createClassMetadata(SingleTableEntityIncompleteDiscriminatorColumnMapping::class); |
|
1065
|
|
|
$this->assertEquals('string', $class->discriminatorColumn['type']); |
|
1066
|
|
|
} |
|
1067
|
|
|
|
|
1068
|
|
|
/** |
|
1069
|
|
|
* @group DDC-514 |
|
1070
|
|
|
* @group DDC-1015 |
|
1071
|
|
|
*/ |
|
1072
|
|
|
public function testDiscriminatorColumnDefaultName() |
|
1073
|
|
|
{ |
|
1074
|
|
|
if (strpos(get_class($this), 'PHPMappingDriver') !== false) { |
|
1075
|
|
|
$this->markTestSkipped('PHP Mapping Drivers have no defaults.'); |
|
1076
|
|
|
} |
|
1077
|
|
|
$class = $this->createClassMetadata(SingleTableEntityNoDiscriminatorColumnMapping::class); |
|
1078
|
|
|
$this->assertEquals('dtype', $class->discriminatorColumn['name']); |
|
1079
|
|
|
$class = $this->createClassMetadata(SingleTableEntityIncompleteDiscriminatorColumnMapping::class); |
|
1080
|
|
|
$this->assertEquals('dtype', $class->discriminatorColumn['name']); |
|
1081
|
|
|
} |
|
1082
|
|
|
|
|
1083
|
|
|
public function testInvalidSubClassCase() |
|
1084
|
|
|
{ |
|
1085
|
|
|
$this->expectException(MappingException::class); |
|
1086
|
|
|
$this->expectExceptionMessage('Entity class \'Doctrine\Tests\Models\CaseSensitiveDiscriminatorMap\cube\' used in the discriminator map of class \'Doctrine\Tests\Models\CaseSensitiveDiscriminatorMap\Shape\' does not exist.'); |
|
1087
|
|
|
$this->createClassMetadata(Shape::class); |
|
1088
|
|
|
} |
|
1089
|
|
|
} |
|
1090
|
|
|
|
|
1091
|
|
|
/** |
|
1092
|
|
|
* @Entity |
|
1093
|
|
|
* @HasLifecycleCallbacks |
|
1094
|
|
|
* @Table( |
|
1095
|
|
|
* name="cms_users", |
|
1096
|
|
|
* uniqueConstraints={@UniqueConstraint(name="search_idx", columns={"name", "user_email"}, options={"where": "name IS NOT NULL"})}, |
|
1097
|
|
|
* indexes={@Index(name="name_idx", columns={"name"}), @Index(name="0", columns={"user_email"})}, |
|
1098
|
|
|
* options={"foo": "bar", "baz": {"key": "val"}} |
|
1099
|
|
|
* ) |
|
1100
|
|
|
* @NamedQueries({@NamedQuery(name="all", query="SELECT u FROM __CLASS__ u")}) |
|
1101
|
|
|
*/ |
|
1102
|
|
|
class User |
|
1103
|
|
|
{ |
|
1104
|
|
|
/** |
|
1105
|
|
|
* @Id |
|
1106
|
|
|
* @Column(type="integer", options={"foo": "bar", "unsigned": false}) |
|
1107
|
|
|
* @generatedValue(strategy="AUTO") |
|
1108
|
|
|
* @SequenceGenerator(sequenceName="tablename_seq", initialValue=1, allocationSize=100) |
|
1109
|
|
|
**/ |
|
1110
|
|
|
public $id; |
|
1111
|
|
|
|
|
1112
|
|
|
/** |
|
1113
|
|
|
* @Column(length=50, nullable=true, unique=true, options={"foo": "bar", "baz": {"key": "val"}, "fixed": false}) |
|
1114
|
|
|
*/ |
|
1115
|
|
|
public $name; |
|
1116
|
|
|
|
|
1117
|
|
|
/** |
|
1118
|
|
|
* @Column(name="user_email", columnDefinition="CHAR(32) NOT NULL") |
|
1119
|
|
|
*/ |
|
1120
|
|
|
public $email; |
|
1121
|
|
|
|
|
1122
|
|
|
/** |
|
1123
|
|
|
* @OneToOne(targetEntity="Address", cascade={"remove"}, inversedBy="user") |
|
1124
|
|
|
* @JoinColumn(onDelete="CASCADE") |
|
1125
|
|
|
*/ |
|
1126
|
|
|
public $address; |
|
1127
|
|
|
|
|
1128
|
|
|
/** |
|
1129
|
|
|
* @OneToMany(targetEntity="Phonenumber", mappedBy="user", cascade={"persist"}, orphanRemoval=true) |
|
1130
|
|
|
* @OrderBy({"number"="ASC"}) |
|
1131
|
|
|
*/ |
|
1132
|
|
|
public $phonenumbers; |
|
1133
|
|
|
|
|
1134
|
|
|
/** |
|
1135
|
|
|
* @ManyToMany(targetEntity="Group", cascade={"all"}) |
|
1136
|
|
|
* @JoinTable(name="cms_user_groups", |
|
1137
|
|
|
* joinColumns={@JoinColumn(name="user_id", referencedColumnName="id", nullable=false, unique=false)}, |
|
1138
|
|
|
* inverseJoinColumns={@JoinColumn(name="group_id", referencedColumnName="id", columnDefinition="INT NULL")} |
|
1139
|
|
|
* ) |
|
1140
|
|
|
*/ |
|
1141
|
|
|
public $groups; |
|
1142
|
|
|
|
|
1143
|
|
|
/** |
|
1144
|
|
|
* @Column(type="integer") |
|
1145
|
|
|
* @Version |
|
1146
|
|
|
*/ |
|
1147
|
|
|
public $version; |
|
1148
|
|
|
|
|
1149
|
|
|
|
|
1150
|
|
|
/** |
|
1151
|
|
|
* @PrePersist |
|
1152
|
|
|
*/ |
|
1153
|
|
|
public function doStuffOnPrePersist() |
|
1154
|
|
|
{ |
|
1155
|
|
|
} |
|
1156
|
|
|
|
|
1157
|
|
|
/** |
|
1158
|
|
|
* @PrePersist |
|
1159
|
|
|
*/ |
|
1160
|
|
|
public function doOtherStuffOnPrePersistToo() { |
|
1161
|
|
|
} |
|
1162
|
|
|
|
|
1163
|
|
|
/** |
|
1164
|
|
|
* @PostPersist |
|
1165
|
|
|
*/ |
|
1166
|
|
|
public function doStuffOnPostPersist() |
|
1167
|
|
|
{ |
|
1168
|
|
|
|
|
1169
|
|
|
} |
|
1170
|
|
|
|
|
1171
|
|
|
public static function loadMetadata(ClassMetadataInfo $metadata) |
|
1172
|
|
|
{ |
|
1173
|
|
|
$metadata->setInheritanceType(ClassMetadataInfo::INHERITANCE_TYPE_NONE); |
|
1174
|
|
|
$metadata->setPrimaryTable( |
|
1175
|
|
|
[ |
|
1176
|
|
|
'name' => 'cms_users', |
|
1177
|
|
|
'options' => ['foo' => 'bar', 'baz' => ['key' => 'val']], |
|
1178
|
|
|
] |
|
1179
|
|
|
); |
|
1180
|
|
|
$metadata->setChangeTrackingPolicy(ClassMetadataInfo::CHANGETRACKING_DEFERRED_IMPLICIT); |
|
1181
|
|
|
$metadata->addLifecycleCallback('doStuffOnPrePersist', 'prePersist'); |
|
1182
|
|
|
$metadata->addLifecycleCallback('doOtherStuffOnPrePersistToo', 'prePersist'); |
|
1183
|
|
|
$metadata->addLifecycleCallback('doStuffOnPostPersist', 'postPersist'); |
|
1184
|
|
|
$metadata->mapField( |
|
1185
|
|
|
[ |
|
1186
|
|
|
'id' => true, |
|
1187
|
|
|
'fieldName' => 'id', |
|
1188
|
|
|
'type' => 'integer', |
|
1189
|
|
|
'columnName' => 'id', |
|
1190
|
|
|
'options' => ['foo' => 'bar', 'unsigned' => false], |
|
1191
|
|
|
] |
|
1192
|
|
|
); |
|
1193
|
|
|
$metadata->mapField( |
|
1194
|
|
|
[ |
|
1195
|
|
|
'fieldName' => 'name', |
|
1196
|
|
|
'type' => 'string', |
|
1197
|
|
|
'length' => 50, |
|
1198
|
|
|
'unique' => true, |
|
1199
|
|
|
'nullable' => true, |
|
1200
|
|
|
'columnName' => 'name', |
|
1201
|
|
|
'options' => ['foo' => 'bar', 'baz' => ['key' => 'val'], 'fixed' => false], |
|
1202
|
|
|
] |
|
1203
|
|
|
); |
|
1204
|
|
|
$metadata->mapField( |
|
1205
|
|
|
[ |
|
1206
|
|
|
'fieldName' => 'email', |
|
1207
|
|
|
'type' => 'string', |
|
1208
|
|
|
'columnName' => 'user_email', |
|
1209
|
|
|
'columnDefinition' => 'CHAR(32) NOT NULL', |
|
1210
|
|
|
] |
|
1211
|
|
|
); |
|
1212
|
|
|
$mapping = ['fieldName' => 'version', 'type' => 'integer']; |
|
1213
|
|
|
$metadata->setVersionMapping($mapping); |
|
1214
|
|
|
$metadata->mapField($mapping); |
|
1215
|
|
|
$metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO); |
|
1216
|
|
|
$metadata->mapOneToOne( |
|
1217
|
|
|
[ |
|
1218
|
|
|
'fieldName' => 'address', |
|
1219
|
|
|
'targetEntity' => Address::class, |
|
1220
|
|
|
'cascade' => |
|
1221
|
|
|
[ |
|
1222
|
|
|
0 => 'remove', |
|
1223
|
|
|
], |
|
1224
|
|
|
'mappedBy' => NULL, |
|
1225
|
|
|
'inversedBy' => 'user', |
|
1226
|
|
|
'joinColumns' => |
|
1227
|
|
|
[ |
|
1228
|
|
|
0 => |
|
1229
|
|
|
[ |
|
1230
|
|
|
'name' => 'address_id', |
|
1231
|
|
|
'referencedColumnName' => 'id', |
|
1232
|
|
|
'onDelete' => 'CASCADE', |
|
1233
|
|
|
], |
|
1234
|
|
|
], |
|
1235
|
|
|
'orphanRemoval' => false, |
|
1236
|
|
|
] |
|
1237
|
|
|
); |
|
1238
|
|
|
$metadata->mapOneToMany( |
|
1239
|
|
|
[ |
|
1240
|
|
|
'fieldName' => 'phonenumbers', |
|
1241
|
|
|
'targetEntity' => Phonenumber::class, |
|
1242
|
|
|
'cascade' => |
|
1243
|
|
|
[ |
|
1244
|
|
|
1 => 'persist', |
|
1245
|
|
|
], |
|
1246
|
|
|
'mappedBy' => 'user', |
|
1247
|
|
|
'orphanRemoval' => true, |
|
1248
|
|
|
'orderBy' => |
|
1249
|
|
|
[ |
|
1250
|
|
|
'number' => 'ASC', |
|
1251
|
|
|
], |
|
1252
|
|
|
] |
|
1253
|
|
|
); |
|
1254
|
|
|
$metadata->mapManyToMany( |
|
1255
|
|
|
[ |
|
1256
|
|
|
'fieldName' => 'groups', |
|
1257
|
|
|
'targetEntity' => Group::class, |
|
1258
|
|
|
'cascade' => |
|
1259
|
|
|
[ |
|
1260
|
|
|
0 => 'remove', |
|
1261
|
|
|
1 => 'persist', |
|
1262
|
|
|
2 => 'refresh', |
|
1263
|
|
|
3 => 'merge', |
|
1264
|
|
|
4 => 'detach', |
|
1265
|
|
|
], |
|
1266
|
|
|
'mappedBy' => NULL, |
|
1267
|
|
|
'joinTable' => |
|
1268
|
|
|
[ |
|
1269
|
|
|
'name' => 'cms_users_groups', |
|
1270
|
|
|
'joinColumns' => |
|
1271
|
|
|
[ |
|
1272
|
|
|
0 => |
|
1273
|
|
|
[ |
|
1274
|
|
|
'name' => 'user_id', |
|
1275
|
|
|
'referencedColumnName' => 'id', |
|
1276
|
|
|
'unique' => false, |
|
1277
|
|
|
'nullable' => false, |
|
1278
|
|
|
], |
|
1279
|
|
|
], |
|
1280
|
|
|
'inverseJoinColumns' => |
|
1281
|
|
|
[ |
|
1282
|
|
|
0 => |
|
1283
|
|
|
[ |
|
1284
|
|
|
'name' => 'group_id', |
|
1285
|
|
|
'referencedColumnName' => 'id', |
|
1286
|
|
|
'columnDefinition' => 'INT NULL', |
|
1287
|
|
|
], |
|
1288
|
|
|
], |
|
1289
|
|
|
], |
|
1290
|
|
|
'orderBy' => NULL, |
|
1291
|
|
|
] |
|
1292
|
|
|
); |
|
1293
|
|
|
$metadata->table['uniqueConstraints'] = [ |
|
1294
|
|
|
'search_idx' => ['columns' => ['name', 'user_email'], 'options'=> ['where' => 'name IS NOT NULL']], |
|
1295
|
|
|
]; |
|
1296
|
|
|
$metadata->table['indexes'] = [ |
|
1297
|
|
|
'name_idx' => ['columns' => ['name']], 0 => ['columns' => ['user_email']] |
|
1298
|
|
|
]; |
|
1299
|
|
|
$metadata->setSequenceGeneratorDefinition( |
|
1300
|
|
|
[ |
|
1301
|
|
|
'sequenceName' => 'tablename_seq', |
|
1302
|
|
|
'allocationSize' => 100, |
|
1303
|
|
|
'initialValue' => 1, |
|
1304
|
|
|
] |
|
1305
|
|
|
); |
|
1306
|
|
|
$metadata->addNamedQuery( |
|
1307
|
|
|
[ |
|
1308
|
|
|
'name' => 'all', |
|
1309
|
|
|
'query' => 'SELECT u FROM __CLASS__ u' |
|
1310
|
|
|
] |
|
1311
|
|
|
); |
|
1312
|
|
|
} |
|
1313
|
|
|
} |
|
1314
|
|
|
|
|
1315
|
|
|
/** |
|
1316
|
|
|
* @Entity |
|
1317
|
|
|
* @InheritanceType("SINGLE_TABLE") |
|
1318
|
|
|
* @DiscriminatorMap({"cat" = "Cat", "dog" = "Dog"}) |
|
1319
|
|
|
* @DiscriminatorColumn(name="discr", length=32, type="string") |
|
1320
|
|
|
*/ |
|
1321
|
|
|
abstract class Animal |
|
1322
|
|
|
{ |
|
1323
|
|
|
/** |
|
1324
|
|
|
* @Id @Column(type="string") @GeneratedValue(strategy="CUSTOM") |
|
1325
|
|
|
* @CustomIdGenerator(class="stdClass") |
|
1326
|
|
|
*/ |
|
1327
|
|
|
public $id; |
|
1328
|
|
|
|
|
1329
|
|
|
public static function loadMetadata(ClassMetadataInfo $metadata) |
|
1330
|
|
|
{ |
|
1331
|
|
|
$metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_CUSTOM); |
|
1332
|
|
|
$metadata->setCustomGeneratorDefinition(["class" => "stdClass"]); |
|
1333
|
|
|
} |
|
1334
|
|
|
} |
|
1335
|
|
|
|
|
1336
|
|
|
/** @Entity */ |
|
1337
|
|
|
class Cat extends Animal |
|
1338
|
|
|
{ |
|
1339
|
|
|
public static function loadMetadata(ClassMetadataInfo $metadata) |
|
1340
|
|
|
{ |
|
1341
|
|
|
|
|
1342
|
|
|
} |
|
1343
|
|
|
} |
|
1344
|
|
|
|
|
1345
|
|
|
/** @Entity */ |
|
1346
|
|
|
class Dog extends Animal |
|
1347
|
|
|
{ |
|
1348
|
|
|
public static function loadMetadata(ClassMetadataInfo $metadata) |
|
1349
|
|
|
{ |
|
1350
|
|
|
|
|
1351
|
|
|
} |
|
1352
|
|
|
} |
|
1353
|
|
|
|
|
1354
|
|
|
/** |
|
1355
|
|
|
* @Entity |
|
1356
|
|
|
*/ |
|
1357
|
|
|
class DDC1170Entity |
|
1358
|
|
|
{ |
|
1359
|
|
|
|
|
1360
|
|
|
/** |
|
1361
|
|
|
* @param string $value |
|
1362
|
|
|
*/ |
|
1363
|
|
|
function __construct($value = null) |
|
|
|
|
|
|
1364
|
|
|
{ |
|
1365
|
|
|
$this->value = $value; |
|
1366
|
|
|
} |
|
1367
|
|
|
|
|
1368
|
|
|
/** |
|
1369
|
|
|
* @Id |
|
1370
|
|
|
* @GeneratedValue(strategy="NONE") |
|
1371
|
|
|
* @Column(type="integer", columnDefinition = "INT unsigned NOT NULL") |
|
1372
|
|
|
**/ |
|
1373
|
|
|
private $id; |
|
1374
|
|
|
|
|
1375
|
|
|
/** |
|
1376
|
|
|
* @Column(columnDefinition = "VARCHAR(255) NOT NULL") |
|
1377
|
|
|
*/ |
|
1378
|
|
|
private $value; |
|
1379
|
|
|
|
|
1380
|
|
|
/** |
|
1381
|
|
|
* @return int |
|
1382
|
|
|
*/ |
|
1383
|
|
|
public function getId() |
|
1384
|
|
|
{ |
|
1385
|
|
|
return $this->id; |
|
1386
|
|
|
} |
|
1387
|
|
|
|
|
1388
|
|
|
/** |
|
1389
|
|
|
* @return string |
|
1390
|
|
|
*/ |
|
1391
|
|
|
public function getValue() |
|
1392
|
|
|
{ |
|
1393
|
|
|
return $this->value; |
|
1394
|
|
|
} |
|
1395
|
|
|
|
|
1396
|
|
|
public static function loadMetadata(ClassMetadataInfo $metadata) |
|
1397
|
|
|
{ |
|
1398
|
|
|
$metadata->mapField( |
|
1399
|
|
|
[ |
|
1400
|
|
|
'id' => true, |
|
1401
|
|
|
'fieldName' => 'id', |
|
1402
|
|
|
'columnDefinition' => 'INT unsigned NOT NULL', |
|
1403
|
|
|
] |
|
1404
|
|
|
); |
|
1405
|
|
|
|
|
1406
|
|
|
$metadata->mapField( |
|
1407
|
|
|
[ |
|
1408
|
|
|
'fieldName' => 'value', |
|
1409
|
|
|
'columnDefinition' => 'VARCHAR(255) NOT NULL' |
|
1410
|
|
|
] |
|
1411
|
|
|
); |
|
1412
|
|
|
|
|
1413
|
|
|
$metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_NONE); |
|
1414
|
|
|
} |
|
1415
|
|
|
|
|
1416
|
|
|
} |
|
1417
|
|
|
|
|
1418
|
|
|
/** |
|
1419
|
|
|
* @Entity |
|
1420
|
|
|
* @InheritanceType("SINGLE_TABLE") |
|
1421
|
|
|
* @DiscriminatorMap({"ONE" = "DDC807SubClasse1", "TWO" = "DDC807SubClasse2"}) |
|
1422
|
|
|
* @DiscriminatorColumn(name = "dtype", columnDefinition="ENUM('ONE','TWO')") |
|
1423
|
|
|
*/ |
|
1424
|
|
|
class DDC807Entity |
|
1425
|
|
|
{ |
|
1426
|
|
|
/** |
|
1427
|
|
|
* @Id |
|
1428
|
|
|
* @Column(type="integer") |
|
1429
|
|
|
* @GeneratedValue(strategy="NONE") |
|
1430
|
|
|
**/ |
|
1431
|
|
|
public $id; |
|
1432
|
|
|
|
|
1433
|
|
|
public static function loadMetadata(ClassMetadataInfo $metadata) |
|
1434
|
|
|
{ |
|
1435
|
|
|
$metadata->mapField( |
|
1436
|
|
|
[ |
|
1437
|
|
|
'id' => true, |
|
1438
|
|
|
'fieldName' => 'id', |
|
1439
|
|
|
] |
|
1440
|
|
|
); |
|
1441
|
|
|
|
|
1442
|
|
|
$metadata->setDiscriminatorColumn( |
|
1443
|
|
|
[ |
|
1444
|
|
|
'name' => "dtype", |
|
1445
|
|
|
'type' => "string", |
|
1446
|
|
|
'columnDefinition' => "ENUM('ONE','TWO')" |
|
1447
|
|
|
] |
|
1448
|
|
|
); |
|
1449
|
|
|
|
|
1450
|
|
|
$metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_NONE); |
|
1451
|
|
|
} |
|
1452
|
|
|
} |
|
1453
|
|
|
|
|
1454
|
|
|
class DDC807SubClasse1 {} |
|
1455
|
|
|
class DDC807SubClasse2 {} |
|
1456
|
|
|
|
|
1457
|
|
|
class Address {} |
|
1458
|
|
|
class Phonenumber {} |
|
1459
|
|
|
class Group {} |
|
1460
|
|
|
|
|
1461
|
|
|
/** |
|
1462
|
|
|
* @Entity |
|
1463
|
|
|
* @Table(indexes={@Index(columns={"content"}, flags={"fulltext"}, options={"where": "content IS NOT NULL"})}) |
|
1464
|
|
|
*/ |
|
1465
|
|
|
class Comment |
|
1466
|
|
|
{ |
|
1467
|
|
|
/** |
|
1468
|
|
|
* @Column(type="text") |
|
1469
|
|
|
*/ |
|
1470
|
|
|
private $content; |
|
|
|
|
|
|
1471
|
|
|
|
|
1472
|
|
|
public static function loadMetadata(ClassMetadataInfo $metadata) |
|
1473
|
|
|
{ |
|
1474
|
|
|
$metadata->setInheritanceType(ClassMetadataInfo::INHERITANCE_TYPE_NONE); |
|
1475
|
|
|
$metadata->setPrimaryTable( |
|
1476
|
|
|
[ |
|
1477
|
|
|
'indexes' => [ |
|
1478
|
|
|
['columns' => ['content'], 'flags' => ['fulltext'], 'options' => ['where' => 'content IS NOT NULL']] |
|
1479
|
|
|
] |
|
1480
|
|
|
] |
|
1481
|
|
|
); |
|
1482
|
|
|
|
|
1483
|
|
|
$metadata->mapField( |
|
1484
|
|
|
[ |
|
1485
|
|
|
'fieldName' => 'content', |
|
1486
|
|
|
'type' => 'text', |
|
1487
|
|
|
'scale' => 0, |
|
1488
|
|
|
'length' => NULL, |
|
1489
|
|
|
'unique' => false, |
|
1490
|
|
|
'nullable' => false, |
|
1491
|
|
|
'precision' => 0, |
|
1492
|
|
|
'columnName' => 'content', |
|
1493
|
|
|
] |
|
1494
|
|
|
); |
|
1495
|
|
|
} |
|
1496
|
|
|
} |
|
1497
|
|
|
|
|
1498
|
|
|
/** |
|
1499
|
|
|
* @Entity |
|
1500
|
|
|
* @InheritanceType("SINGLE_TABLE") |
|
1501
|
|
|
* @DiscriminatorMap({ |
|
1502
|
|
|
* "ONE" = "SingleTableEntityNoDiscriminatorColumnMappingSub1", |
|
1503
|
|
|
* "TWO" = "SingleTableEntityNoDiscriminatorColumnMappingSub2" |
|
1504
|
|
|
* }) |
|
1505
|
|
|
*/ |
|
1506
|
|
|
class SingleTableEntityNoDiscriminatorColumnMapping |
|
1507
|
|
|
{ |
|
1508
|
|
|
/** |
|
1509
|
|
|
* @Id |
|
1510
|
|
|
* @Column(type="integer") |
|
1511
|
|
|
* @GeneratedValue(strategy="NONE") |
|
1512
|
|
|
*/ |
|
1513
|
|
|
public $id; |
|
1514
|
|
|
|
|
1515
|
|
|
public static function loadMetadata(ClassMetadataInfo $metadata) |
|
1516
|
|
|
{ |
|
1517
|
|
|
$metadata->mapField( |
|
1518
|
|
|
[ |
|
1519
|
|
|
'id' => true, |
|
1520
|
|
|
'fieldName' => 'id', |
|
1521
|
|
|
] |
|
1522
|
|
|
); |
|
1523
|
|
|
|
|
1524
|
|
|
$metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_NONE); |
|
1525
|
|
|
} |
|
1526
|
|
|
} |
|
1527
|
|
|
|
|
1528
|
|
|
class SingleTableEntityNoDiscriminatorColumnMappingSub1 extends SingleTableEntityNoDiscriminatorColumnMapping {} |
|
1529
|
|
|
class SingleTableEntityNoDiscriminatorColumnMappingSub2 extends SingleTableEntityNoDiscriminatorColumnMapping {} |
|
1530
|
|
|
|
|
1531
|
|
|
/** |
|
1532
|
|
|
* @Entity |
|
1533
|
|
|
* @InheritanceType("SINGLE_TABLE") |
|
1534
|
|
|
* @DiscriminatorMap({ |
|
1535
|
|
|
* "ONE" = "SingleTableEntityIncompleteDiscriminatorColumnMappingSub1", |
|
1536
|
|
|
* "TWO" = "SingleTableEntityIncompleteDiscriminatorColumnMappingSub2" |
|
1537
|
|
|
* }) |
|
1538
|
|
|
* @DiscriminatorColumn(name="dtype") |
|
1539
|
|
|
*/ |
|
1540
|
|
|
class SingleTableEntityIncompleteDiscriminatorColumnMapping |
|
1541
|
|
|
{ |
|
1542
|
|
|
/** |
|
1543
|
|
|
* @Id |
|
1544
|
|
|
* @Column(type="integer") |
|
1545
|
|
|
* @GeneratedValue(strategy="NONE") |
|
1546
|
|
|
*/ |
|
1547
|
|
|
public $id; |
|
1548
|
|
|
|
|
1549
|
|
|
public static function loadMetadata(ClassMetadataInfo $metadata) |
|
1550
|
|
|
{ |
|
1551
|
|
|
$metadata->mapField( |
|
1552
|
|
|
[ |
|
1553
|
|
|
'id' => true, |
|
1554
|
|
|
'fieldName' => 'id', |
|
1555
|
|
|
] |
|
1556
|
|
|
); |
|
1557
|
|
|
|
|
1558
|
|
|
$metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_NONE); |
|
1559
|
|
|
} |
|
1560
|
|
|
} |
|
1561
|
|
|
|
|
1562
|
|
|
class SingleTableEntityIncompleteDiscriminatorColumnMappingSub1 |
|
1563
|
|
|
extends SingleTableEntityIncompleteDiscriminatorColumnMapping {} |
|
1564
|
|
|
class SingleTableEntityIncompleteDiscriminatorColumnMappingSub2 |
|
1565
|
|
|
extends SingleTableEntityIncompleteDiscriminatorColumnMapping {} |
|
1566
|
|
|
|
doctrine /
orm
Loading history...
This function has been deprecated. The supplier of the function has supplied an explanatory message.
The explanatory message should give you some clue as to whether and when the function will be removed and what other function to use instead.