Completed
Pull Request — 2.11.x (#3956)
by David
14:33
created

SQLServerPlatform::doModifyLimitQuery()   B

Complexity

Conditions 6
Paths 16

Size

Total Lines 44
Code Lines 23

Duplication

Lines 0
Ratio 0 %

Code Coverage

Tests 18
CRAP Score 6.0052

Importance

Changes 0
Metric Value
eloc 23
dl 0
loc 44
ccs 18
cts 19
cp 0.9474
rs 8.9297
c 0
b 0
f 0
cc 6
nc 16
nop 3
crap 6.0052
1
<?php
2
3
namespace Doctrine\DBAL\Platforms;
4
5
use Doctrine\DBAL\LockMode;
6
use Doctrine\DBAL\Schema\Column;
7
use Doctrine\DBAL\Schema\ColumnDiff;
8
use Doctrine\DBAL\Schema\ForeignKeyConstraint;
9
use Doctrine\DBAL\Schema\Identifier;
10
use Doctrine\DBAL\Schema\Index;
11
use Doctrine\DBAL\Schema\Table;
12
use Doctrine\DBAL\Schema\TableDiff;
13
use InvalidArgumentException;
14
use function array_merge;
15
use function array_unique;
16
use function array_values;
17
use function count;
18
use function crc32;
19
use function dechex;
20
use function explode;
21
use function func_get_args;
22
use function implode;
23
use function is_array;
24
use function is_bool;
25
use function is_numeric;
26
use function is_string;
27
use function preg_match;
28
use function sprintf;
29
use function str_replace;
30
use function stripos;
31
use function stristr;
32
use function strlen;
33
use function strpos;
34
use function strtoupper;
35
use function substr;
36
use function substr_count;
37
38
/**
39
 * The SQLServerPlatform provides the behavior, features and SQL dialect of the
40
 * Microsoft SQL Server database platform.
41
 *
42
 * @deprecated Use SQL Server 2012 or newer
43
 */
44
class SQLServerPlatform extends AbstractPlatform
45
{
46
    /**
47
     * {@inheritdoc}
48
     */
49 8580
    public function getCurrentDateSQL()
50
    {
51 8580
        return $this->getConvertExpression('date', 'GETDATE()');
52
    }
53
54
    /**
55
     * {@inheritdoc}
56
     */
57 8574
    public function getCurrentTimeSQL()
58
    {
59 8574
        return $this->getConvertExpression('time', 'GETDATE()');
60
    }
61
62
    /**
63
     * Returns an expression that converts an expression of one data type to another.
64
     *
65
     * @param string $dataType   The target native data type. Alias data types cannot be used.
66
     * @param string $expression The SQL expression to convert.
67
     *
68
     * @return string
69
     */
70 8580
    private function getConvertExpression($dataType, $expression)
71
    {
72 8580
        return sprintf('CONVERT(%s, %s)', $dataType, $expression);
73
    }
74
75
    /**
76
     * {@inheritdoc}
77
     */
78 1440
    protected function getDateArithmeticIntervalExpression($date, $operator, $interval, $unit)
79
    {
80 1440
        $factorClause = '';
81
82 1440
        if ($operator === '-') {
83 1440
            $factorClause = '-1 * ';
84
        }
85
86 1440
        return 'DATEADD(' . $unit . ', ' . $factorClause . $interval . ', ' . $date . ')';
87
    }
88
89
    /**
90
     * {@inheritDoc}
91
     */
92 1408
    public function getDateDiffExpression($date1, $date2)
93
    {
94 1408
        return 'DATEDIFF(day, ' . $date2 . ',' . $date1 . ')';
95
    }
96
97
    /**
98
     * {@inheritDoc}
99
     *
100
     * Microsoft SQL Server prefers "autoincrement" identity columns
101
     * since sequences can only be emulated with a table.
102
     */
103 8070
    public function prefersIdentityColumns()
104
    {
105 8070
        return true;
106
    }
107
108
    /**
109
     * {@inheritDoc}
110
     *
111
     * Microsoft SQL Server supports this through AUTO_INCREMENT columns.
112
     */
113 1255
    public function supportsIdentityColumns()
114
    {
115 1255
        return true;
116
    }
117
118
    /**
119
     * {@inheritDoc}
120
     */
121 1503
    public function supportsReleaseSavepoints()
122
    {
123 1503
        return false;
124
    }
125
126
    /**
127
     * {@inheritdoc}
128
     */
129 1300
    public function supportsSchemas()
130
    {
131 1300
        return true;
132
    }
133
134
    /**
135
     * {@inheritdoc}
136
     */
137 1216
    public function getDefaultSchemaName()
138
    {
139 1216
        return 'dbo';
140
    }
141
142
    /**
143
     * {@inheritDoc}
144
     */
145 7116
    public function supportsColumnCollation()
146
    {
147 7116
        return true;
148
    }
149
150
    /**
151
     * {@inheritDoc}
152
     */
153 8893
    public function hasNativeGuidType()
154
    {
155 8893
        return true;
156
    }
157
158
    /**
159
     * {@inheritDoc}
160
     */
161 8655
    public function getCreateDatabaseSQL($name)
162
    {
163 8655
        return 'CREATE DATABASE ' . $name;
164
    }
165
166
    /**
167
     * {@inheritDoc}
168
     */
169 8655
    public function getDropDatabaseSQL($name)
170
    {
171 8655
        return 'DROP DATABASE ' . $name;
172
    }
173
174
    /**
175
     * {@inheritDoc}
176
     */
177 1527
    public function supportsCreateDropDatabase()
178
    {
179 1527
        return true;
180
    }
181
182
    /**
183
     * {@inheritDoc}
184
     */
185 7790
    public function getCreateSchemaSQL($schemaName)
186
    {
187 7790
        return 'CREATE SCHEMA ' . $schemaName;
188
    }
189
190
    /**
191
     * {@inheritDoc}
192
     */
193 6114
    public function getDropForeignKeySQL($foreignKey, $table)
194
    {
195 6114
        if (! $foreignKey instanceof ForeignKeyConstraint) {
196 5528
            $foreignKey = new Identifier($foreignKey);
197
        }
198
199 6114
        if (! $table instanceof Table) {
200 6114
            $table = new Identifier($table);
201
        }
202
203 6114
        $foreignKey = $foreignKey->getQuotedName($this);
204 6114
        $table      = $table->getQuotedName($this);
205
206 6114
        return 'ALTER TABLE ' . $table . ' DROP CONSTRAINT ' . $foreignKey;
207
    }
208
209
    /**
210
     * {@inheritDoc}
211
     */
212 1273
    public function getDropIndexSQL($index, $table = null)
213
    {
214 1273
        if ($index instanceof Index) {
215 1261
            $index = $index->getQuotedName($this);
216 1273
        } elseif (! is_string($index)) {
217
            throw new InvalidArgumentException('AbstractPlatform::getDropIndexSQL() expects $index parameter to be string or \Doctrine\DBAL\Schema\Index.');
218
        }
219
220 1273
        if (! isset($table)) {
221
            return 'DROP INDEX ' . $index;
222
        }
223
224 1273
        if ($table instanceof Table) {
225 1273
            $table = $table->getQuotedName($this);
226
        }
227
228 1273
        return sprintf(
229
            <<<SQL
230
IF EXISTS (SELECT * FROM sysobjects WHERE name = '%s')
231
    ALTER TABLE %s DROP CONSTRAINT %s
232
ELSE
233
    DROP INDEX %s ON %s
234
SQL
235
            ,
236 1273
            $index,
237 1273
            $table,
238 1273
            $index,
239 1273
            $index,
240 1273
            $table
241
        );
242
    }
243
244
    /**
245
     * {@inheritDoc}
246
     */
247 8770
    protected function _getCreateTableSQL($tableName, array $columns, array $options = [])
248
    {
249 8770
        $defaultConstraintsSql = [];
250 8770
        $commentsSql           = [];
251
252 8770
        $tableComment = $options['comment'] ?? null;
253 8770
        if ($tableComment !== null) {
254 1157
            $commentsSql[] = $this->getCommentOnTableSQL($tableName, $tableComment);
255
        }
256
257
        // @todo does other code breaks because of this?
258
        // force primary keys to be not null
259 8770
        foreach ($columns as &$column) {
260 8770
            if (isset($column['primary']) && $column['primary']) {
261 8098
                $column['notnull'] = true;
262
            }
263
264
            // Build default constraints SQL statements.
265 8770
            if (isset($column['default'])) {
266 7574
                $defaultConstraintsSql[] = 'ALTER TABLE ' . $tableName .
267 7574
                    ' ADD' . $this->getDefaultConstraintDeclarationSQL($tableName, $column);
268
            }
269
270 8770
            if (empty($column['comment']) && ! is_numeric($column['comment'])) {
271 8764
                continue;
272
            }
273
274 7795
            $commentsSql[] = $this->getCreateColumnCommentSQL($tableName, $column['name'], $column['comment']);
275
        }
276
277 8770
        $columnListSql = $this->getColumnDeclarationListSQL($columns);
278
279 8770
        if (isset($options['uniqueConstraints']) && ! empty($options['uniqueConstraints'])) {
280
            foreach ($options['uniqueConstraints'] as $name => $definition) {
281
                $columnListSql .= ', ' . $this->getUniqueConstraintDeclarationSQL($name, $definition);
282
            }
283
        }
284
285 8770
        if (isset($options['primary']) && ! empty($options['primary'])) {
286 8101
            $flags = '';
287 8101
            if (isset($options['primary_index']) && $options['primary_index']->hasFlag('nonclustered')) {
288 7453
                $flags = ' NONCLUSTERED';
289
            }
290 8101
            $columnListSql .= ', PRIMARY KEY' . $flags . ' (' . implode(', ', array_unique(array_values($options['primary']))) . ')';
291
        }
292
293 8770
        $query = 'CREATE TABLE ' . $tableName . ' (' . $columnListSql;
294
295 8770
        $check = $this->getCheckDeclarationSQL($columns);
296 8770
        if (! empty($check)) {
297
            $query .= ', ' . $check;
298
        }
299 8770
        $query .= ')';
300
301 8770
        $sql = [$query];
302
303 8770
        if (isset($options['indexes']) && ! empty($options['indexes'])) {
304 6725
            foreach ($options['indexes'] as $index) {
305 6725
                $sql[] = $this->getCreateIndexSQL($index, $tableName);
306
            }
307
        }
308
309 8770
        if (isset($options['foreignKeys'])) {
310 6609
            foreach ((array) $options['foreignKeys'] as $definition) {
311 6355
                $sql[] = $this->getCreateForeignKeySQL($definition, $tableName);
312
            }
313
        }
314
315 8770
        return array_merge($sql, $commentsSql, $defaultConstraintsSql);
316
    }
317
318
    /**
319
     * {@inheritDoc}
320
     */
321 7431
    public function getCreatePrimaryKeySQL(Index $index, $table)
322
    {
323 7431
        if ($table instanceof Table) {
324
            $identifier = $table->getQuotedName($this);
325
        } else {
326 7431
            $identifier = $table;
327
        }
328
329 7431
        $sql = 'ALTER TABLE ' . $identifier . ' ADD PRIMARY KEY';
330
331 7431
        if ($index->hasFlag('nonclustered')) {
332 7428
            $sql .= ' NONCLUSTERED';
333
        }
334
335 7431
        return $sql . ' (' . $this->getIndexFieldDeclarationListSQL($index) . ')';
336
    }
337
338
    /**
339
     * Returns the SQL statement for creating a column comment.
340
     *
341
     * SQL Server does not support native column comments,
342
     * therefore the extended properties functionality is used
343
     * as a workaround to store them.
344
     * The property name used to store column comments is "MS_Description"
345
     * which provides compatibility with SQL Server Management Studio,
346
     * as column comments are stored in the same property there when
347
     * specifying a column's "Description" attribute.
348
     *
349
     * @param string      $tableName  The quoted table name to which the column belongs.
350
     * @param string      $columnName The quoted column name to create the comment for.
351
     * @param string|null $comment    The column's comment.
352
     *
353
     * @return string
354
     */
355 7804
    protected function getCreateColumnCommentSQL($tableName, $columnName, $comment)
356
    {
357 7804
        if (strpos($tableName, '.') !== false) {
358 7356
            [$schemaSQL, $tableSQL] = explode('.', $tableName);
359 7356
            $schemaSQL              = $this->quoteStringLiteral($schemaSQL);
360 7356
            $tableSQL               = $this->quoteStringLiteral($tableSQL);
361
        } else {
362 7710
            $schemaSQL = "'dbo'";
363 7710
            $tableSQL  = $this->quoteStringLiteral($tableName);
364
        }
365
366 7804
        return $this->getAddExtendedPropertySQL(
367 7804
            'MS_Description',
368
            $comment,
369 7804
            'SCHEMA',
370
            $schemaSQL,
371 7804
            'TABLE',
372
            $tableSQL,
373 7804
            'COLUMN',
374
            $columnName
375
        );
376
    }
377
378
    /**
379
     * Returns the SQL snippet for declaring a default constraint.
380
     *
381
     * @param string  $table  Name of the table to return the default constraint declaration for.
382
     * @param mixed[] $column Column definition.
383
     *
384
     * @return string
385
     *
386
     * @throws InvalidArgumentException
387
     */
388 7717
    public function getDefaultConstraintDeclarationSQL($table, array $column)
389
    {
390 7717
        if (! isset($column['default'])) {
391
            throw new InvalidArgumentException("Incomplete column definition. 'default' required.");
392
        }
393
394 7717
        $columnName = new Identifier($column['name']);
395
396
        return ' CONSTRAINT ' .
397 7717
            $this->generateDefaultConstraintName($table, $column['name']) .
398 7717
            $this->getDefaultValueDeclarationSQL($column) .
399 7717
            ' FOR ' . $columnName->getQuotedName($this);
400
    }
401
402
    /**
403
     * {@inheritDoc}
404
     */
405 6106
    public function getUniqueConstraintDeclarationSQL($name, Index $index)
406
    {
407 6106
        $constraint = parent::getUniqueConstraintDeclarationSQL($name, $index);
408
409 6106
        $constraint = $this->_appendUniqueConstraintDefinition($constraint, $index);
410
411 6106
        return $constraint;
412
    }
413
414
    /**
415
     * {@inheritDoc}
416
     */
417 7884
    public function getCreateIndexSQL(Index $index, $table)
418
    {
419 7884
        $constraint = parent::getCreateIndexSQL($index, $table);
420
421 7884
        if ($index->isUnique() && ! $index->isPrimary()) {
422 6722
            $constraint = $this->_appendUniqueConstraintDefinition($constraint, $index);
423
        }
424
425 7884
        return $constraint;
426
    }
427
428
    /**
429
     * {@inheritDoc}
430
     */
431 7884
    protected function getCreateIndexSQLFlags(Index $index)
432
    {
433 7884
        $type = '';
434 7884
        if ($index->isUnique()) {
435 6722
            $type .= 'UNIQUE ';
436
        }
437
438 7884
        if ($index->hasFlag('clustered')) {
439 7478
            $type .= 'CLUSTERED ';
440 6737
        } elseif ($index->hasFlag('nonclustered')) {
441
            $type .= 'NONCLUSTERED ';
442
        }
443
444 7884
        return $type;
445
    }
446
447
    /**
448
     * Extend unique key constraint with required filters
449
     *
450
     * @param string $sql
451
     *
452
     * @return string
453
     */
454 6728
    private function _appendUniqueConstraintDefinition($sql, Index $index)
455
    {
456 6728
        $fields = [];
457
458 6728
        foreach ($index->getQuotedColumns($this) as $field) {
459 6728
            $fields[] = $field . ' IS NOT NULL';
460
        }
461
462 6728
        return $sql . ' WHERE ' . implode(' AND ', $fields);
463
    }
464
465
    /**
466
     * {@inheritDoc}
467
     */
468 7836
    public function getAlterTableSQL(TableDiff $diff)
469
    {
470 7836
        $queryParts  = [];
471 7836
        $sql         = [];
472 7836
        $columnSql   = [];
473 7836
        $commentsSql = [];
474
475 7836
        foreach ($diff->addedColumns as $column) {
476 7791
            if ($this->onSchemaAlterTableAddColumn($column, $diff, $columnSql)) {
477
                continue;
478
            }
479
480 7791
            $columnDef    = $column->toArray();
481 7791
            $queryParts[] = 'ADD ' . $this->getColumnDeclarationSQL($column->getQuotedName($this), $columnDef);
482
483 7791
            if (isset($columnDef['default'])) {
484 6912
                $queryParts[] = $this->getAlterTableAddDefaultConstraintClause($diff->name, $column);
485
            }
486
487 7791
            $comment = $this->getColumnComment($column);
488
489 7791
            if (empty($comment) && ! is_numeric($comment)) {
490 7697
                continue;
491
            }
492
493 7770
            $commentsSql[] = $this->getCreateColumnCommentSQL(
494 7770
                $diff->name,
495 7770
                $column->getQuotedName($this),
496
                $comment
497
            );
498
        }
499
500 7836
        foreach ($diff->removedColumns as $column) {
501 7706
            if ($this->onSchemaAlterTableRemoveColumn($column, $diff, $columnSql)) {
502
                continue;
503
            }
504
505 7706
            $queryParts[] = 'DROP COLUMN ' . $column->getQuotedName($this);
506
        }
507
508 7836
        foreach ($diff->changedColumns as $columnDiff) {
509 7784
            if ($this->onSchemaAlterTableChangeColumn($columnDiff, $diff, $columnSql)) {
510
                continue;
511
            }
512
513 7784
            $column     = $columnDiff->column;
514 7784
            $comment    = $this->getColumnComment($column);
515 7784
            $hasComment = ! empty($comment) || is_numeric($comment);
516
517 7784
            if ($columnDiff->fromColumn instanceof Column) {
518 7769
                $fromComment    = $this->getColumnComment($columnDiff->fromColumn);
519 7769
                $hasFromComment = ! empty($fromComment) || is_numeric($fromComment);
520
521 7769
                if ($hasFromComment && $hasComment && $fromComment !== $comment) {
522 7723
                    $commentsSql[] = $this->getAlterColumnCommentSQL(
523 7723
                        $diff->name,
524 7723
                        $column->getQuotedName($this),
525
                        $comment
526
                    );
527 7766
                } elseif ($hasFromComment && ! $hasComment) {
528 7745
                    $commentsSql[] = $this->getDropColumnCommentSQL($diff->name, $column->getQuotedName($this));
529 7697
                } elseif ($hasComment) {
530 7676
                    $commentsSql[] = $this->getCreateColumnCommentSQL(
531 7676
                        $diff->name,
532 7676
                        $column->getQuotedName($this),
533
                        $comment
534
                    );
535
                }
536
            }
537
538
            // Do not add query part if only comment has changed.
539 7784
            if ($columnDiff->hasChanged('comment') && count($columnDiff->changedProperties) === 1) {
540 7751
                continue;
541
            }
542
543 7709
            $requireDropDefaultConstraint = $this->alterColumnRequiresDropDefaultConstraint($columnDiff);
544
545 7709
            if ($requireDropDefaultConstraint) {
546 7603
                $queryParts[] = $this->getAlterTableDropDefaultConstraintClause(
547 7603
                    $diff->name,
548 7603
                    $columnDiff->oldColumnName
549
                );
550
            }
551
552 7709
            $columnDef = $column->toArray();
553
554 7709
            $queryParts[] = 'ALTER COLUMN ' .
555 7709
                    $this->getColumnDeclarationSQL($column->getQuotedName($this), $columnDef);
556
557 7709
            if (! isset($columnDef['default']) || (! $requireDropDefaultConstraint && ! $columnDiff->hasChanged('default'))) {
558 7691
                continue;
559
            }
560
561 7606
            $queryParts[] = $this->getAlterTableAddDefaultConstraintClause($diff->name, $column);
562
        }
563
564 7836
        foreach ($diff->renamedColumns as $oldColumnName => $column) {
565 7691
            if ($this->onSchemaAlterTableRenameColumn($oldColumnName, $column, $diff, $columnSql)) {
566
                continue;
567
            }
568
569 7691
            $oldColumnName = new Identifier($oldColumnName);
570
571 7691
            $sql[] = "sp_RENAME '" .
572 7691
                $diff->getName($this)->getQuotedName($this) . '.' . $oldColumnName->getQuotedName($this) .
573 7691
                "', '" . $column->getQuotedName($this) . "', 'COLUMN'";
574
575
            // Recreate default constraint with new column name if necessary (for future reference).
576 7691
            if ($column->getDefault() === null) {
577 7685
                continue;
578
            }
579
580 6117
            $queryParts[] = $this->getAlterTableDropDefaultConstraintClause(
581 6117
                $diff->name,
582 6117
                $oldColumnName->getQuotedName($this)
583
            );
584 6117
            $queryParts[] = $this->getAlterTableAddDefaultConstraintClause($diff->name, $column);
585
        }
586
587 7836
        $tableSql = [];
588
589 7836
        if ($this->onSchemaAlterTable($diff, $tableSql)) {
590
            return array_merge($tableSql, $columnSql);
591
        }
592
593 7836
        foreach ($queryParts as $query) {
594 7812
            $sql[] = 'ALTER TABLE ' . $diff->getName($this)->getQuotedName($this) . ' ' . $query;
595
        }
596
597 7836
        $sql = array_merge($sql, $commentsSql);
598
599 7836
        $newName = $diff->getNewName();
600
601 7836
        if ($newName !== false) {
602 6626
            $sql[] = "sp_RENAME '" . $diff->getName($this)->getQuotedName($this) . "', '" . $newName->getName() . "'";
603
604
            /**
605
             * Rename table's default constraints names
606
             * to match the new table name.
607
             * This is necessary to ensure that the default
608
             * constraints can be referenced in future table
609
             * alterations as the table name is encoded in
610
             * default constraints' names.
611
             */
612 6626
            $sql[] = "DECLARE @sql NVARCHAR(MAX) = N''; " .
613
                "SELECT @sql += N'EXEC sp_rename N''' + dc.name + ''', N''' " .
614 6626
                "+ REPLACE(dc.name, '" . $this->generateIdentifierName($diff->name) . "', " .
615 6626
                "'" . $this->generateIdentifierName($newName->getName()) . "') + ''', ''OBJECT'';' " .
616 6626
                'FROM sys.default_constraints dc ' .
617 6626
                'JOIN sys.tables tbl ON dc.parent_object_id = tbl.object_id ' .
618 6626
                "WHERE tbl.name = '" . $newName->getName() . "';" .
619 6626
                'EXEC sp_executesql @sql';
620
        }
621
622 7836
        $sql = array_merge(
623 7836
            $this->getPreAlterTableIndexForeignKeySQL($diff),
624 7836
            $sql,
625 7836
            $this->getPostAlterTableIndexForeignKeySQL($diff)
626
        );
627
628 7836
        return array_merge($sql, $tableSql, $columnSql);
629
    }
630
631
    /**
632
     * Returns the SQL clause for adding a default constraint in an ALTER TABLE statement.
633
     *
634
     * @param string $tableName The name of the table to generate the clause for.
635
     * @param Column $column    The column to generate the clause for.
636
     *
637
     * @return string
638
     */
639 7609
    private function getAlterTableAddDefaultConstraintClause($tableName, Column $column)
640
    {
641 7609
        $columnDef         = $column->toArray();
642 7609
        $columnDef['name'] = $column->getQuotedName($this);
643
644 7609
        return 'ADD' . $this->getDefaultConstraintDeclarationSQL($tableName, $columnDef);
645
    }
646
647
    /**
648
     * Returns the SQL clause for dropping an existing default constraint in an ALTER TABLE statement.
649
     *
650
     * @param string $tableName  The name of the table to generate the clause for.
651
     * @param string $columnName The name of the column to generate the clause for.
652
     *
653
     * @return string
654
     */
655 7606
    private function getAlterTableDropDefaultConstraintClause($tableName, $columnName)
656
    {
657 7606
        return 'DROP CONSTRAINT ' . $this->generateDefaultConstraintName($tableName, $columnName);
658
    }
659
660
    /**
661
     * Checks whether a column alteration requires dropping its default constraint first.
662
     *
663
     * Different to other database vendors SQL Server implements column default values
664
     * as constraints and therefore changes in a column's default value as well as changes
665
     * in a column's type require dropping the default constraint first before being to
666
     * alter the particular column to the new definition.
667
     *
668
     * @param ColumnDiff $columnDiff The column diff to evaluate.
669
     *
670
     * @return bool True if the column alteration requires dropping its default constraint first, false otherwise.
671
     */
672 7709
    private function alterColumnRequiresDropDefaultConstraint(ColumnDiff $columnDiff)
673
    {
674
        // We can only decide whether to drop an existing default constraint
675
        // if we know the original default value.
676 7709
        if (! $columnDiff->fromColumn instanceof Column) {
677 6037
            return false;
678
        }
679
680
        // We only need to drop an existing default constraint if we know the
681
        // column was defined with a default value before.
682 7697
        if ($columnDiff->fromColumn->getDefault() === null) {
683 7679
            return false;
684
        }
685
686
        // We need to drop an existing default constraint if the column was
687
        // defined with a default value before and it has changed.
688 7603
        if ($columnDiff->hasChanged('default')) {
689 7402
            return true;
690
        }
691
692
        // We need to drop an existing default constraint if the column was
693
        // defined with a default value before and the native column type has changed.
694 7591
        return $columnDiff->hasChanged('type') || $columnDiff->hasChanged('fixed');
695
    }
696
697
    /**
698
     * Returns the SQL statement for altering a column comment.
699
     *
700
     * SQL Server does not support native column comments,
701
     * therefore the extended properties functionality is used
702
     * as a workaround to store them.
703
     * The property name used to store column comments is "MS_Description"
704
     * which provides compatibility with SQL Server Management Studio,
705
     * as column comments are stored in the same property there when
706
     * specifying a column's "Description" attribute.
707
     *
708
     * @param string      $tableName  The quoted table name to which the column belongs.
709
     * @param string      $columnName The quoted column name to alter the comment for.
710
     * @param string|null $comment    The column's comment.
711
     *
712
     * @return string
713
     */
714 7723
    protected function getAlterColumnCommentSQL($tableName, $columnName, $comment)
715
    {
716 7723
        if (strpos($tableName, '.') !== false) {
717 7278
            [$schemaSQL, $tableSQL] = explode('.', $tableName);
718 7278
            $schemaSQL              = $this->quoteStringLiteral($schemaSQL);
719 7278
            $tableSQL               = $this->quoteStringLiteral($tableSQL);
720
        } else {
721 7676
            $schemaSQL = "'dbo'";
722 7676
            $tableSQL  = $this->quoteStringLiteral($tableName);
723
        }
724
725 7723
        return $this->getUpdateExtendedPropertySQL(
726 7723
            'MS_Description',
727
            $comment,
728 7723
            'SCHEMA',
729
            $schemaSQL,
730 7723
            'TABLE',
731
            $tableSQL,
732 7723
            'COLUMN',
733
            $columnName
734
        );
735
    }
736
737
    /**
738
     * Returns the SQL statement for dropping a column comment.
739
     *
740
     * SQL Server does not support native column comments,
741
     * therefore the extended properties functionality is used
742
     * as a workaround to store them.
743
     * The property name used to store column comments is "MS_Description"
744
     * which provides compatibility with SQL Server Management Studio,
745
     * as column comments are stored in the same property there when
746
     * specifying a column's "Description" attribute.
747
     *
748
     * @param string $tableName  The quoted table name to which the column belongs.
749
     * @param string $columnName The quoted column name to drop the comment for.
750
     *
751
     * @return string
752
     */
753 7745
    protected function getDropColumnCommentSQL($tableName, $columnName)
754
    {
755 7745
        if (strpos($tableName, '.') !== false) {
756 7303
            [$schemaSQL, $tableSQL] = explode('.', $tableName);
757 7303
            $schemaSQL              = $this->quoteStringLiteral($schemaSQL);
758 7303
            $tableSQL               = $this->quoteStringLiteral($tableSQL);
759
        } else {
760 7676
            $schemaSQL = "'dbo'";
761 7676
            $tableSQL  = $this->quoteStringLiteral($tableName);
762
        }
763
764 7745
        return $this->getDropExtendedPropertySQL(
765 7745
            'MS_Description',
766 7745
            'SCHEMA',
767
            $schemaSQL,
768 7745
            'TABLE',
769
            $tableSQL,
770 7745
            'COLUMN',
771
            $columnName
772
        );
773
    }
774
775
    /**
776
     * {@inheritdoc}
777
     */
778 6248
    protected function getRenameIndexSQL($oldIndexName, Index $index, $tableName)
779
    {
780 6248
        return [sprintf(
781 15
            "EXEC sp_RENAME N'%s.%s', N'%s', N'INDEX'",
782 6248
            $tableName,
783 6248
            $oldIndexName,
784 6248
            $index->getQuotedName($this)
785
        ),
786
        ];
787
    }
788
789
    /**
790
     * Returns the SQL statement for adding an extended property to a database object.
791
     *
792
     * @link http://msdn.microsoft.com/en-us/library/ms180047%28v=sql.90%29.aspx
793
     *
794
     * @param string      $name       The name of the property to add.
795
     * @param string|null $value      The value of the property to add.
796
     * @param string|null $level0Type The type of the object at level 0 the property belongs to.
797
     * @param string|null $level0Name The name of the object at level 0 the property belongs to.
798
     * @param string|null $level1Type The type of the object at level 1 the property belongs to.
799
     * @param string|null $level1Name The name of the object at level 1 the property belongs to.
800
     * @param string|null $level2Type The type of the object at level 2 the property belongs to.
801
     * @param string|null $level2Name The name of the object at level 2 the property belongs to.
802
     *
803
     * @return string
804
     */
805 7804
    public function getAddExtendedPropertySQL(
806
        $name,
807
        $value = null,
808
        $level0Type = null,
809
        $level0Name = null,
810
        $level1Type = null,
811
        $level1Name = null,
812
        $level2Type = null,
813
        $level2Name = null
814
    ) {
815
        return 'EXEC sp_addextendedproperty ' .
816 7804
            'N' . $this->quoteStringLiteral($name) . ', N' . $this->quoteStringLiteral((string) $value) . ', ' .
817 7804
            'N' . $this->quoteStringLiteral((string) $level0Type) . ', ' . $level0Name . ', ' .
818 7804
            'N' . $this->quoteStringLiteral((string) $level1Type) . ', ' . $level1Name . ', ' .
819 7804
            'N' . $this->quoteStringLiteral((string) $level2Type) . ', ' . $level2Name;
820
    }
821
822
    /**
823
     * Returns the SQL statement for dropping an extended property from a database object.
824
     *
825
     * @link http://technet.microsoft.com/en-gb/library/ms178595%28v=sql.90%29.aspx
826
     *
827
     * @param string      $name       The name of the property to drop.
828
     * @param string|null $level0Type The type of the object at level 0 the property belongs to.
829
     * @param string|null $level0Name The name of the object at level 0 the property belongs to.
830
     * @param string|null $level1Type The type of the object at level 1 the property belongs to.
831
     * @param string|null $level1Name The name of the object at level 1 the property belongs to.
832
     * @param string|null $level2Type The type of the object at level 2 the property belongs to.
833
     * @param string|null $level2Name The name of the object at level 2 the property belongs to.
834
     *
835
     * @return string
836
     */
837 7745
    public function getDropExtendedPropertySQL(
838
        $name,
839
        $level0Type = null,
840
        $level0Name = null,
841
        $level1Type = null,
842
        $level1Name = null,
843
        $level2Type = null,
844
        $level2Name = null
845
    ) {
846
        return 'EXEC sp_dropextendedproperty ' .
847 7745
            'N' . $this->quoteStringLiteral($name) . ', ' .
848 7745
            'N' . $this->quoteStringLiteral((string) $level0Type) . ', ' . $level0Name . ', ' .
849 7745
            'N' . $this->quoteStringLiteral((string) $level1Type) . ', ' . $level1Name . ', ' .
850 7745
            'N' . $this->quoteStringLiteral((string) $level2Type) . ', ' . $level2Name;
851
    }
852
853
    /**
854
     * Returns the SQL statement for updating an extended property of a database object.
855
     *
856
     * @link http://msdn.microsoft.com/en-us/library/ms186885%28v=sql.90%29.aspx
857
     *
858
     * @param string      $name       The name of the property to update.
859
     * @param string|null $value      The value of the property to update.
860
     * @param string|null $level0Type The type of the object at level 0 the property belongs to.
861
     * @param string|null $level0Name The name of the object at level 0 the property belongs to.
862
     * @param string|null $level1Type The type of the object at level 1 the property belongs to.
863
     * @param string|null $level1Name The name of the object at level 1 the property belongs to.
864
     * @param string|null $level2Type The type of the object at level 2 the property belongs to.
865
     * @param string|null $level2Name The name of the object at level 2 the property belongs to.
866
     *
867
     * @return string
868
     */
869 7723
    public function getUpdateExtendedPropertySQL(
870
        $name,
871
        $value = null,
872
        $level0Type = null,
873
        $level0Name = null,
874
        $level1Type = null,
875
        $level1Name = null,
876
        $level2Type = null,
877
        $level2Name = null
878
    ) {
879
        return 'EXEC sp_updateextendedproperty ' .
880 7723
            'N' . $this->quoteStringLiteral($name) . ', N' . $this->quoteStringLiteral((string) $value) . ', ' .
881 7723
            'N' . $this->quoteStringLiteral((string) $level0Type) . ', ' . $level0Name . ', ' .
882 7723
            'N' . $this->quoteStringLiteral((string) $level1Type) . ', ' . $level1Name . ', ' .
883 7723
            'N' . $this->quoteStringLiteral((string) $level2Type) . ', ' . $level2Name;
884
    }
885
886
    /**
887
     * {@inheritDoc}
888
     */
889 990
    public function getEmptyIdentityInsertSQL($quotedTableName, $quotedIdentifierColumnName)
890
    {
891 990
        return 'INSERT INTO ' . $quotedTableName . ' DEFAULT VALUES';
892
    }
893
894
    /**
895
     * {@inheritDoc}
896
     */
897
    public function getListTablesSQL()
898
    {
899
        // "sysdiagrams" table must be ignored as it's internal SQL Server table for Database Diagrams
900
        // Category 2 must be ignored as it is "MS SQL Server 'pseudo-system' object[s]" for replication
901
        return "SELECT name FROM sysobjects WHERE type = 'U' AND name != 'sysdiagrams' AND category != 2 ORDER BY name";
902
    }
903
904
    /**
905
     * {@inheritDoc}
906
     */
907 7288
    public function getListTableColumnsSQL($table, $database = null)
908
    {
909
        return "SELECT    col.name,
910
                          type.name AS type,
911
                          col.max_length AS length,
912
                          ~col.is_nullable AS notnull,
913
                          def.definition AS [default],
914
                          col.scale,
915
                          col.precision,
916
                          col.is_identity AS autoincrement,
917
                          col.collation_name AS collation,
918
                          CAST(prop.value AS NVARCHAR(MAX)) AS comment -- CAST avoids driver error for sql_variant type
919
                FROM      sys.columns AS col
920
                JOIN      sys.types AS type
921
                ON        col.user_type_id = type.user_type_id
922
                JOIN      sys.objects AS obj
923
                ON        col.object_id = obj.object_id
924
                JOIN      sys.schemas AS scm
925
                ON        obj.schema_id = scm.schema_id
926
                LEFT JOIN sys.default_constraints def
927
                ON        col.default_object_id = def.object_id
928
                AND       col.object_id = def.parent_object_id
929
                LEFT JOIN sys.extended_properties AS prop
930
                ON        obj.object_id = prop.major_id
931
                AND       col.column_id = prop.minor_id
932
                AND       prop.name = 'MS_Description'
933
                WHERE     obj.type = 'U'
934 7288
                AND       " . $this->getTableWhereClause($table, 'scm.name', 'obj.name');
935
    }
936
937
    /**
938
     * @param string      $table
939
     * @param string|null $database
940
     *
941
     * @return string
942
     */
943 7244
    public function getListTableForeignKeysSQL($table, $database = null)
0 ignored issues
show
Unused Code introduced by
The parameter $database is not used and could be removed. ( Ignorable by Annotation )

If this is a false-positive, you can also ignore this issue in your code via the ignore-unused  annotation

943
    public function getListTableForeignKeysSQL($table, /** @scrutinizer ignore-unused */ $database = null)

This check looks for parameters that have been defined for a function or method, but which are not used in the method body.

Loading history...
944
    {
945
        return 'SELECT f.name AS ForeignKey,
946
                SCHEMA_NAME (f.SCHEMA_ID) AS SchemaName,
947
                OBJECT_NAME (f.parent_object_id) AS TableName,
948
                COL_NAME (fc.parent_object_id,fc.parent_column_id) AS ColumnName,
949
                SCHEMA_NAME (o.SCHEMA_ID) ReferenceSchemaName,
950
                OBJECT_NAME (f.referenced_object_id) AS ReferenceTableName,
951
                COL_NAME(fc.referenced_object_id,fc.referenced_column_id) AS ReferenceColumnName,
952
                f.delete_referential_action_desc,
953
                f.update_referential_action_desc
954
                FROM sys.foreign_keys AS f
955
                INNER JOIN sys.foreign_key_columns AS fc
956
                INNER JOIN sys.objects AS o ON o.OBJECT_ID = fc.referenced_object_id
957
                ON f.OBJECT_ID = fc.constraint_object_id
958
                WHERE ' .
959 7244
                $this->getTableWhereClause($table, 'SCHEMA_NAME (f.schema_id)', 'OBJECT_NAME (f.parent_object_id)');
960
    }
961
962
    /**
963
     * {@inheritDoc}
964
     */
965 7200
    public function getListTableIndexesSQL($table, $currentDatabase = null)
966
    {
967
        return "SELECT idx.name AS key_name,
968
                       col.name AS column_name,
969
                       ~idx.is_unique AS non_unique,
970
                       idx.is_primary_key AS [primary],
971
                       CASE idx.type
972
                           WHEN '1' THEN 'clustered'
973
                           WHEN '2' THEN 'nonclustered'
974
                           ELSE NULL
975
                       END AS flags
976
                FROM sys.tables AS tbl
977
                JOIN sys.schemas AS scm ON tbl.schema_id = scm.schema_id
978
                JOIN sys.indexes AS idx ON tbl.object_id = idx.object_id
979
                JOIN sys.index_columns AS idxcol ON idx.object_id = idxcol.object_id AND idx.index_id = idxcol.index_id
980
                JOIN sys.columns AS col ON idxcol.object_id = col.object_id AND idxcol.column_id = col.column_id
981 7200
                WHERE " . $this->getTableWhereClause($table, 'scm.name', 'tbl.name') . '
982
                ORDER BY idx.index_id ASC, idxcol.key_ordinal ASC';
983
    }
984
985
    /**
986
     * {@inheritDoc}
987
     */
988 1255
    public function getCreateViewSQL($name, $sql)
989
    {
990 1255
        return 'CREATE VIEW ' . $name . ' AS ' . $sql;
991
    }
992
993
    /**
994
     * {@inheritDoc}
995
     */
996 1255
    public function getListViewsSQL($database)
997
    {
998 1255
        return "SELECT name FROM sysobjects WHERE type = 'V' ORDER BY name";
999
    }
1000
1001
    /**
1002
     * Returns the where clause to filter schema and table name in a query.
1003
     *
1004
     * @param string $table        The full qualified name of the table.
1005
     * @param string $schemaColumn The name of the column to compare the schema to in the where clause.
1006
     * @param string $tableColumn  The name of the column to compare the table to in the where clause.
1007
     *
1008
     * @return string
1009
     */
1010 7300
    private function getTableWhereClause($table, $schemaColumn, $tableColumn)
1011
    {
1012 7300
        if (strpos($table, '.') !== false) {
1013 7143
            [$schema, $table] = explode('.', $table);
1014 7143
            $schema           = $this->quoteStringLiteral($schema);
1015 7143
            $table            = $this->quoteStringLiteral($table);
1016
        } else {
1017 7291
            $schema = 'SCHEMA_NAME()';
1018 7291
            $table  = $this->quoteStringLiteral($table);
1019
        }
1020
1021 7300
        return sprintf('(%s = %s AND %s = %s)', $tableColumn, $table, $schemaColumn, $schema);
1022
    }
1023
1024
    /**
1025
     * {@inheritDoc}
1026
     */
1027 1255
    public function getDropViewSQL($name)
1028
    {
1029 1255
        return 'DROP VIEW ' . $name;
1030
    }
1031
1032
    /**
1033
     * {@inheritDoc}
1034
     *
1035
     * @deprecated Use application-generated UUIDs instead
1036
     */
1037
    public function getGuidExpression()
1038
    {
1039
        return 'NEWID()';
1040
    }
1041
1042
    /**
1043
     * {@inheritDoc}
1044
     */
1045 1437
    public function getLocateExpression($str, $substr, $startPos = false)
1046
    {
1047 1437
        if ($startPos === false) {
1048 1437
            return 'CHARINDEX(' . $substr . ', ' . $str . ')';
1049
        }
1050
1051 1437
        return 'CHARINDEX(' . $substr . ', ' . $str . ', ' . $startPos . ')';
1052
    }
1053
1054
    /**
1055
     * {@inheritDoc}
1056
     */
1057
    public function getModExpression($expression1, $expression2)
1058
    {
1059
        return $expression1 . ' % ' . $expression2;
1060
    }
1061
1062
    /**
1063
     * {@inheritDoc}
1064
     */
1065 1488
    public function getTrimExpression($str, $pos = TrimMode::UNSPECIFIED, $char = false)
1066
    {
1067 1488
        if (! $char) {
1068 1488
            switch ($pos) {
1069
                case TrimMode::LEADING:
1070 1485
                    $trimFn = 'LTRIM';
1071 1485
                    break;
1072
1073
                case TrimMode::TRAILING:
1074 1482
                    $trimFn = 'RTRIM';
1075 1482
                    break;
1076
1077
                default:
1078 1488
                    return 'LTRIM(RTRIM(' . $str . '))';
1079
            }
1080
1081 1485
            return $trimFn . '(' . $str . ')';
1082
        }
1083
1084
        /** Original query used to get those expressions
1085
          declare @c varchar(100) = 'xxxBarxxx', @trim_char char(1) = 'x';
1086
          declare @pat varchar(10) = '%[^' + @trim_char + ']%';
1087
          select @c as string
1088
          , @trim_char as trim_char
1089
          , stuff(@c, 1, patindex(@pat, @c) - 1, null) as trim_leading
1090
          , reverse(stuff(reverse(@c), 1, patindex(@pat, reverse(@c)) - 1, null)) as trim_trailing
1091
          , 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;
1092
         */
1093 1476
        $pattern = "'%[^' + " . $char . " + ']%'";
1094
1095 1476
        if ($pos === TrimMode::LEADING) {
1096 1473
            return 'stuff(' . $str . ', 1, patindex(' . $pattern . ', ' . $str . ') - 1, null)';
1097
        }
1098
1099 1476
        if ($pos === TrimMode::TRAILING) {
1100 1470
            return 'reverse(stuff(reverse(' . $str . '), 1, patindex(' . $pattern . ', reverse(' . $str . ')) - 1, null))';
1101
        }
1102
1103 1476
        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))';
1104
    }
1105
1106
    /**
1107
     * {@inheritDoc}
1108
     */
1109 8153
    public function getConcatExpression()
1110
    {
1111 8153
        $args = func_get_args();
1112
1113 8153
        return '(' . implode(' + ', $args) . ')';
1114
    }
1115
1116
    /**
1117
     * {@inheritDoc}
1118
     */
1119 8440
    public function getListDatabasesSQL()
1120
    {
1121 8440
        return 'SELECT * FROM sys.databases';
1122
    }
1123
1124
    /**
1125
     * {@inheritDoc}
1126
     */
1127 1297
    public function getListNamespacesSQL()
1128
    {
1129 1297
        return "SELECT name FROM sys.schemas WHERE name NOT IN('guest', 'INFORMATION_SCHEMA', 'sys')";
1130
    }
1131
1132
    /**
1133
     * {@inheritDoc}
1134
     */
1135
    public function getSubstringExpression($value, $from, $length = null)
1136
    {
1137
        if ($length !== null) {
1138
            return 'SUBSTRING(' . $value . ', ' . $from . ', ' . $length . ')';
1139
        }
1140
1141
        return 'SUBSTRING(' . $value . ', ' . $from . ', LEN(' . $value . ') - ' . $from . ' + 1)';
1142
    }
1143
1144
    /**
1145
     * {@inheritDoc}
1146
     */
1147
    public function getLengthExpression($column)
1148
    {
1149
        return 'LEN(' . $column . ')';
1150
    }
1151
1152
    /**
1153
     * {@inheritDoc}
1154
     */
1155 8128
    public function getSetTransactionIsolationSQL($level)
1156
    {
1157 8128
        return 'SET TRANSACTION ISOLATION LEVEL ' . $this->_getTransactionIsolationLevelSQL($level);
1158
    }
1159
1160
    /**
1161
     * {@inheritDoc}
1162
     */
1163 8761
    public function getIntegerTypeDeclarationSQL(array $field)
1164
    {
1165 8761
        return 'INT' . $this->_getCommonIntegerTypeDeclarationSQL($field);
1166
    }
1167
1168
    /**
1169
     * {@inheritDoc}
1170
     */
1171 1082
    public function getBigIntTypeDeclarationSQL(array $field)
1172
    {
1173 1082
        return 'BIGINT' . $this->_getCommonIntegerTypeDeclarationSQL($field);
1174
    }
1175
1176
    /**
1177
     * {@inheritDoc}
1178
     */
1179 1231
    public function getSmallIntTypeDeclarationSQL(array $field)
1180
    {
1181 1231
        return 'SMALLINT' . $this->_getCommonIntegerTypeDeclarationSQL($field);
1182
    }
1183
1184
    /**
1185
     * {@inheritDoc}
1186
     */
1187 6803
    public function getGuidTypeDeclarationSQL(array $field)
1188
    {
1189 6803
        return 'UNIQUEIDENTIFIER';
1190
    }
1191
1192
    /**
1193
     * {@inheritDoc}
1194
     */
1195 8650
    protected function getVarcharTypeDeclarationSQLSnippet($length, $fixed)
1196
    {
1197 8650
        return $fixed ? ($length ? 'NCHAR(' . $length . ')' : 'CHAR(255)') : ($length ? 'NVARCHAR(' . $length . ')' : 'NVARCHAR(255)');
1198
    }
1199
1200
    /**
1201
     * {@inheritdoc}
1202
     */
1203 7536
    protected function getBinaryTypeDeclarationSQLSnippet($length, $fixed)
1204
    {
1205 7536
        return $fixed ? 'BINARY(' . ($length ?: 255) . ')' : 'VARBINARY(' . ($length ?: 255) . ')';
1206
    }
1207
1208
    /**
1209
     * {@inheritdoc}
1210
     */
1211 7542
    public function getBinaryMaxLength()
1212
    {
1213 7542
        return 8000;
1214
    }
1215
1216
    /**
1217
     * {@inheritDoc}
1218
     */
1219 2755
    public function getClobTypeDeclarationSQL(array $field)
1220
    {
1221 2755
        return 'VARCHAR(MAX)';
1222
    }
1223
1224
    /**
1225
     * {@inheritDoc}
1226
     */
1227 8761
    protected function _getCommonIntegerTypeDeclarationSQL(array $columnDef)
1228
    {
1229 8761
        return ! empty($columnDef['autoincrement']) ? ' IDENTITY' : '';
1230
    }
1231
1232
    /**
1233
     * {@inheritDoc}
1234
     */
1235
    public function getDateTimeTypeDeclarationSQL(array $fieldDeclaration)
1236
    {
1237
        return 'DATETIME';
1238
    }
1239
1240
    /**
1241
     * {@inheritDoc}
1242
     */
1243
    public function getDateTypeDeclarationSQL(array $fieldDeclaration)
1244
    {
1245
        return 'DATETIME';
1246
    }
1247
1248
    /**
1249
     * {@inheritDoc}
1250
     */
1251
    public function getTimeTypeDeclarationSQL(array $fieldDeclaration)
1252
    {
1253
        return 'DATETIME';
1254
    }
1255
1256
    /**
1257
     * {@inheritDoc}
1258
     */
1259 6644
    public function getBooleanTypeDeclarationSQL(array $field)
1260
    {
1261 6644
        return 'BIT';
1262
    }
1263
1264
    /**
1265
     * {@inheritDoc}
1266
     */
1267 8042
    protected function doModifyLimitQuery($query, $limit, $offset = null)
1268
    {
1269 8042
        $where = [];
1270
1271 8042
        if ($offset > 0) {
1272 7954
            $where[] = sprintf('doctrine_rownum >= %d', $offset + 1);
1273
        }
1274
1275 8042
        if ($limit !== null) {
1276 8040
            $where[] = sprintf('doctrine_rownum <= %d', $offset + $limit);
1277 8040
            $top     = sprintf('TOP %d', $offset + $limit);
1278
        } else {
1279 5352
            $top = 'TOP 9223372036854775807';
1280
        }
1281
1282 8042
        if (empty($where)) {
1283 5352
            return $query;
1284
        }
1285
1286
        // We'll find a SELECT or SELECT distinct and prepend TOP n to it
1287
        // Even if the TOP n is very large, the use of a CTE will
1288
        // allow the SQL Server query planner to optimize it so it doesn't
1289
        // actually scan the entire range covered by the TOP clause.
1290 8040
        if (! preg_match('/^(\s*SELECT\s+(?:DISTINCT\s+)?)(.*)$/is', $query, $matches)) {
1291
            return $query;
1292
        }
1293
1294 8040
        $query = $matches[1] . $top . ' ' . $matches[2];
1295
1296 8040
        if (stristr($query, 'ORDER BY')) {
1297
            // Inner order by is not valid in SQL Server for our purposes
1298
            // unless it's in a TOP N subquery.
1299 7976
            $query = $this->scrubInnerOrderBy($query);
1300
        }
1301
1302
        // Build a new limited query around the original, using a CTE
1303 8040
        return sprintf(
1304
            'WITH dctrn_cte AS (%s) '
1305
            . 'SELECT * FROM ('
1306
            . 'SELECT *, ROW_NUMBER() OVER (ORDER BY (SELECT 0)) AS doctrine_rownum FROM dctrn_cte'
1307
            . ') AS doctrine_tbl '
1308 40
            . 'WHERE %s ORDER BY doctrine_rownum ASC',
1309 8040
            $query,
1310 8040
            implode(' AND ', $where)
1311
        );
1312
    }
1313
1314
    /**
1315
     * Remove ORDER BY clauses in subqueries - they're not supported by SQL Server.
1316
     * Caveat: will leave ORDER BY in TOP N subqueries.
1317
     *
1318
     * @param string $query
1319
     *
1320
     * @return string
1321
     */
1322 7976
    private function scrubInnerOrderBy($query)
1323
    {
1324 7976
        $count  = substr_count(strtoupper($query), 'ORDER BY');
1325 7976
        $offset = 0;
1326
1327 7976
        while ($count-- > 0) {
1328 7976
            $orderByPos = stripos($query, ' ORDER BY', $offset);
1329 7976
            if ($orderByPos === false) {
1330 2902
                break;
1331
            }
1332
1333 7976
            $qLen            = strlen($query);
1334 7976
            $parenCount      = 0;
1335 7976
            $currentPosition = $orderByPos;
1336
1337 7976
            while ($parenCount >= 0 && $currentPosition < $qLen) {
1338 7976
                if ($query[$currentPosition] === '(') {
1339 7652
                    $parenCount++;
1340 7976
                } elseif ($query[$currentPosition] === ')') {
1341 7814
                    $parenCount--;
1342
                }
1343
1344 7976
                $currentPosition++;
1345
            }
1346
1347 7976
            if ($this->isOrderByInTopNSubquery($query, $orderByPos)) {
1348
                // If the order by clause is in a TOP N subquery, do not remove
1349
                // it and continue iteration from the current position.
1350 7973
                $offset = $currentPosition;
1351 7973
                continue;
1352
            }
1353
1354 7810
            if ($currentPosition >= $qLen - 1) {
1355
                continue;
1356
            }
1357
1358 7810
            $query  = substr($query, 0, $orderByPos) . substr($query, $currentPosition - 1);
1359 7810
            $offset = $orderByPos;
1360
        }
1361
1362 7976
        return $query;
1363
    }
1364
1365
    /**
1366
     * Check an ORDER BY clause to see if it is in a TOP N query or subquery.
1367
     *
1368
     * @param string $query           The query
1369
     * @param int    $currentPosition Start position of ORDER BY clause
1370
     *
1371
     * @return bool true if ORDER BY is in a TOP N query, false otherwise
1372
     */
1373 7976
    private function isOrderByInTopNSubquery($query, $currentPosition)
1374
    {
1375
        // Grab query text on the same nesting level as the ORDER BY clause we're examining.
1376 7976
        $subQueryBuffer = '';
1377 7976
        $parenCount     = 0;
1378
1379
        // If $parenCount goes negative, we've exited the subquery we're examining.
1380
        // If $currentPosition goes negative, we've reached the beginning of the query.
1381 7976
        while ($parenCount >= 0 && $currentPosition >= 0) {
1382 7976
            if ($query[$currentPosition] === '(') {
1383 7817
                $parenCount--;
1384 7976
            } elseif ($query[$currentPosition] === ')') {
1385 7739
                $parenCount++;
1386
            }
1387
1388
            // Only yank query text on the same nesting level as the ORDER BY clause.
1389 7976
            $subQueryBuffer = ($parenCount === 0 ? $query[$currentPosition] : ' ') . $subQueryBuffer;
1390
1391 7976
            $currentPosition--;
1392
        }
1393
1394 7976
        return (bool) preg_match('/SELECT\s+(DISTINCT\s+)?TOP\s/i', $subQueryBuffer);
1395
    }
1396
1397
    /**
1398
     * {@inheritDoc}
1399
     */
1400 2650
    public function supportsLimitOffset()
1401
    {
1402 2650
        return false;
1403
    }
1404
1405
    /**
1406
     * {@inheritDoc}
1407
     */
1408 6644
    public function convertBooleans($item)
1409
    {
1410 6644
        if (is_array($item)) {
1411
            foreach ($item as $key => $value) {
1412
                if (! is_bool($value) && ! is_numeric($value)) {
1413
                    continue;
1414
                }
1415
1416
                $item[$key] = $value ? 1 : 0;
1417
            }
1418 6644
        } elseif (is_bool($item) || is_numeric($item)) {
1419 6644
            $item = $item ? 1 : 0;
1420
        }
1421
1422 6644
        return $item;
1423
    }
1424
1425
    /**
1426
     * {@inheritDoc}
1427
     */
1428 1088
    public function getCreateTemporaryTableSnippetSQL()
1429
    {
1430 1088
        return 'CREATE TABLE';
1431
    }
1432
1433
    /**
1434
     * {@inheritDoc}
1435
     */
1436 1088
    public function getTemporaryTableName($tableName)
1437
    {
1438 1088
        return '#' . $tableName;
1439
    }
1440
1441
    /**
1442
     * {@inheritDoc}
1443
     */
1444
    public function getDateTimeFormatString()
1445
    {
1446
        return 'Y-m-d H:i:s.000';
1447
    }
1448
1449
    /**
1450
     * {@inheritDoc}
1451
     */
1452
    public function getDateFormatString()
1453
    {
1454
        return 'Y-m-d H:i:s.000';
1455
    }
1456
1457
    /**
1458
     * {@inheritDoc}
1459
     */
1460
    public function getTimeFormatString()
1461
    {
1462
        return 'Y-m-d H:i:s.000';
1463
    }
1464
1465
    /**
1466
     * {@inheritDoc}
1467
     */
1468
    public function getDateTimeTzFormatString()
1469
    {
1470
        return $this->getDateTimeFormatString();
1471
    }
1472
1473
    /**
1474
     * {@inheritDoc}
1475
     */
1476 3838
    public function getName()
1477
    {
1478 3838
        return 'mssql';
1479
    }
1480
1481
    /**
1482
     * {@inheritDoc}
1483
     */
1484 7693
    protected function initializeDoctrineTypeMappings()
1485
    {
1486 7693
        $this->doctrineTypeMapping = [
1487
            'bigint' => 'bigint',
1488
            'numeric' => 'decimal',
1489
            'bit' => 'boolean',
1490
            'smallint' => 'smallint',
1491
            'decimal' => 'decimal',
1492
            'smallmoney' => 'integer',
1493
            'int' => 'integer',
1494
            'tinyint' => 'smallint',
1495
            'money' => 'integer',
1496
            'float' => 'float',
1497
            'real' => 'float',
1498
            'double' => 'float',
1499
            'double precision' => 'float',
1500
            'smalldatetime' => 'datetime',
1501
            'datetime' => 'datetime',
1502
            'char' => 'string',
1503
            'varchar' => 'string',
1504
            'text' => 'text',
1505
            'nchar' => 'string',
1506
            'nvarchar' => 'string',
1507
            'ntext' => 'text',
1508
            'binary' => 'binary',
1509
            'varbinary' => 'binary',
1510
            'image' => 'blob',
1511
            'uniqueidentifier' => 'guid',
1512
        ];
1513 7693
    }
1514
1515
    /**
1516
     * {@inheritDoc}
1517
     */
1518 1503
    public function createSavePoint($savepoint)
1519
    {
1520 1503
        return 'SAVE TRANSACTION ' . $savepoint;
1521
    }
1522
1523
    /**
1524
     * {@inheritDoc}
1525
     */
1526
    public function releaseSavePoint($savepoint)
1527
    {
1528
        return '';
1529
    }
1530
1531
    /**
1532
     * {@inheritDoc}
1533
     */
1534 1503
    public function rollbackSavePoint($savepoint)
1535
    {
1536 1503
        return 'ROLLBACK TRANSACTION ' . $savepoint;
1537
    }
1538
1539
    /**
1540
     * {@inheritdoc}
1541
     */
1542 7008
    public function getForeignKeyReferentialActionSQL($action)
1543
    {
1544
        // RESTRICT is not supported, therefore falling back to NO ACTION.
1545 7008
        if (strtoupper($action) === 'RESTRICT') {
1546 6428
            return 'NO ACTION';
1547
        }
1548
1549 7005
        return parent::getForeignKeyReferentialActionSQL($action);
1550
    }
1551
1552
    /**
1553
     * {@inheritDoc}
1554
     */
1555 3763
    public function appendLockHint($fromClause, $lockMode)
1556
    {
1557 3763
        switch (true) {
1558
            case $lockMode === LockMode::NONE:
1559 3001
                return $fromClause . ' WITH (NOLOCK)';
1560
1561 3762
            case $lockMode === LockMode::PESSIMISTIC_READ:
1562 2951
                return $fromClause . ' WITH (HOLDLOCK, ROWLOCK)';
1563
1564 3761
            case $lockMode === LockMode::PESSIMISTIC_WRITE:
1565 3669
                return $fromClause . ' WITH (UPDLOCK, ROWLOCK)';
1566
1567
            default:
1568 3029
                return $fromClause;
1569
        }
1570
    }
1571
1572
    /**
1573
     * {@inheritDoc}
1574
     */
1575 1094
    public function getForUpdateSQL()
1576
    {
1577 1094
        return ' ';
1578
    }
1579
1580
    /**
1581
     * {@inheritDoc}
1582
     */
1583 2337
    protected function getReservedKeywordsClass()
1584
    {
1585 2337
        return Keywords\SQLServerKeywords::class;
1586
    }
1587
1588
    /**
1589
     * {@inheritDoc}
1590
     */
1591 8204
    public function quoteSingleIdentifier($str)
1592
    {
1593 8204
        return '[' . str_replace(']', '][', $str) . ']';
1594
    }
1595
1596
    /**
1597
     * {@inheritDoc}
1598
     */
1599 6475
    public function getTruncateTableSQL($tableName, $cascade = false)
1600
    {
1601 6475
        $tableIdentifier = new Identifier($tableName);
1602
1603 6475
        return 'TRUNCATE TABLE ' . $tableIdentifier->getQuotedName($this);
1604
    }
1605
1606
    /**
1607
     * {@inheritDoc}
1608
     */
1609 7819
    public function getBlobTypeDeclarationSQL(array $field)
1610
    {
1611 7819
        return 'VARBINARY(MAX)';
1612
    }
1613
1614
    /**
1615
     * {@inheritdoc}
1616
     *
1617
     * Modifies column declaration order as it differs in Microsoft SQL Server.
1618
     */
1619 8812
    public function getColumnDeclarationSQL($name, array $field)
1620
    {
1621 8812
        if (isset($field['columnDefinition'])) {
1622 6003
            $columnDef = $this->getCustomTypeDeclarationSQL($field);
1623
        } else {
1624 8809
            $collation = isset($field['collation']) && $field['collation'] ?
1625 8809
                ' ' . $this->getColumnCollationDeclarationSQL($field['collation']) : '';
1626
1627 8809
            $notnull = isset($field['notnull']) && $field['notnull'] ? ' NOT NULL' : '';
1628
1629 8809
            $unique = isset($field['unique']) && $field['unique'] ?
1630 8809
                ' ' . $this->getUniqueFieldDeclarationSQL() : '';
1631
1632 8809
            $check = isset($field['check']) && $field['check'] ?
1633 8809
                ' ' . $field['check'] : '';
1634
1635 8809
            $typeDecl  = $field['type']->getSQLDeclaration($field, $this);
1636 8809
            $columnDef = $typeDecl . $collation . $notnull . $unique . $check;
1637
        }
1638
1639 8812
        return $name . ' ' . $columnDef;
1640
    }
1641
1642
    /**
1643
     * Returns a unique default constraint name for a table and column.
1644
     *
1645
     * @param string $table  Name of the table to generate the unique default constraint name for.
1646
     * @param string $column Name of the column in the table to generate the unique default constraint name for.
1647
     *
1648
     * @return string
1649
     */
1650 7717
    private function generateDefaultConstraintName($table, $column)
1651
    {
1652 7717
        return 'DF_' . $this->generateIdentifierName($table) . '_' . $this->generateIdentifierName($column);
1653
    }
1654
1655
    /**
1656
     * Returns a hash value for a given identifier.
1657
     *
1658
     * @param string $identifier Identifier to generate a hash value for.
1659
     *
1660
     * @return string
1661
     */
1662 7720
    private function generateIdentifierName($identifier)
1663
    {
1664
        // Always generate name for unquoted identifiers to ensure consistency.
1665 7720
        $identifier = new Identifier($identifier);
1666
1667 7720
        return strtoupper(dechex(crc32($identifier->getName())));
1668
    }
1669
1670 1157
    protected function getCommentOnTableSQL(string $tableName, ?string $comment) : string
1671
    {
1672 1157
        return sprintf(
1673
            <<<'SQL'
1674
EXEC sys.sp_addextendedproperty @name=N'MS_Description', 
1675
  @value=N%s, @level0type=N'SCHEMA', @level0name=N'dbo', 
1676
  @level1type=N'TABLE', @level1name=N%s
1677
SQL
1678
            ,
1679 1157
            $this->quoteStringLiteral((string) $comment),
1680 1157
            $this->quoteStringLiteral($tableName)
1681
        );
1682
    }
1683
1684 1342
    public function getListTableMetadataSQL(string $table) : string
1685
    {
1686 1342
        return sprintf(
1687
            <<<'SQL'
1688
SELECT
1689
  p.value AS [table_comment]
1690
FROM
1691
  sys.tables AS tbl
1692
  INNER JOIN sys.extended_properties AS p ON p.major_id=tbl.object_id AND p.minor_id=0 AND p.class=1
1693
WHERE
1694
  (tbl.name=N%s and SCHEMA_NAME(tbl.schema_id)=N'dbo' and p.name=N'MS_Description')
1695
SQL
1696
            ,
1697 1342
            $this->quoteStringLiteral($table)
1698
        );
1699
    }
1700
}
1701