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 | 85207 | public function __construct() |
|
154 | { |
||
155 | 85207 | } |
|
156 | |||
157 | /** |
||
158 | * Sets the EventManager used by the Platform. |
||
159 | */ |
||
160 | 78445 | public function setEventManager(EventManager $eventManager) |
|
161 | { |
||
162 | 78445 | $this->_eventManager = $eventManager; |
|
163 | 78445 | } |
|
164 | |||
165 | /** |
||
166 | * Gets the EventManager used by the Platform. |
||
167 | * |
||
168 | * @return EventManager |
||
169 | */ |
||
170 | 75403 | public function getEventManager() |
|
171 | { |
||
172 | 75403 | 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 | 75517 | private function initializeAllDoctrineTypeMappings() |
|
234 | { |
||
235 | 75517 | $this->initializeDoctrineTypeMappings(); |
|
236 | |||
237 | 75517 | foreach (Type::getTypesMap() as $typeName => $className) { |
|
238 | 75517 | foreach (Type::getType($typeName)->getMappedDatabaseTypes($this) as $dbType) { |
|
239 | 42187 | $this->doctrineTypeMapping[$dbType] = $typeName; |
|
240 | } |
||
241 | } |
||
242 | 75517 | } |
|
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 | 77793 | public function getVarcharTypeDeclarationSQL(array $field) |
|
252 | { |
||
253 | 77793 | if (! isset($field['length'])) { |
|
254 | 73987 | $field['length'] = $this->getVarcharDefaultLength(); |
|
255 | } |
||
256 | |||
257 | 77793 | $fixed = $field['fixed'] ?? false; |
|
258 | |||
259 | 77793 | $maxLength = $fixed |
|
260 | 75564 | ? $this->getCharMaxLength() |
|
261 | 77793 | : $this->getVarcharMaxLength(); |
|
262 | |||
263 | 77793 | if ($field['length'] > $maxLength) { |
|
264 | return $this->getClobTypeDeclarationSQL($field); |
||
265 | } |
||
266 | |||
267 | 77793 | 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 | 74152 | public function getBinaryTypeDeclarationSQL(array $field) |
|
278 | { |
||
279 | 74152 | if (! isset($field['length'])) { |
|
280 | 74095 | $field['length'] = $this->getBinaryDefaultLength(); |
|
281 | } |
||
282 | |||
283 | 74152 | $fixed = $field['fixed'] ?? false; |
|
284 | |||
285 | 74152 | $maxLength = $this->getBinaryMaxLength(); |
|
286 | |||
287 | 74152 | if ($field['length'] > $maxLength) { |
|
288 | 71762 | if ($maxLength > 0) { |
|
289 | 71486 | @trigger_error(sprintf( |
|
290 | 24 | 'Binary field length %d is greater than supported by the platform (%d). Reduce the field length or use a BLOB field instead.', |
|
291 | 71486 | $field['length'], |
|
292 | 71486 | $maxLength |
|
293 | 71486 | ), E_USER_DEPRECATED); |
|
294 | } |
||
295 | |||
296 | 71762 | return $this->getBlobTypeDeclarationSQL($field); |
|
297 | } |
||
298 | |||
299 | 74128 | 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 | 73290 | public function getGuidTypeDeclarationSQL(array $field) |
|
313 | { |
||
314 | 73290 | $field['length'] = 36; |
|
315 | 73290 | $field['fixed'] = true; |
|
316 | |||
317 | 73290 | 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 | 71431 | public function getJsonTypeDeclarationSQL(array $field) |
|
331 | { |
||
332 | 71431 | 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 | 73488 | public function registerDoctrineTypeMapping($dbType, $doctrineType) |
|
397 | { |
||
398 | 73488 | if ($this->doctrineTypeMapping === null) { |
|
399 | 72800 | $this->initializeAllDoctrineTypeMappings(); |
|
400 | } |
||
401 | |||
402 | 73488 | if (! Types\Type::hasType($doctrineType)) { |
|
403 | 70896 | throw DBALException::typeNotFound($doctrineType); |
|
404 | } |
||
405 | |||
406 | 73452 | $dbType = strtolower($dbType); |
|
407 | 73452 | $this->doctrineTypeMapping[$dbType] = $doctrineType; |
|
408 | |||
409 | 73452 | $doctrineType = Type::getType($doctrineType); |
|
410 | |||
411 | 73452 | if (! $doctrineType->requiresSQLCommentHint($this)) { |
|
412 | 73416 | return; |
|
413 | } |
||
414 | |||
415 | 70871 | $this->markDoctrineTypeCommented($doctrineType); |
|
416 | 70871 | } |
|
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 | 75515 | public function getDoctrineTypeMapping($dbType) |
|
428 | { |
||
429 | 75515 | if ($this->doctrineTypeMapping === null) { |
|
430 | 75361 | $this->initializeAllDoctrineTypeMappings(); |
|
431 | } |
||
432 | |||
433 | 75515 | $dbType = strtolower($dbType); |
|
434 | |||
435 | 75515 | if (! isset($this->doctrineTypeMapping[$dbType])) { |
|
436 | 70946 | throw new DBALException('Unknown database type ' . $dbType . ' requested, ' . static::class . ' may not support it.'); |
|
437 | } |
||
438 | |||
439 | 75479 | 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 | 72726 | public function hasDoctrineTypeMappingFor($dbType) |
|
450 | { |
||
451 | 72726 | if ($this->doctrineTypeMapping === null) { |
|
452 | 68831 | $this->initializeAllDoctrineTypeMappings(); |
|
453 | } |
||
454 | |||
455 | 72726 | $dbType = strtolower($dbType); |
|
456 | |||
457 | 72726 | 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 | 79280 | protected function initializeCommentedDoctrineTypes() |
|
466 | { |
||
467 | 79280 | $this->doctrineTypeComments = []; |
|
468 | |||
469 | 79280 | foreach (Type::getTypesMap() as $typeName => $className) { |
|
470 | 79280 | $type = Type::getType($typeName); |
|
471 | |||
472 | 79280 | if (! $type->requiresSQLCommentHint($this)) { |
|
473 | 79280 | continue; |
|
474 | } |
||
475 | |||
476 | 79280 | $this->doctrineTypeComments[] = $typeName; |
|
477 | } |
||
478 | 79280 | } |
|
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 | 79527 | public function isCommentedDoctrineType(Type $doctrineType) |
|
486 | { |
||
487 | 79527 | if ($this->doctrineTypeComments === null) { |
|
488 | 79244 | $this->initializeCommentedDoctrineTypes(); |
|
489 | } |
||
490 | |||
491 | 79527 | assert(is_array($this->doctrineTypeComments)); |
|
492 | |||
493 | 79527 | 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 | 70871 | public function markDoctrineTypeCommented($doctrineType) |
|
504 | { |
||
505 | 70871 | if ($this->doctrineTypeComments === null) { |
|
506 | 70871 | $this->initializeCommentedDoctrineTypes(); |
|
507 | } |
||
508 | |||
509 | 70871 | assert(is_array($this->doctrineTypeComments)); |
|
510 | |||
511 | 70871 | $this->doctrineTypeComments[] = $doctrineType instanceof Type ? $doctrineType->getName() : $doctrineType; |
|
512 | 70871 | } |
|
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 | 74720 | public function getDoctrineTypeComment(Type $doctrineType) |
|
520 | { |
||
521 | 74720 | 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 | 78593 | protected function getColumnComment(Column $column) |
|
530 | { |
||
531 | 78593 | $comment = $column->getComment(); |
|
532 | |||
533 | 78593 | if ($this->isCommentedDoctrineType($column->getType())) { |
|
534 | 74720 | $comment .= $this->getDoctrineTypeComment($column->getType()); |
|
535 | } |
||
536 | |||
537 | 78593 | return $comment; |
|
538 | } |
||
539 | |||
540 | /** |
||
541 | * Gets the character used for identifier quoting. |
||
542 | * |
||
543 | * @return string |
||
544 | */ |
||
545 | 73911 | public function getIdentifierQuoteCharacter() |
|
546 | { |
||
547 | 73911 | 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 | 75307 | public function getCharMaxLength() : int |
|
574 | { |
||
575 | 75307 | return $this->getVarcharMaxLength(); |
|
576 | } |
||
577 | |||
578 | /** |
||
579 | * Gets the maximum length of a varchar field. |
||
580 | * |
||
581 | * @return int |
||
582 | */ |
||
583 | 72822 | public function getVarcharMaxLength() |
|
584 | { |
||
585 | 72822 | return 4000; |
|
586 | } |
||
587 | |||
588 | /** |
||
589 | * Gets the default length of a varchar field. |
||
590 | * |
||
591 | * @return int |
||
592 | */ |
||
593 | 73963 | public function getVarcharDefaultLength() |
|
594 | { |
||
595 | 73963 | 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 | 71795 | public function getBinaryDefaultLength() |
|
614 | { |
||
615 | 71795 | 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 | 58164 | public function getRegexpExpression() |
|
636 | { |
||
637 | 58164 | 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 | 67893 | public function getTrimExpression($str, $mode = TrimMode::UNSPECIFIED, $char = false) |
|
792 | { |
||
793 | 67893 | $expression = ''; |
|
794 | |||
795 | 67893 | switch ($mode) { |
|
796 | case TrimMode::LEADING: |
||
797 | 67817 | $expression = 'LEADING '; |
|
798 | 67817 | break; |
|
799 | |||
800 | case TrimMode::TRAILING: |
||
801 | 67795 | $expression = 'TRAILING '; |
|
802 | 67795 | break; |
|
803 | |||
804 | case TrimMode::BOTH: |
||
805 | 67773 | $expression = 'BOTH '; |
|
806 | 67773 | break; |
|
807 | } |
||
808 | |||
809 | 67893 | if ($char !== false) { |
|
810 | 67789 | $expression .= $char . ' '; |
|
811 | } |
||
812 | |||
813 | 67893 | if ($mode || $char !== false) { |
|
814 | 67867 | $expression .= 'FROM '; |
|
815 | } |
||
816 | |||
817 | 67893 | 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 | 33024 | public function getRtrimExpression($str) |
|
828 | { |
||
829 | 33024 | 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 | 33024 | public function getLtrimExpression($str) |
|
840 | { |
||
841 | 33024 | 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) |
||
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 | 58141 | public function getConcatExpression() |
|
926 | { |
||
927 | 58141 | 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 | 78339 | public function getIsNullExpression($expression) |
|
958 | { |
||
959 | 78339 | 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 | 76286 | public function getDateAddSecondsExpression($date, $seconds) |
|
1068 | { |
||
1069 | 76286 | 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 | 76286 | public function getDateSubSecondsExpression($date, $seconds) |
|
1083 | { |
||
1084 | 76286 | 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 | 76286 | public function getDateAddMinutesExpression($date, $minutes) |
|
1098 | { |
||
1099 | 76286 | 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 | 76286 | public function getDateSubMinutesExpression($date, $minutes) |
|
1113 | { |
||
1114 | 76286 | 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 | 76286 | public function getDateAddHourExpression($date, $hours) |
|
1128 | { |
||
1129 | 76286 | 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 | 76286 | public function getDateSubHourExpression($date, $hours) |
|
1143 | { |
||
1144 | 76286 | 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 | 76290 | public function getDateAddDaysExpression($date, $days) |
|
1158 | { |
||
1159 | 76290 | 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 | 76286 | public function getDateSubDaysExpression($date, $days) |
|
1173 | { |
||
1174 | 76286 | 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 | 76286 | public function getDateAddWeeksExpression($date, $weeks) |
|
1188 | { |
||
1189 | 76286 | 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 | 76286 | public function getDateSubWeeksExpression($date, $weeks) |
|
1203 | { |
||
1204 | 76286 | 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 | 76286 | public function getDateAddMonthExpression($date, $months) |
|
1218 | { |
||
1219 | 76286 | 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 | 76286 | public function getDateSubMonthExpression($date, $months) |
|
1233 | { |
||
1234 | 76286 | 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 | 76286 | public function getDateAddQuartersExpression($date, $quarters) |
|
1248 | { |
||
1249 | 76286 | 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 | 76286 | public function getDateSubQuartersExpression($date, $quarters) |
|
1263 | { |
||
1264 | 76286 | 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 | 76286 | public function getDateAddYearsExpression($date, $years) |
|
1278 | { |
||
1279 | 76286 | 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 | 76286 | public function getDateSubYearsExpression($date, $years) |
|
1293 | { |
||
1294 | 76286 | 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 | 75944 | public function getBitAndComparisonExpression($value1, $value2) |
|
1324 | { |
||
1325 | 75944 | 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 | 75943 | public function getBitOrComparisonExpression($value1, $value2) |
|
1337 | { |
||
1338 | 75943 | return '(' . $value1 . ' | ' . $value2 . ')'; |
|
1339 | } |
||
1340 | |||
1341 | /** |
||
1342 | * Returns the FOR UPDATE expression. |
||
1343 | * |
||
1344 | * @return string |
||
1345 | */ |
||
1346 | 61122 | public function getForUpdateSQL() |
|
1347 | { |
||
1348 | 61122 | 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 | 64069 | public function appendLockHint($fromClause, $lockMode) |
|
1361 | { |
||
1362 | 64069 | 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 | 69891 | public function getWriteLockSQL() |
|
1386 | { |
||
1387 | 69891 | 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 | 61177 | public function getDropDatabaseSQL($database) |
|
1398 | { |
||
1399 | 61177 | 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 | 77773 | public function getDropTableSQL($table) |
|
1412 | { |
||
1413 | 77773 | $tableArg = $table; |
|
1414 | |||
1415 | 77773 | if ($table instanceof Table) { |
|
1416 | 8217 | $table = $table->getQuotedName($this); |
|
1417 | } |
||
1418 | |||
1419 | 77773 | if (! is_string($table)) { |
|
1420 | throw new InvalidArgumentException('getDropTableSQL() expects $table parameter to be string or \Doctrine\DBAL\Schema\Table.'); |
||
1421 | } |
||
1422 | |||
1423 | 77773 | if ($this->_eventManager !== null && $this->_eventManager->hasListeners(Events::onSchemaDropTable)) { |
|
1424 | 70121 | $eventArgs = new SchemaDropTableEventArgs($tableArg, $this); |
|
1425 | 70121 | $this->_eventManager->dispatchEvent(Events::onSchemaDropTable, $eventArgs); |
|
1426 | |||
1427 | 70121 | 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 | 77773 | 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 | 32039 | public function getDropTemporaryTableSQL($table) |
|
1449 | { |
||
1450 | 32039 | 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 | 60854 | public function getDropIndexSQL($index, $table = null) |
|
1464 | { |
||
1465 | 60854 | if ($index instanceof Index) { |
|
1466 | 60825 | $index = $index->getQuotedName($this); |
|
1467 | 26754 | } elseif (! is_string($index)) { |
|
1468 | throw new InvalidArgumentException('AbstractPlatform::getDropIndexSQL() expects $index parameter to be string or \Doctrine\DBAL\Schema\Index.'); |
||
1469 | } |
||
1470 | |||
1471 | 60854 | 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 | 70959 | public function getDropConstraintSQL($constraint, $table) |
|
1483 | { |
||
1484 | 70959 | if (! $constraint instanceof Constraint) { |
|
1485 | 69605 | $constraint = new Identifier($constraint); |
|
1486 | } |
||
1487 | |||
1488 | 70959 | if (! $table instanceof Table) { |
|
1489 | 70959 | $table = new Identifier($table); |
|
1490 | } |
||
1491 | |||
1492 | 70959 | $constraint = $constraint->getQuotedName($this); |
|
1493 | 70959 | $table = $table->getQuotedName($this); |
|
1494 | |||
1495 | 70959 | 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 | 72208 | public function getDropForeignKeySQL($foreignKey, $table) |
|
1507 | { |
||
1508 | 72208 | if (! $foreignKey instanceof ForeignKeyConstraint) { |
|
1509 | 69376 | $foreignKey = new Identifier($foreignKey); |
|
1510 | } |
||
1511 | |||
1512 | 72208 | if (! $table instanceof Table) { |
|
1513 | 72208 | $table = new Identifier($table); |
|
1514 | } |
||
1515 | |||
1516 | 72208 | $foreignKey = $foreignKey->getQuotedName($this); |
|
1517 | 72208 | $table = $table->getQuotedName($this); |
|
1518 | |||
1519 | 72208 | 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 | 78307 | public function getCreateTableSQL(Table $table, $createFlags = self::CREATE_INDEXES) |
|
1534 | { |
||
1535 | 78307 | if (! is_int($createFlags)) { |
|
1536 | throw new InvalidArgumentException('Second argument of AbstractPlatform::getCreateTableSQL() has to be integer.'); |
||
1537 | } |
||
1538 | |||
1539 | 78307 | if (count($table->getColumns()) === 0) { |
|
1540 | 70421 | throw DBALException::noColumnsSpecifiedForTable($table->getName()); |
|
1541 | } |
||
1542 | |||
1543 | 78271 | $tableName = $table->getQuotedName($this); |
|
1544 | 78271 | $options = $table->getOptions(); |
|
1545 | 78271 | $options['uniqueConstraints'] = []; |
|
1546 | 78271 | $options['indexes'] = []; |
|
1547 | 78271 | $options['primary'] = []; |
|
1548 | |||
1549 | 78271 | if (($createFlags&self::CREATE_INDEXES) > 0) { |
|
1550 | 78225 | foreach ($table->getIndexes() as $index) { |
|
1551 | /** @var $index Index */ |
||
1552 | 77979 | if ($index->isPrimary()) { |
|
1553 | 77847 | $options['primary'] = $index->getQuotedColumns($this); |
|
1554 | 77847 | $options['primary_index'] = $index; |
|
1555 | } else { |
||
1556 | 76554 | $options['indexes'][$index->getQuotedName($this)] = $index; |
|
1557 | } |
||
1558 | } |
||
1559 | } |
||
1560 | |||
1561 | 78271 | $columnSql = []; |
|
1562 | 78271 | $columns = []; |
|
1563 | |||
1564 | 78271 | foreach ($table->getColumns() as $column) { |
|
1565 | 78271 | if ($this->_eventManager !== null && $this->_eventManager->hasListeners(Events::onSchemaCreateTableColumn)) { |
|
1566 | 70146 | $eventArgs = new SchemaCreateTableColumnEventArgs($column, $table, $this); |
|
1567 | 70146 | $this->_eventManager->dispatchEvent(Events::onSchemaCreateTableColumn, $eventArgs); |
|
1568 | |||
1569 | 70146 | $columnSql = array_merge($columnSql, $eventArgs->getSql()); |
|
1570 | |||
1571 | 70146 | if ($eventArgs->isDefaultPrevented()) { |
|
1572 | continue; |
||
1573 | } |
||
1574 | } |
||
1575 | |||
1576 | 78271 | $columnData = $column->toArray(); |
|
1577 | 78271 | $columnData['name'] = $column->getQuotedName($this); |
|
1578 | 78271 | $columnData['version'] = $column->hasPlatformOption('version') ? $column->getPlatformOption('version') : false; |
|
1579 | 78271 | $columnData['comment'] = $this->getColumnComment($column); |
|
1580 | |||
1581 | 78271 | if ($columnData['type'] instanceof Types\StringType && $columnData['length'] === null) { |
|
1582 | 77411 | $columnData['length'] = 255; |
|
1583 | } |
||
1584 | |||
1585 | 78271 | if (in_array($column->getName(), $options['primary'])) { |
|
1586 | 77807 | $columnData['primary'] = true; |
|
1587 | } |
||
1588 | |||
1589 | 78271 | $columns[$columnData['name']] = $columnData; |
|
1590 | } |
||
1591 | |||
1592 | 78271 | if (($createFlags&self::CREATE_FOREIGNKEYS) > 0) { |
|
1593 | 77819 | $options['foreignKeys'] = []; |
|
1594 | 77819 | foreach ($table->getForeignKeys() as $fkConstraint) { |
|
1595 | 76047 | $options['foreignKeys'][] = $fkConstraint; |
|
1596 | } |
||
1597 | } |
||
1598 | |||
1599 | 78271 | if ($this->_eventManager !== null && $this->_eventManager->hasListeners(Events::onSchemaCreateTable)) { |
|
1600 | 70146 | $eventArgs = new SchemaCreateTableEventArgs($table, $columns, $options, $this); |
|
1601 | 70146 | $this->_eventManager->dispatchEvent(Events::onSchemaCreateTable, $eventArgs); |
|
1602 | |||
1603 | 70146 | if ($eventArgs->isDefaultPrevented()) { |
|
1604 | return array_merge($eventArgs->getSql(), $columnSql); |
||
1605 | } |
||
1606 | } |
||
1607 | |||
1608 | 78271 | $sql = $this->_getCreateTableSQL($tableName, $columns, $options); |
|
1609 | 78271 | if ($this->supportsCommentOnStatement()) { |
|
1610 | 74193 | foreach ($table->getColumns() as $column) { |
|
1611 | 74193 | $comment = $this->getColumnComment($column); |
|
1612 | |||
1613 | 74193 | if ($comment === null || $comment === '') { |
|
1614 | 74159 | continue; |
|
1615 | } |
||
1616 | |||
1617 | 71591 | $sql[] = $this->getCommentOnColumnSQL($tableName, $column->getQuotedName($this), $comment); |
|
1618 | } |
||
1619 | } |
||
1620 | |||
1621 | 78271 | 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 | 70341 | public function getCommentOnColumnSQL($tableName, $columnName, $comment) |
|
1632 | { |
||
1633 | 70341 | $tableName = new Identifier($tableName); |
|
1634 | 70341 | $columnName = new Identifier($columnName); |
|
1635 | |||
1636 | 70341 | return sprintf( |
|
1637 | 131 | 'COMMENT ON COLUMN %s.%s IS %s', |
|
1638 | 70341 | $tableName->getQuotedName($this), |
|
1639 | 70341 | $columnName->getQuotedName($this), |
|
1640 | 70341 | $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 | 72390 | public function getInlineColumnCommentSQL($comment) |
|
1654 | { |
||
1655 | 72390 | if (! $this->supportsInlineColumnComments()) { |
|
1656 | 69263 | throw DBALException::notSupported(__METHOD__); |
|
1657 | } |
||
1658 | |||
1659 | 71216 | 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 | 72310 | protected function _getCreateTableSQL($tableName, array $columns, array $options = []) |
|
1672 | { |
||
1673 | 72310 | $columnListSql = $this->getColumnDeclarationListSQL($columns); |
|
1674 | |||
1675 | 72310 | if (isset($options['uniqueConstraints']) && ! empty($options['uniqueConstraints'])) { |
|
1676 | foreach ($options['uniqueConstraints'] as $name => $definition) { |
||
1677 | $columnListSql .= ', ' . $this->getUniqueConstraintDeclarationSQL($name, $definition); |
||
1678 | } |
||
1679 | } |
||
1680 | |||
1681 | 72310 | if (isset($options['primary']) && ! empty($options['primary'])) { |
|
1682 | 72190 | $columnListSql .= ', PRIMARY KEY(' . implode(', ', array_unique(array_values($options['primary']))) . ')'; |
|
1683 | } |
||
1684 | |||
1685 | 72310 | if (isset($options['indexes']) && ! empty($options['indexes'])) { |
|
1686 | foreach ($options['indexes'] as $index => $definition) { |
||
1687 | $columnListSql .= ', ' . $this->getIndexDeclarationSQL($index, $definition); |
||
1688 | } |
||
1689 | } |
||
1690 | |||
1691 | 72310 | $query = 'CREATE TABLE ' . $tableName . ' (' . $columnListSql; |
|
1692 | |||
1693 | 72310 | $check = $this->getCheckDeclarationSQL($columns); |
|
1694 | 72310 | if (! empty($check)) { |
|
1695 | 71764 | $query .= ', ' . $check; |
|
1696 | } |
||
1697 | 72310 | $query .= ')'; |
|
1698 | |||
1699 | 72310 | $sql[] = $query; |
|
1700 | |||
1701 | 72310 | if (isset($options['foreignKeys'])) { |
|
1702 | 72228 | foreach ((array) $options['foreignKeys'] as $definition) { |
|
1703 | 71904 | $sql[] = $this->getCreateForeignKeySQL($definition, $tableName); |
|
1704 | } |
||
1705 | } |
||
1706 | |||
1707 | 72310 | return $sql; |
|
1708 | } |
||
1709 | |||
1710 | /** |
||
1711 | * @return string |
||
1712 | */ |
||
1713 | 63984 | public function getCreateTemporaryTableSnippetSQL() |
|
1714 | { |
||
1715 | 63984 | 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 | 70311 | public function getCreateConstraintSQL(Constraint $constraint, $table) |
|
1752 | { |
||
1753 | 70311 | if ($table instanceof Table) { |
|
1754 | $table = $table->getQuotedName($this); |
||
1755 | } |
||
1756 | |||
1757 | 70311 | $query = 'ALTER TABLE ' . $table . ' ADD CONSTRAINT ' . $constraint->getQuotedName($this); |
|
1758 | |||
1759 | 70311 | $columnList = '(' . implode(', ', $constraint->getQuotedColumns($this)) . ')'; |
|
1760 | |||
1761 | 70311 | $referencesClause = ''; |
|
1762 | 70311 | if ($constraint instanceof Index) { |
|
1763 | 70311 | if ($constraint->isPrimary()) { |
|
1764 | 70311 | $query .= ' PRIMARY KEY'; |
|
1765 | 70261 | } elseif ($constraint->isUnique()) { |
|
1766 | 70261 | $query .= ' UNIQUE'; |
|
1767 | } else { |
||
1768 | throw new InvalidArgumentException( |
||
1769 | 70311 | 'Can only create primary or unique constraints, no common indexes with getCreateConstraintSQL().' |
|
1770 | ); |
||
1771 | } |
||
1772 | 70261 | } elseif ($constraint instanceof ForeignKeyConstraint) { |
|
1773 | 70261 | $query .= ' FOREIGN KEY'; |
|
1774 | |||
1775 | 70261 | $referencesClause = ' REFERENCES ' . $constraint->getQuotedForeignTableName($this) . |
|
1776 | 70261 | ' (' . implode(', ', $constraint->getQuotedForeignColumns($this)) . ')'; |
|
1777 | } |
||
1778 | 70311 | $query .= ' ' . $columnList . $referencesClause; |
|
1779 | |||
1780 | 70311 | 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 | 75196 | public function getCreateIndexSQL(Index $index, $table) |
|
1793 | { |
||
1794 | 75196 | if ($table instanceof Table) { |
|
1795 | 74251 | $table = $table->getQuotedName($this); |
|
1796 | } |
||
1797 | 75196 | $name = $index->getQuotedName($this); |
|
1798 | 75196 | $columns = $index->getColumns(); |
|
1799 | |||
1800 | 75196 | if (count($columns) === 0) { |
|
1801 | throw new InvalidArgumentException("Incomplete definition. 'columns' required."); |
||
1802 | } |
||
1803 | |||
1804 | 75196 | if ($index->isPrimary()) { |
|
1805 | 68352 | return $this->getCreatePrimaryKeySQL($index, $table); |
|
1806 | } |
||
1807 | |||
1808 | 75158 | $query = 'CREATE ' . $this->getCreateIndexSQLFlags($index) . 'INDEX ' . $name . ' ON ' . $table; |
|
1809 | 75158 | $query .= ' (' . $this->getIndexFieldDeclarationListSQL($index) . ')' . $this->getPartialIndexSQL($index); |
|
1810 | |||
1811 | 75158 | return $query; |
|
1812 | } |
||
1813 | |||
1814 | /** |
||
1815 | * Adds condition for partial index. |
||
1816 | * |
||
1817 | * @return string |
||
1818 | */ |
||
1819 | 76428 | protected function getPartialIndexSQL(Index $index) |
|
1820 | { |
||
1821 | 76428 | if ($this->supportsPartialIndexes() && $index->hasOption('where')) { |
|
1822 | 58382 | return ' WHERE ' . $index->getOption('where'); |
|
1823 | } |
||
1824 | |||
1825 | 76418 | return ''; |
|
1826 | } |
||
1827 | |||
1828 | /** |
||
1829 | * Adds additional flags for index generation. |
||
1830 | * |
||
1831 | * @return string |
||
1832 | */ |
||
1833 | 73453 | protected function getCreateIndexSQLFlags(Index $index) |
|
1834 | { |
||
1835 | 73453 | 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 | 71696 | public function getCreatePrimaryKeySQL(Index $index, $table) |
|
1846 | { |
||
1847 | 71696 | if ($table instanceof Table) { |
|
1848 | $table = $table->getQuotedName($this); |
||
1849 | } |
||
1850 | |||
1851 | 71696 | 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 | 69655 | public function getCreateSchemaSQL($schemaName) |
|
0 ignored issues
–
show
|
|||
1864 | { |
||
1865 | 69655 | 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 | 77973 | public function quoteIdentifier($str) |
|
1882 | { |
||
1883 | 77973 | if (strpos($str, '.') !== false) { |
|
1884 | 71822 | $parts = array_map([$this, 'quoteSingleIdentifier'], explode('.', $str)); |
|
1885 | |||
1886 | 71822 | return implode('.', $parts); |
|
1887 | } |
||
1888 | |||
1889 | 77973 | 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 | 77550 | public function quoteSingleIdentifier($str) |
|
1900 | { |
||
1901 | 77550 | $c = $this->getIdentifierQuoteCharacter(); |
|
1902 | |||
1903 | 77550 | 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 | 76064 | public function getCreateForeignKeySQL(ForeignKeyConstraint $foreignKey, $table) |
|
1915 | { |
||
1916 | 76064 | if ($table instanceof Table) { |
|
1917 | 2977 | $table = $table->getQuotedName($this); |
|
1918 | } |
||
1919 | |||
1920 | 76064 | 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 | 75178 | protected function onSchemaAlterTableAddColumn(Column $column, TableDiff $diff, &$columnSql) |
|
1943 | { |
||
1944 | 75178 | if ($this->_eventManager === null) { |
|
1945 | 70320 | return false; |
|
1946 | } |
||
1947 | |||
1948 | 75018 | if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTableAddColumn)) { |
|
1949 | 74982 | return false; |
|
1950 | } |
||
1951 | |||
1952 | 70096 | $eventArgs = new SchemaAlterTableAddColumnEventArgs($column, $diff, $this); |
|
1953 | 70096 | $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableAddColumn, $eventArgs); |
|
1954 | |||
1955 | 70096 | $columnSql = array_merge($columnSql, $eventArgs->getSql()); |
|
1956 | |||
1957 | 70096 | return $eventArgs->isDefaultPrevented(); |
|
1958 | } |
||
1959 | |||
1960 | /** |
||
1961 | * @param string[] $columnSql |
||
1962 | * |
||
1963 | * @return bool |
||
1964 | */ |
||
1965 | 74352 | protected function onSchemaAlterTableRemoveColumn(Column $column, TableDiff $diff, &$columnSql) |
|
1966 | { |
||
1967 | 74352 | if ($this->_eventManager === null) { |
|
1968 | 70274 | return false; |
|
1969 | } |
||
1970 | |||
1971 | 74238 | if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTableRemoveColumn)) { |
|
1972 | 74202 | return false; |
|
1973 | } |
||
1974 | |||
1975 | 70096 | $eventArgs = new SchemaAlterTableRemoveColumnEventArgs($column, $diff, $this); |
|
1976 | 70096 | $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableRemoveColumn, $eventArgs); |
|
1977 | |||
1978 | 70096 | $columnSql = array_merge($columnSql, $eventArgs->getSql()); |
|
1979 | |||
1980 | 70096 | return $eventArgs->isDefaultPrevented(); |
|
1981 | } |
||
1982 | |||
1983 | /** |
||
1984 | * @param string[] $columnSql |
||
1985 | * |
||
1986 | * @return bool |
||
1987 | */ |
||
1988 | 75230 | protected function onSchemaAlterTableChangeColumn(ColumnDiff $columnDiff, TableDiff $diff, &$columnSql) |
|
1989 | { |
||
1990 | 75230 | if ($this->_eventManager === null) { |
|
1991 | 71744 | return false; |
|
1992 | } |
||
1993 | |||
1994 | 74898 | if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTableChangeColumn)) { |
|
1995 | 74862 | return false; |
|
1996 | } |
||
1997 | |||
1998 | 70096 | $eventArgs = new SchemaAlterTableChangeColumnEventArgs($columnDiff, $diff, $this); |
|
1999 | 70096 | $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableChangeColumn, $eventArgs); |
|
2000 | |||
2001 | 70096 | $columnSql = array_merge($columnSql, $eventArgs->getSql()); |
|
2002 | |||
2003 | 70096 | return $eventArgs->isDefaultPrevented(); |
|
2004 | } |
||
2005 | |||
2006 | /** |
||
2007 | * @param string $oldColumnName |
||
2008 | * @param string[] $columnSql |
||
2009 | * |
||
2010 | * @return bool |
||
2011 | */ |
||
2012 | 74101 | protected function onSchemaAlterTableRenameColumn($oldColumnName, Column $column, TableDiff $diff, &$columnSql) |
|
2013 | { |
||
2014 | 74101 | if ($this->_eventManager === null) { |
|
2015 | 69551 | return false; |
|
2016 | } |
||
2017 | |||
2018 | 73985 | if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTableRenameColumn)) { |
|
2019 | 71148 | return false; |
|
2020 | } |
||
2021 | |||
2022 | 70096 | $eventArgs = new SchemaAlterTableRenameColumnEventArgs($oldColumnName, $column, $diff, $this); |
|
2023 | 70096 | $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableRenameColumn, $eventArgs); |
|
2024 | |||
2025 | 70096 | $columnSql = array_merge($columnSql, $eventArgs->getSql()); |
|
2026 | |||
2027 | 70096 | return $eventArgs->isDefaultPrevented(); |
|
2028 | } |
||
2029 | |||
2030 | /** |
||
2031 | * @param string[] $sql |
||
2032 | * |
||
2033 | * @return bool |
||
2034 | */ |
||
2035 | 75994 | protected function onSchemaAlterTable(TableDiff $diff, &$sql) |
|
2036 | { |
||
2037 | 75994 | if ($this->_eventManager === null) { |
|
2038 | 72082 | return false; |
|
2039 | } |
||
2040 | |||
2041 | 75324 | if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTable)) { |
|
2042 | 75288 | return false; |
|
2043 | } |
||
2044 | |||
2045 | 70096 | $eventArgs = new SchemaAlterTableEventArgs($diff, $this); |
|
2046 | 70096 | $this->_eventManager->dispatchEvent(Events::onSchemaAlterTable, $eventArgs); |
|
2047 | |||
2048 | 70096 | $sql = array_merge($sql, $eventArgs->getSql()); |
|
2049 | |||
2050 | 70096 | return $eventArgs->isDefaultPrevented(); |
|
2051 | } |
||
2052 | |||
2053 | /** |
||
2054 | * @return string[] |
||
2055 | */ |
||
2056 | 75846 | protected function getPreAlterTableIndexForeignKeySQL(TableDiff $diff) |
|
2057 | { |
||
2058 | 75846 | $tableName = $diff->getName($this)->getQuotedName($this); |
|
2059 | |||
2060 | 75846 | $sql = []; |
|
2061 | 75846 | if ($this->supportsForeignKeyConstraints()) { |
|
2062 | 75846 | foreach ($diff->removedForeignKeys as $foreignKey) { |
|
2063 | 73915 | $sql[] = $this->getDropForeignKeySQL($foreignKey, $tableName); |
|
2064 | } |
||
2065 | 75846 | foreach ($diff->changedForeignKeys as $foreignKey) { |
|
2066 | 69200 | $sql[] = $this->getDropForeignKeySQL($foreignKey, $tableName); |
|
2067 | } |
||
2068 | } |
||
2069 | |||
2070 | 75846 | foreach ($diff->removedIndexes as $index) { |
|
2071 | 74393 | $sql[] = $this->getDropIndexSQL($index, $tableName); |
|
2072 | } |
||
2073 | 75846 | foreach ($diff->changedIndexes as $index) { |
|
2074 | 73970 | $sql[] = $this->getDropIndexSQL($index, $tableName); |
|
2075 | } |
||
2076 | |||
2077 | 75846 | return $sql; |
|
2078 | } |
||
2079 | |||
2080 | /** |
||
2081 | * @return string[] |
||
2082 | */ |
||
2083 | 75846 | protected function getPostAlterTableIndexForeignKeySQL(TableDiff $diff) |
|
2084 | { |
||
2085 | 75846 | $sql = []; |
|
2086 | 75846 | $newName = $diff->getNewName(); |
|
2087 | |||
2088 | 75846 | if ($newName !== false) { |
|
2089 | 70592 | $tableName = $newName->getQuotedName($this); |
|
2090 | } else { |
||
2091 | 75776 | $tableName = $diff->getName($this)->getQuotedName($this); |
|
2092 | } |
||
2093 | |||
2094 | 75846 | if ($this->supportsForeignKeyConstraints()) { |
|
2095 | 75846 | foreach ($diff->addedForeignKeys as $foreignKey) { |
|
2096 | 74012 | $sql[] = $this->getCreateForeignKeySQL($foreignKey, $tableName); |
|
2097 | } |
||
2098 | |||
2099 | 75846 | foreach ($diff->changedForeignKeys as $foreignKey) { |
|
2100 | 69200 | $sql[] = $this->getCreateForeignKeySQL($foreignKey, $tableName); |
|
2101 | } |
||
2102 | } |
||
2103 | |||
2104 | 75846 | foreach ($diff->addedIndexes as $index) { |
|
2105 | 73951 | $sql[] = $this->getCreateIndexSQL($index, $tableName); |
|
2106 | } |
||
2107 | |||
2108 | 75846 | foreach ($diff->changedIndexes as $index) { |
|
2109 | 73970 | $sql[] = $this->getCreateIndexSQL($index, $tableName); |
|
2110 | } |
||
2111 | |||
2112 | 75846 | foreach ($diff->renamedIndexes as $oldIndexName => $index) { |
|
2113 | 74155 | $oldIndexName = new Identifier($oldIndexName); |
|
2114 | 74155 | $sql = array_merge( |
|
2115 | 74155 | $sql, |
|
2116 | 74155 | $this->getRenameIndexSQL($oldIndexName->getQuotedName($this), $index, $tableName) |
|
2117 | ); |
||
2118 | } |
||
2119 | |||
2120 | 75846 | 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 | 69331 | protected function getRenameIndexSQL($oldIndexName, Index $index, $tableName) |
|
2133 | { |
||
2134 | return [ |
||
2135 | 69331 | $this->getDropIndexSQL($oldIndexName, $tableName), |
|
2136 | 69331 | $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 | 78271 | public function getColumnDeclarationListSQL(array $fields) |
|
2180 | { |
||
2181 | 78271 | $queryFields = []; |
|
2182 | |||
2183 | 78271 | foreach ($fields as $fieldName => $field) { |
|
2184 | 78271 | $queryFields[] = $this->getColumnDeclarationSQL($fieldName, $field); |
|
2185 | } |
||
2186 | |||
2187 | 78271 | 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 | 77754 | public function getColumnDeclarationSQL($name, array $field) |
|
2224 | { |
||
2225 | 77754 | if (isset($field['columnDefinition'])) { |
|
2226 | 72336 | $columnDef = $this->getCustomTypeDeclarationSQL($field); |
|
2227 | } else { |
||
2228 | 77726 | $default = $this->getDefaultValueDeclarationSQL($field); |
|
2229 | |||
2230 | 77726 | $charset = isset($field['charset']) && $field['charset'] ? |
|
2231 | 77726 | ' ' . $this->getColumnCharsetDeclarationSQL($field['charset']) : ''; |
|
2232 | |||
2233 | 77726 | $collation = isset($field['collation']) && $field['collation'] ? |
|
2234 | 77726 | ' ' . $this->getColumnCollationDeclarationSQL($field['collation']) : ''; |
|
2235 | |||
2236 | 77726 | $notnull = isset($field['notnull']) && $field['notnull'] ? ' NOT NULL' : ''; |
|
2237 | |||
2238 | 77726 | $unique = isset($field['unique']) && $field['unique'] ? |
|
2239 | 77726 | ' ' . $this->getUniqueFieldDeclarationSQL() : ''; |
|
2240 | |||
2241 | 77726 | $check = isset($field['check']) && $field['check'] ? |
|
2242 | 77726 | ' ' . $field['check'] : ''; |
|
2243 | |||
2244 | 77726 | $typeDecl = $field['type']->getSQLDeclaration($field, $this); |
|
2245 | 77726 | $columnDef = $typeDecl . $charset . $default . $notnull . $unique . $check . $collation; |
|
2246 | |||
2247 | 77726 | if ($this->supportsInlineColumnComments() && isset($field['comment']) && $field['comment'] !== '') { |
|
2248 | 71491 | $columnDef .= ' ' . $this->getInlineColumnCommentSQL($field['comment']); |
|
2249 | } |
||
2250 | } |
||
2251 | |||
2252 | 77754 | 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 | 74949 | public function getDecimalTypeDeclarationSQL(array $columnDef) |
|
2263 | { |
||
2264 | 74949 | $columnDef['precision'] = ! isset($columnDef['precision']) || empty($columnDef['precision']) |
|
2265 | 74949 | ? 10 : $columnDef['precision']; |
|
2266 | 74949 | $columnDef['scale'] = ! isset($columnDef['scale']) || empty($columnDef['scale']) |
|
2267 | 74949 | ? 0 : $columnDef['scale']; |
|
2268 | |||
2269 | 74949 | 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 | 78104 | public function getDefaultValueDeclarationSQL($field) |
|
2281 | { |
||
2282 | 78104 | if (! isset($field['default'])) { |
|
2283 | 77968 | return empty($field['notnull']) ? ' DEFAULT NULL' : ''; |
|
2284 | } |
||
2285 | |||
2286 | 74963 | $default = $field['default']; |
|
2287 | |||
2288 | 74963 | if (! isset($field['type'])) { |
|
2289 | return " DEFAULT '" . $default . "'"; |
||
2290 | } |
||
2291 | |||
2292 | 74963 | $type = $field['type']; |
|
2293 | |||
2294 | 74963 | if ($type instanceof Types\PhpIntegerMappingType) { |
|
2295 | 74727 | return ' DEFAULT ' . $default; |
|
2296 | } |
||
2297 | |||
2298 | 74894 | if ($type instanceof Types\PhpDateTimeMappingType && $default === $this->getCurrentTimestampSQL()) { |
|
2299 | 72590 | return ' DEFAULT ' . $this->getCurrentTimestampSQL(); |
|
2300 | } |
||
2301 | |||
2302 | 74864 | if ($type instanceof Types\TimeType && $default === $this->getCurrentTimeSQL()) { |
|
2303 | 11926 | return ' DEFAULT ' . $this->getCurrentTimeSQL(); |
|
2304 | } |
||
2305 | |||
2306 | 74864 | if ($type instanceof Types\DateType && $default === $this->getCurrentDateSQL()) { |
|
2307 | 70665 | return ' DEFAULT ' . $this->getCurrentDateSQL(); |
|
2308 | } |
||
2309 | |||
2310 | 74834 | if ($type instanceof Types\BooleanType) { |
|
2311 | 74706 | return " DEFAULT '" . $this->convertBooleans($default) . "'"; |
|
2312 | } |
||
2313 | |||
2314 | 74472 | 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 | 72847 | public function getCheckDeclarationSQL(array $definition) |
|
2326 | { |
||
2327 | 72847 | $constraints = []; |
|
2328 | 72847 | foreach ($definition as $field => $def) { |
|
2329 | 72847 | if (is_string($def)) { |
|
2330 | $constraints[] = 'CHECK (' . $def . ')'; |
||
2331 | } else { |
||
2332 | 72847 | if (isset($def['min'])) { |
|
2333 | 71772 | $constraints[] = 'CHECK (' . $field . ' >= ' . $def['min'] . ')'; |
|
2334 | } |
||
2335 | |||
2336 | 72847 | if (isset($def['max'])) { |
|
2337 | 72278 | $constraints[] = 'CHECK (' . $field . ' <= ' . $def['max'] . ')'; |
|
2338 | } |
||
2339 | } |
||
2340 | } |
||
2341 | |||
2342 | 72847 | 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 | 70341 | public function getUniqueConstraintDeclarationSQL($name, Index $index) |
|
2357 | { |
||
2358 | 70341 | $columns = $index->getColumns(); |
|
2359 | 70341 | $name = new Identifier($name); |
|
2360 | |||
2361 | 70341 | if (count($columns) === 0) { |
|
2362 | throw new InvalidArgumentException("Incomplete definition. 'columns' required."); |
||
2363 | } |
||
2364 | |||
2365 | 70341 | return 'CONSTRAINT ' . $name->getQuotedName($this) . ' UNIQUE (' |
|
2366 | 70341 | . $this->getIndexFieldDeclarationListSQL($index) |
|
2367 | 70341 | . ')' . $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 | 72943 | public function getIndexDeclarationSQL($name, Index $index) |
|
2382 | { |
||
2383 | 72943 | $columns = $index->getColumns(); |
|
2384 | 72943 | $name = new Identifier($name); |
|
2385 | |||
2386 | 72943 | if (count($columns) === 0) { |
|
2387 | throw new InvalidArgumentException("Incomplete definition. 'columns' required."); |
||
2388 | } |
||
2389 | |||
2390 | 72943 | return $this->getCreateIndexSQLFlags($index) . 'INDEX ' . $name->getQuotedName($this) . ' (' |
|
2391 | 72943 | . $this->getIndexFieldDeclarationListSQL($index) |
|
2392 | 72943 | . ')' . $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 | 72344 | public function getCustomTypeDeclarationSQL(array $columnDef) |
|
2405 | { |
||
2406 | 72344 | 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 | 76568 | public function getIndexFieldDeclarationListSQL($columnsOrIndex) : string |
|
2416 | { |
||
2417 | 76568 | if ($columnsOrIndex instanceof Index) { |
|
2418 | 76480 | return implode(', ', $columnsOrIndex->getQuotedColumns($this)); |
|
2419 | } |
||
2420 | |||
2421 | 33916 | if (! is_array($columnsOrIndex)) { |
|
2422 | throw new InvalidArgumentException('Fields argument should be an Index or array.'); |
||
2423 | } |
||
2424 | |||
2425 | 33916 | $ret = []; |
|
2426 | |||
2427 | 33916 | foreach ($columnsOrIndex as $column => $definition) { |
|
2428 | 33916 | if (is_array($definition)) { |
|
2429 | $ret[] = $column; |
||
2430 | } else { |
||
2431 | 33916 | $ret[] = $definition; |
|
2432 | } |
||
2433 | } |
||
2434 | |||
2435 | 33916 | 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 | 61076 | public function getTemporaryTableName($tableName) |
|
2465 | { |
||
2466 | 61076 | 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 | 76217 | public function getForeignKeyDeclarationSQL(ForeignKeyConstraint $foreignKey) |
|
2477 | { |
||
2478 | 76217 | $sql = $this->getForeignKeyBaseDeclarationSQL($foreignKey); |
|
2479 | 76193 | $sql .= $this->getAdvancedForeignKeyOptionsSQL($foreignKey); |
|
2480 | |||
2481 | 76193 | 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 | 76161 | public function getAdvancedForeignKeyOptionsSQL(ForeignKeyConstraint $foreignKey) |
|
2493 | { |
||
2494 | 76161 | $query = ''; |
|
2495 | 76161 | if ($this->supportsForeignKeyOnUpdate() && $foreignKey->hasOption('onUpdate')) { |
|
2496 | 33349 | $query .= ' ON UPDATE ' . $this->getForeignKeyReferentialActionSQL($foreignKey->getOption('onUpdate')); |
|
2497 | } |
||
2498 | 76161 | if ($foreignKey->hasOption('onDelete')) { |
|
2499 | 73654 | $query .= ' ON DELETE ' . $this->getForeignKeyReferentialActionSQL($foreignKey->getOption('onDelete')); |
|
2500 | } |
||
2501 | |||
2502 | 76161 | 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 | 74532 | public function getForeignKeyReferentialActionSQL($action) |
|
2515 | { |
||
2516 | 74532 | $upper = strtoupper($action); |
|
2517 | 71533 | switch ($upper) { |
|
2518 | 3241 | case 'CASCADE': |
|
2519 | 3040 | case 'SET NULL': |
|
2520 | 2997 | case 'NO ACTION': |
|
2521 | 2970 | case 'RESTRICT': |
|
2522 | 2941 | case 'SET DEFAULT': |
|
2523 | 74498 | return $upper; |
|
2524 | default: |
||
2525 | 70969 | 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 | 76137 | public function getForeignKeyBaseDeclarationSQL(ForeignKeyConstraint $foreignKey) |
|
2538 | { |
||
2539 | 76137 | $sql = ''; |
|
2540 | 76137 | if (strlen($foreignKey->getName())) { |
|
2541 | 76024 | $sql .= 'CONSTRAINT ' . $foreignKey->getQuotedName($this) . ' '; |
|
2542 | } |
||
2543 | 76137 | $sql .= 'FOREIGN KEY ('; |
|
2544 | |||
2545 | 76137 | if (count($foreignKey->getLocalColumns()) === 0) { |
|
2546 | throw new InvalidArgumentException("Incomplete definition. 'local' required."); |
||
2547 | } |
||
2548 | 76137 | if (count($foreignKey->getForeignColumns()) === 0) { |
|
2549 | throw new InvalidArgumentException("Incomplete definition. 'foreign' required."); |
||
2550 | } |
||
2551 | 76137 | if (strlen($foreignKey->getForeignTableName()) === 0) { |
|
2552 | throw new InvalidArgumentException("Incomplete definition. 'foreignTable' required."); |
||
2553 | } |
||
2554 | |||
2555 | 76137 | return $sql . implode(', ', $foreignKey->getQuotedLocalColumns($this)) |
|
2556 | 76137 | . ') REFERENCES ' |
|
2557 | 76137 | . $foreignKey->getQuotedForeignTableName($this) . ' (' |
|
2558 | 76137 | . 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 | 72537 | public function getColumnCollationDeclarationSQL($collation) |
|
2597 | { |
||
2598 | 72537 | 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 | 32751 | public function prefersSequences() |
|
2608 | { |
||
2609 | 32751 | 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 | 61900 | public function prefersIdentityColumns() |
|
2619 | { |
||
2620 | 61900 | 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 | 73301 | public function convertBooleans($item) |
|
2638 | { |
||
2639 | 73301 | 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 | 73301 | } elseif (is_bool($item)) { |
|
2648 | 73299 | $item = (int) $item; |
|
2649 | } |
||
2650 | |||
2651 | 73301 | 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 | 72755 | public function convertFromBoolean($item) |
|
2664 | { |
||
2665 | 72755 | 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 | 67348 | public function convertBooleansToDatabaseValue($item) |
|
2679 | { |
||
2680 | 67348 | 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 | 71048 | public function getCurrentDateSQL() |
|
2689 | { |
||
2690 | 71048 | 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 | 11926 | public function getCurrentTimeSQL() |
|
2699 | { |
||
2700 | 11926 | 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 | 71746 | public function getCurrentTimestampSQL() |
|
2709 | { |
||
2710 | 71746 | 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 | 68707 | protected function _getTransactionIsolationLevelSQL($level) |
|
2723 | { |
||
2724 | 22 | switch ($level) { |
|
2725 | 68685 | case TransactionIsolationLevel::READ_UNCOMMITTED: |
|
2726 | 68707 | return 'READ UNCOMMITTED'; |
|
2727 | 68685 | case TransactionIsolationLevel::READ_COMMITTED: |
|
2728 | 68707 | return 'READ COMMITTED'; |
|
2729 | 68685 | case TransactionIsolationLevel::REPEATABLE_READ: |
|
2730 | 68707 | return 'REPEATABLE READ'; |
|
2731 | 68685 | case TransactionIsolationLevel::SERIALIZABLE: |
|
2732 | 68707 | 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 | 2980 | public function getListDatabasesSQL() |
|
2744 | { |
||
2745 | 2980 | 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 | 58081 | public function getCreateDatabaseSQL($database) |
|
2926 | { |
||
2927 | 58081 | 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 | 46512 | public function getDateTimeTzTypeDeclarationSQL(array $fieldDeclaration) |
|
2967 | { |
||
2968 | 46512 | 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 | 71406 | public function getFloatDeclarationSQL(array $fieldDeclaration) |
|
3008 | { |
||
3009 | 71406 | 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 | 60062 | public function supportsSequences() |
|
3032 | { |
||
3033 | 60062 | 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 | 57933 | public function supportsIdentityColumns() |
|
3045 | { |
||
3046 | 57933 | 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 | 71285 | public function usesSequenceEmulatedIdentityColumns() |
|
3059 | { |
||
3060 | 71285 | 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 | 69584 | public function getIdentitySequenceName($tableName, $columnName) |
|
3076 | { |
||
3077 | 69584 | throw DBALException::notSupported(__METHOD__); |
|
3078 | } |
||
3079 | |||
3080 | /** |
||
3081 | * Whether the platform supports indexes. |
||
3082 | * |
||
3083 | * @return bool |
||
3084 | */ |
||
3085 | 32624 | public function supportsIndexes() |
|
3086 | { |
||
3087 | 32624 | return true; |
|
3088 | } |
||
3089 | |||
3090 | /** |
||
3091 | * Whether the platform supports partial indexes. |
||
3092 | * |
||
3093 | * @return bool |
||
3094 | */ |
||
3095 | 75102 | public function supportsPartialIndexes() |
|
3096 | { |
||
3097 | 75102 | return false; |
|
3098 | } |
||
3099 | |||
3100 | /** |
||
3101 | * Whether the platform supports indexes with column length definitions. |
||
3102 | */ |
||
3103 | 74844 | public function supportsColumnLengthIndexes() : bool |
|
3104 | { |
||
3105 | 74844 | return false; |
|
3106 | } |
||
3107 | |||
3108 | /** |
||
3109 | * Whether the platform supports altering tables. |
||
3110 | * |
||
3111 | * @return bool |
||
3112 | */ |
||
3113 | 74168 | public function supportsAlterTable() |
|
3114 | { |
||
3115 | 74168 | return true; |
|
3116 | } |
||
3117 | |||
3118 | /** |
||
3119 | * Whether the platform supports transactions. |
||
3120 | * |
||
3121 | * @return bool |
||
3122 | */ |
||
3123 | 32649 | public function supportsTransactions() |
|
3124 | { |
||
3125 | 32649 | return true; |
|
3126 | } |
||
3127 | |||
3128 | /** |
||
3129 | * Whether the platform supports savepoints. |
||
3130 | * |
||
3131 | * @return bool |
||
3132 | */ |
||
3133 | 77053 | public function supportsSavepoints() |
|
3134 | { |
||
3135 | 77053 | return true; |
|
3136 | } |
||
3137 | |||
3138 | /** |
||
3139 | * Whether the platform supports releasing savepoints. |
||
3140 | * |
||
3141 | * @return bool |
||
3142 | */ |
||
3143 | 72096 | public function supportsReleaseSavepoints() |
|
3144 | { |
||
3145 | 72096 | return $this->supportsSavepoints(); |
|
3146 | } |
||
3147 | |||
3148 | /** |
||
3149 | * Whether the platform supports primary key constraints. |
||
3150 | * |
||
3151 | * @return bool |
||
3152 | */ |
||
3153 | 32724 | public function supportsPrimaryConstraints() |
|
3154 | { |
||
3155 | 32724 | return true; |
|
3156 | } |
||
3157 | |||
3158 | /** |
||
3159 | * Whether the platform supports foreign key constraints. |
||
3160 | * |
||
3161 | * @return bool |
||
3162 | */ |
||
3163 | 76877 | public function supportsForeignKeyConstraints() |
|
3164 | { |
||
3165 | 76877 | return true; |
|
3166 | } |
||
3167 | |||
3168 | /** |
||
3169 | * Whether this platform supports onUpdate in foreign key constraints. |
||
3170 | * |
||
3171 | * @return bool |
||
3172 | */ |
||
3173 | 76169 | public function supportsForeignKeyOnUpdate() |
|
3174 | { |
||
3175 | 76169 | return $this->supportsForeignKeyConstraints(); |
|
3176 | } |
||
3177 | |||
3178 | /** |
||
3179 | * Whether the platform supports database schemas. |
||
3180 | * |
||
3181 | * @return bool |
||
3182 | */ |
||
3183 | 60117 | public function supportsSchemas() |
|
3184 | { |
||
3185 | 60117 | 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 | 32474 | public function canEmulateSchemas() |
|
3198 | { |
||
3199 | 32474 | 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 | 70809 | public function supportsCreateDropDatabase() |
|
3222 | { |
||
3223 | 70809 | 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 | 32524 | public function supportsGettingAffectedRows() |
|
3232 | { |
||
3233 | 32524 | return true; |
|
3234 | } |
||
3235 | |||
3236 | /** |
||
3237 | * Whether this platform support to add inline column comments as postfix. |
||
3238 | * |
||
3239 | * @return bool |
||
3240 | */ |
||
3241 | 74237 | public function supportsInlineColumnComments() |
|
3242 | { |
||
3243 | 74237 | return false; |
|
3244 | } |
||
3245 | |||
3246 | /** |
||
3247 | * Whether this platform support the proprietary syntax "COMMENT ON asset". |
||
3248 | * |
||
3249 | * @return bool |
||
3250 | */ |
||
3251 | 74918 | public function supportsCommentOnStatement() |
|
3252 | { |
||
3253 | 74918 | return false; |
|
3254 | } |
||
3255 | |||
3256 | /** |
||
3257 | * Does this platform have native guid type. |
||
3258 | * |
||
3259 | * @return bool |
||
3260 | */ |
||
3261 | 76094 | public function hasNativeGuidType() |
|
3262 | { |
||
3263 | 76094 | return false; |
|
3264 | } |
||
3265 | |||
3266 | /** |
||
3267 | * Does this platform have native JSON type. |
||
3268 | * |
||
3269 | * @return bool |
||
3270 | */ |
||
3271 | 76279 | public function hasNativeJsonType() |
|
3272 | { |
||
3273 | 76279 | 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 | 74126 | public function supportsViews() |
|
3292 | { |
||
3293 | 74126 | 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 | 71140 | public function getDateTimeFormatString() |
|
3313 | { |
||
3314 | 71140 | 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 | 46765 | public function getDateTimeTzFormatString() |
|
3324 | { |
||
3325 | 46765 | 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 | 66687 | public function getDateFormatString() |
|
3335 | { |
||
3336 | 66687 | 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 | 66564 | public function getTimeFormatString() |
|
3346 | { |
||
3347 | 66564 | 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 | 76058 | final public function modifyLimitQuery($query, $limit, $offset = null) |
|
3362 | { |
||
3363 | 76058 | if ($limit !== null) { |
|
3364 | 76002 | $limit = (int) $limit; |
|
3365 | } |
||
3366 | |||
3367 | 76058 | $offset = (int) $offset; |
|
3368 | |||
3369 | 76058 | 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 | 76058 | 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 | 76058 | 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 | 61203 | protected function doModifyLimitQuery($query, $limit, $offset) |
|
3396 | { |
||
3397 | 61203 | if ($limit !== null) { |
|
3398 | 61191 | $query .= ' LIMIT ' . $limit; |
|
3399 | } |
||
3400 | |||
3401 | 61203 | if ($offset > 0) { |
|
3402 | 24268 | $query .= ' OFFSET ' . $offset; |
|
3403 | } |
||
3404 | |||
3405 | 61203 | return $query; |
|
3406 | } |
||
3407 | |||
3408 | /** |
||
3409 | * Whether the database platform support offsets in modify limit clauses. |
||
3410 | * |
||
3411 | * @return bool |
||
3412 | */ |
||
3413 | 75513 | public function supportsLimitOffset() |
|
3414 | { |
||
3415 | 75513 | 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 | 75315 | public function getMaxIdentifierLength() |
|
3449 | { |
||
3450 | 75315 | 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 | 43126 | public function getEmptyIdentityInsertSQL($tableName, $identifierColumnName) |
|
3462 | { |
||
3463 | 43126 | 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 | 71889 | public function getTruncateTableSQL($tableName, $cascade = false) |
|
3478 | { |
||
3479 | 71889 | $tableIdentifier = new Identifier($tableName); |
|
3480 | |||
3481 | 71889 | 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 | 74185 | public function getDummySelectSQL() |
|
3490 | { |
||
3491 | 74185 | $expression = func_num_args() > 0 ? func_get_arg(0) : '1'; |
|
3492 | |||
3493 | 74185 | 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 | 68168 | public function createSavePoint($savepoint) |
|
3504 | { |
||
3505 | 68168 | 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 | 68166 | public function releaseSavePoint($savepoint) |
|
3516 | { |
||
3517 | 68166 | 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 | 68168 | public function rollbackSavePoint($savepoint) |
|
3528 | { |
||
3529 | 68168 | 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 | 79711 | final public function getReservedKeywordsList() |
|
3540 | { |
||
3541 | // Check for an existing instantiation of the keywords class. |
||
3542 | 79711 | if ($this->_keywords) { |
|
3543 | 79577 | return $this->_keywords; |
|
3544 | } |
||
3545 | |||
3546 | 79428 | $class = $this->getReservedKeywordsClass(); |
|
3547 | 79428 | $keywords = new $class(); |
|
3548 | 79428 | 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 | 79428 | $this->_keywords = $keywords; |
|
3554 | |||
3555 | 79428 | 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 | 76255 | public function quoteStringLiteral($str) |
|
3581 | { |
||
3582 | 76255 | $c = $this->getStringLiteralQuoteCharacter(); |
|
3583 | |||
3584 | 76255 | 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 | 76291 | public function getStringLiteralQuoteCharacter() |
|
3593 | { |
||
3594 | 76291 | 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 | 76015 | final public function escapeStringForLike(string $inputString, string $escapeChar) : string |
|
3606 | { |
||
3607 | 76015 | return preg_replace( |
|
3608 | 76015 | '~([' . preg_quote($this->getLikeWildcardCharacters() . $escapeChar, '~') . '])~u', |
|
3609 | 76015 | addcslashes($escapeChar, '\\') . '$1', |
|
3610 | 76015 | $inputString |
|
3611 | ); |
||
3612 | } |
||
3613 | |||
3614 | 76015 | protected function getLikeWildcardCharacters() : string |
|
3615 | { |
||
3616 | 76015 | 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.