<form method="POST">
    <h3>Editing: SqlServerGrammar.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace Illuminate\Database\Query\Grammars;

use Illuminate\Database\Query\Builder;
use Illuminate\Support\Arr;
use Illuminate\Support\Str;

class SqlServerGrammar extends Grammar
{
    /**
     * All of the available clause operators.
     *
     * @var string[]
     */
    protected $operators = [
        '=', '&lt;', '&gt;', '&lt;=', '&gt;=', '!&lt;', '!&gt;', '&lt;&gt;', '!=',
        'like', 'not like', 'ilike',
        '&amp;', '&amp;=', '|', '|=', '^', '^=',
    ];

    /**
     * Compile a select query into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return string
     */
    public function compileSelect(Builder $query)
    {
        if (! $query-&gt;offset) {
            return parent::compileSelect($query);
        }

        if (is_null($query-&gt;columns)) {
            $query-&gt;columns = ['*'];
        }

        $components = $this-&gt;compileComponents($query);

        if (! empty($components['orders'])) {
            return parent::compileSelect($query).&quot; offset {$query-&gt;offset} rows fetch next {$query-&gt;limit} rows only&quot;;
        }

        // If an offset is present on the query, we will need to wrap the query in
        // a big &quot;ANSI&quot; offset syntax block. This is very nasty compared to the
        // other database systems but is necessary for implementing features.
        return $this-&gt;compileAnsiOffset(
            $query, $components
        );
    }

    /**
     * Compile the &quot;select *&quot; portion of the query.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $columns
     * @return string|null
     */
    protected function compileColumns(Builder $query, $columns)
    {
        if (! is_null($query-&gt;aggregate)) {
            return;
        }

        $select = $query-&gt;distinct ? 'select distinct ' : 'select ';

        // If there is a limit on the query, but not an offset, we will add the top
        // clause to the query, which serves as a &quot;limit&quot; type clause within the
        // SQL Server system similar to the limit keywords available in MySQL.
        if (is_numeric($query-&gt;limit) &amp;&amp; $query-&gt;limit &gt; 0 &amp;&amp; $query-&gt;offset &lt;= 0) {
            $select .= 'top '.((int) $query-&gt;limit).' ';
        }

        return $select.$this-&gt;columnize($columns);
    }

    /**
     * Compile the &quot;from&quot; portion of the query.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  string  $table
     * @return string
     */
    protected function compileFrom(Builder $query, $table)
    {
        $from = parent::compileFrom($query, $table);

        if (is_string($query-&gt;lock)) {
            return $from.' '.$query-&gt;lock;
        }

        if (! is_null($query-&gt;lock)) {
            return $from.' with(rowlock,'.($query-&gt;lock ? 'updlock,' : '').'holdlock)';
        }

        return $from;
    }

    /**
     * {@inheritdoc}
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $where
     * @return string
     */
    protected function whereBitwise(Builder $query, $where)
    {
        $value = $this-&gt;parameter($where['value']);

        $operator = str_replace('?', '??', $where['operator']);

        return '('.$this-&gt;wrap($where['column']).' '.$operator.' '.$value.') != 0';
    }

    /**
     * Compile a &quot;where date&quot; clause.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $where
     * @return string
     */
    protected function whereDate(Builder $query, $where)
    {
        $value = $this-&gt;parameter($where['value']);

        return 'cast('.$this-&gt;wrap($where['column']).' as date) '.$where['operator'].' '.$value;
    }

    /**
     * Compile a &quot;where time&quot; clause.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $where
     * @return string
     */
    protected function whereTime(Builder $query, $where)
    {
        $value = $this-&gt;parameter($where['value']);

        return 'cast('.$this-&gt;wrap($where['column']).' as time) '.$where['operator'].' '.$value;
    }

    /**
     * Compile a &quot;JSON contains&quot; statement into SQL.
     *
     * @param  string  $column
     * @param  string  $value
     * @return string
     */
    protected function compileJsonContains($column, $value)
    {
        [$field, $path] = $this-&gt;wrapJsonFieldAndPath($column);

        return $value.' in (select [value] from openjson('.$field.$path.'))';
    }

    /**
     * Prepare the binding for a &quot;JSON contains&quot; statement.
     *
     * @param  mixed  $binding
     * @return string
     */
    public function prepareBindingForJsonContains($binding)
    {
        return is_bool($binding) ? json_encode($binding) : $binding;
    }

    /**
     * Compile a &quot;JSON length&quot; statement into SQL.
     *
     * @param  string  $column
     * @param  string  $operator
     * @param  string  $value
     * @return string
     */
    protected function compileJsonLength($column, $operator, $value)
    {
        [$field, $path] = $this-&gt;wrapJsonFieldAndPath($column);

        return '(select count(*) from openjson('.$field.$path.')) '.$operator.' '.$value;
    }

    /**
     * {@inheritdoc}
     *
     * @param  array  $having
     * @return string
     */
    protected function compileHaving(array $having)
    {
        if ($having['type'] === 'Bitwise') {
            return $this-&gt;compileHavingBitwise($having);
        }

        return parent::compileHaving($having);
    }

    /**
     * Compile a having clause involving a bitwise operator.
     *
     * @param  array  $having
     * @return string
     */
    protected function compileHavingBitwise($having)
    {
        $column = $this-&gt;wrap($having['column']);

        $parameter = $this-&gt;parameter($having['value']);

        return $having['boolean'].' ('.$column.' '.$having['operator'].' '.$parameter.') != 0';
    }

    /**
     * Create a full ANSI offset clause for the query.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $components
     * @return string
     */
    protected function compileAnsiOffset(Builder $query, $components)
    {
        // An ORDER BY clause is required to make this offset query work, so if one does
        // not exist we'll just create a dummy clause to trick the database and so it
        // does not complain about the queries for not having an &quot;order by&quot; clause.
        if (empty($components['orders'])) {
            $components['orders'] = 'order by (select 0)';
        }

        // We need to add the row number to the query so we can compare it to the offset
        // and limit values given for the statements. So we will add an expression to
        // the &quot;select&quot; that will give back the row numbers on each of the records.
        $components['columns'] .= $this-&gt;compileOver($components['orders']);

        unset($components['orders']);

        if ($this-&gt;queryOrderContainsSubquery($query)) {
            $query-&gt;bindings = $this-&gt;sortBindingsForSubqueryOrderBy($query);
        }

        // Next we need to calculate the constraints that should be placed on the query
        // to get the right offset and limit from our query but if there is no limit
        // set we will just handle the offset only since that is all that matters.
        $sql = $this-&gt;concatenate($components);

        return $this-&gt;compileTableExpression($sql, $query);
    }

    /**
     * Compile the over statement for a table expression.
     *
     * @param  string  $orderings
     * @return string
     */
    protected function compileOver($orderings)
    {
        return &quot;, row_number() over ({$orderings}) as row_num&quot;;
    }

    /**
     * Determine if the query's order by clauses contain a subquery.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return bool
     */
    protected function queryOrderContainsSubquery($query)
    {
        if (! is_array($query-&gt;orders)) {
            return false;
        }

        return Arr::first($query-&gt;orders, function ($value) {
            return $this-&gt;isExpression($value['column'] ?? null);
        }, false) !== false;
    }

    /**
     * Move the order bindings to be after the &quot;select&quot; statement to account for an order by subquery.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return array
     */
    protected function sortBindingsForSubqueryOrderBy($query)
    {
        return Arr::sort($query-&gt;bindings, function ($bindings, $key) {
            return array_search($key, ['select', 'order', 'from', 'join', 'where', 'groupBy', 'having', 'union', 'unionOrder']);
        });
    }

    /**
     * Compile a common table expression for a query.
     *
     * @param  string  $sql
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return string
     */
    protected function compileTableExpression($sql, $query)
    {
        $constraint = $this-&gt;compileRowConstraint($query);

        return &quot;select * from ({$sql}) as temp_table where row_num {$constraint} order by row_num&quot;;
    }

    /**
     * Compile the limit / offset row constraint for a query.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return string
     */
    protected function compileRowConstraint($query)
    {
        $start = (int) $query-&gt;offset + 1;

        if ($query-&gt;limit &gt; 0) {
            $finish = (int) $query-&gt;offset + (int) $query-&gt;limit;

            return &quot;between {$start} and {$finish}&quot;;
        }

        return &quot;&gt;= {$start}&quot;;
    }

    /**
     * Compile a delete statement without joins into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  string  $table
     * @param  string  $where
     * @return string
     */
    protected function compileDeleteWithoutJoins(Builder $query, $table, $where)
    {
        $sql = parent::compileDeleteWithoutJoins($query, $table, $where);

        return ! is_null($query-&gt;limit) &amp;&amp; $query-&gt;limit &gt; 0 &amp;&amp; $query-&gt;offset &lt;= 0
                        ? Str::replaceFirst('delete', 'delete top ('.$query-&gt;limit.')', $sql)
                        : $sql;
    }

    /**
     * Compile the random statement into SQL.
     *
     * @param  string  $seed
     * @return string
     */
    public function compileRandom($seed)
    {
        return 'NEWID()';
    }

    /**
     * Compile the &quot;limit&quot; portions of the query.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  int  $limit
     * @return string
     */
    protected function compileLimit(Builder $query, $limit)
    {
        return '';
    }

    /**
     * Compile the &quot;offset&quot; portions of the query.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  int  $offset
     * @return string
     */
    protected function compileOffset(Builder $query, $offset)
    {
        return '';
    }

    /**
     * Compile the lock into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  bool|string  $value
     * @return string
     */
    protected function compileLock(Builder $query, $value)
    {
        return '';
    }

    /**
     * Wrap a union subquery in parentheses.
     *
     * @param  string  $sql
     * @return string
     */
    protected function wrapUnion($sql)
    {
        return 'select * from ('.$sql.') as '.$this-&gt;wrapTable('temp_table');
    }

    /**
     * Compile an exists statement into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return string
     */
    public function compileExists(Builder $query)
    {
        $existsQuery = clone $query;

        $existsQuery-&gt;columns = [];

        return $this-&gt;compileSelect($existsQuery-&gt;selectRaw('1 [exists]')-&gt;limit(1));
    }

    /**
     * Compile an update statement with joins into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  string  $table
     * @param  string  $columns
     * @param  string  $where
     * @return string
     */
    protected function compileUpdateWithJoins(Builder $query, $table, $columns, $where)
    {
        $alias = last(explode(' as ', $table));

        $joins = $this-&gt;compileJoins($query, $query-&gt;joins);

        return &quot;update {$alias} set {$columns} from {$table} {$joins} {$where}&quot;;
    }

    /**
     * Compile an &quot;upsert&quot; statement into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $values
     * @param  array  $uniqueBy
     * @param  array  $update
     * @return string
     */
    public function compileUpsert(Builder $query, array $values, array $uniqueBy, array $update)
    {
        $columns = $this-&gt;columnize(array_keys(reset($values)));

        $sql = 'merge '.$this-&gt;wrapTable($query-&gt;from).' ';

        $parameters = collect($values)-&gt;map(function ($record) {
            return '('.$this-&gt;parameterize($record).')';
        })-&gt;implode(', ');

        $sql .= 'using (values '.$parameters.') '.$this-&gt;wrapTable('laravel_source').' ('.$columns.') ';

        $on = collect($uniqueBy)-&gt;map(function ($column) use ($query) {
            return $this-&gt;wrap('laravel_source.'.$column).' = '.$this-&gt;wrap($query-&gt;from.'.'.$column);
        })-&gt;implode(' and ');

        $sql .= 'on '.$on.' ';

        if ($update) {
            $update = collect($update)-&gt;map(function ($value, $key) {
                return is_numeric($key)
                    ? $this-&gt;wrap($value).' = '.$this-&gt;wrap('laravel_source.'.$value)
                    : $this-&gt;wrap($key).' = '.$this-&gt;parameter($value);
            })-&gt;implode(', ');

            $sql .= 'when matched then update set '.$update.' ';
        }

        $sql .= 'when not matched then insert ('.$columns.') values ('.$columns.');';

        return $sql;
    }

    /**
     * Prepare the bindings for an update statement.
     *
     * @param  array  $bindings
     * @param  array  $values
     * @return array
     */
    public function prepareBindingsForUpdate(array $bindings, array $values)
    {
        $cleanBindings = Arr::except($bindings, 'select');

        return array_values(
            array_merge($values, Arr::flatten($cleanBindings))
        );
    }

    /**
     * Compile the SQL statement to define a savepoint.
     *
     * @param  string  $name
     * @return string
     */
    public function compileSavepoint($name)
    {
        return 'SAVE TRANSACTION '.$name;
    }

    /**
     * Compile the SQL statement to execute a savepoint rollback.
     *
     * @param  string  $name
     * @return string
     */
    public function compileSavepointRollBack($name)
    {
        return 'ROLLBACK TRANSACTION '.$name;
    }

    /**
     * Get the format for database stored dates.
     *
     * @return string
     */
    public function getDateFormat()
    {
        return 'Y-m-d H:i:s.v';
    }

    /**
     * Wrap a single string in keyword identifiers.
     *
     * @param  string  $value
     * @return string
     */
    protected function wrapValue($value)
    {
        return $value === '*' ? $value : '['.str_replace(']', ']]', $value).']';
    }

    /**
     * Wrap the given JSON selector.
     *
     * @param  string  $value
     * @return string
     */
    protected function wrapJsonSelector($value)
    {
        [$field, $path] = $this-&gt;wrapJsonFieldAndPath($value);

        return 'json_value('.$field.$path.')';
    }

    /**
     * Wrap the given JSON boolean value.
     *
     * @param  string  $value
     * @return string
     */
    protected function wrapJsonBooleanValue($value)
    {
        return &quot;'&quot;.$value.&quot;'&quot;;
    }

    /**
     * Wrap a table in keyword identifiers.
     *
     * @param  \Illuminate\Database\Query\Expression|string  $table
     * @return string
     */
    public function wrapTable($table)
    {
        if (! $this-&gt;isExpression($table)) {
            return $this-&gt;wrapTableValuedFunction(parent::wrapTable($table));
        }

        return $this-&gt;getValue($table);
    }

    /**
     * Wrap a table in keyword identifiers.
     *
     * @param  string  $table
     * @return string
     */
    protected function wrapTableValuedFunction($table)
    {
        if (preg_match('/^(.+?)(\(.*?\))]$/', $table, $matches) === 1) {
            $table = $matches[1].']'.$matches[2];
        }

        return $table;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>