|
1
|
|
|
<?php |
|
2
|
|
|
|
|
3
|
|
|
declare(strict_types=1); |
|
4
|
|
|
|
|
5
|
|
|
namespace Doctrine\DBAL\Platforms; |
|
6
|
|
|
|
|
7
|
|
|
use Doctrine\DBAL\Exception\ColumnLengthRequired; |
|
8
|
|
|
use Doctrine\DBAL\LockMode; |
|
9
|
|
|
use Doctrine\DBAL\Schema\Column; |
|
10
|
|
|
use Doctrine\DBAL\Schema\ColumnDiff; |
|
11
|
|
|
use Doctrine\DBAL\Schema\ForeignKeyConstraint; |
|
12
|
|
|
use Doctrine\DBAL\Schema\Identifier; |
|
13
|
|
|
use Doctrine\DBAL\Schema\Index; |
|
14
|
|
|
use Doctrine\DBAL\Schema\Sequence; |
|
15
|
|
|
use Doctrine\DBAL\Schema\Table; |
|
16
|
|
|
use Doctrine\DBAL\Schema\TableDiff; |
|
17
|
|
|
use InvalidArgumentException; |
|
18
|
|
|
use function array_merge; |
|
19
|
|
|
use function array_unique; |
|
20
|
|
|
use function array_values; |
|
21
|
|
|
use function count; |
|
22
|
|
|
use function crc32; |
|
23
|
|
|
use function dechex; |
|
24
|
|
|
use function explode; |
|
25
|
|
|
use function implode; |
|
26
|
|
|
use function in_array; |
|
27
|
|
|
use function is_array; |
|
28
|
|
|
use function is_bool; |
|
29
|
|
|
use function is_numeric; |
|
30
|
|
|
use function is_string; |
|
31
|
|
|
use function preg_match; |
|
32
|
|
|
use function preg_match_all; |
|
33
|
|
|
use function sprintf; |
|
34
|
|
|
use function str_replace; |
|
35
|
|
|
use function strpos; |
|
36
|
|
|
use function strtoupper; |
|
37
|
|
|
use function substr_count; |
|
38
|
|
|
use const PREG_OFFSET_CAPTURE; |
|
39
|
|
|
|
|
40
|
|
|
/** |
|
41
|
|
|
* Provides the behavior, features and SQL dialect of the Microsoft SQL Server 2012 database platform. |
|
42
|
|
|
*/ |
|
43
|
|
|
class SQLServer2012Platform extends AbstractPlatform |
|
44
|
|
|
{ |
|
45
|
|
|
public function getCurrentDateSQL() : string |
|
46
|
|
|
{ |
|
47
|
|
|
return $this->getConvertExpression('date', 'GETDATE()'); |
|
48
|
|
|
} |
|
49
|
|
|
|
|
50
|
|
|
public function getCurrentTimeSQL() : string |
|
51
|
|
|
{ |
|
52
|
|
|
return $this->getConvertExpression('time', 'GETDATE()'); |
|
53
|
|
|
} |
|
54
|
|
|
|
|
55
|
|
|
/** |
|
56
|
|
|
* Returns an expression that converts an expression of one data type to another. |
|
57
|
|
|
* |
|
58
|
|
|
* @param string $dataType The target native data type. Alias data types cannot be used. |
|
59
|
|
|
* @param string $expression The SQL expression to convert. |
|
60
|
|
|
*/ |
|
61
|
|
|
private function getConvertExpression(string $dataType, string $expression) : string |
|
62
|
|
|
{ |
|
63
|
|
|
return sprintf('CONVERT(%s, %s)', $dataType, $expression); |
|
64
|
|
|
} |
|
65
|
|
|
|
|
66
|
|
|
protected function getDateArithmeticIntervalExpression(string $date, string $operator, string $interval, string $unit) : string |
|
67
|
|
|
{ |
|
68
|
|
|
$factorClause = ''; |
|
69
|
|
|
|
|
70
|
|
|
if ($operator === '-') { |
|
71
|
|
|
$factorClause = '-1 * '; |
|
72
|
|
|
} |
|
73
|
|
|
|
|
74
|
|
|
return 'DATEADD(' . $unit . ', ' . $factorClause . $interval . ', ' . $date . ')'; |
|
75
|
|
|
} |
|
76
|
|
|
|
|
77
|
|
|
public function getDateDiffExpression(string $date1, string $date2) : string |
|
78
|
|
|
{ |
|
79
|
|
|
return 'DATEDIFF(day, ' . $date2 . ',' . $date1 . ')'; |
|
80
|
|
|
} |
|
81
|
|
|
|
|
82
|
|
|
/** |
|
83
|
|
|
* {@inheritDoc} |
|
84
|
|
|
* |
|
85
|
|
|
* Microsoft SQL Server prefers "autoincrement" identity columns |
|
86
|
|
|
* since sequences can only be emulated with a table. |
|
87
|
|
|
*/ |
|
88
|
|
|
public function prefersIdentityColumns() : bool |
|
89
|
|
|
{ |
|
90
|
|
|
return true; |
|
91
|
|
|
} |
|
92
|
|
|
|
|
93
|
|
|
/** |
|
94
|
|
|
* {@inheritDoc} |
|
95
|
|
|
* |
|
96
|
|
|
* Microsoft SQL Server supports this through AUTO_INCREMENT columns. |
|
97
|
|
|
*/ |
|
98
|
|
|
public function supportsIdentityColumns() : bool |
|
99
|
|
|
{ |
|
100
|
|
|
return true; |
|
101
|
|
|
} |
|
102
|
|
|
|
|
103
|
|
|
public function supportsReleaseSavepoints() : bool |
|
104
|
|
|
{ |
|
105
|
|
|
return false; |
|
106
|
|
|
} |
|
107
|
|
|
|
|
108
|
|
|
public function supportsSchemas() : bool |
|
109
|
|
|
{ |
|
110
|
|
|
return true; |
|
111
|
|
|
} |
|
112
|
|
|
|
|
113
|
|
|
public function getDefaultSchemaName() : string |
|
114
|
|
|
{ |
|
115
|
|
|
return 'dbo'; |
|
116
|
|
|
} |
|
117
|
|
|
|
|
118
|
|
|
public function supportsColumnCollation() : bool |
|
119
|
|
|
{ |
|
120
|
|
|
return true; |
|
121
|
|
|
} |
|
122
|
|
|
|
|
123
|
|
|
public function supportsSequences() : bool |
|
124
|
|
|
{ |
|
125
|
|
|
return true; |
|
126
|
|
|
} |
|
127
|
|
|
|
|
128
|
|
|
public function getAlterSequenceSQL(Sequence $sequence) : string |
|
129
|
|
|
{ |
|
130
|
|
|
return 'ALTER SEQUENCE ' . $sequence->getQuotedName($this) . |
|
131
|
|
|
' INCREMENT BY ' . $sequence->getAllocationSize(); |
|
132
|
|
|
} |
|
133
|
|
|
|
|
134
|
|
|
public function getCreateSequenceSQL(Sequence $sequence) : string |
|
135
|
|
|
{ |
|
136
|
|
|
return 'CREATE SEQUENCE ' . $sequence->getQuotedName($this) . |
|
137
|
|
|
' START WITH ' . $sequence->getInitialValue() . |
|
138
|
|
|
' INCREMENT BY ' . $sequence->getAllocationSize() . |
|
139
|
|
|
' MINVALUE ' . $sequence->getInitialValue(); |
|
140
|
|
|
} |
|
141
|
|
|
|
|
142
|
|
|
/** |
|
143
|
|
|
* {@inheritdoc} |
|
144
|
|
|
*/ |
|
145
|
|
|
public function getDropSequenceSQL($sequence) : string |
|
146
|
|
|
{ |
|
147
|
|
|
if ($sequence instanceof Sequence) { |
|
148
|
|
|
$sequence = $sequence->getQuotedName($this); |
|
149
|
|
|
} |
|
150
|
|
|
|
|
151
|
|
|
return 'DROP SEQUENCE ' . $sequence; |
|
152
|
|
|
} |
|
153
|
|
|
|
|
154
|
|
|
public function getListSequencesSQL(string $database) : string |
|
155
|
|
|
{ |
|
156
|
|
|
return 'SELECT seq.name, |
|
157
|
|
|
CAST( |
|
158
|
|
|
seq.increment AS VARCHAR(MAX) |
|
159
|
|
|
) AS increment, -- CAST avoids driver error for sql_variant type |
|
160
|
|
|
CAST( |
|
161
|
|
|
seq.start_value AS VARCHAR(MAX) |
|
162
|
|
|
) AS start_value -- CAST avoids driver error for sql_variant type |
|
163
|
|
|
FROM sys.sequences AS seq'; |
|
164
|
|
|
} |
|
165
|
|
|
|
|
166
|
|
|
public function getSequenceNextValSQL(string $sequenceName) : string |
|
167
|
|
|
{ |
|
168
|
|
|
return 'SELECT NEXT VALUE FOR ' . $sequenceName; |
|
169
|
|
|
} |
|
170
|
|
|
|
|
171
|
|
|
public function hasNativeGuidType() : bool |
|
172
|
|
|
{ |
|
173
|
|
|
return true; |
|
174
|
|
|
} |
|
175
|
|
|
|
|
176
|
|
|
public function getCreateDatabaseSQL(string $database) : string |
|
177
|
|
|
{ |
|
178
|
|
|
return 'CREATE DATABASE ' . $database; |
|
179
|
|
|
} |
|
180
|
|
|
|
|
181
|
|
|
public function getDropDatabaseSQL(string $database) : string |
|
182
|
|
|
{ |
|
183
|
|
|
return 'DROP DATABASE ' . $database; |
|
184
|
|
|
} |
|
185
|
|
|
|
|
186
|
|
|
public function supportsCreateDropDatabase() : bool |
|
187
|
|
|
{ |
|
188
|
|
|
return true; |
|
189
|
|
|
} |
|
190
|
|
|
|
|
191
|
|
|
public function getCreateSchemaSQL(string $schemaName) : string |
|
192
|
|
|
{ |
|
193
|
|
|
return 'CREATE SCHEMA ' . $schemaName; |
|
194
|
|
|
} |
|
195
|
|
|
|
|
196
|
|
|
/** |
|
197
|
|
|
* {@inheritDoc} |
|
198
|
|
|
*/ |
|
199
|
|
|
public function getDropForeignKeySQL($foreignKey, $table) : string |
|
200
|
|
|
{ |
|
201
|
|
|
if (! $foreignKey instanceof ForeignKeyConstraint) { |
|
202
|
|
|
$foreignKey = new Identifier($foreignKey); |
|
203
|
|
|
} |
|
204
|
|
|
|
|
205
|
|
|
if (! $table instanceof Table) { |
|
206
|
|
|
$table = new Identifier($table); |
|
207
|
|
|
} |
|
208
|
|
|
|
|
209
|
|
|
$foreignKey = $foreignKey->getQuotedName($this); |
|
210
|
|
|
$table = $table->getQuotedName($this); |
|
211
|
|
|
|
|
212
|
|
|
return 'ALTER TABLE ' . $table . ' DROP CONSTRAINT ' . $foreignKey; |
|
213
|
|
|
} |
|
214
|
|
|
|
|
215
|
|
|
/** |
|
216
|
|
|
* {@inheritDoc} |
|
217
|
|
|
*/ |
|
218
|
|
|
public function getDropIndexSQL($index, $table = null) : string |
|
219
|
|
|
{ |
|
220
|
|
|
if ($index instanceof Index) { |
|
221
|
|
|
$index = $index->getQuotedName($this); |
|
222
|
|
|
} elseif (! is_string($index)) { |
|
223
|
|
|
throw new InvalidArgumentException(sprintf( |
|
224
|
|
|
'AbstractPlatform::getDropIndexSQL() expects $index parameter to be a string or an instanceof %s.', |
|
225
|
|
|
Index::class |
|
226
|
|
|
)); |
|
227
|
|
|
} |
|
228
|
|
|
|
|
229
|
|
|
if (! isset($table)) { |
|
230
|
|
|
return 'DROP INDEX ' . $index; |
|
231
|
|
|
} |
|
232
|
|
|
|
|
233
|
|
|
if ($table instanceof Table) { |
|
234
|
|
|
$table = $table->getQuotedName($this); |
|
235
|
|
|
} |
|
236
|
|
|
|
|
237
|
|
|
return sprintf( |
|
238
|
|
|
<<<SQL |
|
239
|
|
|
IF EXISTS (SELECT * FROM sysobjects WHERE name = '%s') |
|
240
|
|
|
ALTER TABLE %s DROP CONSTRAINT %s |
|
241
|
|
|
ELSE |
|
242
|
|
|
DROP INDEX %s ON %s |
|
243
|
|
|
SQL |
|
244
|
|
|
, |
|
245
|
|
|
$index, |
|
246
|
|
|
$table, |
|
247
|
|
|
$index, |
|
248
|
|
|
$index, |
|
249
|
|
|
$table |
|
250
|
|
|
); |
|
251
|
|
|
} |
|
252
|
|
|
|
|
253
|
|
|
/** |
|
254
|
|
|
* {@inheritDoc} |
|
255
|
|
|
*/ |
|
256
|
|
|
protected function _getCreateTableSQL(string $tableName, array $columns, array $options = []) : array |
|
257
|
|
|
{ |
|
258
|
|
|
$defaultConstraintsSql = []; |
|
259
|
|
|
$commentsSql = []; |
|
260
|
|
|
|
|
261
|
|
|
$tableComment = $options['comment'] ?? null; |
|
262
|
|
|
if ($tableComment !== null) { |
|
263
|
|
|
$commentsSql[] = $this->getCommentOnTableSQL($tableName, $tableComment); |
|
264
|
|
|
} |
|
265
|
|
|
|
|
266
|
|
|
// @todo does other code breaks because of this? |
|
267
|
|
|
// force primary keys to be not null |
|
268
|
|
|
foreach ($columns as &$column) { |
|
269
|
|
|
if (isset($column['primary']) && $column['primary']) { |
|
270
|
|
|
$column['notnull'] = true; |
|
271
|
|
|
} |
|
272
|
|
|
|
|
273
|
|
|
// Build default constraints SQL statements. |
|
274
|
|
|
if (isset($column['default'])) { |
|
275
|
|
|
$defaultConstraintsSql[] = 'ALTER TABLE ' . $tableName . |
|
276
|
|
|
' ADD' . $this->getDefaultConstraintDeclarationSQL($tableName, $column); |
|
277
|
|
|
} |
|
278
|
|
|
|
|
279
|
|
|
if (empty($column['comment']) && ! is_numeric($column['comment'])) { |
|
280
|
|
|
continue; |
|
281
|
|
|
} |
|
282
|
|
|
|
|
283
|
|
|
$commentsSql[] = $this->getCreateColumnCommentSQL($tableName, $column['name'], $column['comment']); |
|
284
|
|
|
} |
|
285
|
|
|
|
|
286
|
|
|
$columnListSql = $this->getColumnDeclarationListSQL($columns); |
|
287
|
|
|
|
|
288
|
|
|
if (isset($options['uniqueConstraints']) && ! empty($options['uniqueConstraints'])) { |
|
289
|
|
|
foreach ($options['uniqueConstraints'] as $name => $definition) { |
|
290
|
|
|
$columnListSql .= ', ' . $this->getUniqueConstraintDeclarationSQL($name, $definition); |
|
291
|
|
|
} |
|
292
|
|
|
} |
|
293
|
|
|
|
|
294
|
|
|
if (isset($options['primary']) && ! empty($options['primary'])) { |
|
295
|
|
|
$flags = ''; |
|
296
|
|
|
if (isset($options['primary_index']) && $options['primary_index']->hasFlag('nonclustered')) { |
|
297
|
|
|
$flags = ' NONCLUSTERED'; |
|
298
|
|
|
} |
|
299
|
|
|
|
|
300
|
|
|
$columnListSql .= ', PRIMARY KEY' . $flags . ' (' . implode(', ', array_unique(array_values($options['primary']))) . ')'; |
|
301
|
|
|
} |
|
302
|
|
|
|
|
303
|
|
|
$query = 'CREATE TABLE ' . $tableName . ' (' . $columnListSql; |
|
304
|
|
|
|
|
305
|
|
|
$check = $this->getCheckDeclarationSQL($columns); |
|
306
|
|
|
if (! empty($check)) { |
|
307
|
|
|
$query .= ', ' . $check; |
|
308
|
|
|
} |
|
309
|
|
|
|
|
310
|
|
|
$query .= ')'; |
|
311
|
|
|
|
|
312
|
|
|
$sql = [$query]; |
|
313
|
|
|
|
|
314
|
|
|
if (isset($options['indexes']) && ! empty($options['indexes'])) { |
|
315
|
|
|
foreach ($options['indexes'] as $index) { |
|
316
|
|
|
$sql[] = $this->getCreateIndexSQL($index, $tableName); |
|
317
|
|
|
} |
|
318
|
|
|
} |
|
319
|
|
|
|
|
320
|
|
|
if (isset($options['foreignKeys'])) { |
|
321
|
|
|
foreach ((array) $options['foreignKeys'] as $definition) { |
|
322
|
|
|
$sql[] = $this->getCreateForeignKeySQL($definition, $tableName); |
|
323
|
|
|
} |
|
324
|
|
|
} |
|
325
|
|
|
|
|
326
|
|
|
return array_merge($sql, $commentsSql, $defaultConstraintsSql); |
|
327
|
|
|
} |
|
328
|
|
|
|
|
329
|
|
|
/** |
|
330
|
|
|
* {@inheritDoc} |
|
331
|
|
|
*/ |
|
332
|
|
|
public function getCreatePrimaryKeySQL(Index $index, $table) : string |
|
333
|
|
|
{ |
|
334
|
|
|
if ($table instanceof Table) { |
|
335
|
|
|
$identifier = $table->getQuotedName($this); |
|
336
|
|
|
} else { |
|
337
|
|
|
$identifier = $table; |
|
338
|
|
|
} |
|
339
|
|
|
|
|
340
|
|
|
$sql = 'ALTER TABLE ' . $identifier . ' ADD PRIMARY KEY'; |
|
341
|
|
|
|
|
342
|
|
|
if ($index->hasFlag('nonclustered')) { |
|
343
|
|
|
$sql .= ' NONCLUSTERED'; |
|
344
|
|
|
} |
|
345
|
|
|
|
|
346
|
|
|
return $sql . ' (' . $this->getIndexFieldDeclarationListSQL($index) . ')'; |
|
347
|
|
|
} |
|
348
|
|
|
|
|
349
|
|
|
/** |
|
350
|
|
|
* Returns the SQL statement for creating a column comment. |
|
351
|
|
|
* |
|
352
|
|
|
* SQL Server does not support native column comments, |
|
353
|
|
|
* therefore the extended properties functionality is used |
|
354
|
|
|
* as a workaround to store them. |
|
355
|
|
|
* The property name used to store column comments is "MS_Description" |
|
356
|
|
|
* which provides compatibility with SQL Server Management Studio, |
|
357
|
|
|
* as column comments are stored in the same property there when |
|
358
|
|
|
* specifying a column's "Description" attribute. |
|
359
|
|
|
* |
|
360
|
|
|
* @param string $tableName The quoted table name to which the column belongs. |
|
361
|
|
|
* @param string $columnName The quoted column name to create the comment for. |
|
362
|
|
|
* @param string|null $comment The column's comment. |
|
363
|
|
|
*/ |
|
364
|
|
|
protected function getCreateColumnCommentSQL(string $tableName, string $columnName, ?string $comment) : string |
|
365
|
|
|
{ |
|
366
|
|
|
if (strpos($tableName, '.') !== false) { |
|
367
|
|
|
[$schemaSQL, $tableSQL] = explode('.', $tableName); |
|
368
|
|
|
$schemaSQL = $this->quoteStringLiteral($schemaSQL); |
|
369
|
|
|
$tableSQL = $this->quoteStringLiteral($tableSQL); |
|
370
|
|
|
} else { |
|
371
|
|
|
$schemaSQL = "'dbo'"; |
|
372
|
|
|
$tableSQL = $this->quoteStringLiteral($tableName); |
|
373
|
|
|
} |
|
374
|
|
|
|
|
375
|
|
|
return $this->getAddExtendedPropertySQL( |
|
376
|
|
|
'MS_Description', |
|
377
|
|
|
$comment, |
|
378
|
|
|
'SCHEMA', |
|
379
|
|
|
$schemaSQL, |
|
380
|
|
|
'TABLE', |
|
381
|
|
|
$tableSQL, |
|
382
|
|
|
'COLUMN', |
|
383
|
|
|
$columnName |
|
384
|
|
|
); |
|
385
|
|
|
} |
|
386
|
|
|
|
|
387
|
|
|
/** |
|
388
|
|
|
* Returns the SQL snippet for declaring a default constraint. |
|
389
|
|
|
* |
|
390
|
|
|
* @param string $table Name of the table to return the default constraint declaration for. |
|
391
|
|
|
* @param mixed[] $column Column definition. |
|
392
|
|
|
* |
|
393
|
|
|
* @throws InvalidArgumentException |
|
394
|
|
|
*/ |
|
395
|
|
|
public function getDefaultConstraintDeclarationSQL(string $table, array $column) : string |
|
396
|
|
|
{ |
|
397
|
|
|
if (! isset($column['default'])) { |
|
398
|
|
|
throw new InvalidArgumentException('Incomplete column definition. "default" required.'); |
|
399
|
|
|
} |
|
400
|
|
|
|
|
401
|
|
|
$columnName = new Identifier($column['name']); |
|
402
|
|
|
|
|
403
|
|
|
return ' CONSTRAINT ' . |
|
404
|
|
|
$this->generateDefaultConstraintName($table, $column['name']) . |
|
405
|
|
|
$this->getDefaultValueDeclarationSQL($column) . |
|
406
|
|
|
' FOR ' . $columnName->getQuotedName($this); |
|
407
|
|
|
} |
|
408
|
|
|
|
|
409
|
|
|
/** |
|
410
|
|
|
* {@inheritDoc} |
|
411
|
|
|
*/ |
|
412
|
|
|
public function getCreateIndexSQL(Index $index, $table) : string |
|
413
|
|
|
{ |
|
414
|
|
|
$constraint = parent::getCreateIndexSQL($index, $table); |
|
415
|
|
|
|
|
416
|
|
|
if ($index->isUnique() && ! $index->isPrimary()) { |
|
417
|
|
|
$constraint = $this->_appendUniqueConstraintDefinition($constraint, $index); |
|
418
|
|
|
} |
|
419
|
|
|
|
|
420
|
|
|
return $constraint; |
|
421
|
|
|
} |
|
422
|
|
|
|
|
423
|
|
|
protected function getCreateIndexSQLFlags(Index $index) : string |
|
424
|
|
|
{ |
|
425
|
|
|
$type = ''; |
|
426
|
|
|
if ($index->isUnique()) { |
|
427
|
|
|
$type .= 'UNIQUE '; |
|
428
|
|
|
} |
|
429
|
|
|
|
|
430
|
|
|
if ($index->hasFlag('clustered')) { |
|
431
|
|
|
$type .= 'CLUSTERED '; |
|
432
|
|
|
} elseif ($index->hasFlag('nonclustered')) { |
|
433
|
|
|
$type .= 'NONCLUSTERED '; |
|
434
|
|
|
} |
|
435
|
|
|
|
|
436
|
|
|
return $type; |
|
437
|
|
|
} |
|
438
|
|
|
|
|
439
|
|
|
/** |
|
440
|
|
|
* Extend unique key constraint with required filters |
|
441
|
|
|
*/ |
|
442
|
|
|
private function _appendUniqueConstraintDefinition(string $sql, Index $index) : string |
|
443
|
|
|
{ |
|
444
|
|
|
$fields = []; |
|
445
|
|
|
|
|
446
|
|
|
foreach ($index->getQuotedColumns($this) as $field) { |
|
447
|
|
|
$fields[] = $field . ' IS NOT NULL'; |
|
448
|
|
|
} |
|
449
|
|
|
|
|
450
|
|
|
return $sql . ' WHERE ' . implode(' AND ', $fields); |
|
451
|
|
|
} |
|
452
|
|
|
|
|
453
|
|
|
/** |
|
454
|
|
|
* {@inheritDoc} |
|
455
|
|
|
*/ |
|
456
|
|
|
public function getAlterTableSQL(TableDiff $diff) : array |
|
457
|
|
|
{ |
|
458
|
|
|
$queryParts = []; |
|
459
|
|
|
$sql = []; |
|
460
|
|
|
$columnSql = []; |
|
461
|
|
|
$commentsSql = []; |
|
462
|
|
|
|
|
463
|
|
|
foreach ($diff->addedColumns as $column) { |
|
464
|
|
|
if ($this->onSchemaAlterTableAddColumn($column, $diff, $columnSql)) { |
|
465
|
|
|
continue; |
|
466
|
|
|
} |
|
467
|
|
|
|
|
468
|
|
|
$columnDef = $column->toArray(); |
|
469
|
|
|
$queryParts[] = 'ADD ' . $this->getColumnDeclarationSQL($column->getQuotedName($this), $columnDef); |
|
470
|
|
|
|
|
471
|
|
|
if (isset($columnDef['default'])) { |
|
472
|
|
|
$queryParts[] = $this->getAlterTableAddDefaultConstraintClause($diff->name, $column); |
|
473
|
|
|
} |
|
474
|
|
|
|
|
475
|
|
|
$comment = $this->getColumnComment($column); |
|
476
|
|
|
|
|
477
|
|
|
if (empty($comment) && ! is_numeric($comment)) { |
|
478
|
|
|
continue; |
|
479
|
|
|
} |
|
480
|
|
|
|
|
481
|
|
|
$commentsSql[] = $this->getCreateColumnCommentSQL( |
|
482
|
|
|
$diff->name, |
|
483
|
|
|
$column->getQuotedName($this), |
|
484
|
|
|
$comment |
|
485
|
|
|
); |
|
486
|
|
|
} |
|
487
|
|
|
|
|
488
|
|
|
foreach ($diff->removedColumns as $column) { |
|
489
|
|
|
if ($this->onSchemaAlterTableRemoveColumn($column, $diff, $columnSql)) { |
|
490
|
|
|
continue; |
|
491
|
|
|
} |
|
492
|
|
|
|
|
493
|
|
|
$queryParts[] = 'DROP COLUMN ' . $column->getQuotedName($this); |
|
494
|
|
|
} |
|
495
|
|
|
|
|
496
|
|
|
foreach ($diff->changedColumns as $columnDiff) { |
|
497
|
|
|
if ($this->onSchemaAlterTableChangeColumn($columnDiff, $diff, $columnSql)) { |
|
498
|
|
|
continue; |
|
499
|
|
|
} |
|
500
|
|
|
|
|
501
|
|
|
$column = $columnDiff->column; |
|
502
|
|
|
$comment = $this->getColumnComment($column); |
|
503
|
|
|
$hasComment = ! empty($comment) || is_numeric($comment); |
|
504
|
|
|
|
|
505
|
|
|
if ($columnDiff->fromColumn instanceof Column) { |
|
506
|
|
|
$fromComment = $this->getColumnComment($columnDiff->fromColumn); |
|
507
|
|
|
$hasFromComment = ! empty($fromComment) || is_numeric($fromComment); |
|
508
|
|
|
|
|
509
|
|
|
if ($hasFromComment && $hasComment && $fromComment !== $comment) { |
|
510
|
|
|
$commentsSql[] = $this->getAlterColumnCommentSQL( |
|
511
|
|
|
$diff->name, |
|
512
|
|
|
$column->getQuotedName($this), |
|
513
|
|
|
$comment |
|
514
|
|
|
); |
|
515
|
|
|
} elseif ($hasFromComment && ! $hasComment) { |
|
516
|
|
|
$commentsSql[] = $this->getDropColumnCommentSQL($diff->name, $column->getQuotedName($this)); |
|
517
|
|
|
} elseif ($hasComment) { |
|
518
|
|
|
$commentsSql[] = $this->getCreateColumnCommentSQL( |
|
519
|
|
|
$diff->name, |
|
520
|
|
|
$column->getQuotedName($this), |
|
521
|
|
|
$comment |
|
522
|
|
|
); |
|
523
|
|
|
} |
|
524
|
|
|
} |
|
525
|
|
|
|
|
526
|
|
|
// Do not add query part if only comment has changed. |
|
527
|
|
|
if ($columnDiff->hasChanged('comment') && count($columnDiff->changedProperties) === 1) { |
|
528
|
|
|
continue; |
|
529
|
|
|
} |
|
530
|
|
|
|
|
531
|
|
|
$requireDropDefaultConstraint = $this->alterColumnRequiresDropDefaultConstraint($columnDiff); |
|
532
|
|
|
|
|
533
|
|
|
if ($requireDropDefaultConstraint) { |
|
534
|
|
|
$queryParts[] = $this->getAlterTableDropDefaultConstraintClause( |
|
535
|
|
|
$diff->name, |
|
536
|
|
|
$columnDiff->oldColumnName |
|
537
|
|
|
); |
|
538
|
|
|
} |
|
539
|
|
|
|
|
540
|
|
|
$columnDef = $column->toArray(); |
|
541
|
|
|
|
|
542
|
|
|
$queryParts[] = 'ALTER COLUMN ' . |
|
543
|
|
|
$this->getColumnDeclarationSQL($column->getQuotedName($this), $columnDef); |
|
544
|
|
|
|
|
545
|
|
|
if (! isset($columnDef['default']) || (! $requireDropDefaultConstraint && ! $columnDiff->hasChanged('default'))) { |
|
546
|
|
|
continue; |
|
547
|
|
|
} |
|
548
|
|
|
|
|
549
|
|
|
$queryParts[] = $this->getAlterTableAddDefaultConstraintClause($diff->name, $column); |
|
550
|
|
|
} |
|
551
|
|
|
|
|
552
|
|
|
foreach ($diff->renamedColumns as $oldColumnName => $column) { |
|
553
|
|
|
if ($this->onSchemaAlterTableRenameColumn($oldColumnName, $column, $diff, $columnSql)) { |
|
554
|
|
|
continue; |
|
555
|
|
|
} |
|
556
|
|
|
|
|
557
|
|
|
$oldColumnName = new Identifier($oldColumnName); |
|
558
|
|
|
|
|
559
|
|
|
$sql[] = "sp_RENAME '" . |
|
560
|
|
|
$diff->getName($this)->getQuotedName($this) . '.' . $oldColumnName->getQuotedName($this) . |
|
561
|
|
|
"', '" . $column->getQuotedName($this) . "', 'COLUMN'"; |
|
562
|
|
|
|
|
563
|
|
|
// Recreate default constraint with new column name if necessary (for future reference). |
|
564
|
|
|
if ($column->getDefault() === null) { |
|
565
|
|
|
continue; |
|
566
|
|
|
} |
|
567
|
|
|
|
|
568
|
|
|
$queryParts[] = $this->getAlterTableDropDefaultConstraintClause( |
|
569
|
|
|
$diff->name, |
|
570
|
|
|
$oldColumnName->getQuotedName($this) |
|
571
|
|
|
); |
|
572
|
|
|
$queryParts[] = $this->getAlterTableAddDefaultConstraintClause($diff->name, $column); |
|
573
|
|
|
} |
|
574
|
|
|
|
|
575
|
|
|
$tableSql = []; |
|
576
|
|
|
|
|
577
|
|
|
if ($this->onSchemaAlterTable($diff, $tableSql)) { |
|
578
|
|
|
return array_merge($tableSql, $columnSql); |
|
579
|
|
|
} |
|
580
|
|
|
|
|
581
|
|
|
foreach ($queryParts as $query) { |
|
582
|
|
|
$sql[] = 'ALTER TABLE ' . $diff->getName($this)->getQuotedName($this) . ' ' . $query; |
|
583
|
|
|
} |
|
584
|
|
|
|
|
585
|
|
|
$sql = array_merge($sql, $commentsSql); |
|
586
|
|
|
|
|
587
|
|
|
$newName = $diff->getNewName(); |
|
588
|
|
|
|
|
589
|
|
|
if ($newName !== null) { |
|
590
|
|
|
$sql[] = "sp_RENAME '" . $diff->getName($this)->getQuotedName($this) . "', '" . $newName->getName() . "'"; |
|
591
|
|
|
|
|
592
|
|
|
/** |
|
593
|
|
|
* Rename table's default constraints names |
|
594
|
|
|
* to match the new table name. |
|
595
|
|
|
* This is necessary to ensure that the default |
|
596
|
|
|
* constraints can be referenced in future table |
|
597
|
|
|
* alterations as the table name is encoded in |
|
598
|
|
|
* default constraints' names. |
|
599
|
|
|
*/ |
|
600
|
|
|
$sql[] = "DECLARE @sql NVARCHAR(MAX) = N''; " . |
|
601
|
|
|
"SELECT @sql += N'EXEC sp_rename N''' + dc.name + ''', N''' " . |
|
602
|
|
|
"+ REPLACE(dc.name, '" . $this->generateIdentifierName($diff->name) . "', " . |
|
603
|
|
|
"'" . $this->generateIdentifierName($newName->getName()) . "') + ''', ''OBJECT'';' " . |
|
604
|
|
|
'FROM sys.default_constraints dc ' . |
|
605
|
|
|
'JOIN sys.tables tbl ON dc.parent_object_id = tbl.object_id ' . |
|
606
|
|
|
"WHERE tbl.name = '" . $newName->getName() . "';" . |
|
607
|
|
|
'EXEC sp_executesql @sql'; |
|
608
|
|
|
} |
|
609
|
|
|
|
|
610
|
|
|
$sql = array_merge( |
|
611
|
|
|
$this->getPreAlterTableIndexForeignKeySQL($diff), |
|
612
|
|
|
$sql, |
|
613
|
|
|
$this->getPostAlterTableIndexForeignKeySQL($diff) |
|
614
|
|
|
); |
|
615
|
|
|
|
|
616
|
|
|
return array_merge($sql, $tableSql, $columnSql); |
|
617
|
|
|
} |
|
618
|
|
|
|
|
619
|
|
|
/** |
|
620
|
|
|
* Returns the SQL clause for adding a default constraint in an ALTER TABLE statement. |
|
621
|
|
|
* |
|
622
|
|
|
* @param string $tableName The name of the table to generate the clause for. |
|
623
|
|
|
* @param Column $column The column to generate the clause for. |
|
624
|
|
|
*/ |
|
625
|
|
|
private function getAlterTableAddDefaultConstraintClause(string $tableName, Column $column) : string |
|
626
|
|
|
{ |
|
627
|
|
|
$columnDef = $column->toArray(); |
|
628
|
|
|
$columnDef['name'] = $column->getQuotedName($this); |
|
629
|
|
|
|
|
630
|
|
|
return 'ADD' . $this->getDefaultConstraintDeclarationSQL($tableName, $columnDef); |
|
631
|
|
|
} |
|
632
|
|
|
|
|
633
|
|
|
/** |
|
634
|
|
|
* Returns the SQL clause for dropping an existing default constraint in an ALTER TABLE statement. |
|
635
|
|
|
* |
|
636
|
|
|
* @param string $tableName The name of the table to generate the clause for. |
|
637
|
|
|
* @param string $columnName The name of the column to generate the clause for. |
|
638
|
|
|
*/ |
|
639
|
|
|
private function getAlterTableDropDefaultConstraintClause(string $tableName, string $columnName) : string |
|
640
|
|
|
{ |
|
641
|
|
|
return 'DROP CONSTRAINT ' . $this->generateDefaultConstraintName($tableName, $columnName); |
|
642
|
|
|
} |
|
643
|
|
|
|
|
644
|
|
|
/** |
|
645
|
|
|
* Checks whether a column alteration requires dropping its default constraint first. |
|
646
|
|
|
* |
|
647
|
|
|
* Different to other database vendors SQL Server implements column default values |
|
648
|
|
|
* as constraints and therefore changes in a column's default value as well as changes |
|
649
|
|
|
* in a column's type require dropping the default constraint first before being to |
|
650
|
|
|
* alter the particular column to the new definition. |
|
651
|
|
|
* |
|
652
|
|
|
* @param ColumnDiff $columnDiff The column diff to evaluate. |
|
653
|
|
|
* |
|
654
|
|
|
* @return bool True if the column alteration requires dropping its default constraint first, false otherwise. |
|
655
|
|
|
*/ |
|
656
|
|
|
private function alterColumnRequiresDropDefaultConstraint(ColumnDiff $columnDiff) : bool |
|
657
|
|
|
{ |
|
658
|
|
|
// We can only decide whether to drop an existing default constraint |
|
659
|
|
|
// if we know the original default value. |
|
660
|
|
|
if (! $columnDiff->fromColumn instanceof Column) { |
|
661
|
|
|
return false; |
|
662
|
|
|
} |
|
663
|
|
|
|
|
664
|
|
|
// We only need to drop an existing default constraint if we know the |
|
665
|
|
|
// column was defined with a default value before. |
|
666
|
|
|
if ($columnDiff->fromColumn->getDefault() === null) { |
|
667
|
|
|
return false; |
|
668
|
|
|
} |
|
669
|
|
|
|
|
670
|
|
|
// We need to drop an existing default constraint if the column was |
|
671
|
|
|
// defined with a default value before and it has changed. |
|
672
|
|
|
if ($columnDiff->hasChanged('default')) { |
|
673
|
|
|
return true; |
|
674
|
|
|
} |
|
675
|
|
|
|
|
676
|
|
|
// We need to drop an existing default constraint if the column was |
|
677
|
|
|
// defined with a default value before and the native column type has changed. |
|
678
|
|
|
return $columnDiff->hasChanged('type') || $columnDiff->hasChanged('fixed'); |
|
679
|
|
|
} |
|
680
|
|
|
|
|
681
|
|
|
/** |
|
682
|
|
|
* Returns the SQL statement for altering a column comment. |
|
683
|
|
|
* |
|
684
|
|
|
* SQL Server does not support native column comments, |
|
685
|
|
|
* therefore the extended properties functionality is used |
|
686
|
|
|
* as a workaround to store them. |
|
687
|
|
|
* The property name used to store column comments is "MS_Description" |
|
688
|
|
|
* which provides compatibility with SQL Server Management Studio, |
|
689
|
|
|
* as column comments are stored in the same property there when |
|
690
|
|
|
* specifying a column's "Description" attribute. |
|
691
|
|
|
* |
|
692
|
|
|
* @param string $tableName The quoted table name to which the column belongs. |
|
693
|
|
|
* @param string $columnName The quoted column name to alter the comment for. |
|
694
|
|
|
* @param string|null $comment The column's comment. |
|
695
|
|
|
*/ |
|
696
|
|
|
protected function getAlterColumnCommentSQL(string $tableName, string $columnName, ?string $comment) : string |
|
697
|
|
|
{ |
|
698
|
|
|
if (strpos($tableName, '.') !== false) { |
|
699
|
|
|
[$schemaSQL, $tableSQL] = explode('.', $tableName); |
|
700
|
|
|
$schemaSQL = $this->quoteStringLiteral($schemaSQL); |
|
701
|
|
|
$tableSQL = $this->quoteStringLiteral($tableSQL); |
|
702
|
|
|
} else { |
|
703
|
|
|
$schemaSQL = "'dbo'"; |
|
704
|
|
|
$tableSQL = $this->quoteStringLiteral($tableName); |
|
705
|
|
|
} |
|
706
|
|
|
|
|
707
|
|
|
return $this->getUpdateExtendedPropertySQL( |
|
708
|
|
|
'MS_Description', |
|
709
|
|
|
$comment, |
|
710
|
|
|
'SCHEMA', |
|
711
|
|
|
$schemaSQL, |
|
712
|
|
|
'TABLE', |
|
713
|
|
|
$tableSQL, |
|
714
|
|
|
'COLUMN', |
|
715
|
|
|
$columnName |
|
716
|
|
|
); |
|
717
|
|
|
} |
|
718
|
|
|
|
|
719
|
|
|
/** |
|
720
|
|
|
* Returns the SQL statement for dropping a column comment. |
|
721
|
|
|
* |
|
722
|
|
|
* SQL Server does not support native column comments, |
|
723
|
|
|
* therefore the extended properties functionality is used |
|
724
|
|
|
* as a workaround to store them. |
|
725
|
|
|
* The property name used to store column comments is "MS_Description" |
|
726
|
|
|
* which provides compatibility with SQL Server Management Studio, |
|
727
|
|
|
* as column comments are stored in the same property there when |
|
728
|
|
|
* specifying a column's "Description" attribute. |
|
729
|
|
|
* |
|
730
|
|
|
* @param string $tableName The quoted table name to which the column belongs. |
|
731
|
|
|
* @param string $columnName The quoted column name to drop the comment for. |
|
732
|
|
|
*/ |
|
733
|
|
|
protected function getDropColumnCommentSQL(string $tableName, string $columnName) : string |
|
734
|
|
|
{ |
|
735
|
|
|
if (strpos($tableName, '.') !== false) { |
|
736
|
|
|
[$schemaSQL, $tableSQL] = explode('.', $tableName); |
|
737
|
|
|
$schemaSQL = $this->quoteStringLiteral($schemaSQL); |
|
738
|
|
|
$tableSQL = $this->quoteStringLiteral($tableSQL); |
|
739
|
|
|
} else { |
|
740
|
|
|
$schemaSQL = "'dbo'"; |
|
741
|
|
|
$tableSQL = $this->quoteStringLiteral($tableName); |
|
742
|
|
|
} |
|
743
|
|
|
|
|
744
|
|
|
return $this->getDropExtendedPropertySQL( |
|
745
|
|
|
'MS_Description', |
|
746
|
|
|
'SCHEMA', |
|
747
|
|
|
$schemaSQL, |
|
748
|
|
|
'TABLE', |
|
749
|
|
|
$tableSQL, |
|
750
|
|
|
'COLUMN', |
|
751
|
|
|
$columnName |
|
752
|
|
|
); |
|
753
|
|
|
} |
|
754
|
|
|
|
|
755
|
|
|
/** |
|
756
|
|
|
* {@inheritdoc} |
|
757
|
|
|
*/ |
|
758
|
|
|
protected function getRenameIndexSQL(string $oldIndexName, Index $index, string $tableName) : array |
|
759
|
|
|
{ |
|
760
|
|
|
return [sprintf( |
|
761
|
|
|
"EXEC sp_RENAME N'%s.%s', N'%s', N'INDEX'", |
|
762
|
|
|
$tableName, |
|
763
|
|
|
$oldIndexName, |
|
764
|
|
|
$index->getQuotedName($this) |
|
765
|
|
|
), |
|
766
|
|
|
]; |
|
767
|
|
|
} |
|
768
|
|
|
|
|
769
|
|
|
/** |
|
770
|
|
|
* Returns the SQL statement for adding an extended property to a database object. |
|
771
|
|
|
* |
|
772
|
|
|
* @link http://msdn.microsoft.com/en-us/library/ms180047%28v=sql.90%29.aspx |
|
773
|
|
|
* |
|
774
|
|
|
* @param string $name The name of the property to add. |
|
775
|
|
|
* @param string|null $value The value of the property to add. |
|
776
|
|
|
* @param string|null $level0Type The type of the object at level 0 the property belongs to. |
|
777
|
|
|
* @param string|null $level0Name The name of the object at level 0 the property belongs to. |
|
778
|
|
|
* @param string|null $level1Type The type of the object at level 1 the property belongs to. |
|
779
|
|
|
* @param string|null $level1Name The name of the object at level 1 the property belongs to. |
|
780
|
|
|
* @param string|null $level2Type The type of the object at level 2 the property belongs to. |
|
781
|
|
|
* @param string|null $level2Name The name of the object at level 2 the property belongs to. |
|
782
|
|
|
*/ |
|
783
|
|
|
public function getAddExtendedPropertySQL( |
|
784
|
|
|
string $name, |
|
785
|
|
|
?string $value = null, |
|
786
|
|
|
?string $level0Type = null, |
|
787
|
|
|
?string $level0Name = null, |
|
788
|
|
|
?string $level1Type = null, |
|
789
|
|
|
?string $level1Name = null, |
|
790
|
|
|
?string $level2Type = null, |
|
791
|
|
|
?string $level2Name = null |
|
792
|
|
|
) : string { |
|
793
|
|
|
return 'EXEC sp_addextendedproperty ' . |
|
794
|
|
|
'N' . $this->quoteStringLiteral($name) . ', N' . $this->quoteStringLiteral((string) $value) . ', ' . |
|
795
|
|
|
'N' . $this->quoteStringLiteral((string) $level0Type) . ', ' . $level0Name . ', ' . |
|
796
|
|
|
'N' . $this->quoteStringLiteral((string) $level1Type) . ', ' . $level1Name . ', ' . |
|
797
|
|
|
'N' . $this->quoteStringLiteral((string) $level2Type) . ', ' . $level2Name; |
|
798
|
|
|
} |
|
799
|
|
|
|
|
800
|
|
|
/** |
|
801
|
|
|
* Returns the SQL statement for dropping an extended property from a database object. |
|
802
|
|
|
* |
|
803
|
|
|
* @link http://technet.microsoft.com/en-gb/library/ms178595%28v=sql.90%29.aspx |
|
804
|
|
|
* |
|
805
|
|
|
* @param string $name The name of the property to drop. |
|
806
|
|
|
* @param string|null $level0Type The type of the object at level 0 the property belongs to. |
|
807
|
|
|
* @param string|null $level0Name The name of the object at level 0 the property belongs to. |
|
808
|
|
|
* @param string|null $level1Type The type of the object at level 1 the property belongs to. |
|
809
|
|
|
* @param string|null $level1Name The name of the object at level 1 the property belongs to. |
|
810
|
|
|
* @param string|null $level2Type The type of the object at level 2 the property belongs to. |
|
811
|
|
|
* @param string|null $level2Name The name of the object at level 2 the property belongs to. |
|
812
|
|
|
*/ |
|
813
|
|
|
public function getDropExtendedPropertySQL( |
|
814
|
|
|
string $name, |
|
815
|
|
|
?string $level0Type = null, |
|
816
|
|
|
?string $level0Name = null, |
|
817
|
|
|
?string $level1Type = null, |
|
818
|
|
|
?string $level1Name = null, |
|
819
|
|
|
?string $level2Type = null, |
|
820
|
|
|
?string $level2Name = null |
|
821
|
|
|
) : string { |
|
822
|
|
|
return 'EXEC sp_dropextendedproperty ' . |
|
823
|
|
|
'N' . $this->quoteStringLiteral($name) . ', ' . |
|
824
|
|
|
'N' . $this->quoteStringLiteral((string) $level0Type) . ', ' . $level0Name . ', ' . |
|
825
|
|
|
'N' . $this->quoteStringLiteral((string) $level1Type) . ', ' . $level1Name . ', ' . |
|
826
|
|
|
'N' . $this->quoteStringLiteral((string) $level2Type) . ', ' . $level2Name; |
|
827
|
|
|
} |
|
828
|
|
|
|
|
829
|
|
|
/** |
|
830
|
|
|
* Returns the SQL statement for updating an extended property of a database object. |
|
831
|
|
|
* |
|
832
|
|
|
* @link http://msdn.microsoft.com/en-us/library/ms186885%28v=sql.90%29.aspx |
|
833
|
|
|
* |
|
834
|
|
|
* @param string $name The name of the property to update. |
|
835
|
|
|
* @param string|null $value The value of the property to update. |
|
836
|
|
|
* @param string|null $level0Type The type of the object at level 0 the property belongs to. |
|
837
|
|
|
* @param string|null $level0Name The name of the object at level 0 the property belongs to. |
|
838
|
|
|
* @param string|null $level1Type The type of the object at level 1 the property belongs to. |
|
839
|
|
|
* @param string|null $level1Name The name of the object at level 1 the property belongs to. |
|
840
|
|
|
* @param string|null $level2Type The type of the object at level 2 the property belongs to. |
|
841
|
|
|
* @param string|null $level2Name The name of the object at level 2 the property belongs to. |
|
842
|
|
|
*/ |
|
843
|
|
|
public function getUpdateExtendedPropertySQL( |
|
844
|
|
|
string $name, |
|
845
|
|
|
?string $value = null, |
|
846
|
|
|
?string $level0Type = null, |
|
847
|
|
|
?string $level0Name = null, |
|
848
|
|
|
?string $level1Type = null, |
|
849
|
|
|
?string $level1Name = null, |
|
850
|
|
|
?string $level2Type = null, |
|
851
|
|
|
?string $level2Name = null |
|
852
|
|
|
) : string { |
|
853
|
|
|
return 'EXEC sp_updateextendedproperty ' . |
|
854
|
|
|
'N' . $this->quoteStringLiteral($name) . ', N' . $this->quoteStringLiteral((string) $value) . ', ' . |
|
855
|
|
|
'N' . $this->quoteStringLiteral((string) $level0Type) . ', ' . $level0Name . ', ' . |
|
856
|
|
|
'N' . $this->quoteStringLiteral((string) $level1Type) . ', ' . $level1Name . ', ' . |
|
857
|
|
|
'N' . $this->quoteStringLiteral((string) $level2Type) . ', ' . $level2Name; |
|
858
|
|
|
} |
|
859
|
|
|
|
|
860
|
|
|
public function getEmptyIdentityInsertSQL(string $tableName, string $identifierColumnName) : string |
|
861
|
|
|
{ |
|
862
|
|
|
return 'INSERT INTO ' . $tableName . ' DEFAULT VALUES'; |
|
863
|
|
|
} |
|
864
|
|
|
|
|
865
|
|
|
public function getListTablesSQL() : string |
|
866
|
|
|
{ |
|
867
|
|
|
// "sysdiagrams" table must be ignored as it's internal SQL Server table for Database Diagrams |
|
868
|
|
|
// Category 2 must be ignored as it is "MS SQL Server 'pseudo-system' object[s]" for replication |
|
869
|
|
|
return "SELECT name, SCHEMA_NAME (uid) AS schema_name FROM sysobjects WHERE type = 'U' AND name != 'sysdiagrams' AND category != 2 ORDER BY name"; |
|
870
|
|
|
} |
|
871
|
|
|
|
|
872
|
|
|
public function getListTableColumnsSQL(string $table, ?string $database = null) : string |
|
873
|
|
|
{ |
|
874
|
|
|
return "SELECT col.name, |
|
875
|
|
|
type.name AS type, |
|
876
|
|
|
col.max_length AS length, |
|
877
|
|
|
~col.is_nullable AS notnull, |
|
878
|
|
|
def.definition AS [default], |
|
879
|
|
|
col.scale, |
|
880
|
|
|
col.precision, |
|
881
|
|
|
col.is_identity AS autoincrement, |
|
882
|
|
|
col.collation_name AS collation, |
|
883
|
|
|
CAST(prop.value AS NVARCHAR(MAX)) AS comment -- CAST avoids driver error for sql_variant type |
|
884
|
|
|
FROM sys.columns AS col |
|
885
|
|
|
JOIN sys.types AS type |
|
886
|
|
|
ON col.user_type_id = type.user_type_id |
|
887
|
|
|
JOIN sys.objects AS obj |
|
888
|
|
|
ON col.object_id = obj.object_id |
|
889
|
|
|
JOIN sys.schemas AS scm |
|
890
|
|
|
ON obj.schema_id = scm.schema_id |
|
891
|
|
|
LEFT JOIN sys.default_constraints def |
|
892
|
|
|
ON col.default_object_id = def.object_id |
|
893
|
|
|
AND col.object_id = def.parent_object_id |
|
894
|
|
|
LEFT JOIN sys.extended_properties AS prop |
|
895
|
|
|
ON obj.object_id = prop.major_id |
|
896
|
|
|
AND col.column_id = prop.minor_id |
|
897
|
|
|
AND prop.name = 'MS_Description' |
|
898
|
|
|
WHERE obj.type = 'U' |
|
899
|
|
|
AND " . $this->getTableWhereClause($table, 'scm.name', 'obj.name'); |
|
900
|
|
|
} |
|
901
|
|
|
|
|
902
|
|
|
public function getListTableForeignKeysSQL(string $table, ?string $database = null) : string |
|
903
|
|
|
{ |
|
904
|
|
|
return 'SELECT f.name AS ForeignKey, |
|
905
|
|
|
SCHEMA_NAME (f.SCHEMA_ID) AS SchemaName, |
|
906
|
|
|
OBJECT_NAME (f.parent_object_id) AS TableName, |
|
907
|
|
|
COL_NAME (fc.parent_object_id,fc.parent_column_id) AS ColumnName, |
|
908
|
|
|
SCHEMA_NAME (o.SCHEMA_ID) ReferenceSchemaName, |
|
909
|
|
|
OBJECT_NAME (f.referenced_object_id) AS ReferenceTableName, |
|
910
|
|
|
COL_NAME(fc.referenced_object_id,fc.referenced_column_id) AS ReferenceColumnName, |
|
911
|
|
|
f.delete_referential_action_desc, |
|
912
|
|
|
f.update_referential_action_desc |
|
913
|
|
|
FROM sys.foreign_keys AS f |
|
914
|
|
|
INNER JOIN sys.foreign_key_columns AS fc |
|
915
|
|
|
INNER JOIN sys.objects AS o ON o.OBJECT_ID = fc.referenced_object_id |
|
916
|
|
|
ON f.OBJECT_ID = fc.constraint_object_id |
|
917
|
|
|
WHERE ' . |
|
918
|
|
|
$this->getTableWhereClause($table, 'SCHEMA_NAME (f.schema_id)', 'OBJECT_NAME (f.parent_object_id)'); |
|
919
|
|
|
} |
|
920
|
|
|
|
|
921
|
|
|
public function getListTableIndexesSQL(string $table, ?string $currentDatabase = null) : string |
|
922
|
|
|
{ |
|
923
|
|
|
return "SELECT idx.name AS key_name, |
|
924
|
|
|
col.name AS column_name, |
|
925
|
|
|
~idx.is_unique AS non_unique, |
|
926
|
|
|
idx.is_primary_key AS [primary], |
|
927
|
|
|
CASE idx.type |
|
928
|
|
|
WHEN '1' THEN 'clustered' |
|
929
|
|
|
WHEN '2' THEN 'nonclustered' |
|
930
|
|
|
ELSE NULL |
|
931
|
|
|
END AS flags |
|
932
|
|
|
FROM sys.tables AS tbl |
|
933
|
|
|
JOIN sys.schemas AS scm ON tbl.schema_id = scm.schema_id |
|
934
|
|
|
JOIN sys.indexes AS idx ON tbl.object_id = idx.object_id |
|
935
|
|
|
JOIN sys.index_columns AS idxcol ON idx.object_id = idxcol.object_id AND idx.index_id = idxcol.index_id |
|
936
|
|
|
JOIN sys.columns AS col ON idxcol.object_id = col.object_id AND idxcol.column_id = col.column_id |
|
937
|
|
|
WHERE " . $this->getTableWhereClause($table, 'scm.name', 'tbl.name') . ' |
|
938
|
|
|
ORDER BY idx.index_id ASC, idxcol.key_ordinal ASC'; |
|
939
|
|
|
} |
|
940
|
|
|
|
|
941
|
|
|
public function getCreateViewSQL(string $name, string $sql) : string |
|
942
|
|
|
{ |
|
943
|
|
|
return 'CREATE VIEW ' . $name . ' AS ' . $sql; |
|
944
|
|
|
} |
|
945
|
|
|
|
|
946
|
|
|
public function getListViewsSQL(string $database) : string |
|
947
|
|
|
{ |
|
948
|
|
|
return "SELECT name FROM sysobjects WHERE type = 'V' ORDER BY name"; |
|
949
|
|
|
} |
|
950
|
|
|
|
|
951
|
|
|
/** |
|
952
|
|
|
* Returns the where clause to filter schema and table name in a query. |
|
953
|
|
|
* |
|
954
|
|
|
* @param string $table The full qualified name of the table. |
|
955
|
|
|
* @param string $schemaColumn The name of the column to compare the schema to in the where clause. |
|
956
|
|
|
* @param string $tableColumn The name of the column to compare the table to in the where clause. |
|
957
|
|
|
*/ |
|
958
|
|
|
private function getTableWhereClause(string $table, string $schemaColumn, string $tableColumn) : string |
|
959
|
|
|
{ |
|
960
|
|
|
if (strpos($table, '.') !== false) { |
|
961
|
|
|
[$schema, $table] = explode('.', $table); |
|
962
|
|
|
$schema = $this->quoteStringLiteral($schema); |
|
963
|
|
|
$table = $this->quoteStringLiteral($table); |
|
964
|
|
|
} else { |
|
965
|
|
|
$schema = 'SCHEMA_NAME()'; |
|
966
|
|
|
$table = $this->quoteStringLiteral($table); |
|
967
|
|
|
} |
|
968
|
|
|
|
|
969
|
|
|
return sprintf('(%s = %s AND %s = %s)', $tableColumn, $table, $schemaColumn, $schema); |
|
970
|
|
|
} |
|
971
|
|
|
|
|
972
|
|
|
public function getDropViewSQL(string $name) : string |
|
973
|
|
|
{ |
|
974
|
|
|
return 'DROP VIEW ' . $name; |
|
975
|
|
|
} |
|
976
|
|
|
|
|
977
|
|
|
public function getLocateExpression(string $string, string $substring, ?string $start = null) : string |
|
978
|
|
|
{ |
|
979
|
|
|
if ($start === null) { |
|
980
|
|
|
return sprintf('CHARINDEX(%s, %s)', $substring, $string); |
|
981
|
|
|
} |
|
982
|
|
|
|
|
983
|
|
|
return sprintf('CHARINDEX(%s, %s, %s)', $substring, $string, $start); |
|
984
|
|
|
} |
|
985
|
|
|
|
|
986
|
|
|
public function getModExpression(string $dividend, string $divisor) : string |
|
987
|
|
|
{ |
|
988
|
|
|
return $dividend . ' % ' . $divisor; |
|
989
|
|
|
} |
|
990
|
|
|
|
|
991
|
|
|
public function getTrimExpression(string $str, int $mode = TrimMode::UNSPECIFIED, ?string $char = null) : string |
|
992
|
|
|
{ |
|
993
|
|
|
if (! in_array($mode, [TrimMode::UNSPECIFIED, TrimMode::LEADING, TrimMode::TRAILING, TrimMode::BOTH], true)) { |
|
994
|
|
|
throw new InvalidArgumentException( |
|
995
|
|
|
sprintf('The value of $mode is expected to be one of the TrimMode constants, %d given', $mode) |
|
996
|
|
|
); |
|
997
|
|
|
} |
|
998
|
|
|
|
|
999
|
|
|
if ($char === null) { |
|
1000
|
|
|
switch ($mode) { |
|
1001
|
|
|
case TrimMode::LEADING: |
|
1002
|
|
|
return 'LTRIM(' . $str . ')'; |
|
1003
|
|
|
|
|
1004
|
|
|
case TrimMode::TRAILING: |
|
1005
|
|
|
return 'RTRIM(' . $str . ')'; |
|
1006
|
|
|
|
|
1007
|
|
|
default: |
|
1008
|
|
|
return 'LTRIM(RTRIM(' . $str . '))'; |
|
1009
|
|
|
} |
|
1010
|
|
|
} |
|
1011
|
|
|
|
|
1012
|
|
|
/** Original query used to get those expressions |
|
1013
|
|
|
declare @c varchar(100) = 'xxxBarxxx', @trim_char char(1) = 'x'; |
|
1014
|
|
|
declare @pat varchar(10) = '%[^' + @trim_char + ']%'; |
|
1015
|
|
|
select @c as string |
|
1016
|
|
|
, @trim_char as trim_char |
|
1017
|
|
|
, stuff(@c, 1, patindex(@pat, @c) - 1, null) as trim_leading |
|
1018
|
|
|
, reverse(stuff(reverse(@c), 1, patindex(@pat, reverse(@c)) - 1, null)) as trim_trailing |
|
1019
|
|
|
, reverse(stuff(reverse(stuff(@c, 1, patindex(@pat, @c) - 1, null)), 1, patindex(@pat, reverse(stuff(@c, 1, patindex(@pat, @c) - 1, null))) - 1, null)) as trim_both; |
|
1020
|
|
|
*/ |
|
1021
|
|
|
$pattern = "'%[^' + " . $char . " + ']%'"; |
|
1022
|
|
|
|
|
1023
|
|
|
if ($mode === TrimMode::LEADING) { |
|
1024
|
|
|
return 'stuff(' . $str . ', 1, patindex(' . $pattern . ', ' . $str . ') - 1, null)'; |
|
1025
|
|
|
} |
|
1026
|
|
|
|
|
1027
|
|
|
if ($mode === TrimMode::TRAILING) { |
|
1028
|
|
|
return 'reverse(stuff(reverse(' . $str . '), 1, patindex(' . $pattern . ', reverse(' . $str . ')) - 1, null))'; |
|
1029
|
|
|
} |
|
1030
|
|
|
|
|
1031
|
|
|
return 'reverse(stuff(reverse(stuff(' . $str . ', 1, patindex(' . $pattern . ', ' . $str . ') - 1, null)), 1, patindex(' . $pattern . ', reverse(stuff(' . $str . ', 1, patindex(' . $pattern . ', ' . $str . ') - 1, null))) - 1, null))'; |
|
1032
|
|
|
} |
|
1033
|
|
|
|
|
1034
|
|
|
public function getConcatExpression(string ...$string) : string |
|
1035
|
|
|
{ |
|
1036
|
|
|
return '(' . implode(' + ', $string) . ')'; |
|
1037
|
|
|
} |
|
1038
|
|
|
|
|
1039
|
|
|
public function getListDatabasesSQL() : string |
|
1040
|
|
|
{ |
|
1041
|
|
|
return 'SELECT * FROM sys.databases'; |
|
1042
|
|
|
} |
|
1043
|
|
|
|
|
1044
|
|
|
public function getListNamespacesSQL() : string |
|
1045
|
|
|
{ |
|
1046
|
|
|
return "SELECT name FROM sys.schemas WHERE name NOT IN('guest', 'INFORMATION_SCHEMA', 'sys')"; |
|
1047
|
|
|
} |
|
1048
|
|
|
|
|
1049
|
|
|
public function getSubstringExpression(string $string, string $start, ?string $length = null) : string |
|
1050
|
|
|
{ |
|
1051
|
|
|
if ($length === null) { |
|
1052
|
|
|
return sprintf('SUBSTRING(%s, %s, LEN(%s) - %s + 1)', $string, $start, $string, $start); |
|
1053
|
|
|
} |
|
1054
|
|
|
|
|
1055
|
|
|
return sprintf('SUBSTRING(%s, %s, %s)', $string, $start, $length); |
|
1056
|
|
|
} |
|
1057
|
|
|
|
|
1058
|
|
|
public function getLengthExpression(string $string) : string |
|
1059
|
|
|
{ |
|
1060
|
|
|
return 'LEN(' . $string . ')'; |
|
1061
|
|
|
} |
|
1062
|
|
|
|
|
1063
|
|
|
public function getCurrentDatabaseExpression() : string |
|
1064
|
|
|
{ |
|
1065
|
|
|
return 'DB_NAME()'; |
|
1066
|
|
|
} |
|
1067
|
|
|
|
|
1068
|
|
|
public function getSetTransactionIsolationSQL(int $level) : string |
|
1069
|
|
|
{ |
|
1070
|
|
|
return 'SET TRANSACTION ISOLATION LEVEL ' . $this->_getTransactionIsolationLevelSQL($level); |
|
1071
|
|
|
} |
|
1072
|
|
|
|
|
1073
|
|
|
/** |
|
1074
|
|
|
* {@inheritDoc} |
|
1075
|
|
|
*/ |
|
1076
|
|
|
public function getIntegerTypeDeclarationSQL(array $columnDef) : string |
|
1077
|
|
|
{ |
|
1078
|
|
|
return 'INT' . $this->_getCommonIntegerTypeDeclarationSQL($columnDef); |
|
1079
|
|
|
} |
|
1080
|
|
|
|
|
1081
|
|
|
/** |
|
1082
|
|
|
* {@inheritDoc} |
|
1083
|
|
|
*/ |
|
1084
|
|
|
public function getBigIntTypeDeclarationSQL(array $columnDef) : string |
|
1085
|
|
|
{ |
|
1086
|
|
|
return 'BIGINT' . $this->_getCommonIntegerTypeDeclarationSQL($columnDef); |
|
1087
|
|
|
} |
|
1088
|
|
|
|
|
1089
|
|
|
/** |
|
1090
|
|
|
* {@inheritDoc} |
|
1091
|
|
|
*/ |
|
1092
|
|
|
public function getSmallIntTypeDeclarationSQL(array $columnDef) : string |
|
1093
|
|
|
{ |
|
1094
|
|
|
return 'SMALLINT' . $this->_getCommonIntegerTypeDeclarationSQL($columnDef); |
|
1095
|
|
|
} |
|
1096
|
|
|
|
|
1097
|
|
|
/** |
|
1098
|
|
|
* {@inheritDoc} |
|
1099
|
|
|
*/ |
|
1100
|
|
|
public function getGuidTypeDeclarationSQL(array $column) : string |
|
1101
|
|
|
{ |
|
1102
|
|
|
return 'UNIQUEIDENTIFIER'; |
|
1103
|
|
|
} |
|
1104
|
|
|
|
|
1105
|
|
|
/** |
|
1106
|
|
|
* {@inheritDoc} |
|
1107
|
|
|
*/ |
|
1108
|
|
|
public function getDateTimeTzTypeDeclarationSQL(array $fieldDeclaration) : string |
|
1109
|
|
|
{ |
|
1110
|
|
|
return 'DATETIMEOFFSET(6)'; |
|
1111
|
|
|
} |
|
1112
|
|
|
|
|
1113
|
|
|
protected function getCharTypeDeclarationSQLSnippet(?int $length) : string |
|
1114
|
|
|
{ |
|
1115
|
|
|
$sql = 'NCHAR'; |
|
1116
|
|
|
|
|
1117
|
|
|
if ($length !== null) { |
|
1118
|
|
|
$sql .= sprintf('(%d)', $length); |
|
1119
|
|
|
} |
|
1120
|
|
|
|
|
1121
|
|
|
return $sql; |
|
1122
|
|
|
} |
|
1123
|
|
|
|
|
1124
|
|
|
protected function getVarcharTypeDeclarationSQLSnippet(?int $length) : string |
|
1125
|
|
|
{ |
|
1126
|
|
|
if ($length === null) { |
|
1127
|
|
|
throw ColumnLengthRequired::new($this, 'NVARCHAR'); |
|
1128
|
|
|
} |
|
1129
|
|
|
|
|
1130
|
|
|
return sprintf('NVARCHAR(%d)', $length); |
|
1131
|
|
|
} |
|
1132
|
|
|
|
|
1133
|
|
|
/** |
|
1134
|
|
|
* {@inheritDoc} |
|
1135
|
|
|
*/ |
|
1136
|
|
|
public function getClobTypeDeclarationSQL(array $field) : string |
|
1137
|
|
|
{ |
|
1138
|
|
|
return 'VARCHAR(MAX)'; |
|
1139
|
|
|
} |
|
1140
|
|
|
|
|
1141
|
|
|
/** |
|
1142
|
|
|
* {@inheritDoc} |
|
1143
|
|
|
*/ |
|
1144
|
|
|
protected function _getCommonIntegerTypeDeclarationSQL(array $columnDef) : string |
|
1145
|
|
|
{ |
|
1146
|
|
|
return ! empty($columnDef['autoincrement']) ? ' IDENTITY' : ''; |
|
1147
|
|
|
} |
|
1148
|
|
|
|
|
1149
|
|
|
/** |
|
1150
|
|
|
* {@inheritDoc} |
|
1151
|
|
|
*/ |
|
1152
|
|
|
public function getDateTimeTypeDeclarationSQL(array $fieldDeclaration) : string |
|
1153
|
|
|
{ |
|
1154
|
|
|
// 3 - microseconds precision length |
|
1155
|
|
|
// http://msdn.microsoft.com/en-us/library/ms187819.aspx |
|
1156
|
|
|
return 'DATETIME2(6)'; |
|
1157
|
|
|
} |
|
1158
|
|
|
|
|
1159
|
|
|
/** |
|
1160
|
|
|
* {@inheritDoc} |
|
1161
|
|
|
*/ |
|
1162
|
|
|
public function getDateTypeDeclarationSQL(array $fieldDeclaration) : string |
|
1163
|
|
|
{ |
|
1164
|
|
|
return 'DATE'; |
|
1165
|
|
|
} |
|
1166
|
|
|
|
|
1167
|
|
|
/** |
|
1168
|
|
|
* {@inheritDoc} |
|
1169
|
|
|
*/ |
|
1170
|
|
|
public function getTimeTypeDeclarationSQL(array $fieldDeclaration) : string |
|
1171
|
|
|
{ |
|
1172
|
|
|
return 'TIME(0)'; |
|
1173
|
|
|
} |
|
1174
|
|
|
|
|
1175
|
|
|
/** |
|
1176
|
|
|
* {@inheritDoc} |
|
1177
|
|
|
*/ |
|
1178
|
|
|
public function getBooleanTypeDeclarationSQL(array $columnDef) : string |
|
1179
|
|
|
{ |
|
1180
|
|
|
return 'BIT'; |
|
1181
|
|
|
} |
|
1182
|
|
|
|
|
1183
|
|
|
protected function doModifyLimitQuery(string $query, ?int $limit, int $offset) : string |
|
1184
|
|
|
{ |
|
1185
|
|
|
if ($limit === null && $offset <= 0) { |
|
1186
|
|
|
return $query; |
|
1187
|
|
|
} |
|
1188
|
|
|
|
|
1189
|
|
|
// Queries using OFFSET... FETCH MUST have an ORDER BY clause |
|
1190
|
|
|
// Find the position of the last instance of ORDER BY and ensure it is not within a parenthetical statement |
|
1191
|
|
|
// but can be in a newline |
|
1192
|
|
|
$matches = []; |
|
1193
|
|
|
$matchesCount = preg_match_all('/[\\s]+order\\s+by\\s/im', $query, $matches, PREG_OFFSET_CAPTURE); |
|
1194
|
|
|
$orderByPos = false; |
|
1195
|
|
|
if ($matchesCount > 0) { |
|
1196
|
|
|
$orderByPos = $matches[0][$matchesCount - 1][1]; |
|
1197
|
|
|
} |
|
1198
|
|
|
|
|
1199
|
|
|
if ($orderByPos === false |
|
1200
|
|
|
|| substr_count($query, '(', $orderByPos) - substr_count($query, ')', $orderByPos) |
|
1201
|
|
|
) { |
|
1202
|
|
|
if (preg_match('/^SELECT\s+DISTINCT/im', $query)) { |
|
1203
|
|
|
// SQL Server won't let us order by a non-selected column in a DISTINCT query, |
|
1204
|
|
|
// so we have to do this madness. This says, order by the first column in the |
|
1205
|
|
|
// result. SQL Server's docs say that a nonordered query's result order is non- |
|
1206
|
|
|
// deterministic anyway, so this won't do anything that a bunch of update and |
|
1207
|
|
|
// deletes to the table wouldn't do anyway. |
|
1208
|
|
|
$query .= ' ORDER BY 1'; |
|
1209
|
|
|
} else { |
|
1210
|
|
|
// In another DBMS, we could do ORDER BY 0, but SQL Server gets angry if you |
|
1211
|
|
|
// use constant expressions in the order by list. |
|
1212
|
|
|
$query .= ' ORDER BY (SELECT 0)'; |
|
1213
|
|
|
} |
|
1214
|
|
|
} |
|
1215
|
|
|
|
|
1216
|
|
|
// This looks somewhat like MYSQL, but limit/offset are in inverse positions |
|
1217
|
|
|
// Supposedly SQL:2008 core standard. |
|
1218
|
|
|
// Per TSQL spec, FETCH NEXT n ROWS ONLY is not valid without OFFSET n ROWS. |
|
1219
|
|
|
$query .= sprintf(' OFFSET %d ROWS', $offset); |
|
1220
|
|
|
|
|
1221
|
|
|
if ($limit !== null) { |
|
1222
|
|
|
$query .= sprintf(' FETCH NEXT %d ROWS ONLY', $limit); |
|
1223
|
|
|
} |
|
1224
|
|
|
|
|
1225
|
|
|
return $query; |
|
1226
|
|
|
} |
|
1227
|
|
|
|
|
1228
|
|
|
public function supportsLimitOffset() : bool |
|
1229
|
|
|
{ |
|
1230
|
|
|
return true; |
|
1231
|
|
|
} |
|
1232
|
|
|
|
|
1233
|
|
|
/** |
|
1234
|
|
|
* {@inheritDoc} |
|
1235
|
|
|
*/ |
|
1236
|
|
|
public function convertBooleans($item) |
|
1237
|
|
|
{ |
|
1238
|
|
|
if (is_array($item)) { |
|
1239
|
|
|
foreach ($item as $key => $value) { |
|
1240
|
|
|
if (! is_bool($value) && ! is_numeric($value)) { |
|
1241
|
|
|
continue; |
|
1242
|
|
|
} |
|
1243
|
|
|
|
|
1244
|
|
|
$item[$key] = $value ? 1 : 0; |
|
1245
|
|
|
} |
|
1246
|
|
|
} elseif (is_bool($item) || is_numeric($item)) { |
|
1247
|
|
|
$item = $item ? 1 : 0; |
|
1248
|
|
|
} |
|
1249
|
|
|
|
|
1250
|
|
|
return $item; |
|
1251
|
|
|
} |
|
1252
|
|
|
|
|
1253
|
|
|
public function getCreateTemporaryTableSnippetSQL() : string |
|
1254
|
|
|
{ |
|
1255
|
|
|
return 'CREATE TABLE'; |
|
1256
|
|
|
} |
|
1257
|
|
|
|
|
1258
|
|
|
public function getTemporaryTableName(string $tableName) : string |
|
1259
|
|
|
{ |
|
1260
|
|
|
return '#' . $tableName; |
|
1261
|
|
|
} |
|
1262
|
|
|
|
|
1263
|
|
|
public function getDateTimeFormatString() : string |
|
1264
|
|
|
{ |
|
1265
|
|
|
return 'Y-m-d H:i:s.u'; |
|
1266
|
|
|
} |
|
1267
|
|
|
|
|
1268
|
|
|
public function getDateFormatString() : string |
|
1269
|
|
|
{ |
|
1270
|
|
|
return 'Y-m-d'; |
|
1271
|
|
|
} |
|
1272
|
|
|
|
|
1273
|
|
|
public function getTimeFormatString() : string |
|
1274
|
|
|
{ |
|
1275
|
|
|
return 'H:i:s'; |
|
1276
|
|
|
} |
|
1277
|
|
|
|
|
1278
|
|
|
public function getDateTimeTzFormatString() : string |
|
1279
|
|
|
{ |
|
1280
|
|
|
return 'Y-m-d H:i:s.u P'; |
|
1281
|
|
|
} |
|
1282
|
|
|
|
|
1283
|
|
|
public function getName() : string |
|
1284
|
|
|
{ |
|
1285
|
|
|
return 'mssql'; |
|
1286
|
|
|
} |
|
1287
|
|
|
|
|
1288
|
|
|
protected function initializeDoctrineTypeMappings() : void |
|
1289
|
|
|
{ |
|
1290
|
|
|
$this->doctrineTypeMapping = [ |
|
1291
|
|
|
'bigint' => 'bigint', |
|
1292
|
|
|
'binary' => 'binary', |
|
1293
|
|
|
'bit' => 'boolean', |
|
1294
|
|
|
'char' => 'string', |
|
1295
|
|
|
'date' => 'date', |
|
1296
|
|
|
'datetime' => 'datetime', |
|
1297
|
|
|
'datetime2' => 'datetime', |
|
1298
|
|
|
'datetimeoffset' => 'datetimetz', |
|
1299
|
|
|
'decimal' => 'decimal', |
|
1300
|
|
|
'double' => 'float', |
|
1301
|
|
|
'double precision' => 'float', |
|
1302
|
|
|
'float' => 'float', |
|
1303
|
|
|
'image' => 'blob', |
|
1304
|
|
|
'int' => 'integer', |
|
1305
|
|
|
'money' => 'integer', |
|
1306
|
|
|
'nchar' => 'string', |
|
1307
|
|
|
'ntext' => 'text', |
|
1308
|
|
|
'numeric' => 'decimal', |
|
1309
|
|
|
'nvarchar' => 'string', |
|
1310
|
|
|
'real' => 'float', |
|
1311
|
|
|
'smalldatetime' => 'datetime', |
|
1312
|
|
|
'smallint' => 'smallint', |
|
1313
|
|
|
'smallmoney' => 'integer', |
|
1314
|
|
|
'text' => 'text', |
|
1315
|
|
|
'time' => 'time', |
|
1316
|
|
|
'tinyint' => 'smallint', |
|
1317
|
|
|
'uniqueidentifier' => 'guid', |
|
1318
|
|
|
'varbinary' => 'binary', |
|
1319
|
|
|
'varchar' => 'string', |
|
1320
|
|
|
]; |
|
1321
|
|
|
} |
|
1322
|
|
|
|
|
1323
|
|
|
public function createSavePoint(string $savepoint) : string |
|
1324
|
|
|
{ |
|
1325
|
|
|
return 'SAVE TRANSACTION ' . $savepoint; |
|
1326
|
|
|
} |
|
1327
|
|
|
|
|
1328
|
|
|
public function releaseSavePoint(string $savepoint) : string |
|
1329
|
|
|
{ |
|
1330
|
|
|
return ''; |
|
1331
|
|
|
} |
|
1332
|
|
|
|
|
1333
|
|
|
public function rollbackSavePoint(string $savepoint) : string |
|
1334
|
|
|
{ |
|
1335
|
|
|
return 'ROLLBACK TRANSACTION ' . $savepoint; |
|
1336
|
|
|
} |
|
1337
|
|
|
|
|
1338
|
|
|
public function getForeignKeyReferentialActionSQL(string $action) : string |
|
1339
|
|
|
{ |
|
1340
|
|
|
// RESTRICT is not supported, therefore falling back to NO ACTION. |
|
1341
|
|
|
if (strtoupper($action) === 'RESTRICT') { |
|
1342
|
|
|
return 'NO ACTION'; |
|
1343
|
|
|
} |
|
1344
|
|
|
|
|
1345
|
|
|
return parent::getForeignKeyReferentialActionSQL($action); |
|
1346
|
|
|
} |
|
1347
|
|
|
|
|
1348
|
|
|
public function appendLockHint(string $fromClause, ?int $lockMode) : string |
|
1349
|
|
|
{ |
|
1350
|
|
|
switch (true) { |
|
1351
|
|
|
case $lockMode === LockMode::NONE: |
|
1352
|
|
|
return $fromClause . ' WITH (NOLOCK)'; |
|
1353
|
|
|
|
|
1354
|
|
|
case $lockMode === LockMode::PESSIMISTIC_READ: |
|
1355
|
|
|
return $fromClause . ' WITH (HOLDLOCK, ROWLOCK)'; |
|
1356
|
|
|
|
|
1357
|
|
|
case $lockMode === LockMode::PESSIMISTIC_WRITE: |
|
1358
|
|
|
return $fromClause . ' WITH (UPDLOCK, ROWLOCK)'; |
|
1359
|
|
|
|
|
1360
|
|
|
default: |
|
1361
|
|
|
return $fromClause; |
|
1362
|
|
|
} |
|
1363
|
|
|
} |
|
1364
|
|
|
|
|
1365
|
|
|
public function getForUpdateSQL() : string |
|
1366
|
|
|
{ |
|
1367
|
|
|
return ' '; |
|
1368
|
|
|
} |
|
1369
|
|
|
|
|
1370
|
|
|
protected function getReservedKeywordsClass() : string |
|
1371
|
|
|
{ |
|
1372
|
|
|
return Keywords\SQLServer2012Keywords::class; |
|
1373
|
|
|
} |
|
1374
|
|
|
|
|
1375
|
|
|
public function quoteSingleIdentifier(string $str) : string |
|
1376
|
|
|
{ |
|
1377
|
|
|
return '[' . str_replace(']', '][', $str) . ']'; |
|
1378
|
|
|
} |
|
1379
|
|
|
|
|
1380
|
|
|
public function getTruncateTableSQL(string $tableName, bool $cascade = false) : string |
|
1381
|
|
|
{ |
|
1382
|
|
|
$tableIdentifier = new Identifier($tableName); |
|
1383
|
|
|
|
|
1384
|
|
|
return 'TRUNCATE TABLE ' . $tableIdentifier->getQuotedName($this); |
|
1385
|
|
|
} |
|
1386
|
|
|
|
|
1387
|
|
|
/** |
|
1388
|
|
|
* {@inheritDoc} |
|
1389
|
|
|
*/ |
|
1390
|
|
|
public function getBlobTypeDeclarationSQL(array $field) : string |
|
1391
|
|
|
{ |
|
1392
|
|
|
return 'VARBINARY(MAX)'; |
|
1393
|
|
|
} |
|
1394
|
|
|
|
|
1395
|
|
|
/** |
|
1396
|
|
|
* {@inheritdoc} |
|
1397
|
|
|
* |
|
1398
|
|
|
* Modifies column declaration order as it differs in Microsoft SQL Server. |
|
1399
|
|
|
*/ |
|
1400
|
|
|
public function getColumnDeclarationSQL(string $name, array $field) : string |
|
1401
|
|
|
{ |
|
1402
|
|
|
if (isset($field['columnDefinition'])) { |
|
1403
|
|
|
$columnDef = $this->getCustomTypeDeclarationSQL($field); |
|
1404
|
|
|
} else { |
|
1405
|
|
|
$collation = isset($field['collation']) && $field['collation'] ? |
|
1406
|
|
|
' ' . $this->getColumnCollationDeclarationSQL($field['collation']) : ''; |
|
1407
|
|
|
|
|
1408
|
|
|
$notnull = isset($field['notnull']) && $field['notnull'] ? ' NOT NULL' : ''; |
|
1409
|
|
|
|
|
1410
|
|
|
$unique = isset($field['unique']) && $field['unique'] ? |
|
1411
|
|
|
' ' . $this->getUniqueFieldDeclarationSQL() : ''; |
|
1412
|
|
|
|
|
1413
|
|
|
$check = isset($field['check']) && $field['check'] ? |
|
1414
|
|
|
' ' . $field['check'] : ''; |
|
1415
|
|
|
|
|
1416
|
|
|
$typeDecl = $field['type']->getSQLDeclaration($field, $this); |
|
1417
|
|
|
$columnDef = $typeDecl . $collation . $notnull . $unique . $check; |
|
1418
|
|
|
} |
|
1419
|
|
|
|
|
1420
|
|
|
return $name . ' ' . $columnDef; |
|
1421
|
|
|
} |
|
1422
|
|
|
|
|
1423
|
|
|
protected function getLikeWildcardCharacters() : string |
|
1424
|
|
|
{ |
|
1425
|
|
|
return parent::getLikeWildcardCharacters() . '[]^'; |
|
1426
|
|
|
} |
|
1427
|
|
|
|
|
1428
|
|
|
/** |
|
1429
|
|
|
* Returns a unique default constraint name for a table and column. |
|
1430
|
|
|
* |
|
1431
|
|
|
* @param string $table Name of the table to generate the unique default constraint name for. |
|
1432
|
|
|
* @param string $column Name of the column in the table to generate the unique default constraint name for. |
|
1433
|
|
|
*/ |
|
1434
|
|
|
private function generateDefaultConstraintName(string $table, string $column) : string |
|
1435
|
|
|
{ |
|
1436
|
|
|
return 'DF_' . $this->generateIdentifierName($table) . '_' . $this->generateIdentifierName($column); |
|
1437
|
|
|
} |
|
1438
|
|
|
|
|
1439
|
|
|
/** |
|
1440
|
|
|
* Returns a hash value for a given identifier. |
|
1441
|
|
|
* |
|
1442
|
|
|
* @param string $identifier Identifier to generate a hash value for. |
|
1443
|
|
|
*/ |
|
1444
|
|
|
private function generateIdentifierName(string $identifier) : string |
|
1445
|
|
|
{ |
|
1446
|
|
|
// Always generate name for unquoted identifiers to ensure consistency. |
|
1447
|
|
|
$identifier = new Identifier($identifier); |
|
1448
|
|
|
|
|
1449
|
|
|
return strtoupper(dechex(crc32($identifier->getName()))); |
|
1450
|
|
|
} |
|
1451
|
|
|
|
|
1452
|
|
|
protected function getCommentOnTableSQL(string $tableName, ?string $comment) : string |
|
1453
|
|
|
{ |
|
1454
|
|
|
return sprintf( |
|
1455
|
|
|
<<<'SQL' |
|
1456
|
|
|
EXEC sys.sp_addextendedproperty @name=N'MS_Description', |
|
1457
|
|
|
@value=N%s, @level0type=N'SCHEMA', @level0name=N'dbo', |
|
1458
|
|
|
@level1type=N'TABLE', @level1name=N%s |
|
1459
|
|
|
SQL |
|
1460
|
|
|
, |
|
1461
|
|
|
$this->quoteStringLiteral((string) $comment), |
|
1462
|
|
|
$this->quoteStringLiteral($tableName) |
|
1463
|
|
|
); |
|
1464
|
|
|
} |
|
1465
|
|
|
|
|
1466
|
|
|
public function getListTableMetadataSQL(string $table) : string |
|
1467
|
|
|
{ |
|
1468
|
|
|
return sprintf( |
|
1469
|
|
|
<<<'SQL' |
|
1470
|
|
|
SELECT |
|
1471
|
|
|
p.value AS [table_comment] |
|
1472
|
|
|
FROM |
|
1473
|
|
|
sys.tables AS tbl |
|
1474
|
|
|
INNER JOIN sys.extended_properties AS p ON p.major_id=tbl.object_id AND p.minor_id=0 AND p.class=1 |
|
1475
|
|
|
WHERE |
|
1476
|
|
|
(tbl.name=N%s and SCHEMA_NAME(tbl.schema_id)=N'dbo' and p.name=N'MS_Description') |
|
1477
|
|
|
SQL |
|
1478
|
|
|
, |
|
1479
|
|
|
$this->quoteStringLiteral($table) |
|
1480
|
|
|
); |
|
1481
|
|
|
} |
|
1482
|
|
|
} |
|
1483
|
|
|
|
doctrine /
dbal
