1
|
|
|
<?php |
2
|
|
|
|
3
|
|
|
declare(strict_types=1); |
4
|
|
|
|
5
|
|
|
namespace Doctrine\ODM\MongoDB\Query; |
6
|
|
|
|
7
|
|
|
use BadMethodCallException; |
8
|
|
|
use Doctrine\ODM\MongoDB\DocumentManager; |
9
|
|
|
use Doctrine\ODM\MongoDB\Iterator\CachingIterator; |
10
|
|
|
use Doctrine\ODM\MongoDB\Iterator\HydratingIterator; |
11
|
|
|
use Doctrine\ODM\MongoDB\Iterator\Iterator; |
12
|
|
|
use Doctrine\ODM\MongoDB\Iterator\PrimingIterator; |
13
|
|
|
use Doctrine\ODM\MongoDB\Mapping\ClassMetadata; |
14
|
|
|
use Doctrine\ODM\MongoDB\MongoDBException; |
15
|
|
|
use InvalidArgumentException; |
16
|
|
|
use IteratorAggregate; |
17
|
|
|
use MongoDB\Collection; |
18
|
|
|
use MongoDB\Driver\Cursor; |
19
|
|
|
use MongoDB\Operation\FindOneAndUpdate; |
20
|
|
|
use UnexpectedValueException; |
21
|
|
|
use function array_combine; |
22
|
|
|
use function array_filter; |
23
|
|
|
use function array_flip; |
24
|
|
|
use function array_intersect_key; |
25
|
|
|
use function array_keys; |
26
|
|
|
use function array_map; |
27
|
|
|
use function array_merge; |
28
|
|
|
use function array_values; |
29
|
|
|
use function is_array; |
30
|
|
|
use function is_callable; |
31
|
|
|
|
32
|
|
|
/** |
33
|
|
|
* ODM Query wraps the raw Doctrine MongoDB queries to add additional functionality |
34
|
|
|
* and to hydrate the raw arrays of data to Doctrine document objects. |
35
|
|
|
*/ |
36
|
|
|
class Query implements IteratorAggregate |
37
|
|
|
{ |
38
|
|
|
public const TYPE_FIND = 1; |
39
|
|
|
public const TYPE_FIND_AND_UPDATE = 2; |
40
|
|
|
public const TYPE_FIND_AND_REMOVE = 3; |
41
|
|
|
public const TYPE_INSERT = 4; |
42
|
|
|
public const TYPE_UPDATE = 5; |
43
|
|
|
public const TYPE_REMOVE = 6; |
44
|
|
|
public const TYPE_GROUP = 7; |
45
|
|
|
public const TYPE_MAP_REDUCE = 8; |
46
|
|
|
public const TYPE_DISTINCT = 9; |
47
|
|
|
public const TYPE_COUNT = 11; |
48
|
|
|
|
49
|
|
|
/** |
50
|
|
|
* @deprecated 1.1 Will be removed for 2.0 |
51
|
|
|
*/ |
52
|
|
|
public const TYPE_GEO_LOCATION = 10; |
53
|
|
|
|
54
|
|
|
public const HINT_REFRESH = 1; |
55
|
|
|
// 2 was used for HINT_SLAVE_OKAY, which was removed in 2.0 |
56
|
|
|
public const HINT_READ_PREFERENCE = 3; |
57
|
|
|
public const HINT_READ_ONLY = 5; |
58
|
|
|
|
59
|
|
|
/** |
60
|
|
|
* The DocumentManager instance. |
61
|
|
|
* |
62
|
|
|
* @var DocumentManager |
63
|
|
|
*/ |
64
|
|
|
private $dm; |
65
|
|
|
|
66
|
|
|
/** |
67
|
|
|
* The ClassMetadata instance. |
68
|
|
|
* |
69
|
|
|
* @var ClassMetadata |
70
|
|
|
*/ |
71
|
|
|
private $class; |
72
|
|
|
|
73
|
|
|
/** |
74
|
|
|
* Whether to hydrate results as document class instances. |
75
|
|
|
* |
76
|
|
|
* @var bool |
77
|
|
|
*/ |
78
|
|
|
private $hydrate = true; |
79
|
|
|
|
80
|
|
|
/** |
81
|
|
|
* Array of primer Closure instances. |
82
|
|
|
* |
83
|
|
|
* @var array |
84
|
|
|
*/ |
85
|
|
|
private $primers = []; |
86
|
|
|
|
87
|
|
|
/** |
88
|
|
|
* Hints for UnitOfWork behavior. |
89
|
|
|
* |
90
|
|
|
* @var array |
91
|
|
|
*/ |
92
|
|
|
private $unitOfWorkHints = []; |
93
|
|
|
|
94
|
|
|
/** |
95
|
|
|
* The Collection instance. |
96
|
|
|
* |
97
|
|
|
* @var Collection |
98
|
|
|
*/ |
99
|
|
|
protected $collection; |
100
|
|
|
|
101
|
|
|
/** |
102
|
|
|
* Query structure generated by the Builder class. |
103
|
|
|
* |
104
|
|
|
* @var array |
105
|
|
|
*/ |
106
|
|
|
private $query; |
107
|
|
|
|
108
|
|
|
/** @var Iterator */ |
109
|
|
|
private $iterator; |
110
|
|
|
|
111
|
|
|
/** |
112
|
|
|
* Query options |
113
|
|
|
* |
114
|
|
|
* @var array |
115
|
|
|
*/ |
116
|
|
|
private $options; |
117
|
|
|
|
118
|
162 |
|
public function __construct(DocumentManager $dm, ClassMetadata $class, Collection $collection, array $query = [], array $options = [], bool $hydrate = true, bool $refresh = false, array $primers = [], bool $readOnly = false) |
119
|
|
|
{ |
120
|
162 |
|
$primers = array_filter($primers); |
121
|
|
|
|
122
|
162 |
|
switch ($query['type']) { |
123
|
162 |
|
case self::TYPE_FIND: |
124
|
38 |
|
case self::TYPE_FIND_AND_UPDATE: |
125
|
26 |
|
case self::TYPE_FIND_AND_REMOVE: |
126
|
23 |
|
case self::TYPE_INSERT: |
127
|
22 |
|
case self::TYPE_UPDATE: |
128
|
8 |
|
case self::TYPE_REMOVE: |
129
|
6 |
|
case self::TYPE_GROUP: |
130
|
6 |
|
case self::TYPE_MAP_REDUCE: |
131
|
6 |
|
case self::TYPE_DISTINCT: |
132
|
4 |
|
case self::TYPE_COUNT: |
133
|
161 |
|
break; |
134
|
|
|
|
135
|
|
|
default: |
136
|
1 |
|
throw new InvalidArgumentException('Invalid query type: ' . $query['type']); |
137
|
|
|
} |
138
|
|
|
|
139
|
161 |
|
$this->collection = $collection; |
140
|
161 |
|
$this->query = $query; |
141
|
161 |
|
$this->options = $options; |
142
|
161 |
|
$this->dm = $dm; |
143
|
161 |
|
$this->class = $class; |
144
|
161 |
|
$this->hydrate = $hydrate; |
145
|
161 |
|
$this->primers = $primers; |
146
|
|
|
|
147
|
161 |
|
$this->setReadOnly($readOnly); |
148
|
161 |
|
$this->setRefresh($refresh); |
149
|
|
|
|
150
|
161 |
|
if (! isset($query['readPreference'])) { |
151
|
155 |
|
return; |
152
|
|
|
} |
153
|
|
|
|
154
|
6 |
|
$this->unitOfWorkHints[self::HINT_READ_PREFERENCE] = $query['readPreference']; |
155
|
6 |
|
} |
156
|
|
|
|
157
|
64 |
|
public function __clone() |
158
|
|
|
{ |
159
|
64 |
|
$this->iterator = null; |
160
|
64 |
|
} |
161
|
|
|
|
162
|
|
|
/** |
163
|
|
|
* Return an array of information about the query structure for debugging. |
164
|
|
|
* |
165
|
|
|
* The $name parameter may be used to return a specific key from the |
166
|
|
|
* internal $query array property. If omitted, the entire array will be |
167
|
|
|
* returned. |
168
|
|
|
*/ |
169
|
27 |
|
public function debug(?string $name = null) |
170
|
|
|
{ |
171
|
27 |
|
return $name !== null ? $this->query[$name] : $this->query; |
172
|
|
|
} |
173
|
|
|
|
174
|
|
|
/** |
175
|
|
|
* Execute the query and returns the results. |
176
|
|
|
* |
177
|
|
|
* @return Iterator|int|string|array |
178
|
|
|
* |
179
|
|
|
* @throws MongoDBException |
180
|
|
|
*/ |
181
|
122 |
|
public function execute() |
182
|
|
|
{ |
183
|
122 |
|
$results = $this->runQuery(); |
184
|
|
|
|
185
|
122 |
|
if (! $this->hydrate) { |
186
|
9 |
|
return $results; |
187
|
|
|
} |
188
|
|
|
|
189
|
116 |
|
if ($results instanceof Cursor) { |
|
|
|
|
190
|
|
|
$results = $this->makeIterator($results); |
191
|
|
|
} |
192
|
|
|
|
193
|
116 |
|
$uow = $this->dm->getUnitOfWork(); |
194
|
|
|
|
195
|
|
|
/* If a single document is returned from a findAndModify command and it |
196
|
|
|
* includes the identifier field, attempt hydration. |
197
|
|
|
*/ |
198
|
116 |
|
if (($this->query['type'] === self::TYPE_FIND_AND_UPDATE || |
199
|
116 |
|
$this->query['type'] === self::TYPE_FIND_AND_REMOVE) && |
200
|
116 |
|
is_array($results) && isset($results['_id'])) { |
201
|
5 |
|
$results = $uow->getOrCreateDocument($this->class->name, $results, $this->unitOfWorkHints); |
202
|
|
|
|
203
|
5 |
|
if (! empty($this->primers)) { |
204
|
1 |
|
$referencePrimer = new ReferencePrimer($this->dm, $uow); |
205
|
|
|
|
206
|
1 |
|
foreach ($this->primers as $fieldName => $primer) { |
207
|
1 |
|
$primer = is_callable($primer) ? $primer : null; |
208
|
1 |
|
$referencePrimer->primeReferences($this->class, [$results], $fieldName, $this->unitOfWorkHints, $primer); |
209
|
|
|
} |
210
|
|
|
} |
211
|
|
|
} |
212
|
|
|
|
213
|
116 |
|
return $results; |
214
|
|
|
} |
215
|
|
|
|
216
|
|
|
/** |
217
|
|
|
* Gets the ClassMetadata instance. |
218
|
|
|
*/ |
219
|
|
|
public function getClass() : ClassMetadata |
220
|
|
|
{ |
221
|
|
|
return $this->class; |
222
|
|
|
} |
223
|
|
|
|
224
|
|
|
public function getDocumentManager() : DocumentManager |
225
|
|
|
{ |
226
|
|
|
return $this->dm; |
227
|
|
|
} |
228
|
|
|
|
229
|
|
|
/** |
230
|
|
|
* Execute the query and return its result, which must be an Iterator. |
231
|
|
|
* |
232
|
|
|
* If the query type is not expected to return an Iterator, |
233
|
|
|
* BadMethodCallException will be thrown before executing the query. |
234
|
|
|
* Otherwise, the query will be executed and UnexpectedValueException will |
235
|
|
|
* be thrown if {@link Query::execute()} does not return an Iterator. |
236
|
|
|
* |
237
|
|
|
* @see http://php.net/manual/en/iteratoraggregate.getiterator.php |
238
|
|
|
* |
239
|
|
|
* @throws BadMethodCallException If the query type would not return an Iterator. |
240
|
|
|
* @throws UnexpectedValueException If the query did not return an Iterator. |
241
|
|
|
* @throws MongoDBException |
242
|
|
|
*/ |
243
|
83 |
|
public function getIterator() : Iterator |
244
|
|
|
{ |
245
|
83 |
|
switch ($this->query['type']) { |
246
|
83 |
|
case self::TYPE_FIND: |
247
|
6 |
|
case self::TYPE_GROUP: |
248
|
6 |
|
case self::TYPE_MAP_REDUCE: |
249
|
6 |
|
case self::TYPE_DISTINCT: |
250
|
77 |
|
break; |
251
|
|
|
|
252
|
|
|
default: |
253
|
6 |
|
throw new BadMethodCallException('Iterator would not be returned for query type: ' . $this->query['type']); |
254
|
|
|
} |
255
|
|
|
|
256
|
77 |
|
if ($this->iterator === null) { |
257
|
77 |
|
$this->iterator = $this->execute(); |
258
|
|
|
} |
259
|
|
|
|
260
|
77 |
|
return $this->iterator; |
261
|
|
|
} |
262
|
|
|
|
263
|
|
|
/** |
264
|
|
|
* Return the query structure. |
265
|
|
|
*/ |
266
|
13 |
|
public function getQuery() : array |
267
|
|
|
{ |
268
|
13 |
|
return $this->query; |
269
|
|
|
} |
270
|
|
|
|
271
|
|
|
/** |
272
|
|
|
* Execute the query and return the first result. |
273
|
|
|
* |
274
|
|
|
* @return array|object|null |
275
|
|
|
*/ |
276
|
64 |
|
public function getSingleResult() |
277
|
|
|
{ |
278
|
64 |
|
$clonedQuery = clone $this; |
279
|
64 |
|
$clonedQuery->query['limit'] = 1; |
280
|
64 |
|
return $clonedQuery->getIterator()->current() ?: null; |
|
|
|
|
281
|
|
|
} |
282
|
|
|
|
283
|
|
|
/** |
284
|
|
|
* Return the query type. |
285
|
|
|
*/ |
286
|
|
|
public function getType() : int |
287
|
|
|
{ |
288
|
|
|
return $this->query['type']; |
289
|
|
|
} |
290
|
|
|
|
291
|
|
|
/** |
292
|
|
|
* Sets whether or not to hydrate the documents to objects. |
293
|
|
|
*/ |
294
|
|
|
public function setHydrate(bool $hydrate) : void |
295
|
|
|
{ |
296
|
|
|
$this->hydrate = $hydrate; |
297
|
|
|
} |
298
|
|
|
|
299
|
|
|
/** |
300
|
|
|
* Set whether documents should be registered in UnitOfWork. If document would |
301
|
|
|
* already be managed it will be left intact and new instance returned. |
302
|
|
|
* |
303
|
|
|
* This option has no effect if hydration is disabled. |
304
|
|
|
*/ |
305
|
161 |
|
public function setReadOnly(bool $readOnly) : void |
306
|
|
|
{ |
307
|
161 |
|
$this->unitOfWorkHints[self::HINT_READ_ONLY] = $readOnly; |
308
|
161 |
|
} |
309
|
|
|
|
310
|
|
|
/** |
311
|
|
|
* Set whether to refresh hydrated documents that are already in the |
312
|
|
|
* identity map. |
313
|
|
|
* |
314
|
|
|
* This option has no effect if hydration is disabled. |
315
|
|
|
*/ |
316
|
161 |
|
public function setRefresh(bool $refresh) : void |
317
|
|
|
{ |
318
|
161 |
|
$this->unitOfWorkHints[self::HINT_REFRESH] = (bool) $refresh; |
319
|
161 |
|
} |
320
|
|
|
|
321
|
|
|
/** |
322
|
|
|
* Execute the query and return its results as an array. |
323
|
|
|
* |
324
|
|
|
* @see IteratorAggregate::toArray() |
325
|
|
|
*/ |
326
|
11 |
|
public function toArray() : array |
327
|
|
|
{ |
328
|
11 |
|
return $this->getIterator()->toArray(); |
|
|
|
|
329
|
|
|
} |
330
|
|
|
|
331
|
|
|
/** |
332
|
|
|
* Returns an array containing the specified keys and their values from the |
333
|
|
|
* query array, provided they exist and are not null. |
334
|
|
|
*/ |
335
|
121 |
|
private function getQueryOptions(string ...$keys) : array |
336
|
|
|
{ |
337
|
121 |
|
return array_filter( |
338
|
121 |
|
array_intersect_key($this->query, array_flip($keys)), |
339
|
|
|
static function ($value) { |
340
|
88 |
|
return $value !== null; |
341
|
121 |
|
} |
342
|
|
|
); |
343
|
|
|
} |
344
|
|
|
|
345
|
106 |
|
private function makeIterator(Cursor $cursor) : Iterator |
346
|
|
|
{ |
347
|
106 |
|
if ($this->hydrate && $this->class) { |
348
|
98 |
|
$cursor = new HydratingIterator($cursor, $this->dm->getUnitOfWork(), $this->class, $this->unitOfWorkHints); |
349
|
|
|
} |
350
|
|
|
|
351
|
106 |
|
$cursor = new CachingIterator($cursor); |
352
|
|
|
|
353
|
106 |
|
if (! empty($this->primers)) { |
354
|
20 |
|
$referencePrimer = new ReferencePrimer($this->dm, $this->dm->getUnitOfWork()); |
355
|
20 |
|
$cursor = new PrimingIterator($cursor, $this->class, $referencePrimer, $this->primers, $this->unitOfWorkHints); |
356
|
|
|
} |
357
|
|
|
|
358
|
106 |
|
return $cursor; |
359
|
|
|
} |
360
|
|
|
|
361
|
|
|
/** |
362
|
|
|
* Returns an array with its keys renamed based on the translation map. |
363
|
|
|
* |
364
|
|
|
* @return array $rename Translation map (from => to) for renaming keys |
365
|
|
|
*/ |
366
|
111 |
|
private function renameQueryOptions(array $options, array $rename) : array |
367
|
|
|
{ |
368
|
111 |
|
if (empty($options)) { |
369
|
42 |
|
return $options; |
370
|
|
|
} |
371
|
|
|
|
372
|
86 |
|
return array_combine( |
373
|
86 |
|
array_map( |
374
|
|
|
static function ($key) use ($rename) { |
375
|
86 |
|
return $rename[$key] ?? $key; |
376
|
86 |
|
}, |
377
|
86 |
|
array_keys($options) |
378
|
|
|
), |
379
|
86 |
|
array_values($options) |
380
|
|
|
); |
381
|
|
|
} |
382
|
|
|
|
383
|
|
|
/** |
384
|
|
|
* Execute the query and return its result. |
385
|
|
|
* |
386
|
|
|
* The return value will vary based on the query type. Commands with results |
387
|
|
|
* (e.g. aggregate, inline mapReduce) may return an ArrayIterator. Other |
388
|
|
|
* commands and operations may return a status array or a boolean, depending |
389
|
|
|
* on the driver's write concern. Queries and some mapReduce commands will |
390
|
|
|
* return an Iterator. |
391
|
|
|
* |
392
|
|
|
* @return Iterator|string|int|array |
393
|
|
|
*/ |
394
|
122 |
|
public function runQuery() |
395
|
|
|
{ |
396
|
122 |
|
$options = $this->options; |
397
|
|
|
|
398
|
122 |
|
switch ($this->query['type']) { |
399
|
122 |
|
case self::TYPE_FIND: |
400
|
106 |
|
$queryOptions = $this->getQueryOptions('select', 'sort', 'skip', 'limit', 'readPreference'); |
401
|
106 |
|
$queryOptions = $this->renameQueryOptions($queryOptions, ['select' => 'projection']); |
402
|
|
|
|
403
|
106 |
|
$cursor = $this->collection->find( |
404
|
106 |
|
$this->query['query'], |
405
|
106 |
|
$queryOptions |
406
|
|
|
); |
407
|
|
|
|
408
|
106 |
|
return $this->makeIterator($cursor); |
409
|
|
|
|
410
|
24 |
|
case self::TYPE_FIND_AND_UPDATE: |
411
|
6 |
|
$queryOptions = $this->getQueryOptions('select', 'sort', 'upsert'); |
412
|
6 |
|
$queryOptions = $this->renameQueryOptions($queryOptions, ['select' => 'projection']); |
413
|
6 |
|
$queryOptions['returnDocument'] = $this->query['new'] ?? false ? FindOneAndUpdate::RETURN_DOCUMENT_AFTER : FindOneAndUpdate::RETURN_DOCUMENT_BEFORE; |
414
|
|
|
|
415
|
6 |
|
return $this->collection->findOneAndUpdate( |
416
|
6 |
|
$this->query['query'], |
417
|
6 |
|
$this->query['newObj'], |
418
|
6 |
|
array_merge($options, $queryOptions) |
419
|
|
|
); |
420
|
|
|
|
421
|
19 |
|
case self::TYPE_FIND_AND_REMOVE: |
422
|
2 |
|
$queryOptions = $this->getQueryOptions('select', 'sort'); |
423
|
2 |
|
$queryOptions = $this->renameQueryOptions($queryOptions, ['select' => 'projection']); |
424
|
|
|
|
425
|
2 |
|
return $this->collection->findOneAndDelete( |
426
|
2 |
|
$this->query['query'], |
427
|
2 |
|
array_merge($options, $queryOptions) |
428
|
|
|
); |
429
|
|
|
|
430
|
17 |
|
case self::TYPE_INSERT: |
431
|
|
|
return $this->collection->insertOne($this->query['newObj'], $options); |
432
|
|
|
|
433
|
17 |
|
case self::TYPE_UPDATE: |
434
|
12 |
|
if ($this->query['multiple'] ?? false) { |
435
|
2 |
|
return $this->collection->updateMany( |
436
|
2 |
|
$this->query['query'], |
437
|
2 |
|
$this->query['newObj'], |
438
|
2 |
|
array_merge($options, $this->getQueryOptions('upsert')) |
439
|
|
|
); |
440
|
|
|
} |
441
|
|
|
|
442
|
10 |
|
return $this->collection->updateOne( |
443
|
10 |
|
$this->query['query'], |
444
|
10 |
|
$this->query['newObj'], |
445
|
10 |
|
array_merge($options, $this->getQueryOptions('upsert')) |
446
|
|
|
); |
447
|
|
|
|
448
|
5 |
|
case self::TYPE_REMOVE: |
449
|
1 |
|
return $this->collection->deleteMany($this->query['query'], $options); |
450
|
|
|
|
451
|
4 |
|
case self::TYPE_DISTINCT: |
452
|
2 |
|
$collection = $this->collection; |
453
|
2 |
|
$query = $this->query; |
454
|
|
|
|
455
|
2 |
|
return $collection->distinct( |
456
|
2 |
|
$query['distinct'], |
457
|
2 |
|
$query['query'], |
458
|
2 |
|
array_merge($options, $this->getQueryOptions('readPreference')) |
459
|
|
|
); |
460
|
|
|
|
461
|
2 |
|
case self::TYPE_COUNT: |
462
|
2 |
|
$collection = $this->collection; |
463
|
2 |
|
$query = $this->query; |
464
|
|
|
|
465
|
2 |
|
return $collection->count( |
466
|
2 |
|
$query['query'], |
467
|
2 |
|
array_merge($options, $this->getQueryOptions('hint', 'limit', 'skip', 'readPreference')) |
468
|
|
|
); |
469
|
|
|
} |
470
|
|
|
} |
471
|
|
|
} |
472
|
|
|
|
This error could be the result of:
1. Missing dependencies
PHP Analyzer uses your
composer.json
file (if available) to determine the dependencies of your project and to determine all the available classes and functions. It expects thecomposer.json
to be in the root folder of your repository.Are you sure this class is defined by one of your dependencies, or did you maybe not list a dependency in either the
require
orrequire-dev
section?2. Missing use statement
PHP does not complain about undefined classes in
ìnstanceof
checks. For example, the following PHP code will work perfectly fine:If you have not tested against this specific condition, such errors might go unnoticed.