1 | <?php |
||||
2 | |||||
3 | namespace Doctrine\DBAL\Platforms; |
||||
4 | |||||
5 | use Doctrine\Common\EventManager; |
||||
6 | use Doctrine\DBAL\DBALException; |
||||
7 | use Doctrine\DBAL\Event\SchemaAlterTableAddColumnEventArgs; |
||||
8 | use Doctrine\DBAL\Event\SchemaAlterTableChangeColumnEventArgs; |
||||
9 | use Doctrine\DBAL\Event\SchemaAlterTableEventArgs; |
||||
10 | use Doctrine\DBAL\Event\SchemaAlterTableRemoveColumnEventArgs; |
||||
11 | use Doctrine\DBAL\Event\SchemaAlterTableRenameColumnEventArgs; |
||||
12 | use Doctrine\DBAL\Event\SchemaCreateTableColumnEventArgs; |
||||
13 | use Doctrine\DBAL\Event\SchemaCreateTableEventArgs; |
||||
14 | use Doctrine\DBAL\Event\SchemaDropTableEventArgs; |
||||
15 | use Doctrine\DBAL\Events; |
||||
16 | use Doctrine\DBAL\Platforms\Keywords\KeywordList; |
||||
17 | use Doctrine\DBAL\Schema\Column; |
||||
18 | use Doctrine\DBAL\Schema\ColumnDiff; |
||||
19 | use Doctrine\DBAL\Schema\Constraint; |
||||
20 | use Doctrine\DBAL\Schema\ForeignKeyConstraint; |
||||
21 | use Doctrine\DBAL\Schema\Identifier; |
||||
22 | use Doctrine\DBAL\Schema\Index; |
||||
23 | use Doctrine\DBAL\Schema\Sequence; |
||||
24 | use Doctrine\DBAL\Schema\Table; |
||||
25 | use Doctrine\DBAL\Schema\TableDiff; |
||||
26 | use Doctrine\DBAL\TransactionIsolationLevel; |
||||
27 | use Doctrine\DBAL\Types; |
||||
28 | use Doctrine\DBAL\Types\Type; |
||||
29 | use InvalidArgumentException; |
||||
30 | use UnexpectedValueException; |
||||
31 | use const E_USER_DEPRECATED; |
||||
32 | use function addcslashes; |
||||
33 | use function array_map; |
||||
34 | use function array_merge; |
||||
35 | use function array_unique; |
||||
36 | use function array_values; |
||||
37 | use function assert; |
||||
38 | use function count; |
||||
39 | use function explode; |
||||
40 | use function func_get_arg; |
||||
41 | use function func_get_args; |
||||
42 | use function func_num_args; |
||||
43 | use function implode; |
||||
44 | use function in_array; |
||||
45 | use function is_array; |
||||
46 | use function is_bool; |
||||
47 | use function is_int; |
||||
48 | use function is_string; |
||||
49 | use function preg_quote; |
||||
50 | use function preg_replace; |
||||
51 | use function sprintf; |
||||
52 | use function str_replace; |
||||
53 | use function strlen; |
||||
54 | use function strpos; |
||||
55 | use function strtolower; |
||||
56 | use function strtoupper; |
||||
57 | use function trigger_error; |
||||
58 | |||||
59 | /** |
||||
60 | * Base class for all DatabasePlatforms. The DatabasePlatforms are the central |
||||
61 | * point of abstraction of platform-specific behaviors, features and SQL dialects. |
||||
62 | * They are a passive source of information. |
||||
63 | * |
||||
64 | * @todo Remove any unnecessary methods. |
||||
65 | */ |
||||
66 | abstract class AbstractPlatform |
||||
67 | { |
||||
68 | public const CREATE_INDEXES = 1; |
||||
69 | |||||
70 | public const CREATE_FOREIGNKEYS = 2; |
||||
71 | |||||
72 | /** |
||||
73 | * @deprecated Use DateIntervalUnit::INTERVAL_UNIT_SECOND. |
||||
74 | */ |
||||
75 | public const DATE_INTERVAL_UNIT_SECOND = DateIntervalUnit::SECOND; |
||||
76 | |||||
77 | /** |
||||
78 | * @deprecated Use DateIntervalUnit::MINUTE. |
||||
79 | */ |
||||
80 | public const DATE_INTERVAL_UNIT_MINUTE = DateIntervalUnit::MINUTE; |
||||
81 | |||||
82 | /** |
||||
83 | * @deprecated Use DateIntervalUnit::HOUR. |
||||
84 | */ |
||||
85 | public const DATE_INTERVAL_UNIT_HOUR = DateIntervalUnit::HOUR; |
||||
86 | |||||
87 | /** |
||||
88 | * @deprecated Use DateIntervalUnit::DAY. |
||||
89 | */ |
||||
90 | public const DATE_INTERVAL_UNIT_DAY = DateIntervalUnit::DAY; |
||||
91 | |||||
92 | /** |
||||
93 | * @deprecated Use DateIntervalUnit::WEEK. |
||||
94 | */ |
||||
95 | public const DATE_INTERVAL_UNIT_WEEK = DateIntervalUnit::WEEK; |
||||
96 | |||||
97 | /** |
||||
98 | * @deprecated Use DateIntervalUnit::MONTH. |
||||
99 | */ |
||||
100 | public const DATE_INTERVAL_UNIT_MONTH = DateIntervalUnit::MONTH; |
||||
101 | |||||
102 | /** |
||||
103 | * @deprecated Use DateIntervalUnit::QUARTER. |
||||
104 | */ |
||||
105 | public const DATE_INTERVAL_UNIT_QUARTER = DateIntervalUnit::QUARTER; |
||||
106 | |||||
107 | /** |
||||
108 | * @deprecated Use DateIntervalUnit::QUARTER. |
||||
109 | */ |
||||
110 | public const DATE_INTERVAL_UNIT_YEAR = DateIntervalUnit::YEAR; |
||||
111 | |||||
112 | /** |
||||
113 | * @deprecated Use TrimMode::UNSPECIFIED. |
||||
114 | */ |
||||
115 | public const TRIM_UNSPECIFIED = TrimMode::UNSPECIFIED; |
||||
116 | |||||
117 | /** |
||||
118 | * @deprecated Use TrimMode::LEADING. |
||||
119 | */ |
||||
120 | public const TRIM_LEADING = TrimMode::LEADING; |
||||
121 | |||||
122 | /** |
||||
123 | * @deprecated Use TrimMode::TRAILING. |
||||
124 | */ |
||||
125 | public const TRIM_TRAILING = TrimMode::TRAILING; |
||||
126 | |||||
127 | /** |
||||
128 | * @deprecated Use TrimMode::BOTH. |
||||
129 | */ |
||||
130 | public const TRIM_BOTH = TrimMode::BOTH; |
||||
131 | |||||
132 | /** @var string[]|null */ |
||||
133 | protected $doctrineTypeMapping = null; |
||||
134 | |||||
135 | /** |
||||
136 | * Contains a list of all columns that should generate parseable column comments for type-detection |
||||
137 | * in reverse engineering scenarios. |
||||
138 | * |
||||
139 | * @var string[]|null |
||||
140 | */ |
||||
141 | protected $doctrineTypeComments = null; |
||||
142 | |||||
143 | /** @var EventManager */ |
||||
144 | protected $_eventManager; |
||||
145 | |||||
146 | /** |
||||
147 | * Holds the KeywordList instance for the current platform. |
||||
148 | * |
||||
149 | * @var KeywordList|null |
||||
150 | */ |
||||
151 | protected $_keywords; |
||||
152 | |||||
153 | 95434 | public function __construct() |
|||
154 | { |
||||
155 | 95434 | } |
|||
156 | |||||
157 | /** |
||||
158 | * Sets the EventManager used by the Platform. |
||||
159 | */ |
||||
160 | 2419 | public function setEventManager(EventManager $eventManager) |
|||
161 | { |
||||
162 | 2419 | $this->_eventManager = $eventManager; |
|||
163 | 2419 | } |
|||
164 | |||||
165 | /** |
||||
166 | * Gets the EventManager used by the Platform. |
||||
167 | * |
||||
168 | * @return EventManager |
||||
169 | */ |
||||
170 | 1617 | public function getEventManager() |
|||
171 | { |
||||
172 | 1617 | return $this->_eventManager; |
|||
173 | } |
||||
174 | |||||
175 | /** |
||||
176 | * Returns the SQL snippet that declares a boolean column. |
||||
177 | * |
||||
178 | * @param mixed[] $columnDef |
||||
179 | * |
||||
180 | * @return string |
||||
181 | */ |
||||
182 | abstract public function getBooleanTypeDeclarationSQL(array $columnDef); |
||||
183 | |||||
184 | /** |
||||
185 | * Returns the SQL snippet that declares a 4 byte integer column. |
||||
186 | * |
||||
187 | * @param mixed[] $columnDef |
||||
188 | * |
||||
189 | * @return string |
||||
190 | */ |
||||
191 | abstract public function getIntegerTypeDeclarationSQL(array $columnDef); |
||||
192 | |||||
193 | /** |
||||
194 | * Returns the SQL snippet that declares an 8 byte integer column. |
||||
195 | * |
||||
196 | * @param mixed[] $columnDef |
||||
197 | * |
||||
198 | * @return string |
||||
199 | */ |
||||
200 | abstract public function getBigIntTypeDeclarationSQL(array $columnDef); |
||||
201 | |||||
202 | /** |
||||
203 | * Returns the SQL snippet that declares a 2 byte integer column. |
||||
204 | * |
||||
205 | * @param mixed[] $columnDef |
||||
206 | * |
||||
207 | * @return string |
||||
208 | */ |
||||
209 | abstract public function getSmallIntTypeDeclarationSQL(array $columnDef); |
||||
210 | |||||
211 | /** |
||||
212 | * Returns the SQL snippet that declares common properties of an integer column. |
||||
213 | * |
||||
214 | * @param mixed[] $columnDef |
||||
215 | * |
||||
216 | * @return string |
||||
217 | */ |
||||
218 | abstract protected function _getCommonIntegerTypeDeclarationSQL(array $columnDef); |
||||
219 | |||||
220 | /** |
||||
221 | * Lazy load Doctrine Type Mappings. |
||||
222 | * |
||||
223 | * @return void |
||||
224 | */ |
||||
225 | abstract protected function initializeDoctrineTypeMappings(); |
||||
226 | |||||
227 | /** |
||||
228 | * Initializes Doctrine Type Mappings with the platform defaults |
||||
229 | * and with all additional type mappings. |
||||
230 | * |
||||
231 | * @return void |
||||
232 | */ |
||||
233 | 2687 | private function initializeAllDoctrineTypeMappings() |
|||
234 | { |
||||
235 | 2687 | $this->initializeDoctrineTypeMappings(); |
|||
236 | |||||
237 | 2687 | foreach (Type::getTypesMap() as $typeName => $className) { |
|||
238 | 2687 | foreach (Type::getType($typeName)->getMappedDatabaseTypes($this) as $dbType) { |
|||
239 | 1584 | $this->doctrineTypeMapping[$dbType] = $typeName; |
|||
240 | } |
||||
241 | } |
||||
242 | 2687 | } |
|||
243 | |||||
244 | /** |
||||
245 | * Returns the SQL snippet used to declare a VARCHAR column type. |
||||
246 | * |
||||
247 | * @param mixed[] $field |
||||
248 | * |
||||
249 | * @return string |
||||
250 | */ |
||||
251 | 9474 | public function getVarcharTypeDeclarationSQL(array $field) |
|||
252 | { |
||||
253 | 9474 | if (! isset($field['length'])) { |
|||
254 | 2234 | $field['length'] = $this->getVarcharDefaultLength(); |
|||
255 | } |
||||
256 | |||||
257 | 9474 | $fixed = $field['fixed'] ?? false; |
|||
258 | |||||
259 | 9474 | $maxLength = $fixed |
|||
260 | 1337 | ? $this->getCharMaxLength() |
|||
261 | 9474 | : $this->getVarcharMaxLength(); |
|||
262 | |||||
263 | 9474 | if ($field['length'] > $maxLength) { |
|||
264 | return $this->getClobTypeDeclarationSQL($field); |
||||
265 | } |
||||
266 | |||||
267 | 9474 | return $this->getVarcharTypeDeclarationSQLSnippet($field['length'], $fixed); |
|||
268 | } |
||||
269 | |||||
270 | /** |
||||
271 | * Returns the SQL snippet used to declare a BINARY/VARBINARY column type. |
||||
272 | * |
||||
273 | * @param mixed[] $field The column definition. |
||||
274 | * |
||||
275 | * @return string |
||||
276 | */ |
||||
277 | 862 | public function getBinaryTypeDeclarationSQL(array $field) |
|||
278 | { |
||||
279 | 862 | if (! isset($field['length'])) { |
|||
280 | 512 | $field['length'] = $this->getBinaryDefaultLength(); |
|||
281 | } |
||||
282 | |||||
283 | 862 | $fixed = $field['fixed'] ?? false; |
|||
284 | |||||
285 | 862 | $maxLength = $this->getBinaryMaxLength(); |
|||
286 | |||||
287 | 862 | if ($field['length'] > $maxLength) { |
|||
288 | 494 | if ($maxLength > 0) { |
|||
289 | 324 | @trigger_error(sprintf( |
|||
290 | 324 | 'Binary field length %d is greater than supported by the platform (%d). Reduce the field length or use a BLOB field instead.', |
|||
291 | 324 | $field['length'], |
|||
292 | 324 | $maxLength |
|||
293 | 324 | ), E_USER_DEPRECATED); |
|||
294 | } |
||||
295 | |||||
296 | 494 | return $this->getBlobTypeDeclarationSQL($field); |
|||
297 | } |
||||
298 | |||||
299 | 530 | return $this->getBinaryTypeDeclarationSQLSnippet($field['length'], $fixed); |
|||
300 | } |
||||
301 | |||||
302 | /** |
||||
303 | * Returns the SQL snippet to declare a GUID/UUID field. |
||||
304 | * |
||||
305 | * By default this maps directly to a CHAR(36) and only maps to more |
||||
306 | * special datatypes when the underlying databases support this datatype. |
||||
307 | * |
||||
308 | * @param mixed[] $field |
||||
309 | * |
||||
310 | * @return string |
||||
311 | */ |
||||
312 | 176 | public function getGuidTypeDeclarationSQL(array $field) |
|||
313 | { |
||||
314 | 176 | $field['length'] = 36; |
|||
315 | 176 | $field['fixed'] = true; |
|||
316 | |||||
317 | 176 | return $this->getVarcharTypeDeclarationSQL($field); |
|||
318 | } |
||||
319 | |||||
320 | /** |
||||
321 | * Returns the SQL snippet to declare a JSON field. |
||||
322 | * |
||||
323 | * By default this maps directly to a CLOB and only maps to more |
||||
324 | * special datatypes when the underlying databases support this datatype. |
||||
325 | * |
||||
326 | * @param mixed[] $field |
||||
327 | * |
||||
328 | * @return string |
||||
329 | */ |
||||
330 | 560 | public function getJsonTypeDeclarationSQL(array $field) |
|||
331 | { |
||||
332 | 560 | return $this->getClobTypeDeclarationSQL($field); |
|||
333 | } |
||||
334 | |||||
335 | /** |
||||
336 | * @param int $length |
||||
337 | * @param bool $fixed |
||||
338 | * |
||||
339 | * @return string |
||||
340 | * |
||||
341 | * @throws DBALException If not supported on this platform. |
||||
342 | */ |
||||
343 | protected function getVarcharTypeDeclarationSQLSnippet($length, $fixed) |
||||
344 | { |
||||
345 | throw DBALException::notSupported('VARCHARs not supported by Platform.'); |
||||
346 | } |
||||
347 | |||||
348 | /** |
||||
349 | * Returns the SQL snippet used to declare a BINARY/VARBINARY column type. |
||||
350 | * |
||||
351 | * @param int $length The length of the column. |
||||
352 | * @param bool $fixed Whether the column length is fixed. |
||||
353 | * |
||||
354 | * @return string |
||||
355 | * |
||||
356 | * @throws DBALException If not supported on this platform. |
||||
357 | */ |
||||
358 | protected function getBinaryTypeDeclarationSQLSnippet($length, $fixed) |
||||
359 | { |
||||
360 | throw DBALException::notSupported('BINARY/VARBINARY column types are not supported by this platform.'); |
||||
361 | } |
||||
362 | |||||
363 | /** |
||||
364 | * Returns the SQL snippet used to declare a CLOB column type. |
||||
365 | * |
||||
366 | * @param mixed[] $field |
||||
367 | * |
||||
368 | * @return string |
||||
369 | */ |
||||
370 | abstract public function getClobTypeDeclarationSQL(array $field); |
||||
371 | |||||
372 | /** |
||||
373 | * Returns the SQL Snippet used to declare a BLOB column type. |
||||
374 | * |
||||
375 | * @param mixed[] $field |
||||
376 | * |
||||
377 | * @return string |
||||
378 | */ |
||||
379 | abstract public function getBlobTypeDeclarationSQL(array $field); |
||||
380 | |||||
381 | /** |
||||
382 | * Gets the name of the platform. |
||||
383 | * |
||||
384 | * @return string |
||||
385 | */ |
||||
386 | abstract public function getName(); |
||||
387 | |||||
388 | /** |
||||
389 | * Registers a doctrine type to be used in conjunction with a column type of this platform. |
||||
390 | * |
||||
391 | * @param string $dbType |
||||
392 | * @param string $doctrineType |
||||
393 | * |
||||
394 | * @throws DBALException If the type is not found. |
||||
395 | */ |
||||
396 | 1492 | public function registerDoctrineTypeMapping($dbType, $doctrineType) |
|||
397 | { |
||||
398 | 1492 | if ($this->doctrineTypeMapping === null) { |
|||
399 | 1485 | $this->initializeAllDoctrineTypeMappings(); |
|||
400 | } |
||||
401 | |||||
402 | 1492 | if (! Types\Type::hasType($doctrineType)) { |
|||
403 | 486 | throw DBALException::typeNotFound($doctrineType); |
|||
404 | } |
||||
405 | |||||
406 | 1006 | $dbType = strtolower($dbType); |
|||
407 | 1006 | $this->doctrineTypeMapping[$dbType] = $doctrineType; |
|||
408 | |||||
409 | 1006 | $doctrineType = Type::getType($doctrineType); |
|||
410 | |||||
411 | 1006 | if (! $doctrineType->requiresSQLCommentHint($this)) { |
|||
412 | 520 | return; |
|||
413 | } |
||||
414 | |||||
415 | 486 | $this->markDoctrineTypeCommented($doctrineType); |
|||
416 | 486 | } |
|||
417 | |||||
418 | /** |
||||
419 | * Gets the Doctrine type that is mapped for the given database column type. |
||||
420 | * |
||||
421 | * @param string $dbType |
||||
422 | * |
||||
423 | * @return string |
||||
424 | * |
||||
425 | * @throws DBALException |
||||
426 | */ |
||||
427 | 3069 | public function getDoctrineTypeMapping($dbType) |
|||
428 | { |
||||
429 | 3069 | if ($this->doctrineTypeMapping === null) { |
|||
430 | 581 | $this->initializeAllDoctrineTypeMappings(); |
|||
431 | } |
||||
432 | |||||
433 | 3069 | $dbType = strtolower($dbType); |
|||
434 | |||||
435 | 3069 | if (! isset($this->doctrineTypeMapping[$dbType])) { |
|||
436 | 486 | throw new DBALException('Unknown database type ' . $dbType . ' requested, ' . static::class . ' may not support it.'); |
|||
437 | } |
||||
438 | |||||
439 | 2583 | return $this->doctrineTypeMapping[$dbType]; |
|||
440 | } |
||||
441 | |||||
442 | /** |
||||
443 | * Checks if a database type is currently supported by this platform. |
||||
444 | * |
||||
445 | * @param string $dbType |
||||
446 | * |
||||
447 | * @return bool |
||||
448 | */ |
||||
449 | 676 | public function hasDoctrineTypeMappingFor($dbType) |
|||
450 | { |
||||
451 | 676 | if ($this->doctrineTypeMapping === null) { |
|||
452 | 621 | $this->initializeAllDoctrineTypeMappings(); |
|||
453 | } |
||||
454 | |||||
455 | 676 | $dbType = strtolower($dbType); |
|||
456 | |||||
457 | 676 | return isset($this->doctrineTypeMapping[$dbType]); |
|||
458 | } |
||||
459 | |||||
460 | /** |
||||
461 | * Initializes the Doctrine Type comments instance variable for in_array() checks. |
||||
462 | * |
||||
463 | * @return void |
||||
464 | */ |
||||
465 | 24404 | protected function initializeCommentedDoctrineTypes() |
|||
466 | { |
||||
467 | 24404 | $this->doctrineTypeComments = []; |
|||
468 | |||||
469 | 24404 | foreach (Type::getTypesMap() as $typeName => $className) { |
|||
470 | 24404 | $type = Type::getType($typeName); |
|||
471 | |||||
472 | 24404 | if (! $type->requiresSQLCommentHint($this)) { |
|||
473 | 24404 | continue; |
|||
474 | } |
||||
475 | |||||
476 | 24404 | $this->doctrineTypeComments[] = $typeName; |
|||
477 | } |
||||
478 | 24404 | } |
|||
479 | |||||
480 | /** |
||||
481 | * Is it necessary for the platform to add a parsable type comment to allow reverse engineering the given type? |
||||
482 | * |
||||
483 | * @return bool |
||||
484 | */ |
||||
485 | 28445 | public function isCommentedDoctrineType(Type $doctrineType) |
|||
486 | { |
||||
487 | 28445 | if ($this->doctrineTypeComments === null) { |
|||
488 | 23918 | $this->initializeCommentedDoctrineTypes(); |
|||
489 | } |
||||
490 | |||||
491 | 28445 | assert(is_array($this->doctrineTypeComments)); |
|||
492 | |||||
493 | 28445 | return in_array($doctrineType->getName(), $this->doctrineTypeComments); |
|||
494 | } |
||||
495 | |||||
496 | /** |
||||
497 | * Marks this type as to be commented in ALTER TABLE and CREATE TABLE statements. |
||||
498 | * |
||||
499 | * @param string|Type $doctrineType |
||||
500 | * |
||||
501 | * @return void |
||||
502 | */ |
||||
503 | 486 | public function markDoctrineTypeCommented($doctrineType) |
|||
504 | { |
||||
505 | 486 | if ($this->doctrineTypeComments === null) { |
|||
506 | 486 | $this->initializeCommentedDoctrineTypes(); |
|||
507 | } |
||||
508 | |||||
509 | 486 | assert(is_array($this->doctrineTypeComments)); |
|||
510 | |||||
511 | 486 | $this->doctrineTypeComments[] = $doctrineType instanceof Type ? $doctrineType->getName() : $doctrineType; |
|||
512 | 486 | } |
|||
513 | |||||
514 | /** |
||||
515 | * Gets the comment to append to a column comment that helps parsing this type in reverse engineering. |
||||
516 | * |
||||
517 | * @return string |
||||
518 | */ |
||||
519 | 1290 | public function getDoctrineTypeComment(Type $doctrineType) |
|||
520 | { |
||||
521 | 1290 | return '(DC2Type:' . $doctrineType->getName() . ')'; |
|||
522 | } |
||||
523 | |||||
524 | /** |
||||
525 | * Gets the comment of a passed column modified by potential doctrine type comment hints. |
||||
526 | * |
||||
527 | * @return string|null |
||||
528 | */ |
||||
529 | 15838 | protected function getColumnComment(Column $column) |
|||
530 | { |
||||
531 | 15838 | $comment = $column->getComment(); |
|||
532 | |||||
533 | 15838 | if ($this->isCommentedDoctrineType($column->getType())) { |
|||
534 | 1290 | $comment .= $this->getDoctrineTypeComment($column->getType()); |
|||
535 | } |
||||
536 | |||||
537 | 15838 | return $comment; |
|||
538 | } |
||||
539 | |||||
540 | /** |
||||
541 | * Gets the character used for identifier quoting. |
||||
542 | * |
||||
543 | * @return string |
||||
544 | */ |
||||
545 | 8261 | public function getIdentifierQuoteCharacter() |
|||
546 | { |
||||
547 | 8261 | return '"'; |
|||
548 | } |
||||
549 | |||||
550 | /** |
||||
551 | * Gets the string portion that starts an SQL comment. |
||||
552 | * |
||||
553 | * @return string |
||||
554 | */ |
||||
555 | public function getSqlCommentStartString() |
||||
556 | { |
||||
557 | return '--'; |
||||
558 | } |
||||
559 | |||||
560 | /** |
||||
561 | * Gets the string portion that ends an SQL comment. |
||||
562 | * |
||||
563 | * @return string |
||||
564 | */ |
||||
565 | public function getSqlCommentEndString() |
||||
566 | { |
||||
567 | return "\n"; |
||||
568 | } |
||||
569 | |||||
570 | /** |
||||
571 | * Gets the maximum length of a char field. |
||||
572 | */ |
||||
573 | 1222 | public function getCharMaxLength() : int |
|||
574 | { |
||||
575 | 1222 | return $this->getVarcharMaxLength(); |
|||
576 | } |
||||
577 | |||||
578 | /** |
||||
579 | * Gets the maximum length of a varchar field. |
||||
580 | * |
||||
581 | * @return int |
||||
582 | */ |
||||
583 | 3515 | public function getVarcharMaxLength() |
|||
584 | { |
||||
585 | 3515 | return 4000; |
|||
586 | } |
||||
587 | |||||
588 | /** |
||||
589 | * Gets the default length of a varchar field. |
||||
590 | * |
||||
591 | * @return int |
||||
592 | */ |
||||
593 | 1910 | public function getVarcharDefaultLength() |
|||
594 | { |
||||
595 | 1910 | return 255; |
|||
596 | } |
||||
597 | |||||
598 | /** |
||||
599 | * Gets the maximum length of a binary field. |
||||
600 | * |
||||
601 | * @return int |
||||
602 | */ |
||||
603 | public function getBinaryMaxLength() |
||||
604 | { |
||||
605 | return 4000; |
||||
606 | } |
||||
607 | |||||
608 | /** |
||||
609 | * Gets the default length of a binary field. |
||||
610 | * |
||||
611 | * @return int |
||||
612 | */ |
||||
613 | 396 | public function getBinaryDefaultLength() |
|||
614 | { |
||||
615 | 396 | return 255; |
|||
616 | } |
||||
617 | |||||
618 | /** |
||||
619 | * Gets all SQL wildcard characters of the platform. |
||||
620 | * |
||||
621 | * @return string[] |
||||
622 | */ |
||||
623 | public function getWildcards() |
||||
624 | { |
||||
625 | return ['%', '_']; |
||||
626 | } |
||||
627 | |||||
628 | /** |
||||
629 | * Returns the regular expression operator. |
||||
630 | * |
||||
631 | * @return string |
||||
632 | * |
||||
633 | * @throws DBALException If not supported on this platform. |
||||
634 | */ |
||||
635 | 135 | public function getRegexpExpression() |
|||
636 | { |
||||
637 | 135 | throw DBALException::notSupported(__METHOD__); |
|||
638 | } |
||||
639 | |||||
640 | /** |
||||
641 | * Returns the global unique identifier expression. |
||||
642 | * |
||||
643 | * @deprecated Use application-generated UUIDs instead |
||||
644 | * |
||||
645 | * @return string |
||||
646 | * |
||||
647 | * @throws DBALException If not supported on this platform. |
||||
648 | */ |
||||
649 | public function getGuidExpression() |
||||
650 | { |
||||
651 | throw DBALException::notSupported(__METHOD__); |
||||
652 | } |
||||
653 | |||||
654 | /** |
||||
655 | * Returns the SQL snippet to get the average value of a column. |
||||
656 | * |
||||
657 | * @param string $column The column to use. |
||||
658 | * |
||||
659 | * @return string Generated SQL including an AVG aggregate function. |
||||
660 | */ |
||||
661 | public function getAvgExpression($column) |
||||
662 | { |
||||
663 | return 'AVG(' . $column . ')'; |
||||
664 | } |
||||
665 | |||||
666 | /** |
||||
667 | * Returns the SQL snippet to get the number of rows (without a NULL value) of a column. |
||||
668 | * |
||||
669 | * If a '*' is used instead of a column the number of selected rows is returned. |
||||
670 | * |
||||
671 | * @param string|int $column The column to use. |
||||
672 | * |
||||
673 | * @return string Generated SQL including a COUNT aggregate function. |
||||
674 | */ |
||||
675 | public function getCountExpression($column) |
||||
676 | { |
||||
677 | return 'COUNT(' . $column . ')'; |
||||
678 | } |
||||
679 | |||||
680 | /** |
||||
681 | * Returns the SQL snippet to get the highest value of a column. |
||||
682 | * |
||||
683 | * @param string $column The column to use. |
||||
684 | * |
||||
685 | * @return string Generated SQL including a MAX aggregate function. |
||||
686 | */ |
||||
687 | public function getMaxExpression($column) |
||||
688 | { |
||||
689 | return 'MAX(' . $column . ')'; |
||||
690 | } |
||||
691 | |||||
692 | /** |
||||
693 | * Returns the SQL snippet to get the lowest value of a column. |
||||
694 | * |
||||
695 | * @param string $column The column to use. |
||||
696 | * |
||||
697 | * @return string Generated SQL including a MIN aggregate function. |
||||
698 | */ |
||||
699 | public function getMinExpression($column) |
||||
700 | { |
||||
701 | return 'MIN(' . $column . ')'; |
||||
702 | } |
||||
703 | |||||
704 | /** |
||||
705 | * Returns the SQL snippet to get the total sum of a column. |
||||
706 | * |
||||
707 | * @param string $column The column to use. |
||||
708 | * |
||||
709 | * @return string Generated SQL including a SUM aggregate function. |
||||
710 | */ |
||||
711 | public function getSumExpression($column) |
||||
712 | { |
||||
713 | return 'SUM(' . $column . ')'; |
||||
714 | } |
||||
715 | |||||
716 | // scalar functions |
||||
717 | |||||
718 | /** |
||||
719 | * Returns the SQL snippet to get the md5 sum of a field. |
||||
720 | * |
||||
721 | * Note: Not SQL92, but common functionality. |
||||
722 | * |
||||
723 | * @param string $column |
||||
724 | * |
||||
725 | * @return string |
||||
726 | */ |
||||
727 | public function getMd5Expression($column) |
||||
728 | { |
||||
729 | return 'MD5(' . $column . ')'; |
||||
730 | } |
||||
731 | |||||
732 | /** |
||||
733 | * Returns the SQL snippet to get the length of a text field. |
||||
734 | * |
||||
735 | * @param string $column |
||||
736 | * |
||||
737 | * @return string |
||||
738 | */ |
||||
739 | public function getLengthExpression($column) |
||||
740 | { |
||||
741 | return 'LENGTH(' . $column . ')'; |
||||
742 | } |
||||
743 | |||||
744 | /** |
||||
745 | * Returns the SQL snippet to get the squared value of a column. |
||||
746 | * |
||||
747 | * @param string $column The column to use. |
||||
748 | * |
||||
749 | * @return string Generated SQL including an SQRT aggregate function. |
||||
750 | */ |
||||
751 | public function getSqrtExpression($column) |
||||
752 | { |
||||
753 | return 'SQRT(' . $column . ')'; |
||||
754 | } |
||||
755 | |||||
756 | /** |
||||
757 | * Returns the SQL snippet to round a numeric field to the number of decimals specified. |
||||
758 | * |
||||
759 | * @param string $column |
||||
760 | * @param int $decimals |
||||
761 | * |
||||
762 | * @return string |
||||
763 | */ |
||||
764 | public function getRoundExpression($column, $decimals = 0) |
||||
765 | { |
||||
766 | return 'ROUND(' . $column . ', ' . $decimals . ')'; |
||||
767 | } |
||||
768 | |||||
769 | /** |
||||
770 | * Returns the SQL snippet to get the remainder of the division operation $expression1 / $expression2. |
||||
771 | * |
||||
772 | * @param string $expression1 |
||||
773 | * @param string $expression2 |
||||
774 | * |
||||
775 | * @return string |
||||
776 | */ |
||||
777 | public function getModExpression($expression1, $expression2) |
||||
778 | { |
||||
779 | return 'MOD(' . $expression1 . ', ' . $expression2 . ')'; |
||||
780 | } |
||||
781 | |||||
782 | /** |
||||
783 | * Returns the SQL snippet to trim a string. |
||||
784 | * |
||||
785 | * @param string $str The expression to apply the trim to. |
||||
786 | * @param int $mode The position of the trim (leading/trailing/both). |
||||
787 | * @param string|bool $char The char to trim, has to be quoted already. Defaults to space. |
||||
788 | * |
||||
789 | * @return string |
||||
790 | */ |
||||
791 | 864 | public function getTrimExpression($str, $mode = TrimMode::UNSPECIFIED, $char = false) |
|||
792 | { |
||||
793 | 864 | $expression = ''; |
|||
794 | |||||
795 | 864 | switch ($mode) { |
|||
796 | case TrimMode::LEADING: |
||||
797 | 216 | $expression = 'LEADING '; |
|||
798 | 216 | break; |
|||
799 | |||||
800 | case TrimMode::TRAILING: |
||||
801 | 216 | $expression = 'TRAILING '; |
|||
802 | 216 | break; |
|||
803 | |||||
804 | case TrimMode::BOTH: |
||||
805 | 216 | $expression = 'BOTH '; |
|||
806 | 216 | break; |
|||
807 | } |
||||
808 | |||||
809 | 864 | if ($char !== false) { |
|||
810 | 672 | $expression .= $char . ' '; |
|||
811 | } |
||||
812 | |||||
813 | 864 | if ($mode || $char !== false) { |
|||
814 | 816 | $expression .= 'FROM '; |
|||
815 | } |
||||
816 | |||||
817 | 864 | return 'TRIM(' . $expression . $str . ')'; |
|||
818 | } |
||||
819 | |||||
820 | /** |
||||
821 | * Returns the SQL snippet to trim trailing space characters from the expression. |
||||
822 | * |
||||
823 | * @param string $str Literal string or column name. |
||||
824 | * |
||||
825 | * @return string |
||||
826 | */ |
||||
827 | 108 | public function getRtrimExpression($str) |
|||
828 | { |
||||
829 | 108 | return 'RTRIM(' . $str . ')'; |
|||
830 | } |
||||
831 | |||||
832 | /** |
||||
833 | * Returns the SQL snippet to trim leading space characters from the expression. |
||||
834 | * |
||||
835 | * @param string $str Literal string or column name. |
||||
836 | * |
||||
837 | * @return string |
||||
838 | */ |
||||
839 | 108 | public function getLtrimExpression($str) |
|||
840 | { |
||||
841 | 108 | return 'LTRIM(' . $str . ')'; |
|||
842 | } |
||||
843 | |||||
844 | /** |
||||
845 | * Returns the SQL snippet to change all characters from the expression to uppercase, |
||||
846 | * according to the current character set mapping. |
||||
847 | * |
||||
848 | * @param string $str Literal string or column name. |
||||
849 | * |
||||
850 | * @return string |
||||
851 | */ |
||||
852 | public function getUpperExpression($str) |
||||
853 | { |
||||
854 | return 'UPPER(' . $str . ')'; |
||||
855 | } |
||||
856 | |||||
857 | /** |
||||
858 | * Returns the SQL snippet to change all characters from the expression to lowercase, |
||||
859 | * according to the current character set mapping. |
||||
860 | * |
||||
861 | * @param string $str Literal string or column name. |
||||
862 | * |
||||
863 | * @return string |
||||
864 | */ |
||||
865 | public function getLowerExpression($str) |
||||
866 | { |
||||
867 | return 'LOWER(' . $str . ')'; |
||||
868 | } |
||||
869 | |||||
870 | /** |
||||
871 | * Returns the SQL snippet to get the position of the first occurrence of substring $substr in string $str. |
||||
872 | * |
||||
873 | * @param string $str Literal string. |
||||
874 | * @param string $substr Literal string to find. |
||||
875 | * @param int|false $startPos Position to start at, beginning of string by default. |
||||
876 | * |
||||
877 | * @return string |
||||
878 | * |
||||
879 | * @throws DBALException If not supported on this platform. |
||||
880 | */ |
||||
881 | public function getLocateExpression($str, $substr, $startPos = false) |
||||
0 ignored issues
–
show
The parameter
$startPos is not used and could be removed.
(
Ignorable by Annotation
)
If this is a false-positive, you can also ignore this issue in your code via the
This check looks for parameters that have been defined for a function or method, but which are not used in the method body.
Loading history...
|
|||||
882 | { |
||||
883 | throw DBALException::notSupported(__METHOD__); |
||||
884 | } |
||||
885 | |||||
886 | /** |
||||
887 | * Returns the SQL snippet to get the current system date. |
||||
888 | * |
||||
889 | * @return string |
||||
890 | */ |
||||
891 | public function getNowExpression() |
||||
892 | { |
||||
893 | return 'NOW()'; |
||||
894 | } |
||||
895 | |||||
896 | /** |
||||
897 | * Returns a SQL snippet to get a substring inside an SQL statement. |
||||
898 | * |
||||
899 | * Note: Not SQL92, but common functionality. |
||||
900 | * |
||||
901 | * SQLite only supports the 2 parameter variant of this function. |
||||
902 | * |
||||
903 | * @param string $value An sql string literal or column name/alias. |
||||
904 | * @param int $from Where to start the substring portion. |
||||
905 | * @param int|null $length The substring portion length. |
||||
906 | * |
||||
907 | * @return string |
||||
908 | */ |
||||
909 | public function getSubstringExpression($value, $from, $length = null) |
||||
910 | { |
||||
911 | if ($length === null) { |
||||
912 | return 'SUBSTRING(' . $value . ' FROM ' . $from . ')'; |
||||
913 | } |
||||
914 | |||||
915 | return 'SUBSTRING(' . $value . ' FROM ' . $from . ' FOR ' . $length . ')'; |
||||
916 | } |
||||
917 | |||||
918 | /** |
||||
919 | * Returns a SQL snippet to concatenate the given expressions. |
||||
920 | * |
||||
921 | * Accepts an arbitrary number of string parameters. Each parameter must contain an expression. |
||||
922 | * |
||||
923 | * @return string |
||||
924 | */ |
||||
925 | 162 | public function getConcatExpression() |
|||
926 | { |
||||
927 | 162 | return implode(' || ', func_get_args()); |
|||
928 | } |
||||
929 | |||||
930 | /** |
||||
931 | * Returns the SQL for a logical not. |
||||
932 | * |
||||
933 | * Example: |
||||
934 | * <code> |
||||
935 | * $q = new Doctrine_Query(); |
||||
936 | * $e = $q->expr; |
||||
937 | * $q->select('*')->from('table') |
||||
938 | * ->where($e->eq('id', $e->not('null')); |
||||
939 | * </code> |
||||
940 | * |
||||
941 | * @param string $expression |
||||
942 | * |
||||
943 | * @return string The logical expression. |
||||
944 | */ |
||||
945 | public function getNotExpression($expression) |
||||
946 | { |
||||
947 | return 'NOT(' . $expression . ')'; |
||||
948 | } |
||||
949 | |||||
950 | /** |
||||
951 | * Returns the SQL that checks if an expression is null. |
||||
952 | * |
||||
953 | * @param string $expression The expression that should be compared to null. |
||||
954 | * |
||||
955 | * @return string The logical expression. |
||||
956 | */ |
||||
957 | 108 | public function getIsNullExpression($expression) |
|||
958 | { |
||||
959 | 108 | return $expression . ' IS NULL'; |
|||
960 | } |
||||
961 | |||||
962 | /** |
||||
963 | * Returns the SQL that checks if an expression is not null. |
||||
964 | * |
||||
965 | * @param string $expression The expression that should be compared to null. |
||||
966 | * |
||||
967 | * @return string The logical expression. |
||||
968 | */ |
||||
969 | public function getIsNotNullExpression($expression) |
||||
970 | { |
||||
971 | return $expression . ' IS NOT NULL'; |
||||
972 | } |
||||
973 | |||||
974 | /** |
||||
975 | * Returns the SQL that checks if an expression evaluates to a value between two values. |
||||
976 | * |
||||
977 | * The parameter $expression is checked if it is between $value1 and $value2. |
||||
978 | * |
||||
979 | * Note: There is a slight difference in the way BETWEEN works on some databases. |
||||
980 | * http://www.w3schools.com/sql/sql_between.asp. If you want complete database |
||||
981 | * independence you should avoid using between(). |
||||
982 | * |
||||
983 | * @param string $expression The value to compare to. |
||||
984 | * @param string $value1 The lower value to compare with. |
||||
985 | * @param string $value2 The higher value to compare with. |
||||
986 | * |
||||
987 | * @return string The logical expression. |
||||
988 | */ |
||||
989 | public function getBetweenExpression($expression, $value1, $value2) |
||||
990 | { |
||||
991 | return $expression . ' BETWEEN ' . $value1 . ' AND ' . $value2; |
||||
992 | } |
||||
993 | |||||
994 | /** |
||||
995 | * Returns the SQL to get the arccosine of a value. |
||||
996 | * |
||||
997 | * @param string $value |
||||
998 | * |
||||
999 | * @return string |
||||
1000 | */ |
||||
1001 | public function getAcosExpression($value) |
||||
1002 | { |
||||
1003 | return 'ACOS(' . $value . ')'; |
||||
1004 | } |
||||
1005 | |||||
1006 | /** |
||||
1007 | * Returns the SQL to get the sine of a value. |
||||
1008 | * |
||||
1009 | * @param string $value |
||||
1010 | * |
||||
1011 | * @return string |
||||
1012 | */ |
||||
1013 | public function getSinExpression($value) |
||||
1014 | { |
||||
1015 | return 'SIN(' . $value . ')'; |
||||
1016 | } |
||||
1017 | |||||
1018 | /** |
||||
1019 | * Returns the SQL to get the PI value. |
||||
1020 | * |
||||
1021 | * @return string |
||||
1022 | */ |
||||
1023 | public function getPiExpression() |
||||
1024 | { |
||||
1025 | return 'PI()'; |
||||
1026 | } |
||||
1027 | |||||
1028 | /** |
||||
1029 | * Returns the SQL to get the cosine of a value. |
||||
1030 | * |
||||
1031 | * @param string $value |
||||
1032 | * |
||||
1033 | * @return string |
||||
1034 | */ |
||||
1035 | public function getCosExpression($value) |
||||
1036 | { |
||||
1037 | return 'COS(' . $value . ')'; |
||||
1038 | } |
||||
1039 | |||||
1040 | /** |
||||
1041 | * Returns the SQL to calculate the difference in days between the two passed dates. |
||||
1042 | * |
||||
1043 | * Computes diff = date1 - date2. |
||||
1044 | * |
||||
1045 | * @param string $date1 |
||||
1046 | * @param string $date2 |
||||
1047 | * |
||||
1048 | * @return string |
||||
1049 | * |
||||
1050 | * @throws DBALException If not supported on this platform. |
||||
1051 | */ |
||||
1052 | public function getDateDiffExpression($date1, $date2) |
||||
1053 | { |
||||
1054 | throw DBALException::notSupported(__METHOD__); |
||||
1055 | } |
||||
1056 | |||||
1057 | /** |
||||
1058 | * Returns the SQL to add the number of given seconds to a date. |
||||
1059 | * |
||||
1060 | * @param string $date |
||||
1061 | * @param int $seconds |
||||
1062 | * |
||||
1063 | * @return string |
||||
1064 | * |
||||
1065 | * @throws DBALException If not supported on this platform. |
||||
1066 | */ |
||||
1067 | 162 | public function getDateAddSecondsExpression($date, $seconds) |
|||
1068 | { |
||||
1069 | 162 | return $this->getDateArithmeticIntervalExpression($date, '+', $seconds, DateIntervalUnit::SECOND); |
|||
1070 | } |
||||
1071 | |||||
1072 | /** |
||||
1073 | * Returns the SQL to subtract the number of given seconds from a date. |
||||
1074 | * |
||||
1075 | * @param string $date |
||||
1076 | * @param int $seconds |
||||
1077 | * |
||||
1078 | * @return string |
||||
1079 | * |
||||
1080 | * @throws DBALException If not supported on this platform. |
||||
1081 | */ |
||||
1082 | 162 | public function getDateSubSecondsExpression($date, $seconds) |
|||
1083 | { |
||||
1084 | 162 | return $this->getDateArithmeticIntervalExpression($date, '-', $seconds, DateIntervalUnit::SECOND); |
|||
1085 | } |
||||
1086 | |||||
1087 | /** |
||||
1088 | * Returns the SQL to add the number of given minutes to a date. |
||||
1089 | * |
||||
1090 | * @param string $date |
||||
1091 | * @param int $minutes |
||||
1092 | * |
||||
1093 | * @return string |
||||
1094 | * |
||||
1095 | * @throws DBALException If not supported on this platform. |
||||
1096 | */ |
||||
1097 | 162 | public function getDateAddMinutesExpression($date, $minutes) |
|||
1098 | { |
||||
1099 | 162 | return $this->getDateArithmeticIntervalExpression($date, '+', $minutes, DateIntervalUnit::MINUTE); |
|||
1100 | } |
||||
1101 | |||||
1102 | /** |
||||
1103 | * Returns the SQL to subtract the number of given minutes from a date. |
||||
1104 | * |
||||
1105 | * @param string $date |
||||
1106 | * @param int $minutes |
||||
1107 | * |
||||
1108 | * @return string |
||||
1109 | * |
||||
1110 | * @throws DBALException If not supported on this platform. |
||||
1111 | */ |
||||
1112 | 162 | public function getDateSubMinutesExpression($date, $minutes) |
|||
1113 | { |
||||
1114 | 162 | return $this->getDateArithmeticIntervalExpression($date, '-', $minutes, DateIntervalUnit::MINUTE); |
|||
1115 | } |
||||
1116 | |||||
1117 | /** |
||||
1118 | * Returns the SQL to add the number of given hours to a date. |
||||
1119 | * |
||||
1120 | * @param string $date |
||||
1121 | * @param int $hours |
||||
1122 | * |
||||
1123 | * @return string |
||||
1124 | * |
||||
1125 | * @throws DBALException If not supported on this platform. |
||||
1126 | */ |
||||
1127 | 162 | public function getDateAddHourExpression($date, $hours) |
|||
1128 | { |
||||
1129 | 162 | return $this->getDateArithmeticIntervalExpression($date, '+', $hours, DateIntervalUnit::HOUR); |
|||
1130 | } |
||||
1131 | |||||
1132 | /** |
||||
1133 | * Returns the SQL to subtract the number of given hours to a date. |
||||
1134 | * |
||||
1135 | * @param string $date |
||||
1136 | * @param int $hours |
||||
1137 | * |
||||
1138 | * @return string |
||||
1139 | * |
||||
1140 | * @throws DBALException If not supported on this platform. |
||||
1141 | */ |
||||
1142 | 162 | public function getDateSubHourExpression($date, $hours) |
|||
1143 | { |
||||
1144 | 162 | return $this->getDateArithmeticIntervalExpression($date, '-', $hours, DateIntervalUnit::HOUR); |
|||
1145 | } |
||||
1146 | |||||
1147 | /** |
||||
1148 | * Returns the SQL to add the number of given days to a date. |
||||
1149 | * |
||||
1150 | * @param string $date |
||||
1151 | * @param int $days |
||||
1152 | * |
||||
1153 | * @return string |
||||
1154 | * |
||||
1155 | * @throws DBALException If not supported on this platform. |
||||
1156 | */ |
||||
1157 | 216 | public function getDateAddDaysExpression($date, $days) |
|||
1158 | { |
||||
1159 | 216 | return $this->getDateArithmeticIntervalExpression($date, '+', $days, DateIntervalUnit::DAY); |
|||
1160 | } |
||||
1161 | |||||
1162 | /** |
||||
1163 | * Returns the SQL to subtract the number of given days to a date. |
||||
1164 | * |
||||
1165 | * @param string $date |
||||
1166 | * @param int $days |
||||
1167 | * |
||||
1168 | * @return string |
||||
1169 | * |
||||
1170 | * @throws DBALException If not supported on this platform. |
||||
1171 | */ |
||||
1172 | 163 | public function getDateSubDaysExpression($date, $days) |
|||
1173 | { |
||||
1174 | 163 | return $this->getDateArithmeticIntervalExpression($date, '-', $days, DateIntervalUnit::DAY); |
|||
1175 | } |
||||
1176 | |||||
1177 | /** |
||||
1178 | * Returns the SQL to add the number of given weeks to a date. |
||||
1179 | * |
||||
1180 | * @param string $date |
||||
1181 | * @param int $weeks |
||||
1182 | * |
||||
1183 | * @return string |
||||
1184 | * |
||||
1185 | * @throws DBALException If not supported on this platform. |
||||
1186 | */ |
||||
1187 | 162 | public function getDateAddWeeksExpression($date, $weeks) |
|||
1188 | { |
||||
1189 | 162 | return $this->getDateArithmeticIntervalExpression($date, '+', $weeks, DateIntervalUnit::WEEK); |
|||
1190 | } |
||||
1191 | |||||
1192 | /** |
||||
1193 | * Returns the SQL to subtract the number of given weeks from a date. |
||||
1194 | * |
||||
1195 | * @param string $date |
||||
1196 | * @param int $weeks |
||||
1197 | * |
||||
1198 | * @return string |
||||
1199 | * |
||||
1200 | * @throws DBALException If not supported on this platform. |
||||
1201 | */ |
||||
1202 | 162 | public function getDateSubWeeksExpression($date, $weeks) |
|||
1203 | { |
||||
1204 | 162 | return $this->getDateArithmeticIntervalExpression($date, '-', $weeks, DateIntervalUnit::WEEK); |
|||
1205 | } |
||||
1206 | |||||
1207 | /** |
||||
1208 | * Returns the SQL to add the number of given months to a date. |
||||
1209 | * |
||||
1210 | * @param string $date |
||||
1211 | * @param int $months |
||||
1212 | * |
||||
1213 | * @return string |
||||
1214 | * |
||||
1215 | * @throws DBALException If not supported on this platform. |
||||
1216 | */ |
||||
1217 | 162 | public function getDateAddMonthExpression($date, $months) |
|||
1218 | { |
||||
1219 | 162 | return $this->getDateArithmeticIntervalExpression($date, '+', $months, DateIntervalUnit::MONTH); |
|||
1220 | } |
||||
1221 | |||||
1222 | /** |
||||
1223 | * Returns the SQL to subtract the number of given months to a date. |
||||
1224 | * |
||||
1225 | * @param string $date |
||||
1226 | * @param int $months |
||||
1227 | * |
||||
1228 | * @return string |
||||
1229 | * |
||||
1230 | * @throws DBALException If not supported on this platform. |
||||
1231 | */ |
||||
1232 | 162 | public function getDateSubMonthExpression($date, $months) |
|||
1233 | { |
||||
1234 | 162 | return $this->getDateArithmeticIntervalExpression($date, '-', $months, DateIntervalUnit::MONTH); |
|||
1235 | } |
||||
1236 | |||||
1237 | /** |
||||
1238 | * Returns the SQL to add the number of given quarters to a date. |
||||
1239 | * |
||||
1240 | * @param string $date |
||||
1241 | * @param int $quarters |
||||
1242 | * |
||||
1243 | * @return string |
||||
1244 | * |
||||
1245 | * @throws DBALException If not supported on this platform. |
||||
1246 | */ |
||||
1247 | 162 | public function getDateAddQuartersExpression($date, $quarters) |
|||
1248 | { |
||||
1249 | 162 | return $this->getDateArithmeticIntervalExpression($date, '+', $quarters, DateIntervalUnit::QUARTER); |
|||
1250 | } |
||||
1251 | |||||
1252 | /** |
||||
1253 | * Returns the SQL to subtract the number of given quarters from a date. |
||||
1254 | * |
||||
1255 | * @param string $date |
||||
1256 | * @param int $quarters |
||||
1257 | * |
||||
1258 | * @return string |
||||
1259 | * |
||||
1260 | * @throws DBALException If not supported on this platform. |
||||
1261 | */ |
||||
1262 | 162 | public function getDateSubQuartersExpression($date, $quarters) |
|||
1263 | { |
||||
1264 | 162 | return $this->getDateArithmeticIntervalExpression($date, '-', $quarters, DateIntervalUnit::QUARTER); |
|||
1265 | } |
||||
1266 | |||||
1267 | /** |
||||
1268 | * Returns the SQL to add the number of given years to a date. |
||||
1269 | * |
||||
1270 | * @param string $date |
||||
1271 | * @param int $years |
||||
1272 | * |
||||
1273 | * @return string |
||||
1274 | * |
||||
1275 | * @throws DBALException If not supported on this platform. |
||||
1276 | */ |
||||
1277 | 162 | public function getDateAddYearsExpression($date, $years) |
|||
1278 | { |
||||
1279 | 162 | return $this->getDateArithmeticIntervalExpression($date, '+', $years, DateIntervalUnit::YEAR); |
|||
1280 | } |
||||
1281 | |||||
1282 | /** |
||||
1283 | * Returns the SQL to subtract the number of given years from a date. |
||||
1284 | * |
||||
1285 | * @param string $date |
||||
1286 | * @param int $years |
||||
1287 | * |
||||
1288 | * @return string |
||||
1289 | * |
||||
1290 | * @throws DBALException If not supported on this platform. |
||||
1291 | */ |
||||
1292 | 162 | public function getDateSubYearsExpression($date, $years) |
|||
1293 | { |
||||
1294 | 162 | return $this->getDateArithmeticIntervalExpression($date, '-', $years, DateIntervalUnit::YEAR); |
|||
1295 | } |
||||
1296 | |||||
1297 | /** |
||||
1298 | * Returns the SQL for a date arithmetic expression. |
||||
1299 | * |
||||
1300 | * @param string $date The column or literal representing a date to perform the arithmetic operation on. |
||||
1301 | * @param string $operator The arithmetic operator (+ or -). |
||||
1302 | * @param int $interval The interval that shall be calculated into the date. |
||||
1303 | * @param string $unit The unit of the interval that shall be calculated into the date. |
||||
1304 | * One of the DATE_INTERVAL_UNIT_* constants. |
||||
1305 | * |
||||
1306 | * @return string |
||||
1307 | * |
||||
1308 | * @throws DBALException If not supported on this platform. |
||||
1309 | */ |
||||
1310 | protected function getDateArithmeticIntervalExpression($date, $operator, $interval, $unit) |
||||
1311 | { |
||||
1312 | throw DBALException::notSupported(__METHOD__); |
||||
1313 | } |
||||
1314 | |||||
1315 | /** |
||||
1316 | * Returns the SQL bit AND comparison expression. |
||||
1317 | * |
||||
1318 | * @param string $value1 |
||||
1319 | * @param string $value2 |
||||
1320 | * |
||||
1321 | * @return string |
||||
1322 | */ |
||||
1323 | 456 | public function getBitAndComparisonExpression($value1, $value2) |
|||
1324 | { |
||||
1325 | 456 | return '(' . $value1 . ' & ' . $value2 . ')'; |
|||
1326 | } |
||||
1327 | |||||
1328 | /** |
||||
1329 | * Returns the SQL bit OR comparison expression. |
||||
1330 | * |
||||
1331 | * @param string $value1 |
||||
1332 | * @param string $value2 |
||||
1333 | * |
||||
1334 | * @return string |
||||
1335 | */ |
||||
1336 | 456 | public function getBitOrComparisonExpression($value1, $value2) |
|||
1337 | { |
||||
1338 | 456 | return '(' . $value1 . ' | ' . $value2 . ')'; |
|||
1339 | } |
||||
1340 | |||||
1341 | /** |
||||
1342 | * Returns the FOR UPDATE expression. |
||||
1343 | * |
||||
1344 | * @return string |
||||
1345 | */ |
||||
1346 | 46 | public function getForUpdateSQL() |
|||
1347 | { |
||||
1348 | 46 | return 'FOR UPDATE'; |
|||
1349 | } |
||||
1350 | |||||
1351 | /** |
||||
1352 | * Honors that some SQL vendors such as MsSql use table hints for locking instead of the ANSI SQL FOR UPDATE specification. |
||||
1353 | * |
||||
1354 | * @param string $fromClause The FROM clause to append the hint for the given lock mode to. |
||||
1355 | * @param int|null $lockMode One of the Doctrine\DBAL\LockMode::* constants. If null is given, nothing will |
||||
1356 | * be appended to the FROM clause. |
||||
1357 | * |
||||
1358 | * @return string |
||||
1359 | */ |
||||
1360 | 48 | public function appendLockHint($fromClause, $lockMode) |
|||
1361 | { |
||||
1362 | 48 | return $fromClause; |
|||
1363 | } |
||||
1364 | |||||
1365 | /** |
||||
1366 | * Returns the SQL snippet to append to any SELECT statement which locks rows in shared read lock. |
||||
1367 | * |
||||
1368 | * This defaults to the ANSI SQL "FOR UPDATE", which is an exclusive lock (Write). Some database |
||||
1369 | * vendors allow to lighten this constraint up to be a real read lock. |
||||
1370 | * |
||||
1371 | * @return string |
||||
1372 | */ |
||||
1373 | public function getReadLockSQL() |
||||
1374 | { |
||||
1375 | return $this->getForUpdateSQL(); |
||||
1376 | } |
||||
1377 | |||||
1378 | /** |
||||
1379 | * Returns the SQL snippet to append to any SELECT statement which obtains an exclusive lock on the rows. |
||||
1380 | * |
||||
1381 | * The semantics of this lock mode should equal the SELECT .. FOR UPDATE of the ANSI SQL standard. |
||||
1382 | * |
||||
1383 | * @return string |
||||
1384 | */ |
||||
1385 | 52 | public function getWriteLockSQL() |
|||
1386 | { |
||||
1387 | 52 | return $this->getForUpdateSQL(); |
|||
1388 | } |
||||
1389 | |||||
1390 | /** |
||||
1391 | * Returns the SQL snippet to drop an existing database. |
||||
1392 | * |
||||
1393 | * @param string $database The name of the database that should be dropped. |
||||
1394 | * |
||||
1395 | * @return string |
||||
1396 | */ |
||||
1397 | 149 | public function getDropDatabaseSQL($database) |
|||
1398 | { |
||||
1399 | 149 | return 'DROP DATABASE ' . $database; |
|||
1400 | } |
||||
1401 | |||||
1402 | /** |
||||
1403 | * Returns the SQL snippet to drop an existing table. |
||||
1404 | * |
||||
1405 | * @param Table|string $table |
||||
1406 | * |
||||
1407 | * @return string |
||||
1408 | * |
||||
1409 | * @throws InvalidArgumentException |
||||
1410 | */ |
||||
1411 | 4839 | public function getDropTableSQL($table) |
|||
1412 | { |
||||
1413 | 4839 | $tableArg = $table; |
|||
1414 | |||||
1415 | 4839 | if ($table instanceof Table) { |
|||
1416 | 391 | $table = $table->getQuotedName($this); |
|||
1417 | } |
||||
1418 | |||||
1419 | 4839 | if (! is_string($table)) { |
|||
1420 | throw new InvalidArgumentException('getDropTableSQL() expects $table parameter to be string or \Doctrine\DBAL\Schema\Table.'); |
||||
1421 | } |
||||
1422 | |||||
1423 | 4839 | if ($this->_eventManager !== null && $this->_eventManager->hasListeners(Events::onSchemaDropTable)) { |
|||
1424 | 486 | $eventArgs = new SchemaDropTableEventArgs($tableArg, $this); |
|||
1425 | 486 | $this->_eventManager->dispatchEvent(Events::onSchemaDropTable, $eventArgs); |
|||
1426 | |||||
1427 | 486 | if ($eventArgs->isDefaultPrevented()) { |
|||
1428 | $sql = $eventArgs->getSql(); |
||||
1429 | |||||
1430 | if ($sql === null) { |
||||
1431 | throw new UnexpectedValueException('Default implementation of DROP TABLE was overridden with NULL'); |
||||
1432 | } |
||||
1433 | |||||
1434 | return $sql; |
||||
1435 | } |
||||
1436 | } |
||||
1437 | |||||
1438 | 4839 | return 'DROP TABLE ' . $table; |
|||
1439 | } |
||||
1440 | |||||
1441 | /** |
||||
1442 | * Returns the SQL to safely drop a temporary table WITHOUT implicitly committing an open transaction. |
||||
1443 | * |
||||
1444 | * @param Table|string $table |
||||
1445 | * |
||||
1446 | * @return string |
||||
1447 | */ |
||||
1448 | 22 | public function getDropTemporaryTableSQL($table) |
|||
1449 | { |
||||
1450 | 22 | return $this->getDropTableSQL($table); |
|||
1451 | } |
||||
1452 | |||||
1453 | /** |
||||
1454 | * Returns the SQL to drop an index from a table. |
||||
1455 | * |
||||
1456 | * @param Index|string $index |
||||
1457 | * @param Table|string $table |
||||
1458 | * |
||||
1459 | * @return string |
||||
1460 | * |
||||
1461 | * @throws InvalidArgumentException |
||||
1462 | */ |
||||
1463 | 248 | public function getDropIndexSQL($index, $table = null) |
|||
1464 | { |
||||
1465 | 248 | if ($index instanceof Index) { |
|||
1466 | 237 | $index = $index->getQuotedName($this); |
|||
1467 | 11 | } elseif (! is_string($index)) { |
|||
1468 | throw new InvalidArgumentException('AbstractPlatform::getDropIndexSQL() expects $index parameter to be string or \Doctrine\DBAL\Schema\Index.'); |
||||
1469 | } |
||||
1470 | |||||
1471 | 248 | return 'DROP INDEX ' . $index; |
|||
1472 | } |
||||
1473 | |||||
1474 | /** |
||||
1475 | * Returns the SQL to drop a constraint. |
||||
1476 | * |
||||
1477 | * @param Constraint|string $constraint |
||||
1478 | * @param Table|string $table |
||||
1479 | * |
||||
1480 | * @return string |
||||
1481 | */ |
||||
1482 | 1197 | public function getDropConstraintSQL($constraint, $table) |
|||
1483 | { |
||||
1484 | 1197 | if (! $constraint instanceof Constraint) { |
|||
1485 | 920 | $constraint = new Identifier($constraint); |
|||
1486 | } |
||||
1487 | |||||
1488 | 1197 | if (! $table instanceof Table) { |
|||
1489 | 1197 | $table = new Identifier($table); |
|||
1490 | } |
||||
1491 | |||||
1492 | 1197 | $constraint = $constraint->getQuotedName($this); |
|||
1493 | 1197 | $table = $table->getQuotedName($this); |
|||
1494 | |||||
1495 | 1197 | return 'ALTER TABLE ' . $table . ' DROP CONSTRAINT ' . $constraint; |
|||
1496 | } |
||||
1497 | |||||
1498 | /** |
||||
1499 | * Returns the SQL to drop a foreign key. |
||||
1500 | * |
||||
1501 | * @param ForeignKeyConstraint|string $foreignKey |
||||
1502 | * @param Table|string $table |
||||
1503 | * |
||||
1504 | * @return string |
||||
1505 | */ |
||||
1506 | 592 | public function getDropForeignKeySQL($foreignKey, $table) |
|||
1507 | { |
||||
1508 | 592 | if (! $foreignKey instanceof ForeignKeyConstraint) { |
|||
1509 | 216 | $foreignKey = new Identifier($foreignKey); |
|||
1510 | } |
||||
1511 | |||||
1512 | 592 | if (! $table instanceof Table) { |
|||
1513 | 592 | $table = new Identifier($table); |
|||
1514 | } |
||||
1515 | |||||
1516 | 592 | $foreignKey = $foreignKey->getQuotedName($this); |
|||
1517 | 592 | $table = $table->getQuotedName($this); |
|||
1518 | |||||
1519 | 592 | return 'ALTER TABLE ' . $table . ' DROP FOREIGN KEY ' . $foreignKey; |
|||
1520 | } |
||||
1521 | |||||
1522 | /** |
||||
1523 | * Returns the SQL statement(s) to create a table with the specified name, columns and constraints |
||||
1524 | * on this platform. |
||||
1525 | * |
||||
1526 | * @param int $createFlags |
||||
1527 | * |
||||
1528 | * @return string[] The sequence of SQL statements. |
||||
1529 | * |
||||
1530 | * @throws DBALException |
||||
1531 | * @throws InvalidArgumentException |
||||
1532 | */ |
||||
1533 | 11963 | public function getCreateTableSQL(Table $table, $createFlags = self::CREATE_INDEXES) |
|||
1534 | { |
||||
1535 | 11963 | if (! is_int($createFlags)) { |
|||
1536 | throw new InvalidArgumentException('Second argument of AbstractPlatform::getCreateTableSQL() has to be integer.'); |
||||
1537 | } |
||||
1538 | |||||
1539 | 11963 | if (count($table->getColumns()) === 0) { |
|||
1540 | 486 | throw DBALException::noColumnsSpecifiedForTable($table->getName()); |
|||
1541 | } |
||||
1542 | |||||
1543 | 11477 | $tableName = $table->getQuotedName($this); |
|||
1544 | 11477 | $options = $table->getOptions(); |
|||
1545 | 11477 | $options['uniqueConstraints'] = []; |
|||
1546 | 11477 | $options['indexes'] = []; |
|||
1547 | 11477 | $options['primary'] = []; |
|||
1548 | |||||
1549 | 11477 | if (($createFlags&self::CREATE_INDEXES) > 0) { |
|||
1550 | 10856 | foreach ($table->getIndexes() as $index) { |
|||
1551 | /** @var $index Index */ |
||||
1552 | 7326 | if ($index->isPrimary()) { |
|||
1553 | 5495 | $options['primary'] = $index->getQuotedColumns($this); |
|||
1554 | 5495 | $options['primary_index'] = $index; |
|||
1555 | } else { |
||||
1556 | 2761 | $options['indexes'][$index->getQuotedName($this)] = $index; |
|||
1557 | } |
||||
1558 | } |
||||
1559 | } |
||||
1560 | |||||
1561 | 11477 | $columnSql = []; |
|||
1562 | 11477 | $columns = []; |
|||
1563 | |||||
1564 | 11477 | foreach ($table->getColumns() as $column) { |
|||
1565 | 11477 | if ($this->_eventManager !== null && $this->_eventManager->hasListeners(Events::onSchemaCreateTableColumn)) { |
|||
1566 | 486 | $eventArgs = new SchemaCreateTableColumnEventArgs($column, $table, $this); |
|||
1567 | 486 | $this->_eventManager->dispatchEvent(Events::onSchemaCreateTableColumn, $eventArgs); |
|||
1568 | |||||
1569 | 486 | $columnSql = array_merge($columnSql, $eventArgs->getSql()); |
|||
1570 | |||||
1571 | 486 | if ($eventArgs->isDefaultPrevented()) { |
|||
1572 | continue; |
||||
1573 | } |
||||
1574 | } |
||||
1575 | |||||
1576 | 11477 | $columnData = $column->toArray(); |
|||
1577 | 11477 | $columnData['name'] = $column->getQuotedName($this); |
|||
1578 | 11477 | $columnData['version'] = $column->hasPlatformOption('version') ? $column->getPlatformOption('version') : false; |
|||
1579 | 11477 | $columnData['comment'] = $this->getColumnComment($column); |
|||
1580 | |||||
1581 | 11477 | if ($columnData['type'] instanceof Types\StringType && $columnData['length'] === null) { |
|||
1582 | 4259 | $columnData['length'] = 255; |
|||
1583 | } |
||||
1584 | |||||
1585 | 11477 | if (in_array($column->getName(), $options['primary'])) { |
|||
1586 | 4955 | $columnData['primary'] = true; |
|||
1587 | } |
||||
1588 | |||||
1589 | 11477 | $columns[$columnData['name']] = $columnData; |
|||
1590 | } |
||||
1591 | |||||
1592 | 11477 | if (($createFlags&self::CREATE_FOREIGNKEYS) > 0) { |
|||
1593 | 5447 | $options['foreignKeys'] = []; |
|||
1594 | 5447 | foreach ($table->getForeignKeys() as $fkConstraint) { |
|||
1595 | 1039 | $options['foreignKeys'][] = $fkConstraint; |
|||
1596 | } |
||||
1597 | } |
||||
1598 | |||||
1599 | 11477 | if ($this->_eventManager !== null && $this->_eventManager->hasListeners(Events::onSchemaCreateTable)) { |
|||
1600 | 486 | $eventArgs = new SchemaCreateTableEventArgs($table, $columns, $options, $this); |
|||
1601 | 486 | $this->_eventManager->dispatchEvent(Events::onSchemaCreateTable, $eventArgs); |
|||
1602 | |||||
1603 | 486 | if ($eventArgs->isDefaultPrevented()) { |
|||
1604 | return array_merge($eventArgs->getSql(), $columnSql); |
||||
1605 | } |
||||
1606 | } |
||||
1607 | |||||
1608 | 11477 | $sql = $this->_getCreateTableSQL($tableName, $columns, $options); |
|||
1609 | 11477 | if ($this->supportsCommentOnStatement()) { |
|||
1610 | 5353 | foreach ($table->getColumns() as $column) { |
|||
1611 | 5353 | $comment = $this->getColumnComment($column); |
|||
1612 | |||||
1613 | 5353 | if ($comment === null || $comment === '') { |
|||
1614 | 4996 | continue; |
|||
1615 | } |
||||
1616 | |||||
1617 | 905 | $sql[] = $this->getCommentOnColumnSQL($tableName, $column->getQuotedName($this), $comment); |
|||
1618 | } |
||||
1619 | } |
||||
1620 | |||||
1621 | 11477 | return array_merge($sql, $columnSql); |
|||
1622 | } |
||||
1623 | |||||
1624 | /** |
||||
1625 | * @param string $tableName |
||||
1626 | * @param string $columnName |
||||
1627 | * @param string|null $comment |
||||
1628 | * |
||||
1629 | * @return string |
||||
1630 | */ |
||||
1631 | 1014 | public function getCommentOnColumnSQL($tableName, $columnName, $comment) |
|||
1632 | { |
||||
1633 | 1014 | $tableName = new Identifier($tableName); |
|||
1634 | 1014 | $columnName = new Identifier($columnName); |
|||
1635 | |||||
1636 | 1014 | return sprintf( |
|||
1637 | 1014 | 'COMMENT ON COLUMN %s.%s IS %s', |
|||
1638 | 1014 | $tableName->getQuotedName($this), |
|||
1639 | 1014 | $columnName->getQuotedName($this), |
|||
1640 | 1014 | $this->quoteStringLiteral((string) $comment) |
|||
1641 | ); |
||||
1642 | } |
||||
1643 | |||||
1644 | /** |
||||
1645 | * Returns the SQL to create inline comment on a column. |
||||
1646 | * |
||||
1647 | * @param string $comment |
||||
1648 | * |
||||
1649 | * @return string |
||||
1650 | * |
||||
1651 | * @throws DBALException If not supported on this platform. |
||||
1652 | */ |
||||
1653 | 1575 | public function getInlineColumnCommentSQL($comment) |
|||
1654 | { |
||||
1655 | 1575 | if (! $this->supportsInlineColumnComments()) { |
|||
1656 | 378 | throw DBALException::notSupported(__METHOD__); |
|||
1657 | } |
||||
1658 | |||||
1659 | 1197 | return 'COMMENT ' . $this->quoteStringLiteral($comment); |
|||
1660 | } |
||||
1661 | |||||
1662 | /** |
||||
1663 | * Returns the SQL used to create a table. |
||||
1664 | * |
||||
1665 | * @param string $tableName |
||||
1666 | * @param mixed[][] $columns |
||||
1667 | * @param mixed[] $options |
||||
1668 | * |
||||
1669 | * @return string[] |
||||
1670 | */ |
||||
1671 | 1017 | protected function _getCreateTableSQL($tableName, array $columns, array $options = []) |
|||
1672 | { |
||||
1673 | 1017 | $columnListSql = $this->getColumnDeclarationListSQL($columns); |
|||
1674 | |||||
1675 | 1017 | if (isset($options['uniqueConstraints']) && ! empty($options['uniqueConstraints'])) { |
|||
1676 | foreach ($options['uniqueConstraints'] as $name => $definition) { |
||||
1677 | $columnListSql .= ', ' . $this->getUniqueConstraintDeclarationSQL($name, $definition); |
||||
1678 | } |
||||
1679 | } |
||||
1680 | |||||
1681 | 1017 | if (isset($options['primary']) && ! empty($options['primary'])) { |
|||
1682 | 531 | $columnListSql .= ', PRIMARY KEY(' . implode(', ', array_unique(array_values($options['primary']))) . ')'; |
|||
1683 | } |
||||
1684 | |||||
1685 | 1017 | if (isset($options['indexes']) && ! empty($options['indexes'])) { |
|||
1686 | foreach ($options['indexes'] as $index => $definition) { |
||||
1687 | $columnListSql .= ', ' . $this->getIndexDeclarationSQL($index, $definition); |
||||
1688 | } |
||||
1689 | } |
||||
1690 | |||||
1691 | 1017 | $query = 'CREATE TABLE ' . $tableName . ' (' . $columnListSql; |
|||
1692 | |||||
1693 | 1017 | $check = $this->getCheckDeclarationSQL($columns); |
|||
1694 | 1017 | if (! empty($check)) { |
|||
1695 | 27 | $query .= ', ' . $check; |
|||
1696 | } |
||||
1697 | 1017 | $query .= ')'; |
|||
1698 | |||||
1699 | 1017 | $sql[] = $query; |
|||
1700 | |||||
1701 | 1017 | if (isset($options['foreignKeys'])) { |
|||
1702 | 457 | foreach ((array) $options['foreignKeys'] as $definition) { |
|||
1703 | 103 | $sql[] = $this->getCreateForeignKeySQL($definition, $tableName); |
|||
1704 | } |
||||
1705 | } |
||||
1706 | |||||
1707 | 1017 | return $sql; |
|||
1708 | } |
||||
1709 | |||||
1710 | /** |
||||
1711 | * @return string |
||||
1712 | */ |
||||
1713 | 44 | public function getCreateTemporaryTableSnippetSQL() |
|||
1714 | { |
||||
1715 | 44 | return 'CREATE TEMPORARY TABLE'; |
|||
1716 | } |
||||
1717 | |||||
1718 | /** |
||||
1719 | * Returns the SQL to create a sequence on this platform. |
||||
1720 | * |
||||
1721 | * @return string |
||||
1722 | * |
||||
1723 | * @throws DBALException If not supported on this platform. |
||||
1724 | */ |
||||
1725 | public function getCreateSequenceSQL(Sequence $sequence) |
||||
1726 | { |
||||
1727 | throw DBALException::notSupported(__METHOD__); |
||||
1728 | } |
||||
1729 | |||||
1730 | /** |
||||
1731 | * Returns the SQL to change a sequence on this platform. |
||||
1732 | * |
||||
1733 | * @return string |
||||
1734 | * |
||||
1735 | * @throws DBALException If not supported on this platform. |
||||
1736 | */ |
||||
1737 | public function getAlterSequenceSQL(Sequence $sequence) |
||||
1738 | { |
||||
1739 | throw DBALException::notSupported(__METHOD__); |
||||
1740 | } |
||||
1741 | |||||
1742 | /** |
||||
1743 | * Returns the SQL to create a constraint on a table on this platform. |
||||
1744 | * |
||||
1745 | * @param Table|string $table |
||||
1746 | * |
||||
1747 | * @return string |
||||
1748 | * |
||||
1749 | * @throws InvalidArgumentException |
||||
1750 | */ |
||||
1751 | 476 | public function getCreateConstraintSQL(Constraint $constraint, $table) |
|||
1752 | { |
||||
1753 | 476 | if ($table instanceof Table) { |
|||
1754 | $table = $table->getQuotedName($this); |
||||
1755 | } |
||||
1756 | |||||
1757 | 476 | $query = 'ALTER TABLE ' . $table . ' ADD CONSTRAINT ' . $constraint->getQuotedName($this); |
|||
1758 | |||||
1759 | 476 | $columnList = '(' . implode(', ', $constraint->getQuotedColumns($this)) . ')'; |
|||
1760 | |||||
1761 | 476 | $referencesClause = ''; |
|||
1762 | 476 | if ($constraint instanceof Index) { |
|||
1763 | 476 | if ($constraint->isPrimary()) { |
|||
1764 | 476 | $query .= ' PRIMARY KEY'; |
|||
1765 | 351 | } elseif ($constraint->isUnique()) { |
|||
1766 | 351 | $query .= ' UNIQUE'; |
|||
1767 | } else { |
||||
1768 | throw new InvalidArgumentException( |
||||
1769 | 476 | 'Can only create primary or unique constraints, no common indexes with getCreateConstraintSQL().' |
|||
1770 | ); |
||||
1771 | } |
||||
1772 | 351 | } elseif ($constraint instanceof ForeignKeyConstraint) { |
|||
1773 | 351 | $query .= ' FOREIGN KEY'; |
|||
1774 | |||||
1775 | 351 | $referencesClause = ' REFERENCES ' . $constraint->getQuotedForeignTableName($this) . |
|||
1776 | 351 | ' (' . implode(', ', $constraint->getQuotedForeignColumns($this)) . ')'; |
|||
1777 | } |
||||
1778 | 476 | $query .= ' ' . $columnList . $referencesClause; |
|||
1779 | |||||
1780 | 476 | return $query; |
|||
1781 | } |
||||
1782 | |||||
1783 | /** |
||||
1784 | * Returns the SQL to create an index on a table on this platform. |
||||
1785 | * |
||||
1786 | * @param Table|string $table The name of the table on which the index is to be created. |
||||
1787 | * |
||||
1788 | * @return string |
||||
1789 | * |
||||
1790 | * @throws InvalidArgumentException |
||||
1791 | */ |
||||
1792 | 4289 | public function getCreateIndexSQL(Index $index, $table) |
|||
1793 | { |
||||
1794 | 4289 | if ($table instanceof Table) { |
|||
1795 | 27 | $table = $table->getQuotedName($this); |
|||
1796 | } |
||||
1797 | 4289 | $name = $index->getQuotedName($this); |
|||
1798 | 4289 | $columns = $index->getColumns(); |
|||
1799 | |||||
1800 | 4289 | if (count($columns) === 0) { |
|||
1801 | throw new InvalidArgumentException("Incomplete definition. 'columns' required."); |
||||
1802 | } |
||||
1803 | |||||
1804 | 4289 | if ($index->isPrimary()) { |
|||
1805 | 567 | return $this->getCreatePrimaryKeySQL($index, $table); |
|||
1806 | } |
||||
1807 | |||||
1808 | 3776 | $query = 'CREATE ' . $this->getCreateIndexSQLFlags($index) . 'INDEX ' . $name . ' ON ' . $table; |
|||
1809 | 3776 | $query .= ' (' . $this->getIndexFieldDeclarationListSQL($index) . ')' . $this->getPartialIndexSQL($index); |
|||
1810 | |||||
1811 | 3776 | return $query; |
|||
1812 | } |
||||
1813 | |||||
1814 | /** |
||||
1815 | * Adds condition for partial index. |
||||
1816 | * |
||||
1817 | * @return string |
||||
1818 | */ |
||||
1819 | 5259 | protected function getPartialIndexSQL(Index $index) |
|||
1820 | { |
||||
1821 | 5259 | if ($this->supportsPartialIndexes() && $index->hasOption('where')) { |
|||
1822 | 142 | return ' WHERE ' . $index->getOption('where'); |
|||
1823 | } |
||||
1824 | |||||
1825 | 5117 | return ''; |
|||
1826 | } |
||||
1827 | |||||
1828 | /** |
||||
1829 | * Adds additional flags for index generation. |
||||
1830 | * |
||||
1831 | * @return string |
||||
1832 | */ |
||||
1833 | 1843 | protected function getCreateIndexSQLFlags(Index $index) |
|||
1834 | { |
||||
1835 | 1843 | return $index->isUnique() ? 'UNIQUE ' : ''; |
|||
1836 | } |
||||
1837 | |||||
1838 | /** |
||||
1839 | * Returns the SQL to create an unnamed primary key constraint. |
||||
1840 | * |
||||
1841 | * @param Table|string $table |
||||
1842 | * |
||||
1843 | * @return string |
||||
1844 | */ |
||||
1845 | 459 | public function getCreatePrimaryKeySQL(Index $index, $table) |
|||
1846 | { |
||||
1847 | 459 | if ($table instanceof Table) { |
|||
1848 | $table = $table->getQuotedName($this); |
||||
1849 | } |
||||
1850 | |||||
1851 | 459 | return 'ALTER TABLE ' . $table . ' ADD PRIMARY KEY (' . $this->getIndexFieldDeclarationListSQL($index) . ')'; |
|||
1852 | } |
||||
1853 | |||||
1854 | /** |
||||
1855 | * Returns the SQL to create a named schema. |
||||
1856 | * |
||||
1857 | * @param string $schemaName |
||||
1858 | * |
||||
1859 | * @return string |
||||
1860 | * |
||||
1861 | * @throws DBALException If not supported on this platform. |
||||
1862 | */ |
||||
1863 | 270 | public function getCreateSchemaSQL($schemaName) |
|||
1864 | { |
||||
1865 | 270 | throw DBALException::notSupported(__METHOD__); |
|||
1866 | } |
||||
1867 | |||||
1868 | /** |
||||
1869 | * Quotes a string so that it can be safely used as a table or column name, |
||||
1870 | * even if it is a reserved word of the platform. This also detects identifier |
||||
1871 | * chains separated by dot and quotes them independently. |
||||
1872 | * |
||||
1873 | * NOTE: Just because you CAN use quoted identifiers doesn't mean |
||||
1874 | * you SHOULD use them. In general, they end up causing way more |
||||
1875 | * problems than they solve. |
||||
1876 | * |
||||
1877 | * @param string $str The identifier name to be quoted. |
||||
1878 | * |
||||
1879 | * @return string The quoted identifier string. |
||||
1880 | */ |
||||
1881 | 10903 | public function quoteIdentifier($str) |
|||
1882 | { |
||||
1883 | 10903 | if (strpos($str, '.') !== false) { |
|||
1884 | 516 | $parts = array_map([$this, 'quoteSingleIdentifier'], explode('.', $str)); |
|||
1885 | |||||
1886 | 516 | return implode('.', $parts); |
|||
1887 | } |
||||
1888 | |||||
1889 | 10903 | return $this->quoteSingleIdentifier($str); |
|||
1890 | } |
||||
1891 | |||||
1892 | /** |
||||
1893 | * Quotes a single identifier (no dot chain separation). |
||||
1894 | * |
||||
1895 | * @param string $str The identifier name to be quoted. |
||||
1896 | * |
||||
1897 | * @return string The quoted identifier string. |
||||
1898 | */ |
||||
1899 | 10125 | public function quoteSingleIdentifier($str) |
|||
1900 | { |
||||
1901 | 10125 | $c = $this->getIdentifierQuoteCharacter(); |
|||
1902 | |||||
1903 | 10125 | return $c . str_replace($c, $c . $c, $str) . $c; |
|||
1904 | } |
||||
1905 | |||||
1906 | /** |
||||
1907 | * Returns the SQL to create a new foreign key. |
||||
1908 | * |
||||
1909 | * @param ForeignKeyConstraint $foreignKey The foreign key constraint. |
||||
1910 | * @param Table|string $table The name of the table on which the foreign key is to be created. |
||||
1911 | * |
||||
1912 | * @return string |
||||
1913 | */ |
||||
1914 | 2412 | public function getCreateForeignKeySQL(ForeignKeyConstraint $foreignKey, $table) |
|||
1915 | { |
||||
1916 | 2412 | if ($table instanceof Table) { |
|||
1917 | 27 | $table = $table->getQuotedName($this); |
|||
1918 | } |
||||
1919 | |||||
1920 | 2412 | return 'ALTER TABLE ' . $table . ' ADD ' . $this->getForeignKeyDeclarationSQL($foreignKey); |
|||
1921 | } |
||||
1922 | |||||
1923 | /** |
||||
1924 | * Gets the SQL statements for altering an existing table. |
||||
1925 | * |
||||
1926 | * This method returns an array of SQL statements, since some platforms need several statements. |
||||
1927 | * |
||||
1928 | * @return string[] |
||||
1929 | * |
||||
1930 | * @throws DBALException If not supported on this platform. |
||||
1931 | */ |
||||
1932 | public function getAlterTableSQL(TableDiff $diff) |
||||
1933 | { |
||||
1934 | throw DBALException::notSupported(__METHOD__); |
||||
1935 | } |
||||
1936 | |||||
1937 | /** |
||||
1938 | * @param mixed[] $columnSql |
||||
1939 | * |
||||
1940 | * @return bool |
||||
1941 | */ |
||||
1942 | 2691 | protected function onSchemaAlterTableAddColumn(Column $column, TableDiff $diff, &$columnSql) |
|||
1943 | { |
||||
1944 | 2691 | if ($this->_eventManager === null) { |
|||
1945 | 2160 | return false; |
|||
1946 | } |
||||
1947 | |||||
1948 | 531 | if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTableAddColumn)) { |
|||
1949 | 45 | return false; |
|||
1950 | } |
||||
1951 | |||||
1952 | 486 | $eventArgs = new SchemaAlterTableAddColumnEventArgs($column, $diff, $this); |
|||
1953 | 486 | $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableAddColumn, $eventArgs); |
|||
1954 | |||||
1955 | 486 | $columnSql = array_merge($columnSql, $eventArgs->getSql()); |
|||
1956 | |||||
1957 | 486 | return $eventArgs->isDefaultPrevented(); |
|||
1958 | } |
||||
1959 | |||||
1960 | /** |
||||
1961 | * @param string[] $columnSql |
||||
1962 | * |
||||
1963 | * @return bool |
||||
1964 | */ |
||||
1965 | 2058 | protected function onSchemaAlterTableRemoveColumn(Column $column, TableDiff $diff, &$columnSql) |
|||
1966 | { |
||||
1967 | 2058 | if ($this->_eventManager === null) { |
|||
1968 | 1539 | return false; |
|||
1969 | } |
||||
1970 | |||||
1971 | 519 | if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTableRemoveColumn)) { |
|||
1972 | 33 | return false; |
|||
1973 | } |
||||
1974 | |||||
1975 | 486 | $eventArgs = new SchemaAlterTableRemoveColumnEventArgs($column, $diff, $this); |
|||
1976 | 486 | $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableRemoveColumn, $eventArgs); |
|||
1977 | |||||
1978 | 486 | $columnSql = array_merge($columnSql, $eventArgs->getSql()); |
|||
1979 | |||||
1980 | 486 | return $eventArgs->isDefaultPrevented(); |
|||
1981 | } |
||||
1982 | |||||
1983 | /** |
||||
1984 | * @param string[] $columnSql |
||||
1985 | * |
||||
1986 | * @return bool |
||||
1987 | */ |
||||
1988 | 5364 | protected function onSchemaAlterTableChangeColumn(ColumnDiff $columnDiff, TableDiff $diff, &$columnSql) |
|||
1989 | { |
||||
1990 | 5364 | if ($this->_eventManager === null) { |
|||
1991 | 4482 | return false; |
|||
1992 | } |
||||
1993 | |||||
1994 | 882 | if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTableChangeColumn)) { |
|||
1995 | 396 | return false; |
|||
1996 | } |
||||
1997 | |||||
1998 | 486 | $eventArgs = new SchemaAlterTableChangeColumnEventArgs($columnDiff, $diff, $this); |
|||
1999 | 486 | $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableChangeColumn, $eventArgs); |
|||
2000 | |||||
2001 | 486 | $columnSql = array_merge($columnSql, $eventArgs->getSql()); |
|||
2002 | |||||
2003 | 486 | return $eventArgs->isDefaultPrevented(); |
|||
2004 | } |
||||
2005 | |||||
2006 | /** |
||||
2007 | * @param string $oldColumnName |
||||
2008 | * @param string[] $columnSql |
||||
2009 | * |
||||
2010 | * @return bool |
||||
2011 | */ |
||||
2012 | 2082 | protected function onSchemaAlterTableRenameColumn($oldColumnName, Column $column, TableDiff $diff, &$columnSql) |
|||
2013 | { |
||||
2014 | 2082 | if ($this->_eventManager === null) { |
|||
2015 | 1566 | return false; |
|||
2016 | } |
||||
2017 | |||||
2018 | 516 | if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTableRenameColumn)) { |
|||
2019 | 30 | return false; |
|||
2020 | } |
||||
2021 | |||||
2022 | 486 | $eventArgs = new SchemaAlterTableRenameColumnEventArgs($oldColumnName, $column, $diff, $this); |
|||
2023 | 486 | $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableRenameColumn, $eventArgs); |
|||
2024 | |||||
2025 | 486 | $columnSql = array_merge($columnSql, $eventArgs->getSql()); |
|||
2026 | |||||
2027 | 486 | return $eventArgs->isDefaultPrevented(); |
|||
2028 | } |
||||
2029 | |||||
2030 | /** |
||||
2031 | * @param string[] $sql |
||||
2032 | * |
||||
2033 | * @return bool |
||||
2034 | */ |
||||
2035 | 10072 | protected function onSchemaAlterTable(TableDiff $diff, &$sql) |
|||
2036 | { |
||||
2037 | 10072 | if ($this->_eventManager === null) { |
|||
2038 | 9045 | return false; |
|||
2039 | } |
||||
2040 | |||||
2041 | 1027 | if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTable)) { |
|||
2042 | 541 | return false; |
|||
2043 | } |
||||
2044 | |||||
2045 | 486 | $eventArgs = new SchemaAlterTableEventArgs($diff, $this); |
|||
2046 | 486 | $this->_eventManager->dispatchEvent(Events::onSchemaAlterTable, $eventArgs); |
|||
2047 | |||||
2048 | 486 | $sql = array_merge($sql, $eventArgs->getSql()); |
|||
2049 | |||||
2050 | 486 | return $eventArgs->isDefaultPrevented(); |
|||
2051 | } |
||||
2052 | |||||
2053 | /** |
||||
2054 | * @return string[] |
||||
2055 | */ |
||||
2056 | 9702 | protected function getPreAlterTableIndexForeignKeySQL(TableDiff $diff) |
|||
2057 | { |
||||
2058 | 9702 | $tableName = $diff->getName($this)->getQuotedName($this); |
|||
2059 | |||||
2060 | 9702 | $sql = []; |
|||
2061 | 9702 | if ($this->supportsForeignKeyConstraints()) { |
|||
2062 | 9702 | foreach ($diff->removedForeignKeys as $foreignKey) { |
|||
2063 | 701 | $sql[] = $this->getDropForeignKeySQL($foreignKey, $tableName); |
|||
2064 | } |
||||
2065 | 9702 | foreach ($diff->changedForeignKeys as $foreignKey) { |
|||
2066 | 540 | $sql[] = $this->getDropForeignKeySQL($foreignKey, $tableName); |
|||
2067 | } |
||||
2068 | } |
||||
2069 | |||||
2070 | 9702 | foreach ($diff->removedIndexes as $index) { |
|||
2071 | 351 | $sql[] = $this->getDropIndexSQL($index, $tableName); |
|||
2072 | } |
||||
2073 | 9702 | foreach ($diff->changedIndexes as $index) { |
|||
2074 | 484 | $sql[] = $this->getDropIndexSQL($index, $tableName); |
|||
2075 | } |
||||
2076 | |||||
2077 | 9702 | return $sql; |
|||
2078 | } |
||||
2079 | |||||
2080 | /** |
||||
2081 | * @return string[] |
||||
2082 | */ |
||||
2083 | 9702 | protected function getPostAlterTableIndexForeignKeySQL(TableDiff $diff) |
|||
2084 | { |
||||
2085 | 9702 | $sql = []; |
|||
2086 | 9702 | $newName = $diff->getNewName(); |
|||
2087 | |||||
2088 | 9702 | if ($newName !== false) { |
|||
2089 | 922 | $tableName = $newName->getQuotedName($this); |
|||
2090 | } else { |
||||
2091 | 8782 | $tableName = $diff->getName($this)->getQuotedName($this); |
|||
2092 | } |
||||
2093 | |||||
2094 | 9702 | if ($this->supportsForeignKeyConstraints()) { |
|||
2095 | 9702 | foreach ($diff->addedForeignKeys as $foreignKey) { |
|||
2096 | 592 | $sql[] = $this->getCreateForeignKeySQL($foreignKey, $tableName); |
|||
2097 | } |
||||
2098 | |||||
2099 | 9702 | foreach ($diff->changedForeignKeys as $foreignKey) { |
|||
2100 | 540 | $sql[] = $this->getCreateForeignKeySQL($foreignKey, $tableName); |
|||
2101 | } |
||||
2102 | } |
||||
2103 | |||||
2104 | 9702 | foreach ($diff->addedIndexes as $index) { |
|||
2105 | 107 | $sql[] = $this->getCreateIndexSQL($index, $tableName); |
|||
2106 | } |
||||
2107 | |||||
2108 | 9702 | foreach ($diff->changedIndexes as $index) { |
|||
2109 | 484 | $sql[] = $this->getCreateIndexSQL($index, $tableName); |
|||
2110 | } |
||||
2111 | |||||
2112 | 9702 | foreach ($diff->renamedIndexes as $oldIndexName => $index) { |
|||
2113 | 2347 | $oldIndexName = new Identifier($oldIndexName); |
|||
2114 | 2347 | $sql = array_merge( |
|||
2115 | 2347 | $sql, |
|||
2116 | 2347 | $this->getRenameIndexSQL($oldIndexName->getQuotedName($this), $index, $tableName) |
|||
2117 | ); |
||||
2118 | } |
||||
2119 | |||||
2120 | 9702 | return $sql; |
|||
2121 | } |
||||
2122 | |||||
2123 | /** |
||||
2124 | * Returns the SQL for renaming an index on a table. |
||||
2125 | * |
||||
2126 | * @param string $oldIndexName The name of the index to rename from. |
||||
2127 | * @param Index $index The definition of the index to rename to. |
||||
2128 | * @param string $tableName The table to rename the given index on. |
||||
2129 | * |
||||
2130 | * @return string[] The sequence of SQL statements for renaming the given index. |
||||
2131 | */ |
||||
2132 | 290 | protected function getRenameIndexSQL($oldIndexName, Index $index, $tableName) |
|||
2133 | { |
||||
2134 | return [ |
||||
2135 | 290 | $this->getDropIndexSQL($oldIndexName, $tableName), |
|||
2136 | 290 | $this->getCreateIndexSQL($index, $tableName), |
|||
2137 | ]; |
||||
2138 | } |
||||
2139 | |||||
2140 | /** |
||||
2141 | * Common code for alter table statement generation that updates the changed Index and Foreign Key definitions. |
||||
2142 | * |
||||
2143 | * @return string[] |
||||
2144 | */ |
||||
2145 | protected function _getAlterTableIndexForeignKeySQL(TableDiff $diff) |
||||
2146 | { |
||||
2147 | return array_merge($this->getPreAlterTableIndexForeignKeySQL($diff), $this->getPostAlterTableIndexForeignKeySQL($diff)); |
||||
2148 | } |
||||
2149 | |||||
2150 | /** |
||||
2151 | * Gets declaration of a number of fields in bulk. |
||||
2152 | * |
||||
2153 | * @param mixed[][] $fields A multidimensional associative array. |
||||
2154 | * The first dimension determines the field name, while the second |
||||
2155 | * dimension is keyed with the name of the properties |
||||
2156 | * of the field being declared as array indexes. Currently, the types |
||||
2157 | * of supported field properties are as follows: |
||||
2158 | * |
||||
2159 | * length |
||||
2160 | * Integer value that determines the maximum length of the text |
||||
2161 | * field. If this argument is missing the field should be |
||||
2162 | * declared to have the longest length allowed by the DBMS. |
||||
2163 | * |
||||
2164 | * default |
||||
2165 | * Text value to be used as default for this field. |
||||
2166 | * |
||||
2167 | * notnull |
||||
2168 | * Boolean flag that indicates whether this field is constrained |
||||
2169 | * to not be set to null. |
||||
2170 | * charset |
||||
2171 | * Text value with the default CHARACTER SET for this field. |
||||
2172 | * collation |
||||
2173 | * Text value with the default COLLATION for this field. |
||||
2174 | * unique |
||||
2175 | * unique constraint |
||||
2176 | * |
||||
2177 | * @return string |
||||
2178 | */ |
||||
2179 | 11477 | public function getColumnDeclarationListSQL(array $fields) |
|||
2180 | { |
||||
2181 | 11477 | $queryFields = []; |
|||
2182 | |||||
2183 | 11477 | foreach ($fields as $fieldName => $field) { |
|||
2184 | 11477 | $queryFields[] = $this->getColumnDeclarationSQL($fieldName, $field); |
|||
2185 | } |
||||
2186 | |||||
2187 | 11477 | return implode(', ', $queryFields); |
|||
2188 | } |
||||
2189 | |||||
2190 | /** |
||||
2191 | * Obtains DBMS specific SQL code portion needed to declare a generic type |
||||
2192 | * field to be used in statements like CREATE TABLE. |
||||
2193 | * |
||||
2194 | * @param string $name The name the field to be declared. |
||||
2195 | * @param mixed[] $field An associative array with the name of the properties |
||||
2196 | * of the field being declared as array indexes. Currently, the types |
||||
2197 | * of supported field properties are as follows: |
||||
2198 | * |
||||
2199 | * length |
||||
2200 | * Integer value that determines the maximum length of the text |
||||
2201 | * field. If this argument is missing the field should be |
||||
2202 | * declared to have the longest length allowed by the DBMS. |
||||
2203 | * |
||||
2204 | * default |
||||
2205 | * Text value to be used as default for this field. |
||||
2206 | * |
||||
2207 | * notnull |
||||
2208 | * Boolean flag that indicates whether this field is constrained |
||||
2209 | * to not be set to null. |
||||
2210 | * charset |
||||
2211 | * Text value with the default CHARACTER SET for this field. |
||||
2212 | * collation |
||||
2213 | * Text value with the default COLLATION for this field. |
||||
2214 | * unique |
||||
2215 | * unique constraint |
||||
2216 | * check |
||||
2217 | * column check constraint |
||||
2218 | * columnDefinition |
||||
2219 | * a string that defines the complete column |
||||
2220 | * |
||||
2221 | * @return string DBMS specific SQL code portion that should be used to declare the column. |
||||
2222 | */ |
||||
2223 | 12167 | public function getColumnDeclarationSQL($name, array $field) |
|||
2224 | { |
||||
2225 | 12167 | if (isset($field['columnDefinition'])) { |
|||
2226 | 393 | $columnDef = $this->getCustomTypeDeclarationSQL($field); |
|||
2227 | } else { |
||||
2228 | 11789 | $default = $this->getDefaultValueDeclarationSQL($field); |
|||
2229 | |||||
2230 | 11789 | $charset = isset($field['charset']) && $field['charset'] ? |
|||
2231 | 11789 | ' ' . $this->getColumnCharsetDeclarationSQL($field['charset']) : ''; |
|||
2232 | |||||
2233 | 11789 | $collation = isset($field['collation']) && $field['collation'] ? |
|||
2234 | 11789 | ' ' . $this->getColumnCollationDeclarationSQL($field['collation']) : ''; |
|||
2235 | |||||
2236 | 11789 | $notnull = isset($field['notnull']) && $field['notnull'] ? ' NOT NULL' : ''; |
|||
2237 | |||||
2238 | 11789 | $unique = isset($field['unique']) && $field['unique'] ? |
|||
2239 | 11789 | ' ' . $this->getUniqueFieldDeclarationSQL() : ''; |
|||
2240 | |||||
2241 | 11789 | $check = isset($field['check']) && $field['check'] ? |
|||
2242 | 11789 | ' ' . $field['check'] : ''; |
|||
2243 | |||||
2244 | 11789 | $typeDecl = $field['type']->getSQLDeclaration($field, $this); |
|||
2245 | 11789 | $columnDef = $typeDecl . $charset . $default . $notnull . $unique . $check . $collation; |
|||
2246 | |||||
2247 | 11789 | if ($this->supportsInlineColumnComments() && isset($field['comment']) && $field['comment'] !== '') { |
|||
2248 | 1067 | $columnDef .= ' ' . $this->getInlineColumnCommentSQL($field['comment']); |
|||
2249 | } |
||||
2250 | } |
||||
2251 | |||||
2252 | 12167 | return $name . ' ' . $columnDef; |
|||
2253 | } |
||||
2254 | |||||
2255 | /** |
||||
2256 | * Returns the SQL snippet that declares a floating point column of arbitrary precision. |
||||
2257 | * |
||||
2258 | * @param mixed[] $columnDef |
||||
2259 | * |
||||
2260 | * @return string |
||||
2261 | */ |
||||
2262 | 3627 | public function getDecimalTypeDeclarationSQL(array $columnDef) |
|||
2263 | { |
||||
2264 | 3627 | $columnDef['precision'] = ! isset($columnDef['precision']) || empty($columnDef['precision']) |
|||
2265 | 3627 | ? 10 : $columnDef['precision']; |
|||
2266 | 3627 | $columnDef['scale'] = ! isset($columnDef['scale']) || empty($columnDef['scale']) |
|||
2267 | 3627 | ? 0 : $columnDef['scale']; |
|||
2268 | |||||
2269 | 3627 | return 'NUMERIC(' . $columnDef['precision'] . ', ' . $columnDef['scale'] . ')'; |
|||
2270 | } |
||||
2271 | |||||
2272 | /** |
||||
2273 | * Obtains DBMS specific SQL code portion needed to set a default value |
||||
2274 | * declaration to be used in statements like CREATE TABLE. |
||||
2275 | * |
||||
2276 | * @param mixed[] $field The field definition array. |
||||
2277 | * |
||||
2278 | * @return string DBMS specific SQL code portion needed to set a default value. |
||||
2279 | */ |
||||
2280 | 13446 | public function getDefaultValueDeclarationSQL($field) |
|||
2281 | { |
||||
2282 | 13446 | if (! isset($field['default'])) { |
|||
2283 | 11576 | return empty($field['notnull']) ? ' DEFAULT NULL' : ''; |
|||
2284 | } |
||||
2285 | |||||
2286 | 2505 | $default = $field['default']; |
|||
2287 | |||||
2288 | 2505 | if (! isset($field['type'])) { |
|||
2289 | return " DEFAULT '" . $default . "'"; |
||||
2290 | } |
||||
2291 | |||||
2292 | 2505 | $type = $field['type']; |
|||
2293 | |||||
2294 | 2505 | if ($type instanceof Types\PhpIntegerMappingType) { |
|||
2295 | 699 | return ' DEFAULT ' . $default; |
|||
2296 | } |
||||
2297 | |||||
2298 | 1877 | if ($type instanceof Types\PhpDateTimeMappingType && $default === $this->getCurrentTimestampSQL()) { |
|||
2299 | 437 | return ' DEFAULT ' . $this->getCurrentTimestampSQL(); |
|||
2300 | } |
||||
2301 | |||||
2302 | 1458 | if ($type instanceof Types\TimeType && $default === $this->getCurrentTimeSQL()) { |
|||
2303 | 4 | return ' DEFAULT ' . $this->getCurrentTimeSQL(); |
|||
2304 | } |
||||
2305 | |||||
2306 | 1458 | if ($type instanceof Types\DateType && $default === $this->getCurrentDateSQL()) { |
|||
2307 | 409 | return ' DEFAULT ' . $this->getCurrentDateSQL(); |
|||
2308 | } |
||||
2309 | |||||
2310 | 1049 | if ($type instanceof Types\BooleanType) { |
|||
2311 | 437 | return " DEFAULT '" . $this->convertBooleans($default) . "'"; |
|||
2312 | } |
||||
2313 | |||||
2314 | 1017 | return " DEFAULT '" . $default . "'"; |
|||
2315 | } |
||||
2316 | |||||
2317 | /** |
||||
2318 | * Obtains DBMS specific SQL code portion needed to set a CHECK constraint |
||||
2319 | * declaration to be used in statements like CREATE TABLE. |
||||
2320 | * |
||||
2321 | * @param string[]|mixed[][] $definition The check definition. |
||||
2322 | * |
||||
2323 | * @return string DBMS specific SQL code portion needed to set a CHECK constraint. |
||||
2324 | */ |
||||
2325 | 3986 | public function getCheckDeclarationSQL(array $definition) |
|||
2326 | { |
||||
2327 | 3986 | $constraints = []; |
|||
2328 | 3986 | foreach ($definition as $field => $def) { |
|||
2329 | 3986 | if (is_string($def)) { |
|||
2330 | $constraints[] = 'CHECK (' . $def . ')'; |
||||
2331 | } else { |
||||
2332 | 3986 | if (isset($def['min'])) { |
|||
2333 | 135 | $constraints[] = 'CHECK (' . $field . ' >= ' . $def['min'] . ')'; |
|||
2334 | } |
||||
2335 | |||||
2336 | 3986 | if (isset($def['max'])) { |
|||
2337 | 641 | $constraints[] = 'CHECK (' . $field . ' <= ' . $def['max'] . ')'; |
|||
2338 | } |
||||
2339 | } |
||||
2340 | } |
||||
2341 | |||||
2342 | 3986 | return implode(', ', $constraints); |
|||
2343 | } |
||||
2344 | |||||
2345 | /** |
||||
2346 | * Obtains DBMS specific SQL code portion needed to set a unique |
||||
2347 | * constraint declaration to be used in statements like CREATE TABLE. |
||||
2348 | * |
||||
2349 | * @param string $name The name of the unique constraint. |
||||
2350 | * @param Index $index The index definition. |
||||
2351 | * |
||||
2352 | * @return string DBMS specific SQL code portion needed to set a constraint. |
||||
2353 | * |
||||
2354 | * @throws InvalidArgumentException |
||||
2355 | */ |
||||
2356 | 756 | public function getUniqueConstraintDeclarationSQL($name, Index $index) |
|||
2357 | { |
||||
2358 | 756 | $columns = $index->getColumns(); |
|||
2359 | 756 | $name = new Identifier($name); |
|||
2360 | |||||
2361 | 756 | if (count($columns) === 0) { |
|||
2362 | throw new InvalidArgumentException("Incomplete definition. 'columns' required."); |
||||
2363 | } |
||||
2364 | |||||
2365 | 756 | return 'CONSTRAINT ' . $name->getQuotedName($this) . ' UNIQUE (' |
|||
2366 | 756 | . $this->getIndexFieldDeclarationListSQL($index) |
|||
2367 | 756 | . ')' . $this->getPartialIndexSQL($index); |
|||
2368 | } |
||||
2369 | |||||
2370 | /** |
||||
2371 | * Obtains DBMS specific SQL code portion needed to set an index |
||||
2372 | * declaration to be used in statements like CREATE TABLE. |
||||
2373 | * |
||||
2374 | * @param string $name The name of the index. |
||||
2375 | * @param Index $index The index definition. |
||||
2376 | * |
||||
2377 | * @return string DBMS specific SQL code portion needed to set an index. |
||||
2378 | * |
||||
2379 | * @throws InvalidArgumentException |
||||
2380 | */ |
||||
2381 | 1494 | public function getIndexDeclarationSQL($name, Index $index) |
|||
2382 | { |
||||
2383 | 1494 | $columns = $index->getColumns(); |
|||
2384 | 1494 | $name = new Identifier($name); |
|||
2385 | |||||
2386 | 1494 | if (count($columns) === 0) { |
|||
2387 | throw new InvalidArgumentException("Incomplete definition. 'columns' required."); |
||||
2388 | } |
||||
2389 | |||||
2390 | 1494 | return $this->getCreateIndexSQLFlags($index) . 'INDEX ' . $name->getQuotedName($this) . ' (' |
|||
2391 | 1494 | . $this->getIndexFieldDeclarationListSQL($index) |
|||
2392 | 1494 | . ')' . $this->getPartialIndexSQL($index); |
|||
2393 | } |
||||
2394 | |||||
2395 | /** |
||||
2396 | * Obtains SQL code portion needed to create a custom column, |
||||
2397 | * e.g. when a field has the "columnDefinition" keyword. |
||||
2398 | * Only "AUTOINCREMENT" and "PRIMARY KEY" are added if appropriate. |
||||
2399 | * |
||||
2400 | * @param mixed[] $columnDef |
||||
2401 | * |
||||
2402 | * @return string |
||||
2403 | */ |
||||
2404 | 501 | public function getCustomTypeDeclarationSQL(array $columnDef) |
|||
2405 | { |
||||
2406 | 501 | return $columnDef['columnDefinition']; |
|||
2407 | } |
||||
2408 | |||||
2409 | /** |
||||
2410 | * Obtains DBMS specific SQL code portion needed to set an index |
||||
2411 | * declaration to be used in statements like CREATE TABLE. |
||||
2412 | * |
||||
2413 | * @param mixed[]|Index $columnsOrIndex array declaration is deprecated, prefer passing Index to this method |
||||
2414 | */ |
||||
2415 | 7149 | public function getIndexFieldDeclarationListSQL($columnsOrIndex) : string |
|||
2416 | { |
||||
2417 | 7149 | if ($columnsOrIndex instanceof Index) { |
|||
2418 | 5961 | return implode(', ', $columnsOrIndex->getQuotedColumns($this)); |
|||
2419 | } |
||||
2420 | |||||
2421 | 1350 | if (! is_array($columnsOrIndex)) { |
|||
2422 | throw new InvalidArgumentException('Fields argument should be an Index or array.'); |
||||
2423 | } |
||||
2424 | |||||
2425 | 1350 | $ret = []; |
|||
2426 | |||||
2427 | 1350 | foreach ($columnsOrIndex as $column => $definition) { |
|||
2428 | 1350 | if (is_array($definition)) { |
|||
2429 | $ret[] = $column; |
||||
2430 | } else { |
||||
2431 | 1350 | $ret[] = $definition; |
|||
2432 | } |
||||
2433 | } |
||||
2434 | |||||
2435 | 1350 | return implode(', ', $ret); |
|||
2436 | } |
||||
2437 | |||||
2438 | /** |
||||
2439 | * Returns the required SQL string that fits between CREATE ... TABLE |
||||
2440 | * to create the table as a temporary table. |
||||
2441 | * |
||||
2442 | * Should be overridden in driver classes to return the correct string for the |
||||
2443 | * specific database type. |
||||
2444 | * |
||||
2445 | * The default is to return the string "TEMPORARY" - this will result in a |
||||
2446 | * SQL error for any database that does not support temporary tables, or that |
||||
2447 | * requires a different SQL command from "CREATE TEMPORARY TABLE". |
||||
2448 | * |
||||
2449 | * @return string The string required to be placed between "CREATE" and "TABLE" |
||||
2450 | * to generate a temporary table, if possible. |
||||
2451 | */ |
||||
2452 | public function getTemporaryTableSQL() |
||||
2453 | { |
||||
2454 | return 'TEMPORARY'; |
||||
2455 | } |
||||
2456 | |||||
2457 | /** |
||||
2458 | * Some vendors require temporary table names to be qualified specially. |
||||
2459 | * |
||||
2460 | * @param string $tableName |
||||
2461 | * |
||||
2462 | * @return string |
||||
2463 | */ |
||||
2464 | 42 | public function getTemporaryTableName($tableName) |
|||
2465 | { |
||||
2466 | 42 | return $tableName; |
|||
2467 | } |
||||
2468 | |||||
2469 | /** |
||||
2470 | * Obtain DBMS specific SQL code portion needed to set the FOREIGN KEY constraint |
||||
2471 | * of a field declaration to be used in statements like CREATE TABLE. |
||||
2472 | * |
||||
2473 | * @return string DBMS specific SQL code portion needed to set the FOREIGN KEY constraint |
||||
2474 | * of a field declaration. |
||||
2475 | */ |
||||
2476 | 3331 | public function getForeignKeyDeclarationSQL(ForeignKeyConstraint $foreignKey) |
|||
2477 | { |
||||
2478 | 3331 | $sql = $this->getForeignKeyBaseDeclarationSQL($foreignKey); |
|||
2479 | 3007 | $sql .= $this->getAdvancedForeignKeyOptionsSQL($foreignKey); |
|||
2480 | |||||
2481 | 3007 | return $sql; |
|||
2482 | } |
||||
2483 | |||||
2484 | /** |
||||
2485 | * Returns the FOREIGN KEY query section dealing with non-standard options |
||||
2486 | * as MATCH, INITIALLY DEFERRED, ON UPDATE, ... |
||||
2487 | * |
||||
2488 | * @param ForeignKeyConstraint $foreignKey The foreign key definition. |
||||
2489 | * |
||||
2490 | * @return string |
||||
2491 | */ |
||||
2492 | 2875 | public function getAdvancedForeignKeyOptionsSQL(ForeignKeyConstraint $foreignKey) |
|||
2493 | { |
||||
2494 | 2875 | $query = ''; |
|||
2495 | 2875 | if ($this->supportsForeignKeyOnUpdate() && $foreignKey->hasOption('onUpdate')) { |
|||
2496 | 108 | $query .= ' ON UPDATE ' . $this->getForeignKeyReferentialActionSQL($foreignKey->getOption('onUpdate')); |
|||
2497 | } |
||||
2498 | 2875 | if ($foreignKey->hasOption('onDelete')) { |
|||
2499 | 267 | $query .= ' ON DELETE ' . $this->getForeignKeyReferentialActionSQL($foreignKey->getOption('onDelete')); |
|||
2500 | } |
||||
2501 | |||||
2502 | 2875 | return $query; |
|||
2503 | } |
||||
2504 | |||||
2505 | /** |
||||
2506 | * Returns the given referential action in uppercase if valid, otherwise throws an exception. |
||||
2507 | * |
||||
2508 | * @param string $action The foreign key referential action. |
||||
2509 | * |
||||
2510 | * @return string |
||||
2511 | * |
||||
2512 | * @throws InvalidArgumentException If unknown referential action given. |
||||
2513 | */ |
||||
2514 | 3291 | public function getForeignKeyReferentialActionSQL($action) |
|||
2515 | { |
||||
2516 | 3291 | $upper = strtoupper($action); |
|||
2517 | 3291 | switch ($upper) { |
|||
2518 | 3291 | case 'CASCADE': |
|||
2519 | 2221 | case 'SET NULL': |
|||
2520 | 1654 | case 'NO ACTION': |
|||
2521 | 1303 | case 'RESTRICT': |
|||
2522 | 925 | case 'SET DEFAULT': |
|||
2523 | 2832 | return $upper; |
|||
2524 | default: |
||||
2525 | 459 | throw new InvalidArgumentException('Invalid foreign key action: ' . $upper); |
|||
2526 | } |
||||
2527 | } |
||||
2528 | |||||
2529 | /** |
||||
2530 | * Obtains DBMS specific SQL code portion needed to set the FOREIGN KEY constraint |
||||
2531 | * of a field declaration to be used in statements like CREATE TABLE. |
||||
2532 | * |
||||
2533 | * @return string |
||||
2534 | * |
||||
2535 | * @throws InvalidArgumentException |
||||
2536 | */ |
||||
2537 | 2251 | public function getForeignKeyBaseDeclarationSQL(ForeignKeyConstraint $foreignKey) |
|||
2538 | { |
||||
2539 | 2251 | $sql = ''; |
|||
2540 | 2251 | if (strlen($foreignKey->getName())) { |
|||
2541 | 1873 | $sql .= 'CONSTRAINT ' . $foreignKey->getQuotedName($this) . ' '; |
|||
2542 | } |
||||
2543 | 2251 | $sql .= 'FOREIGN KEY ('; |
|||
2544 | |||||
2545 | 2251 | if (count($foreignKey->getLocalColumns()) === 0) { |
|||
2546 | throw new InvalidArgumentException("Incomplete definition. 'local' required."); |
||||
2547 | } |
||||
2548 | 2251 | if (count($foreignKey->getForeignColumns()) === 0) { |
|||
2549 | throw new InvalidArgumentException("Incomplete definition. 'foreign' required."); |
||||
2550 | } |
||||
2551 | 2251 | if (strlen($foreignKey->getForeignTableName()) === 0) { |
|||
2552 | throw new InvalidArgumentException("Incomplete definition. 'foreignTable' required."); |
||||
2553 | } |
||||
2554 | |||||
2555 | 2251 | return $sql . implode(', ', $foreignKey->getQuotedLocalColumns($this)) |
|||
2556 | 2251 | . ') REFERENCES ' |
|||
2557 | 2251 | . $foreignKey->getQuotedForeignTableName($this) . ' (' |
|||
2558 | 2251 | . implode(', ', $foreignKey->getQuotedForeignColumns($this)) . ')'; |
|||
2559 | } |
||||
2560 | |||||
2561 | /** |
||||
2562 | * Obtains DBMS specific SQL code portion needed to set the UNIQUE constraint |
||||
2563 | * of a field declaration to be used in statements like CREATE TABLE. |
||||
2564 | * |
||||
2565 | * @return string DBMS specific SQL code portion needed to set the UNIQUE constraint |
||||
2566 | * of a field declaration. |
||||
2567 | */ |
||||
2568 | public function getUniqueFieldDeclarationSQL() |
||||
2569 | { |
||||
2570 | return 'UNIQUE'; |
||||
2571 | } |
||||
2572 | |||||
2573 | /** |
||||
2574 | * Obtains DBMS specific SQL code portion needed to set the CHARACTER SET |
||||
2575 | * of a field declaration to be used in statements like CREATE TABLE. |
||||
2576 | * |
||||
2577 | * @param string $charset The name of the charset. |
||||
2578 | * |
||||
2579 | * @return string DBMS specific SQL code portion needed to set the CHARACTER SET |
||||
2580 | * of a field declaration. |
||||
2581 | */ |
||||
2582 | public function getColumnCharsetDeclarationSQL($charset) |
||||
2583 | { |
||||
2584 | return ''; |
||||
2585 | } |
||||
2586 | |||||
2587 | /** |
||||
2588 | * Obtains DBMS specific SQL code portion needed to set the COLLATION |
||||
2589 | * of a field declaration to be used in statements like CREATE TABLE. |
||||
2590 | * |
||||
2591 | * @param string $collation The name of the collation. |
||||
2592 | * |
||||
2593 | * @return string DBMS specific SQL code portion needed to set the COLLATION |
||||
2594 | * of a field declaration. |
||||
2595 | */ |
||||
2596 | 395 | public function getColumnCollationDeclarationSQL($collation) |
|||
2597 | { |
||||
2598 | 395 | return $this->supportsColumnCollation() ? 'COLLATE ' . $collation : ''; |
|||
2599 | } |
||||
2600 | |||||
2601 | /** |
||||
2602 | * Whether the platform prefers sequences for ID generation. |
||||
2603 | * Subclasses should override this method to return TRUE if they prefer sequences. |
||||
2604 | * |
||||
2605 | * @return bool |
||||
2606 | */ |
||||
2607 | 135 | public function prefersSequences() |
|||
2608 | { |
||||
2609 | 135 | return false; |
|||
2610 | } |
||||
2611 | |||||
2612 | /** |
||||
2613 | * Whether the platform prefers identity columns (eg. autoincrement) for ID generation. |
||||
2614 | * Subclasses should override this method to return TRUE if they prefer identity columns. |
||||
2615 | * |
||||
2616 | * @return bool |
||||
2617 | */ |
||||
2618 | 162 | public function prefersIdentityColumns() |
|||
2619 | { |
||||
2620 | 162 | return false; |
|||
2621 | } |
||||
2622 | |||||
2623 | /** |
||||
2624 | * Some platforms need the boolean values to be converted. |
||||
2625 | * |
||||
2626 | * The default conversion in this implementation converts to integers (false => 0, true => 1). |
||||
2627 | * |
||||
2628 | * Note: if the input is not a boolean the original input might be returned. |
||||
2629 | * |
||||
2630 | * There are two contexts when converting booleans: Literals and Prepared Statements. |
||||
2631 | * This method should handle the literal case |
||||
2632 | * |
||||
2633 | * @param mixed $item A boolean or an array of them. |
||||
2634 | * |
||||
2635 | * @return mixed A boolean database value or an array of them. |
||||
2636 | */ |
||||
2637 | 621 | public function convertBooleans($item) |
|||
2638 | { |
||||
2639 | 621 | if (is_array($item)) { |
|||
2640 | foreach ($item as $k => $value) { |
||||
2641 | if (! is_bool($value)) { |
||||
2642 | continue; |
||||
2643 | } |
||||
2644 | |||||
2645 | $item[$k] = (int) $value; |
||||
2646 | } |
||||
2647 | 621 | } elseif (is_bool($item)) { |
|||
2648 | 594 | $item = (int) $item; |
|||
2649 | } |
||||
2650 | |||||
2651 | 621 | return $item; |
|||
2652 | } |
||||
2653 | |||||
2654 | /** |
||||
2655 | * Some platforms have boolean literals that needs to be correctly converted |
||||
2656 | * |
||||
2657 | * The default conversion tries to convert value into bool "(bool)$item" |
||||
2658 | * |
||||
2659 | * @param mixed $item |
||||
2660 | * |
||||
2661 | * @return bool|null |
||||
2662 | */ |
||||
2663 | 1323 | public function convertFromBoolean($item) |
|||
2664 | { |
||||
2665 | 1323 | return $item === null ? null: (bool) $item; |
|||
2666 | } |
||||
2667 | |||||
2668 | /** |
||||
2669 | * This method should handle the prepared statements case. When there is no |
||||
2670 | * distinction, it's OK to use the same method. |
||||
2671 | * |
||||
2672 | * Note: if the input is not a boolean the original input might be returned. |
||||
2673 | * |
||||
2674 | * @param mixed $item A boolean or an array of them. |
||||
2675 | * |
||||
2676 | * @return mixed A boolean database value or an array of them. |
||||
2677 | */ |
||||
2678 | 202 | public function convertBooleansToDatabaseValue($item) |
|||
2679 | { |
||||
2680 | 202 | return $this->convertBooleans($item); |
|||
2681 | } |
||||
2682 | |||||
2683 | /** |
||||
2684 | * Returns the SQL specific for the platform to get the current date. |
||||
2685 | * |
||||
2686 | * @return string |
||||
2687 | */ |
||||
2688 | 323 | public function getCurrentDateSQL() |
|||
2689 | { |
||||
2690 | 323 | return 'CURRENT_DATE'; |
|||
2691 | } |
||||
2692 | |||||
2693 | /** |
||||
2694 | * Returns the SQL specific for the platform to get the current time. |
||||
2695 | * |
||||
2696 | * @return string |
||||
2697 | */ |
||||
2698 | 12 | public function getCurrentTimeSQL() |
|||
2699 | { |
||||
2700 | 12 | return 'CURRENT_TIME'; |
|||
2701 | } |
||||
2702 | |||||
2703 | /** |
||||
2704 | * Returns the SQL specific for the platform to get the current timestamp |
||||
2705 | * |
||||
2706 | * @return string |
||||
2707 | */ |
||||
2708 | 474 | public function getCurrentTimestampSQL() |
|||
2709 | { |
||||
2710 | 474 | return 'CURRENT_TIMESTAMP'; |
|||
2711 | } |
||||
2712 | |||||
2713 | /** |
||||
2714 | * Returns the SQL for a given transaction isolation level Connection constant. |
||||
2715 | * |
||||
2716 | * @param int $level |
||||
2717 | * |
||||
2718 | * @return string |
||||
2719 | * |
||||
2720 | * @throws InvalidArgumentException |
||||
2721 | */ |
||||
2722 | 297 | protected function _getTransactionIsolationLevelSQL($level) |
|||
2723 | { |
||||
2724 | 297 | switch ($level) { |
|||
2725 | case TransactionIsolationLevel::READ_UNCOMMITTED: |
||||
2726 | 297 | return 'READ UNCOMMITTED'; |
|||
2727 | case TransactionIsolationLevel::READ_COMMITTED: |
||||
2728 | 297 | return 'READ COMMITTED'; |
|||
2729 | case TransactionIsolationLevel::REPEATABLE_READ: |
||||
2730 | 297 | return 'REPEATABLE READ'; |
|||
2731 | case TransactionIsolationLevel::SERIALIZABLE: |
||||
2732 | 297 | return 'SERIALIZABLE'; |
|||
2733 | default: |
||||
2734 | throw new InvalidArgumentException('Invalid isolation level:' . $level); |
||||
2735 | } |
||||
2736 | } |
||||
2737 | |||||
2738 | /** |
||||
2739 | * @return string |
||||
2740 | * |
||||
2741 | * @throws DBALException If not supported on this platform. |
||||
2742 | */ |
||||
2743 | 1 | public function getListDatabasesSQL() |
|||
2744 | { |
||||
2745 | 1 | throw DBALException::notSupported(__METHOD__); |
|||
2746 | } |
||||
2747 | |||||
2748 | /** |
||||
2749 | * Returns the SQL statement for retrieving the namespaces defined in the database. |
||||
2750 | * |
||||
2751 | * @return string |
||||
2752 | * |
||||
2753 | * @throws DBALException If not supported on this platform. |
||||
2754 | */ |
||||
2755 | public function getListNamespacesSQL() |
||||
2756 | { |
||||
2757 | throw DBALException::notSupported(__METHOD__); |
||||
2758 | } |
||||
2759 | |||||
2760 | /** |
||||
2761 | * @param string $database |
||||
2762 | * |
||||
2763 | * @return string |
||||
2764 | * |
||||
2765 | * @throws DBALException If not supported on this platform. |
||||
2766 | */ |
||||
2767 | public function getListSequencesSQL($database) |
||||
2768 | { |
||||
2769 | throw DBALException::notSupported(__METHOD__); |
||||
2770 | } |
||||
2771 | |||||
2772 | /** |
||||
2773 | * @param string $table |
||||
2774 | * |
||||
2775 | * @return string |
||||
2776 | * |
||||
2777 | * @throws DBALException If not supported on this platform. |
||||
2778 | */ |
||||
2779 | public function getListTableConstraintsSQL($table) |
||||
2780 | { |
||||
2781 | throw DBALException::notSupported(__METHOD__); |
||||
2782 | } |
||||
2783 | |||||
2784 | /** |
||||
2785 | * @param string $table |
||||
2786 | * @param string|null $database |
||||
2787 | * |
||||
2788 | * @return string |
||||
2789 | * |
||||
2790 | * @throws DBALException If not supported on this platform. |
||||
2791 | */ |
||||
2792 | public function getListTableColumnsSQL($table, $database = null) |
||||
2793 | { |
||||
2794 | throw DBALException::notSupported(__METHOD__); |
||||
2795 | } |
||||
2796 | |||||
2797 | /** |
||||
2798 | * @return string |
||||
2799 | * |
||||
2800 | * @throws DBALException If not supported on this platform. |
||||
2801 | */ |
||||
2802 | public function getListTablesSQL() |
||||
2803 | { |
||||
2804 | throw DBALException::notSupported(__METHOD__); |
||||
2805 | } |
||||
2806 | |||||
2807 | /** |
||||
2808 | * @return string |
||||
2809 | * |
||||
2810 | * @throws DBALException If not supported on this platform. |
||||
2811 | */ |
||||
2812 | public function getListUsersSQL() |
||||
2813 | { |
||||
2814 | throw DBALException::notSupported(__METHOD__); |
||||
2815 | } |
||||
2816 | |||||
2817 | /** |
||||
2818 | * Returns the SQL to list all views of a database or user. |
||||
2819 | * |
||||
2820 | * @param string $database |
||||
2821 | * |
||||
2822 | * @return string |
||||
2823 | * |
||||
2824 | * @throws DBALException If not supported on this platform. |
||||
2825 | */ |
||||
2826 | public function getListViewsSQL($database) |
||||
2827 | { |
||||
2828 | throw DBALException::notSupported(__METHOD__); |
||||
2829 | } |
||||
2830 | |||||
2831 | /** |
||||
2832 | * Returns the list of indexes for the current database. |
||||
2833 | * |
||||
2834 | * The current database parameter is optional but will always be passed |
||||
2835 | * when using the SchemaManager API and is the database the given table is in. |
||||
2836 | * |
||||
2837 | * Attention: Some platforms only support currentDatabase when they |
||||
2838 | * are connected with that database. Cross-database information schema |
||||
2839 | * requests may be impossible. |
||||
2840 | * |
||||
2841 | * @param string $table |
||||
2842 | * @param string $currentDatabase |
||||
2843 | * |
||||
2844 | * @return string |
||||
2845 | * |
||||
2846 | * @throws DBALException If not supported on this platform. |
||||
2847 | */ |
||||
2848 | public function getListTableIndexesSQL($table, $currentDatabase = null) |
||||
2849 | { |
||||
2850 | throw DBALException::notSupported(__METHOD__); |
||||
2851 | } |
||||
2852 | |||||
2853 | /** |
||||
2854 | * @param string $table |
||||
2855 | * |
||||
2856 | * @return string |
||||
2857 | * |
||||
2858 | * @throws DBALException If not supported on this platform. |
||||
2859 | */ |
||||
2860 | public function getListTableForeignKeysSQL($table) |
||||
2861 | { |
||||
2862 | throw DBALException::notSupported(__METHOD__); |
||||
2863 | } |
||||
2864 | |||||
2865 | /** |
||||
2866 | * @param string $name |
||||
2867 | * @param string $sql |
||||
2868 | * |
||||
2869 | * @return string |
||||
2870 | * |
||||
2871 | * @throws DBALException If not supported on this platform. |
||||
2872 | */ |
||||
2873 | public function getCreateViewSQL($name, $sql) |
||||
2874 | { |
||||
2875 | throw DBALException::notSupported(__METHOD__); |
||||
2876 | } |
||||
2877 | |||||
2878 | /** |
||||
2879 | * @param string $name |
||||
2880 | * |
||||
2881 | * @return string |
||||
2882 | * |
||||
2883 | * @throws DBALException If not supported on this platform. |
||||
2884 | */ |
||||
2885 | public function getDropViewSQL($name) |
||||
2886 | { |
||||
2887 | throw DBALException::notSupported(__METHOD__); |
||||
2888 | } |
||||
2889 | |||||
2890 | /** |
||||
2891 | * Returns the SQL snippet to drop an existing sequence. |
||||
2892 | * |
||||
2893 | * @param Sequence|string $sequence |
||||
2894 | * |
||||
2895 | * @return string |
||||
2896 | * |
||||
2897 | * @throws DBALException If not supported on this platform. |
||||
2898 | */ |
||||
2899 | public function getDropSequenceSQL($sequence) |
||||
2900 | { |
||||
2901 | throw DBALException::notSupported(__METHOD__); |
||||
2902 | } |
||||
2903 | |||||
2904 | /** |
||||
2905 | * @param string $sequenceName |
||||
2906 | * |
||||
2907 | * @return string |
||||
2908 | * |
||||
2909 | * @throws DBALException If not supported on this platform. |
||||
2910 | */ |
||||
2911 | public function getSequenceNextValSQL($sequenceName) |
||||
2912 | { |
||||
2913 | throw DBALException::notSupported(__METHOD__); |
||||
2914 | } |
||||
2915 | |||||
2916 | /** |
||||
2917 | * Returns the SQL to create a new database. |
||||
2918 | * |
||||
2919 | * @param string $database The name of the database that should be created. |
||||
2920 | * |
||||
2921 | * @return string |
||||
2922 | * |
||||
2923 | * @throws DBALException If not supported on this platform. |
||||
2924 | */ |
||||
2925 | 27 | public function getCreateDatabaseSQL($database) |
|||
2926 | { |
||||
2927 | 27 | throw DBALException::notSupported(__METHOD__); |
|||
2928 | } |
||||
2929 | |||||
2930 | /** |
||||
2931 | * Returns the SQL to set the transaction isolation level. |
||||
2932 | * |
||||
2933 | * @param int $level |
||||
2934 | * |
||||
2935 | * @return string |
||||
2936 | * |
||||
2937 | * @throws DBALException If not supported on this platform. |
||||
2938 | */ |
||||
2939 | public function getSetTransactionIsolationSQL($level) |
||||
2940 | { |
||||
2941 | throw DBALException::notSupported(__METHOD__); |
||||
2942 | } |
||||
2943 | |||||
2944 | /** |
||||
2945 | * Obtains DBMS specific SQL to be used to create datetime fields in |
||||
2946 | * statements like CREATE TABLE. |
||||
2947 | * |
||||
2948 | * @param mixed[] $fieldDeclaration |
||||
2949 | * |
||||
2950 | * @return string |
||||
2951 | * |
||||
2952 | * @throws DBALException If not supported on this platform. |
||||
2953 | */ |
||||
2954 | public function getDateTimeTypeDeclarationSQL(array $fieldDeclaration) |
||||
2955 | { |
||||
2956 | throw DBALException::notSupported(__METHOD__); |
||||
2957 | } |
||||
2958 | |||||
2959 | /** |
||||
2960 | * Obtains DBMS specific SQL to be used to create datetime with timezone offset fields. |
||||
2961 | * |
||||
2962 | * @param mixed[] $fieldDeclaration |
||||
2963 | * |
||||
2964 | * @return string |
||||
2965 | */ |
||||
2966 | 240 | public function getDateTimeTzTypeDeclarationSQL(array $fieldDeclaration) |
|||
2967 | { |
||||
2968 | 240 | return $this->getDateTimeTypeDeclarationSQL($fieldDeclaration); |
|||
2969 | } |
||||
2970 | |||||
2971 | |||||
2972 | /** |
||||
2973 | * Obtains DBMS specific SQL to be used to create date fields in statements |
||||
2974 | * like CREATE TABLE. |
||||
2975 | * |
||||
2976 | * @param mixed[] $fieldDeclaration |
||||
2977 | * |
||||
2978 | * @return string |
||||
2979 | * |
||||
2980 | * @throws DBALException If not supported on this platform. |
||||
2981 | */ |
||||
2982 | public function getDateTypeDeclarationSQL(array $fieldDeclaration) |
||||
2983 | { |
||||
2984 | throw DBALException::notSupported(__METHOD__); |
||||
2985 | } |
||||
2986 | |||||
2987 | /** |
||||
2988 | * Obtains DBMS specific SQL to be used to create time fields in statements |
||||
2989 | * like CREATE TABLE. |
||||
2990 | * |
||||
2991 | * @param mixed[] $fieldDeclaration |
||||
2992 | * |
||||
2993 | * @return string |
||||
2994 | * |
||||
2995 | * @throws DBALException If not supported on this platform. |
||||
2996 | */ |
||||
2997 | public function getTimeTypeDeclarationSQL(array $fieldDeclaration) |
||||
2998 | { |
||||
2999 | throw DBALException::notSupported(__METHOD__); |
||||
3000 | } |
||||
3001 | |||||
3002 | /** |
||||
3003 | * @param mixed[] $fieldDeclaration |
||||
3004 | * |
||||
3005 | * @return string |
||||
3006 | */ |
||||
3007 | 2631 | public function getFloatDeclarationSQL(array $fieldDeclaration) |
|||
3008 | { |
||||
3009 | 2631 | return 'DOUBLE PRECISION'; |
|||
3010 | } |
||||
3011 | |||||
3012 | /** |
||||
3013 | * Gets the default transaction isolation level of the platform. |
||||
3014 | * |
||||
3015 | * @see TransactionIsolationLevel |
||||
3016 | * |
||||
3017 | * @return int The default isolation level. |
||||
3018 | */ |
||||
3019 | public function getDefaultTransactionIsolationLevel() |
||||
3020 | { |
||||
3021 | return TransactionIsolationLevel::READ_COMMITTED; |
||||
3022 | } |
||||
3023 | |||||
3024 | /* supports*() methods */ |
||||
3025 | |||||
3026 | /** |
||||
3027 | * Whether the platform supports sequences. |
||||
3028 | * |
||||
3029 | * @return bool |
||||
3030 | */ |
||||
3031 | 179 | public function supportsSequences() |
|||
3032 | { |
||||
3033 | 179 | return false; |
|||
3034 | } |
||||
3035 | |||||
3036 | /** |
||||
3037 | * Whether the platform supports identity columns. |
||||
3038 | * |
||||
3039 | * Identity columns are columns that receive an auto-generated value from the |
||||
3040 | * database on insert of a row. |
||||
3041 | * |
||||
3042 | * @return bool |
||||
3043 | */ |
||||
3044 | 29 | public function supportsIdentityColumns() |
|||
3045 | { |
||||
3046 | 29 | return false; |
|||
3047 | } |
||||
3048 | |||||
3049 | /** |
||||
3050 | * Whether the platform emulates identity columns through sequences. |
||||
3051 | * |
||||
3052 | * Some platforms that do not support identity columns natively |
||||
3053 | * but support sequences can emulate identity columns by using |
||||
3054 | * sequences. |
||||
3055 | * |
||||
3056 | * @return bool |
||||
3057 | */ |
||||
3058 | 342 | public function usesSequenceEmulatedIdentityColumns() |
|||
3059 | { |
||||
3060 | 342 | return false; |
|||
3061 | } |
||||
3062 | |||||
3063 | /** |
||||
3064 | * Returns the name of the sequence for a particular identity column in a particular table. |
||||
3065 | * |
||||
3066 | * @see usesSequenceEmulatedIdentityColumns |
||||
3067 | * |
||||
3068 | * @param string $tableName The name of the table to return the sequence name for. |
||||
3069 | * @param string $columnName The name of the identity column in the table to return the sequence name for. |
||||
3070 | * |
||||
3071 | * @return string |
||||
3072 | * |
||||
3073 | * @throws DBALException If not supported on this platform. |
||||
3074 | */ |
||||
3075 | 324 | public function getIdentitySequenceName($tableName, $columnName) |
|||
3076 | { |
||||
3077 | 324 | throw DBALException::notSupported(__METHOD__); |
|||
3078 | } |
||||
3079 | |||||
3080 | /** |
||||
3081 | * Whether the platform supports indexes. |
||||
3082 | * |
||||
3083 | * @return bool |
||||
3084 | */ |
||||
3085 | 108 | public function supportsIndexes() |
|||
3086 | { |
||||
3087 | 108 | return true; |
|||
3088 | } |
||||
3089 | |||||
3090 | /** |
||||
3091 | * Whether the platform supports partial indexes. |
||||
3092 | * |
||||
3093 | * @return bool |
||||
3094 | */ |
||||
3095 | 4053 | public function supportsPartialIndexes() |
|||
3096 | { |
||||
3097 | 4053 | return false; |
|||
3098 | } |
||||
3099 | |||||
3100 | /** |
||||
3101 | * Whether the platform supports indexes with column length definitions. |
||||
3102 | */ |
||||
3103 | 8162 | public function supportsColumnLengthIndexes() : bool |
|||
3104 | { |
||||
3105 | 8162 | return false; |
|||
3106 | } |
||||
3107 | |||||
3108 | /** |
||||
3109 | * Whether the platform supports altering tables. |
||||
3110 | * |
||||
3111 | * @return bool |
||||
3112 | */ |
||||
3113 | 135 | public function supportsAlterTable() |
|||
3114 | { |
||||
3115 | 135 | return true; |
|||
3116 | } |
||||
3117 | |||||
3118 | /** |
||||
3119 | * Whether the platform supports transactions. |
||||
3120 | * |
||||
3121 | * @return bool |
||||
3122 | */ |
||||
3123 | 108 | public function supportsTransactions() |
|||
3124 | { |
||||
3125 | 108 | return true; |
|||
3126 | } |
||||
3127 | |||||
3128 | /** |
||||
3129 | * Whether the platform supports savepoints. |
||||
3130 | * |
||||
3131 | * @return bool |
||||
3132 | */ |
||||
3133 | 592 | public function supportsSavepoints() |
|||
3134 | { |
||||
3135 | 592 | return true; |
|||
3136 | } |
||||
3137 | |||||
3138 | /** |
||||
3139 | * Whether the platform supports releasing savepoints. |
||||
3140 | * |
||||
3141 | * @return bool |
||||
3142 | */ |
||||
3143 | 130 | public function supportsReleaseSavepoints() |
|||
3144 | { |
||||
3145 | 130 | return $this->supportsSavepoints(); |
|||
3146 | } |
||||
3147 | |||||
3148 | /** |
||||
3149 | * Whether the platform supports primary key constraints. |
||||
3150 | * |
||||
3151 | * @return bool |
||||
3152 | */ |
||||
3153 | 108 | public function supportsPrimaryConstraints() |
|||
3154 | { |
||||
3155 | 108 | return true; |
|||
3156 | } |
||||
3157 | |||||
3158 | /** |
||||
3159 | * Whether the platform supports foreign key constraints. |
||||
3160 | * |
||||
3161 | * @return bool |
||||
3162 | */ |
||||
3163 | 13042 | public function supportsForeignKeyConstraints() |
|||
3164 | { |
||||
3165 | 13042 | return true; |
|||
3166 | } |
||||
3167 | |||||
3168 | /** |
||||
3169 | * Whether this platform supports onUpdate in foreign key constraints. |
||||
3170 | * |
||||
3171 | * @return bool |
||||
3172 | */ |
||||
3173 | 2983 | public function supportsForeignKeyOnUpdate() |
|||
3174 | { |
||||
3175 | 2983 | return $this->supportsForeignKeyConstraints(); |
|||
3176 | } |
||||
3177 | |||||
3178 | /** |
||||
3179 | * Whether the platform supports database schemas. |
||||
3180 | * |
||||
3181 | * @return bool |
||||
3182 | */ |
||||
3183 | 289 | public function supportsSchemas() |
|||
3184 | { |
||||
3185 | 289 | return false; |
|||
3186 | } |
||||
3187 | |||||
3188 | /** |
||||
3189 | * Whether this platform can emulate schemas. |
||||
3190 | * |
||||
3191 | * Platforms that either support or emulate schemas don't automatically |
||||
3192 | * filter a schema for the namespaced elements in {@link |
||||
3193 | * AbstractManager#createSchema}. |
||||
3194 | * |
||||
3195 | * @return bool |
||||
3196 | */ |
||||
3197 | 108 | public function canEmulateSchemas() |
|||
3198 | { |
||||
3199 | 108 | return false; |
|||
3200 | } |
||||
3201 | |||||
3202 | /** |
||||
3203 | * Returns the default schema name. |
||||
3204 | * |
||||
3205 | * @return string |
||||
3206 | * |
||||
3207 | * @throws DBALException If not supported on this platform. |
||||
3208 | */ |
||||
3209 | public function getDefaultSchemaName() |
||||
3210 | { |
||||
3211 | throw DBALException::notSupported(__METHOD__); |
||||
3212 | } |
||||
3213 | |||||
3214 | /** |
||||
3215 | * Whether this platform supports create database. |
||||
3216 | * |
||||
3217 | * Some databases don't allow to create and drop databases at all or only with certain tools. |
||||
3218 | * |
||||
3219 | * @return bool |
||||
3220 | */ |
||||
3221 | 152 | public function supportsCreateDropDatabase() |
|||
3222 | { |
||||
3223 | 152 | return true; |
|||
3224 | } |
||||
3225 | |||||
3226 | /** |
||||
3227 | * Whether the platform supports getting the affected rows of a recent update/delete type query. |
||||
3228 | * |
||||
3229 | * @return bool |
||||
3230 | */ |
||||
3231 | 108 | public function supportsGettingAffectedRows() |
|||
3232 | { |
||||
3233 | 108 | return true; |
|||
3234 | } |
||||
3235 | |||||
3236 | /** |
||||
3237 | * Whether this platform support to add inline column comments as postfix. |
||||
3238 | * |
||||
3239 | * @return bool |
||||
3240 | */ |
||||
3241 | 6620 | public function supportsInlineColumnComments() |
|||
3242 | { |
||||
3243 | 6620 | return false; |
|||
3244 | } |
||||
3245 | |||||
3246 | /** |
||||
3247 | * Whether this platform support the proprietary syntax "COMMENT ON asset". |
||||
3248 | * |
||||
3249 | * @return bool |
||||
3250 | */ |
||||
3251 | 6313 | public function supportsCommentOnStatement() |
|||
3252 | { |
||||
3253 | 6313 | return false; |
|||
3254 | } |
||||
3255 | |||||
3256 | /** |
||||
3257 | * Does this platform have native guid type. |
||||
3258 | * |
||||
3259 | * @return bool |
||||
3260 | */ |
||||
3261 | 8105 | public function hasNativeGuidType() |
|||
3262 | { |
||||
3263 | 8105 | return false; |
|||
3264 | } |
||||
3265 | |||||
3266 | /** |
||||
3267 | * Does this platform have native JSON type. |
||||
3268 | * |
||||
3269 | * @return bool |
||||
3270 | */ |
||||
3271 | 18928 | public function hasNativeJsonType() |
|||
3272 | { |
||||
3273 | 18928 | return false; |
|||
3274 | } |
||||
3275 | |||||
3276 | /** |
||||
3277 | * @deprecated |
||||
3278 | * |
||||
3279 | * @todo Remove in 3.0 |
||||
3280 | */ |
||||
3281 | public function getIdentityColumnNullInsertSQL() |
||||
3282 | { |
||||
3283 | return ''; |
||||
3284 | } |
||||
3285 | |||||
3286 | /** |
||||
3287 | * Whether this platform supports views. |
||||
3288 | * |
||||
3289 | * @return bool |
||||
3290 | */ |
||||
3291 | 27 | public function supportsViews() |
|||
3292 | { |
||||
3293 | 27 | return true; |
|||
3294 | } |
||||
3295 | |||||
3296 | /** |
||||
3297 | * Does this platform support column collation? |
||||
3298 | * |
||||
3299 | * @return bool |
||||
3300 | */ |
||||
3301 | public function supportsColumnCollation() |
||||
3302 | { |
||||
3303 | return false; |
||||
3304 | } |
||||
3305 | |||||
3306 | /** |
||||
3307 | * Gets the format string, as accepted by the date() function, that describes |
||||
3308 | * the format of a stored datetime value of this platform. |
||||
3309 | * |
||||
3310 | * @return string The format string. |
||||
3311 | */ |
||||
3312 | 468 | public function getDateTimeFormatString() |
|||
3313 | { |
||||
3314 | 468 | return 'Y-m-d H:i:s'; |
|||
3315 | } |
||||
3316 | |||||
3317 | /** |
||||
3318 | * Gets the format string, as accepted by the date() function, that describes |
||||
3319 | * the format of a stored datetime with timezone value of this platform. |
||||
3320 | * |
||||
3321 | * @return string The format string. |
||||
3322 | */ |
||||
3323 | 205 | public function getDateTimeTzFormatString() |
|||
3324 | { |
||||
3325 | 205 | return 'Y-m-d H:i:s'; |
|||
3326 | } |
||||
3327 | |||||
3328 | /** |
||||
3329 | * Gets the format string, as accepted by the date() function, that describes |
||||
3330 | * the format of a stored date value of this platform. |
||||
3331 | * |
||||
3332 | * @return string The format string. |
||||
3333 | */ |
||||
3334 | 185 | public function getDateFormatString() |
|||
3335 | { |
||||
3336 | 185 | return 'Y-m-d'; |
|||
3337 | } |
||||
3338 | |||||
3339 | /** |
||||
3340 | * Gets the format string, as accepted by the date() function, that describes |
||||
3341 | * the format of a stored time value of this platform. |
||||
3342 | * |
||||
3343 | * @return string The format string. |
||||
3344 | */ |
||||
3345 | 158 | public function getTimeFormatString() |
|||
3346 | { |
||||
3347 | 158 | return 'H:i:s'; |
|||
3348 | } |
||||
3349 | |||||
3350 | /** |
||||
3351 | * Adds an driver-specific LIMIT clause to the query. |
||||
3352 | * |
||||
3353 | * @param string $query |
||||
3354 | * @param int|null $limit |
||||
3355 | * @param int|null $offset |
||||
3356 | * |
||||
3357 | * @return string |
||||
3358 | * |
||||
3359 | * @throws DBALException |
||||
3360 | */ |
||||
3361 | 3780 | final public function modifyLimitQuery($query, $limit, $offset = null) |
|||
3362 | { |
||||
3363 | 3780 | if ($limit !== null) { |
|||
3364 | 3024 | $limit = (int) $limit; |
|||
3365 | } |
||||
3366 | |||||
3367 | 3780 | $offset = (int) $offset; |
|||
3368 | |||||
3369 | 3780 | if ($offset < 0) { |
|||
3370 | throw new DBALException(sprintf( |
||||
3371 | 'Offset must be a positive integer or zero, %d given', |
||||
3372 | $offset |
||||
3373 | )); |
||||
3374 | } |
||||
3375 | |||||
3376 | 3780 | if ($offset > 0 && ! $this->supportsLimitOffset()) { |
|||
3377 | throw new DBALException(sprintf( |
||||
3378 | 'Platform %s does not support offset values in limit queries.', |
||||
3379 | $this->getName() |
||||
3380 | )); |
||||
3381 | } |
||||
3382 | |||||
3383 | 3780 | return $this->doModifyLimitQuery($query, $limit, $offset); |
|||
3384 | } |
||||
3385 | |||||
3386 | /** |
||||
3387 | * Adds an platform-specific LIMIT clause to the query. |
||||
3388 | * |
||||
3389 | * @param string $query |
||||
3390 | * @param int|null $limit |
||||
3391 | * @param int|null $offset |
||||
3392 | * |
||||
3393 | * @return string |
||||
3394 | */ |
||||
3395 | 550 | protected function doModifyLimitQuery($query, $limit, $offset) |
|||
3396 | { |
||||
3397 | 550 | if ($limit !== null) { |
|||
3398 | 380 | $query .= ' LIMIT ' . $limit; |
|||
3399 | } |
||||
3400 | |||||
3401 | 550 | if ($offset > 0) { |
|||
3402 | 56 | $query .= ' OFFSET ' . $offset; |
|||
3403 | } |
||||
3404 | |||||
3405 | 550 | return $query; |
|||
3406 | } |
||||
3407 | |||||
3408 | /** |
||||
3409 | * Whether the database platform support offsets in modify limit clauses. |
||||
3410 | * |
||||
3411 | * @return bool |
||||
3412 | */ |
||||
3413 | 580 | public function supportsLimitOffset() |
|||
3414 | { |
||||
3415 | 580 | return true; |
|||
3416 | } |
||||
3417 | |||||
3418 | /** |
||||
3419 | * Gets the character casing of a column in an SQL result set of this platform. |
||||
3420 | * |
||||
3421 | * @param string $column The column name for which to get the correct character casing. |
||||
3422 | * |
||||
3423 | * @return string The column name in the character casing used in SQL result sets. |
||||
3424 | */ |
||||
3425 | public function getSQLResultCasing($column) |
||||
3426 | { |
||||
3427 | return $column; |
||||
3428 | } |
||||
3429 | |||||
3430 | /** |
||||
3431 | * Makes any fixes to a name of a schema element (table, sequence, ...) that are required |
||||
3432 | * by restrictions of the platform, like a maximum length. |
||||
3433 | * |
||||
3434 | * @param string $schemaElementName |
||||
3435 | * |
||||
3436 | * @return string |
||||
3437 | */ |
||||
3438 | public function fixSchemaElementName($schemaElementName) |
||||
3439 | { |
||||
3440 | return $schemaElementName; |
||||
3441 | } |
||||
3442 | |||||
3443 | /** |
||||
3444 | * Maximum length of any given database identifier, like tables or column names. |
||||
3445 | * |
||||
3446 | * @return int |
||||
3447 | */ |
||||
3448 | 460 | public function getMaxIdentifierLength() |
|||
3449 | { |
||||
3450 | 460 | return 63; |
|||
3451 | } |
||||
3452 | |||||
3453 | /** |
||||
3454 | * Returns the insert SQL for an empty insert statement. |
||||
3455 | * |
||||
3456 | * @param string $tableName |
||||
3457 | * @param string $identifierColumnName |
||||
3458 | * |
||||
3459 | * @return string |
||||
3460 | */ |
||||
3461 | 16 | public function getEmptyIdentityInsertSQL($tableName, $identifierColumnName) |
|||
3462 | { |
||||
3463 | 16 | return 'INSERT INTO ' . $tableName . ' (' . $identifierColumnName . ') VALUES (null)'; |
|||
3464 | } |
||||
3465 | |||||
3466 | /** |
||||
3467 | * Generates a Truncate Table SQL statement for a given table. |
||||
3468 | * |
||||
3469 | * Cascade is not supported on many platforms but would optionally cascade the truncate by |
||||
3470 | * following the foreign keys. |
||||
3471 | * |
||||
3472 | * @param string $tableName |
||||
3473 | * @param bool $cascade |
||||
3474 | * |
||||
3475 | * @return string |
||||
3476 | */ |
||||
3477 | 207 | public function getTruncateTableSQL($tableName, $cascade = false) |
|||
3478 | { |
||||
3479 | 207 | $tableIdentifier = new Identifier($tableName); |
|||
3480 | |||||
3481 | 207 | return 'TRUNCATE ' . $tableIdentifier->getQuotedName($this); |
|||
3482 | } |
||||
3483 | |||||
3484 | /** |
||||
3485 | * This is for test reasons, many vendors have special requirements for dummy statements. |
||||
3486 | * |
||||
3487 | * @return string |
||||
3488 | */ |
||||
3489 | 233 | public function getDummySelectSQL() |
|||
3490 | { |
||||
3491 | 233 | $expression = func_num_args() > 0 ? func_get_arg(0) : '1'; |
|||
3492 | |||||
3493 | 233 | return sprintf('SELECT %s', $expression); |
|||
3494 | } |
||||
3495 | |||||
3496 | /** |
||||
3497 | * Returns the SQL to create a new savepoint. |
||||
3498 | * |
||||
3499 | * @param string $savepoint |
||||
3500 | * |
||||
3501 | * @return string |
||||
3502 | */ |
||||
3503 | 24 | public function createSavePoint($savepoint) |
|||
3504 | { |
||||
3505 | 24 | return 'SAVEPOINT ' . $savepoint; |
|||
3506 | } |
||||
3507 | |||||
3508 | /** |
||||
3509 | * Returns the SQL to release a savepoint. |
||||
3510 | * |
||||
3511 | * @param string $savepoint |
||||
3512 | * |
||||
3513 | * @return string |
||||
3514 | */ |
||||
3515 | 22 | public function releaseSavePoint($savepoint) |
|||
3516 | { |
||||
3517 | 22 | return 'RELEASE SAVEPOINT ' . $savepoint; |
|||
3518 | } |
||||
3519 | |||||
3520 | /** |
||||
3521 | * Returns the SQL to rollback a savepoint. |
||||
3522 | * |
||||
3523 | * @param string $savepoint |
||||
3524 | * |
||||
3525 | * @return string |
||||
3526 | */ |
||||
3527 | 24 | public function rollbackSavePoint($savepoint) |
|||
3528 | { |
||||
3529 | 24 | return 'ROLLBACK TO SAVEPOINT ' . $savepoint; |
|||
3530 | } |
||||
3531 | |||||
3532 | /** |
||||
3533 | * Returns the keyword list instance of this platform. |
||||
3534 | * |
||||
3535 | * @return KeywordList |
||||
3536 | * |
||||
3537 | * @throws DBALException If no keyword list is specified. |
||||
3538 | */ |
||||
3539 | 30789 | final public function getReservedKeywordsList() |
|||
3540 | { |
||||
3541 | // Check for an existing instantiation of the keywords class. |
||||
3542 | 30789 | if ($this->_keywords) { |
|||
3543 | 28980 | return $this->_keywords; |
|||
3544 | } |
||||
3545 | |||||
3546 | 26402 | $class = $this->getReservedKeywordsClass(); |
|||
3547 | 26402 | $keywords = new $class(); |
|||
3548 | 26402 | if (! $keywords instanceof KeywordList) { |
|||
3549 | throw DBALException::notSupported(__METHOD__); |
||||
3550 | } |
||||
3551 | |||||
3552 | // Store the instance so it doesn't need to be generated on every request. |
||||
3553 | 26402 | $this->_keywords = $keywords; |
|||
3554 | |||||
3555 | 26402 | return $keywords; |
|||
3556 | } |
||||
3557 | |||||
3558 | /** |
||||
3559 | * Returns the class name of the reserved keywords list. |
||||
3560 | * |
||||
3561 | * @return string |
||||
3562 | * |
||||
3563 | * @throws DBALException If not supported on this platform. |
||||
3564 | */ |
||||
3565 | protected function getReservedKeywordsClass() |
||||
3566 | { |
||||
3567 | throw DBALException::notSupported(__METHOD__); |
||||
3568 | } |
||||
3569 | |||||
3570 | /** |
||||
3571 | * Quotes a literal string. |
||||
3572 | * This method is NOT meant to fix SQL injections! |
||||
3573 | * It is only meant to escape this platform's string literal |
||||
3574 | * quote character inside the given literal string. |
||||
3575 | * |
||||
3576 | * @param string $str The literal string to be quoted. |
||||
3577 | * |
||||
3578 | * @return string The quoted literal string. |
||||
3579 | */ |
||||
3580 | 10535 | public function quoteStringLiteral($str) |
|||
3581 | { |
||||
3582 | 10535 | $c = $this->getStringLiteralQuoteCharacter(); |
|||
3583 | |||||
3584 | 10535 | return $c . str_replace($c, $c . $c, $str) . $c; |
|||
3585 | } |
||||
3586 | |||||
3587 | /** |
||||
3588 | * Gets the character used for string literal quoting. |
||||
3589 | * |
||||
3590 | * @return string |
||||
3591 | */ |
||||
3592 | 11021 | public function getStringLiteralQuoteCharacter() |
|||
3593 | { |
||||
3594 | 11021 | return "'"; |
|||
3595 | } |
||||
3596 | |||||
3597 | /** |
||||
3598 | * Escapes metacharacters in a string intended to be used with a LIKE |
||||
3599 | * operator. |
||||
3600 | * |
||||
3601 | * @param string $inputString a literal, unquoted string |
||||
3602 | * @param string $escapeChar should be reused by the caller in the LIKE |
||||
3603 | * expression. |
||||
3604 | */ |
||||
3605 | 513 | final public function escapeStringForLike(string $inputString, string $escapeChar) : string |
|||
3606 | { |
||||
3607 | 513 | return preg_replace( |
|||
3608 | 513 | '~([' . preg_quote($this->getLikeWildcardCharacters() . $escapeChar, '~') . '])~u', |
|||
3609 | 513 | addcslashes($escapeChar, '\\') . '$1', |
|||
3610 | 513 | $inputString |
|||
3611 | ); |
||||
3612 | } |
||||
3613 | |||||
3614 | 513 | protected function getLikeWildcardCharacters() : string |
|||
3615 | { |
||||
3616 | 513 | return '%_'; |
|||
3617 | } |
||||
3618 | } |
||||
3619 |
This check looks for parameters that have been defined for a function or method, but which are not used in the method body.