<form method="POST">
    <h3>Editing: PostgresGrammar.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 PostgresGrammar extends Grammar
{
    /**
     * All of the available clause operators.
     *
     * @var string[]
     */
    protected $operators = [
        '=', '&lt;', '&gt;', '&lt;=', '&gt;=', '&lt;&gt;', '!=',
        'like', 'not like', 'between', 'ilike', 'not ilike',
        '~', '&amp;', '|', '#', '&lt;&lt;', '&gt;&gt;', '&lt;&lt;=', '&gt;&gt;=',
        '&amp;&amp;', '@&gt;', '&lt;@', '?', '?|', '?&amp;', '||', '-', '@?', '@@', '#-',
        'is distinct from', 'is not distinct from',
    ];

    /**
     * The grammar specific bitwise operators.
     *
     * @var array
     */
    protected $bitwiseOperators = [
        '~', '&amp;', '|', '#', '&lt;&lt;', '&gt;&gt;', '&lt;&lt;=', '&gt;&gt;=',
    ];

    /**
     * {@inheritdoc}
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $where
     * @return string
     */
    protected function whereBasic(Builder $query, $where)
    {
        if (Str::contains(strtolower($where['operator']), 'like')) {
            return sprintf(
                '%s::text %s %s',
                $this-&gt;wrap($where['column']),
                $where['operator'],
                $this-&gt;parameter($where['value'])
            );
        }

        return parent::whereBasic($query, $where);
    }

    /**
     * {@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.')::bool';
    }

    /**
     * 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 $this-&gt;wrap($where['column']).'::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 $this-&gt;wrap($where['column']).'::time '.$where['operator'].' '.$value;
    }

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

        return 'extract('.$type.' from '.$this-&gt;wrap($where['column']).') '.$where['operator'].' '.$value;
    }

    /**
     * Compile a &quot;where fulltext&quot; clause.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $where
     * @return string
     */
    public function whereFullText(Builder $query, $where)
    {
        $language = $where['options']['language'] ?? 'english';

        if (! in_array($language, $this-&gt;validFullTextLanguages())) {
            $language = 'english';
        }

        $columns = collect($where['columns'])-&gt;map(function ($column) use ($language) {
            return &quot;to_tsvector('{$language}', {$this-&gt;wrap($column)})&quot;;
        })-&gt;implode(' || ');

        $mode = 'plainto_tsquery';

        if (($where['options']['mode'] ?? []) === 'phrase') {
            $mode = 'phraseto_tsquery';
        }

        if (($where['options']['mode'] ?? []) === 'websearch') {
            $mode = 'websearch_to_tsquery';
        }

        return &quot;({$columns}) @@ {$mode}('{$language}', {$this-&gt;parameter($where['value'])})&quot;;
    }

    /**
     * Get an array of valid full text languages.
     *
     * @return array
     */
    protected function validFullTextLanguages()
    {
        return [
            'simple',
            'arabic',
            'danish',
            'dutch',
            'english',
            'finnish',
            'french',
            'german',
            'hungarian',
            'indonesian',
            'irish',
            'italian',
            'lithuanian',
            'nepali',
            'norwegian',
            'portuguese',
            'romanian',
            'russian',
            'spanish',
            'swedish',
            'tamil',
            'turkish',
        ];
    }

    /**
     * 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 the query is actually performing an aggregating select, we will let that
        // compiler handle the building of the select clauses, as it will need some
        // more syntax that is best handled by that function to keep things neat.
        if (! is_null($query-&gt;aggregate)) {
            return;
        }

        if (is_array($query-&gt;distinct)) {
            $select = 'select distinct on ('.$this-&gt;columnize($query-&gt;distinct).') ';
        } elseif ($query-&gt;distinct) {
            $select = 'select distinct ';
        } else {
            $select = 'select ';
        }

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

    /**
     * Compile a &quot;JSON contains&quot; statement into SQL.
     *
     * @param  string  $column
     * @param  string  $value
     * @return string
     */
    protected function compileJsonContains($column, $value)
    {
        $column = str_replace('-&gt;&gt;', '-&gt;', $this-&gt;wrap($column));

        return '('.$column.')::jsonb @&gt; '.$value;
    }

    /**
     * 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)
    {
        $column = str_replace('-&gt;&gt;', '-&gt;', $this-&gt;wrap($column));

        return 'json_array_length(('.$column.')::json) '.$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.')::bool';
    }

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

        return $value;
    }

    /**
     * Compile an insert ignore statement into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $values
     * @return string
     */
    public function compileInsertOrIgnore(Builder $query, array $values)
    {
        return $this-&gt;compileInsert($query, $values).' on conflict do nothing';
    }

    /**
     * Compile an insert and get ID statement into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $values
     * @param  string  $sequence
     * @return string
     */
    public function compileInsertGetId(Builder $query, $values, $sequence)
    {
        return $this-&gt;compileInsert($query, $values).' returning '.$this-&gt;wrap($sequence ?: 'id');
    }

    /**
     * Compile an update statement into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $values
     * @return string
     */
    public function compileUpdate(Builder $query, array $values)
    {
        if (isset($query-&gt;joins) || isset($query-&gt;limit)) {
            return $this-&gt;compileUpdateWithJoinsOrLimit($query, $values);
        }

        return parent::compileUpdate($query, $values);
    }

    /**
     * Compile the columns for an update statement.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $values
     * @return string
     */
    protected function compileUpdateColumns(Builder $query, array $values)
    {
        return collect($values)-&gt;map(function ($value, $key) {
            $column = last(explode('.', $key));

            if ($this-&gt;isJsonSelector($key)) {
                return $this-&gt;compileJsonUpdateColumn($column, $value);
            }

            return $this-&gt;wrap($column).' = '.$this-&gt;parameter($value);
        })-&gt;implode(', ');
    }

    /**
     * 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)
    {
        $sql = $this-&gt;compileInsert($query, $values);

        $sql .= ' on conflict ('.$this-&gt;columnize($uniqueBy).') do update set ';

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

        return $sql.$columns;
    }

    /**
     * Prepares a JSON column being updated using the JSONB_SET function.
     *
     * @param  string  $key
     * @param  mixed  $value
     * @return string
     */
    protected function compileJsonUpdateColumn($key, $value)
    {
        $segments = explode('-&gt;', $key);

        $field = $this-&gt;wrap(array_shift($segments));

        $path = '\'{&quot;'.implode('&quot;,&quot;', $segments).'&quot;}\'';

        return &quot;{$field} = jsonb_set({$field}::jsonb, {$path}, {$this-&gt;parameter($value)})&quot;;
    }

    /**
     * Compile an update from statement into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $values
     * @return string
     */
    public function compileUpdateFrom(Builder $query, $values)
    {
        $table = $this-&gt;wrapTable($query-&gt;from);

        // Each one of the columns in the update statements needs to be wrapped in the
        // keyword identifiers, also a place-holder needs to be created for each of
        // the values in the list of bindings so we can make the sets statements.
        $columns = $this-&gt;compileUpdateColumns($query, $values);

        $from = '';

        if (isset($query-&gt;joins)) {
            // When using Postgres, updates with joins list the joined tables in the from
            // clause, which is different than other systems like MySQL. Here, we will
            // compile out the tables that are joined and add them to a from clause.
            $froms = collect($query-&gt;joins)-&gt;map(function ($join) {
                return $this-&gt;wrapTable($join-&gt;table);
            })-&gt;all();

            if (count($froms) &gt; 0) {
                $from = ' from '.implode(', ', $froms);
            }
        }

        $where = $this-&gt;compileUpdateWheres($query);

        return trim(&quot;update {$table} set {$columns}{$from} {$where}&quot;);
    }

    /**
     * Compile the additional where clauses for updates with joins.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return string
     */
    protected function compileUpdateWheres(Builder $query)
    {
        $baseWheres = $this-&gt;compileWheres($query);

        if (! isset($query-&gt;joins)) {
            return $baseWheres;
        }

        // Once we compile the join constraints, we will either use them as the where
        // clause or append them to the existing base where clauses. If we need to
        // strip the leading boolean we will do so when using as the only where.
        $joinWheres = $this-&gt;compileUpdateJoinWheres($query);

        if (trim($baseWheres) == '') {
            return 'where '.$this-&gt;removeLeadingBoolean($joinWheres);
        }

        return $baseWheres.' '.$joinWheres;
    }

    /**
     * Compile the &quot;join&quot; clause where clauses for an update.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return string
     */
    protected function compileUpdateJoinWheres(Builder $query)
    {
        $joinWheres = [];

        // Here we will just loop through all of the join constraints and compile them
        // all out then implode them. This should give us &quot;where&quot; like syntax after
        // everything has been built and then we will join it to the real wheres.
        foreach ($query-&gt;joins as $join) {
            foreach ($join-&gt;wheres as $where) {
                $method = &quot;where{$where['type']}&quot;;

                $joinWheres[] = $where['boolean'].' '.$this-&gt;$method($query, $where);
            }
        }

        return implode(' ', $joinWheres);
    }

    /**
     * Prepare the bindings for an update statement.
     *
     * @param  array  $bindings
     * @param  array  $values
     * @return array
     */
    public function prepareBindingsForUpdateFrom(array $bindings, array $values)
    {
        $values = collect($values)-&gt;map(function ($value, $column) {
            return is_array($value) || ($this-&gt;isJsonSelector($column) &amp;&amp; ! $this-&gt;isExpression($value))
                ? json_encode($value)
                : $value;
        })-&gt;all();

        $bindingsWithoutWhere = Arr::except($bindings, ['select', 'where']);

        return array_values(
            array_merge($values, $bindings['where'], Arr::flatten($bindingsWithoutWhere))
        );
    }

    /**
     * Compile an update statement with joins or limit into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $values
     * @return string
     */
    protected function compileUpdateWithJoinsOrLimit(Builder $query, array $values)
    {
        $table = $this-&gt;wrapTable($query-&gt;from);

        $columns = $this-&gt;compileUpdateColumns($query, $values);

        $alias = last(preg_split('/\s+as\s+/i', $query-&gt;from));

        $selectSql = $this-&gt;compileSelect($query-&gt;select($alias.'.ctid'));

        return &quot;update {$table} set {$columns} where {$this-&gt;wrap('ctid')} in ({$selectSql})&quot;;
    }

    /**
     * Prepare the bindings for an update statement.
     *
     * @param  array  $bindings
     * @param  array  $values
     * @return array
     */
    public function prepareBindingsForUpdate(array $bindings, array $values)
    {
        $values = collect($values)-&gt;map(function ($value, $column) {
            return is_array($value) || ($this-&gt;isJsonSelector($column) &amp;&amp; ! $this-&gt;isExpression($value))
                ? json_encode($value)
                : $value;
        })-&gt;all();

        $cleanBindings = Arr::except($bindings, 'select');

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

    /**
     * Compile a delete statement into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return string
     */
    public function compileDelete(Builder $query)
    {
        if (isset($query-&gt;joins) || isset($query-&gt;limit)) {
            return $this-&gt;compileDeleteWithJoinsOrLimit($query);
        }

        return parent::compileDelete($query);
    }

    /**
     * Compile a delete statement with joins or limit into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return string
     */
    protected function compileDeleteWithJoinsOrLimit(Builder $query)
    {
        $table = $this-&gt;wrapTable($query-&gt;from);

        $alias = last(preg_split('/\s+as\s+/i', $query-&gt;from));

        $selectSql = $this-&gt;compileSelect($query-&gt;select($alias.'.ctid'));

        return &quot;delete from {$table} where {$this-&gt;wrap('ctid')} in ({$selectSql})&quot;;
    }

    /**
     * Compile a truncate table statement into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return array
     */
    public function compileTruncate(Builder $query)
    {
        return ['truncate '.$this-&gt;wrapTable($query-&gt;from).' restart identity cascade' =&gt; []];
    }

    /**
     * Wrap the given JSON selector.
     *
     * @param  string  $value
     * @return string
     */
    protected function wrapJsonSelector($value)
    {
        $path = explode('-&gt;', $value);

        $field = $this-&gt;wrapSegments(explode('.', array_shift($path)));

        $wrappedPath = $this-&gt;wrapJsonPathAttributes($path);

        $attribute = array_pop($wrappedPath);

        if (! empty($wrappedPath)) {
            return $field.'-&gt;'.implode('-&gt;', $wrappedPath).'-&gt;&gt;'.$attribute;
        }

        return $field.'-&gt;&gt;'.$attribute;
    }

    /**
     * Wrap the given JSON selector for boolean values.
     *
     * @param  string  $value
     * @return string
     */
    protected function wrapJsonBooleanSelector($value)
    {
        $selector = str_replace(
            '-&gt;&gt;', '-&gt;',
            $this-&gt;wrapJsonSelector($value)
        );

        return '('.$selector.')::jsonb';
    }

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

    /**
     * Wrap the attributes of the give JSON path.
     *
     * @param  array  $path
     * @return array
     */
    protected function wrapJsonPathAttributes($path)
    {
        return array_map(function ($attribute) {
            return filter_var($attribute, FILTER_VALIDATE_INT) !== false
                        ? $attribute
                        : &quot;'$attribute'&quot;;
        }, $path);
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>