Illuminate: ready. (critical)
- DB에서 illuminate를 가져올 수 있도록 설정 - 업그레이듵 불가, RootDB, DB를 직접 수정해야함
This commit is contained in:
+1287
@@ -0,0 +1,1287 @@
|
||||
<?php
|
||||
|
||||
namespace Illuminate\Database\Query\Grammars;
|
||||
|
||||
use Illuminate\Database\Grammar as BaseGrammar;
|
||||
use Illuminate\Database\Query\Builder;
|
||||
use Illuminate\Database\Query\JoinClause;
|
||||
use Illuminate\Support\Arr;
|
||||
use Illuminate\Support\Str;
|
||||
use RuntimeException;
|
||||
|
||||
class Grammar extends BaseGrammar
|
||||
{
|
||||
/**
|
||||
* The grammar specific operators.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected $operators = [];
|
||||
|
||||
/**
|
||||
* The components that make up a select clause.
|
||||
*
|
||||
* @var string[]
|
||||
*/
|
||||
protected $selectComponents = [
|
||||
'aggregate',
|
||||
'columns',
|
||||
'from',
|
||||
'joins',
|
||||
'wheres',
|
||||
'groups',
|
||||
'havings',
|
||||
'orders',
|
||||
'limit',
|
||||
'offset',
|
||||
'lock',
|
||||
];
|
||||
|
||||
/**
|
||||
* Compile a select query into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @return string
|
||||
*/
|
||||
public function compileSelect(Builder $query)
|
||||
{
|
||||
if (($query->unions || $query->havings) && $query->aggregate) {
|
||||
return $this->compileUnionAggregate($query);
|
||||
}
|
||||
|
||||
// If the query does not have any columns set, we'll set the columns to the
|
||||
// * character to just get all of the columns from the database. Then we
|
||||
// can build the query and concatenate all the pieces together as one.
|
||||
$original = $query->columns;
|
||||
|
||||
if (is_null($query->columns)) {
|
||||
$query->columns = ['*'];
|
||||
}
|
||||
|
||||
// To compile the query, we'll spin through each component of the query and
|
||||
// see if that component exists. If it does we'll just call the compiler
|
||||
// function for the component which is responsible for making the SQL.
|
||||
$sql = trim($this->concatenate(
|
||||
$this->compileComponents($query))
|
||||
);
|
||||
|
||||
if ($query->unions) {
|
||||
$sql = $this->wrapUnion($sql).' '.$this->compileUnions($query);
|
||||
}
|
||||
|
||||
$query->columns = $original;
|
||||
|
||||
return $sql;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the components necessary for a select clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @return array
|
||||
*/
|
||||
protected function compileComponents(Builder $query)
|
||||
{
|
||||
$sql = [];
|
||||
|
||||
foreach ($this->selectComponents as $component) {
|
||||
if (isset($query->$component)) {
|
||||
$method = 'compile'.ucfirst($component);
|
||||
|
||||
$sql[$component] = $this->$method($query, $query->$component);
|
||||
}
|
||||
}
|
||||
|
||||
return $sql;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile an aggregated select clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $aggregate
|
||||
* @return string
|
||||
*/
|
||||
protected function compileAggregate(Builder $query, $aggregate)
|
||||
{
|
||||
$column = $this->columnize($aggregate['columns']);
|
||||
|
||||
// If the query has a "distinct" constraint and we're not asking for all columns
|
||||
// we need to prepend "distinct" onto the column name so that the query takes
|
||||
// it into account when it performs the aggregating operations on the data.
|
||||
if (is_array($query->distinct)) {
|
||||
$column = 'distinct '.$this->columnize($query->distinct);
|
||||
} elseif ($query->distinct && $column !== '*') {
|
||||
$column = 'distinct '.$column;
|
||||
}
|
||||
|
||||
return 'select '.$aggregate['function'].'('.$column.') as aggregate';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the "select *" 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->aggregate)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ($query->distinct) {
|
||||
$select = 'select distinct ';
|
||||
} else {
|
||||
$select = 'select ';
|
||||
}
|
||||
|
||||
return $select.$this->columnize($columns);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the "from" portion of the query.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param string $table
|
||||
* @return string
|
||||
*/
|
||||
protected function compileFrom(Builder $query, $table)
|
||||
{
|
||||
return 'from '.$this->wrapTable($table);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the "join" portions of the query.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $joins
|
||||
* @return string
|
||||
*/
|
||||
protected function compileJoins(Builder $query, $joins)
|
||||
{
|
||||
return collect($joins)->map(function ($join) use ($query) {
|
||||
$table = $this->wrapTable($join->table);
|
||||
|
||||
$nestedJoins = is_null($join->joins) ? '' : ' '.$this->compileJoins($query, $join->joins);
|
||||
|
||||
$tableAndNestedJoins = is_null($join->joins) ? $table : '('.$table.$nestedJoins.')';
|
||||
|
||||
return trim("{$join->type} join {$tableAndNestedJoins} {$this->compileWheres($join)}");
|
||||
})->implode(' ');
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the "where" portions of the query.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @return string
|
||||
*/
|
||||
public function compileWheres(Builder $query)
|
||||
{
|
||||
// Each type of where clauses has its own compiler function which is responsible
|
||||
// for actually creating the where clauses SQL. This helps keep the code nice
|
||||
// and maintainable since each clause has a very small method that it uses.
|
||||
if (is_null($query->wheres)) {
|
||||
return '';
|
||||
}
|
||||
|
||||
// If we actually have some where clauses, we will strip off the first boolean
|
||||
// operator, which is added by the query builders for convenience so we can
|
||||
// avoid checking for the first clauses in each of the compilers methods.
|
||||
if (count($sql = $this->compileWheresToArray($query)) > 0) {
|
||||
return $this->concatenateWhereClauses($query, $sql);
|
||||
}
|
||||
|
||||
return '';
|
||||
}
|
||||
|
||||
/**
|
||||
* Get an array of all the where clauses for the query.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @return array
|
||||
*/
|
||||
protected function compileWheresToArray($query)
|
||||
{
|
||||
return collect($query->wheres)->map(function ($where) use ($query) {
|
||||
return $where['boolean'].' '.$this->{"where{$where['type']}"}($query, $where);
|
||||
})->all();
|
||||
}
|
||||
|
||||
/**
|
||||
* Format the where clause statements into one string.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $sql
|
||||
* @return string
|
||||
*/
|
||||
protected function concatenateWhereClauses($query, $sql)
|
||||
{
|
||||
$conjunction = $query instanceof JoinClause ? 'on' : 'where';
|
||||
|
||||
return $conjunction.' '.$this->removeLeadingBoolean(implode(' ', $sql));
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a raw where clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereRaw(Builder $query, $where)
|
||||
{
|
||||
return $where['sql'];
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a basic where clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereBasic(Builder $query, $where)
|
||||
{
|
||||
$value = $this->parameter($where['value']);
|
||||
|
||||
$operator = str_replace('?', '??', $where['operator']);
|
||||
|
||||
return $this->wrap($where['column']).' '.$operator.' '.$value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where in" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereIn(Builder $query, $where)
|
||||
{
|
||||
if (! empty($where['values'])) {
|
||||
return $this->wrap($where['column']).' in ('.$this->parameterize($where['values']).')';
|
||||
}
|
||||
|
||||
return '0 = 1';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where not in" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereNotIn(Builder $query, $where)
|
||||
{
|
||||
if (! empty($where['values'])) {
|
||||
return $this->wrap($where['column']).' not in ('.$this->parameterize($where['values']).')';
|
||||
}
|
||||
|
||||
return '1 = 1';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where not in raw" clause.
|
||||
*
|
||||
* For safety, whereIntegerInRaw ensures this method is only used with integer values.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereNotInRaw(Builder $query, $where)
|
||||
{
|
||||
if (! empty($where['values'])) {
|
||||
return $this->wrap($where['column']).' not in ('.implode(', ', $where['values']).')';
|
||||
}
|
||||
|
||||
return '1 = 1';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where in raw" clause.
|
||||
*
|
||||
* For safety, whereIntegerInRaw ensures this method is only used with integer values.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereInRaw(Builder $query, $where)
|
||||
{
|
||||
if (! empty($where['values'])) {
|
||||
return $this->wrap($where['column']).' in ('.implode(', ', $where['values']).')';
|
||||
}
|
||||
|
||||
return '0 = 1';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where null" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereNull(Builder $query, $where)
|
||||
{
|
||||
return $this->wrap($where['column']).' is null';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where not null" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereNotNull(Builder $query, $where)
|
||||
{
|
||||
return $this->wrap($where['column']).' is not null';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "between" where clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereBetween(Builder $query, $where)
|
||||
{
|
||||
$between = $where['not'] ? 'not between' : 'between';
|
||||
|
||||
$min = $this->parameter(reset($where['values']));
|
||||
|
||||
$max = $this->parameter(end($where['values']));
|
||||
|
||||
return $this->wrap($where['column']).' '.$between.' '.$min.' and '.$max;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "between" where clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereBetweenColumns(Builder $query, $where)
|
||||
{
|
||||
$between = $where['not'] ? 'not between' : 'between';
|
||||
|
||||
$min = $this->wrap(reset($where['values']));
|
||||
|
||||
$max = $this->wrap(end($where['values']));
|
||||
|
||||
return $this->wrap($where['column']).' '.$between.' '.$min.' and '.$max;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where date" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereDate(Builder $query, $where)
|
||||
{
|
||||
return $this->dateBasedWhere('date', $query, $where);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where time" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereTime(Builder $query, $where)
|
||||
{
|
||||
return $this->dateBasedWhere('time', $query, $where);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where day" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereDay(Builder $query, $where)
|
||||
{
|
||||
return $this->dateBasedWhere('day', $query, $where);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where month" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereMonth(Builder $query, $where)
|
||||
{
|
||||
return $this->dateBasedWhere('month', $query, $where);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where year" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereYear(Builder $query, $where)
|
||||
{
|
||||
return $this->dateBasedWhere('year', $query, $where);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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->parameter($where['value']);
|
||||
|
||||
return $type.'('.$this->wrap($where['column']).') '.$where['operator'].' '.$value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a where clause comparing two columns.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereColumn(Builder $query, $where)
|
||||
{
|
||||
return $this->wrap($where['first']).' '.$where['operator'].' '.$this->wrap($where['second']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a nested where clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereNested(Builder $query, $where)
|
||||
{
|
||||
// Here we will calculate what portion of the string we need to remove. If this
|
||||
// is a join clause query, we need to remove the "on" portion of the SQL and
|
||||
// if it is a normal query we need to take the leading "where" of queries.
|
||||
$offset = $query instanceof JoinClause ? 3 : 6;
|
||||
|
||||
return '('.substr($this->compileWheres($where['query']), $offset).')';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a where condition with a sub-select.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereSub(Builder $query, $where)
|
||||
{
|
||||
$select = $this->compileSelect($where['query']);
|
||||
|
||||
return $this->wrap($where['column']).' '.$where['operator']." ($select)";
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a where exists clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereExists(Builder $query, $where)
|
||||
{
|
||||
return 'exists ('.$this->compileSelect($where['query']).')';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a where exists clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereNotExists(Builder $query, $where)
|
||||
{
|
||||
return 'not exists ('.$this->compileSelect($where['query']).')';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a where row values condition.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereRowValues(Builder $query, $where)
|
||||
{
|
||||
$columns = $this->columnize($where['columns']);
|
||||
|
||||
$values = $this->parameterize($where['values']);
|
||||
|
||||
return '('.$columns.') '.$where['operator'].' ('.$values.')';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where JSON boolean" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereJsonBoolean(Builder $query, $where)
|
||||
{
|
||||
$column = $this->wrapJsonBooleanSelector($where['column']);
|
||||
|
||||
$value = $this->wrapJsonBooleanValue(
|
||||
$this->parameter($where['value'])
|
||||
);
|
||||
|
||||
return $column.' '.$where['operator'].' '.$value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where JSON contains" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereJsonContains(Builder $query, $where)
|
||||
{
|
||||
$not = $where['not'] ? 'not ' : '';
|
||||
|
||||
return $not.$this->compileJsonContains(
|
||||
$where['column'], $this->parameter($where['value'])
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "JSON contains" statement into SQL.
|
||||
*
|
||||
* @param string $column
|
||||
* @param string $value
|
||||
* @return string
|
||||
*
|
||||
* @throws \RuntimeException
|
||||
*/
|
||||
protected function compileJsonContains($column, $value)
|
||||
{
|
||||
throw new RuntimeException('This database engine does not support JSON contains operations.');
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepare the binding for a "JSON contains" statement.
|
||||
*
|
||||
* @param mixed $binding
|
||||
* @return string
|
||||
*/
|
||||
public function prepareBindingForJsonContains($binding)
|
||||
{
|
||||
return json_encode($binding);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where JSON length" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereJsonLength(Builder $query, $where)
|
||||
{
|
||||
return $this->compileJsonLength(
|
||||
$where['column'], $where['operator'], $this->parameter($where['value'])
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "JSON length" statement into SQL.
|
||||
*
|
||||
* @param string $column
|
||||
* @param string $operator
|
||||
* @param string $value
|
||||
* @return string
|
||||
*
|
||||
* @throws \RuntimeException
|
||||
*/
|
||||
protected function compileJsonLength($column, $operator, $value)
|
||||
{
|
||||
throw new RuntimeException('This database engine does not support JSON length operations.');
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the "group by" portions of the query.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $groups
|
||||
* @return string
|
||||
*/
|
||||
protected function compileGroups(Builder $query, $groups)
|
||||
{
|
||||
return 'group by '.$this->columnize($groups);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the "having" portions of the query.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $havings
|
||||
* @return string
|
||||
*/
|
||||
protected function compileHavings(Builder $query, $havings)
|
||||
{
|
||||
$sql = implode(' ', array_map([$this, 'compileHaving'], $havings));
|
||||
|
||||
return 'having '.$this->removeLeadingBoolean($sql);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a single having clause.
|
||||
*
|
||||
* @param array $having
|
||||
* @return string
|
||||
*/
|
||||
protected function compileHaving(array $having)
|
||||
{
|
||||
// If the having clause is "raw", we can just return the clause straight away
|
||||
// without doing any more processing on it. Otherwise, we will compile the
|
||||
// clause into SQL based on the components that make it up from builder.
|
||||
if ($having['type'] === 'Raw') {
|
||||
return $having['boolean'].' '.$having['sql'];
|
||||
} elseif ($having['type'] === 'between') {
|
||||
return $this->compileHavingBetween($having);
|
||||
}
|
||||
|
||||
return $this->compileBasicHaving($having);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a basic having clause.
|
||||
*
|
||||
* @param array $having
|
||||
* @return string
|
||||
*/
|
||||
protected function compileBasicHaving($having)
|
||||
{
|
||||
$column = $this->wrap($having['column']);
|
||||
|
||||
$parameter = $this->parameter($having['value']);
|
||||
|
||||
return $having['boolean'].' '.$column.' '.$having['operator'].' '.$parameter;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "between" having clause.
|
||||
*
|
||||
* @param array $having
|
||||
* @return string
|
||||
*/
|
||||
protected function compileHavingBetween($having)
|
||||
{
|
||||
$between = $having['not'] ? 'not between' : 'between';
|
||||
|
||||
$column = $this->wrap($having['column']);
|
||||
|
||||
$min = $this->parameter(head($having['values']));
|
||||
|
||||
$max = $this->parameter(last($having['values']));
|
||||
|
||||
return $having['boolean'].' '.$column.' '.$between.' '.$min.' and '.$max;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the "order by" portions of the query.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $orders
|
||||
* @return string
|
||||
*/
|
||||
protected function compileOrders(Builder $query, $orders)
|
||||
{
|
||||
if (! empty($orders)) {
|
||||
return 'order by '.implode(', ', $this->compileOrdersToArray($query, $orders));
|
||||
}
|
||||
|
||||
return '';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the query orders to an array.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $orders
|
||||
* @return array
|
||||
*/
|
||||
protected function compileOrdersToArray(Builder $query, $orders)
|
||||
{
|
||||
return array_map(function ($order) {
|
||||
return $order['sql'] ?? $this->wrap($order['column']).' '.$order['direction'];
|
||||
}, $orders);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the random statement into SQL.
|
||||
*
|
||||
* @param string $seed
|
||||
* @return string
|
||||
*/
|
||||
public function compileRandom($seed)
|
||||
{
|
||||
return 'RANDOM()';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the "limit" portions of the query.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param int $limit
|
||||
* @return string
|
||||
*/
|
||||
protected function compileLimit(Builder $query, $limit)
|
||||
{
|
||||
return 'limit '.(int) $limit;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the "offset" portions of the query.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param int $offset
|
||||
* @return string
|
||||
*/
|
||||
protected function compileOffset(Builder $query, $offset)
|
||||
{
|
||||
return 'offset '.(int) $offset;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the "union" queries attached to the main query.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @return string
|
||||
*/
|
||||
protected function compileUnions(Builder $query)
|
||||
{
|
||||
$sql = '';
|
||||
|
||||
foreach ($query->unions as $union) {
|
||||
$sql .= $this->compileUnion($union);
|
||||
}
|
||||
|
||||
if (! empty($query->unionOrders)) {
|
||||
$sql .= ' '.$this->compileOrders($query, $query->unionOrders);
|
||||
}
|
||||
|
||||
if (isset($query->unionLimit)) {
|
||||
$sql .= ' '.$this->compileLimit($query, $query->unionLimit);
|
||||
}
|
||||
|
||||
if (isset($query->unionOffset)) {
|
||||
$sql .= ' '.$this->compileOffset($query, $query->unionOffset);
|
||||
}
|
||||
|
||||
return ltrim($sql);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a single union statement.
|
||||
*
|
||||
* @param array $union
|
||||
* @return string
|
||||
*/
|
||||
protected function compileUnion(array $union)
|
||||
{
|
||||
$conjunction = $union['all'] ? ' union all ' : ' union ';
|
||||
|
||||
return $conjunction.$this->wrapUnion($union['query']->toSql());
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap a union subquery in parentheses.
|
||||
*
|
||||
* @param string $sql
|
||||
* @return string
|
||||
*/
|
||||
protected function wrapUnion($sql)
|
||||
{
|
||||
return '('.$sql.')';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a union aggregate query into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @return string
|
||||
*/
|
||||
protected function compileUnionAggregate(Builder $query)
|
||||
{
|
||||
$sql = $this->compileAggregate($query, $query->aggregate);
|
||||
|
||||
$query->aggregate = null;
|
||||
|
||||
return $sql.' from ('.$this->compileSelect($query).') as '.$this->wrapTable('temp_table');
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile an exists statement into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @return string
|
||||
*/
|
||||
public function compileExists(Builder $query)
|
||||
{
|
||||
$select = $this->compileSelect($query);
|
||||
|
||||
return "select exists({$select}) as {$this->wrap('exists')}";
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile an insert statement into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $values
|
||||
* @return string
|
||||
*/
|
||||
public function compileInsert(Builder $query, array $values)
|
||||
{
|
||||
// Essentially we will force every insert to be treated as a batch insert which
|
||||
// simply makes creating the SQL easier for us since we can utilize the same
|
||||
// basic routine regardless of an amount of records given to us to insert.
|
||||
$table = $this->wrapTable($query->from);
|
||||
|
||||
if (empty($values)) {
|
||||
return "insert into {$table} default values";
|
||||
}
|
||||
|
||||
if (! is_array(reset($values))) {
|
||||
$values = [$values];
|
||||
}
|
||||
|
||||
$columns = $this->columnize(array_keys(reset($values)));
|
||||
|
||||
// We need to build a list of parameter place-holders of values that are bound
|
||||
// to the query. Each insert should have the exact same amount of parameter
|
||||
// bindings so we will loop through the record and parameterize them all.
|
||||
$parameters = collect($values)->map(function ($record) {
|
||||
return '('.$this->parameterize($record).')';
|
||||
})->implode(', ');
|
||||
|
||||
return "insert into $table ($columns) values $parameters";
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile an insert ignore statement into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $values
|
||||
* @return string
|
||||
*
|
||||
* @throws \RuntimeException
|
||||
*/
|
||||
public function compileInsertOrIgnore(Builder $query, array $values)
|
||||
{
|
||||
throw new RuntimeException('This database engine does not support inserting while ignoring errors.');
|
||||
}
|
||||
|
||||
/**
|
||||
* 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->compileInsert($query, $values);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile an insert statement using a subquery into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $columns
|
||||
* @param string $sql
|
||||
* @return string
|
||||
*/
|
||||
public function compileInsertUsing(Builder $query, array $columns, string $sql)
|
||||
{
|
||||
return "insert into {$this->wrapTable($query->from)} ({$this->columnize($columns)}) $sql";
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile an update statement into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $values
|
||||
* @return string
|
||||
*/
|
||||
public function compileUpdate(Builder $query, array $values)
|
||||
{
|
||||
$table = $this->wrapTable($query->from);
|
||||
|
||||
$columns = $this->compileUpdateColumns($query, $values);
|
||||
|
||||
$where = $this->compileWheres($query);
|
||||
|
||||
return trim(
|
||||
isset($query->joins)
|
||||
? $this->compileUpdateWithJoins($query, $table, $columns, $where)
|
||||
: $this->compileUpdateWithoutJoins($query, $table, $columns, $where)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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)->map(function ($value, $key) {
|
||||
return $this->wrap($key).' = '.$this->parameter($value);
|
||||
})->implode(', ');
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile an update statement without joins into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param string $table
|
||||
* @param string $columns
|
||||
* @param string $where
|
||||
* @return string
|
||||
*/
|
||||
protected function compileUpdateWithoutJoins(Builder $query, $table, $columns, $where)
|
||||
{
|
||||
return "update {$table} set {$columns} {$where}";
|
||||
}
|
||||
|
||||
/**
|
||||
* 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)
|
||||
{
|
||||
$joins = $this->compileJoins($query, $query->joins);
|
||||
|
||||
return "update {$table} {$joins} set {$columns} {$where}";
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile an "upsert" statement into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $values
|
||||
* @param array $uniqueBy
|
||||
* @param array $update
|
||||
* @return string
|
||||
*
|
||||
* @throws \RuntimeException
|
||||
*/
|
||||
public function compileUpsert(Builder $query, array $values, array $uniqueBy, array $update)
|
||||
{
|
||||
throw new RuntimeException('This database engine does not support upserts.');
|
||||
}
|
||||
|
||||
/**
|
||||
* 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', 'join']);
|
||||
|
||||
return array_values(
|
||||
array_merge($bindings['join'], $values, Arr::flatten($cleanBindings))
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a delete statement into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @return string
|
||||
*/
|
||||
public function compileDelete(Builder $query)
|
||||
{
|
||||
$table = $this->wrapTable($query->from);
|
||||
|
||||
$where = $this->compileWheres($query);
|
||||
|
||||
return trim(
|
||||
isset($query->joins)
|
||||
? $this->compileDeleteWithJoins($query, $table, $where)
|
||||
: $this->compileDeleteWithoutJoins($query, $table, $where)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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)
|
||||
{
|
||||
return "delete from {$table} {$where}";
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a delete statement with joins into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param string $table
|
||||
* @param string $where
|
||||
* @return string
|
||||
*/
|
||||
protected function compileDeleteWithJoins(Builder $query, $table, $where)
|
||||
{
|
||||
$alias = last(explode(' as ', $table));
|
||||
|
||||
$joins = $this->compileJoins($query, $query->joins);
|
||||
|
||||
return "delete {$alias} from {$table} {$joins} {$where}";
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepare the bindings for a delete statement.
|
||||
*
|
||||
* @param array $bindings
|
||||
* @return array
|
||||
*/
|
||||
public function prepareBindingsForDelete(array $bindings)
|
||||
{
|
||||
return Arr::flatten(
|
||||
Arr::except($bindings, 'select')
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a truncate table statement into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @return array
|
||||
*/
|
||||
public function compileTruncate(Builder $query)
|
||||
{
|
||||
return ['truncate table '.$this->wrapTable($query->from) => []];
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the lock into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param bool|string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function compileLock(Builder $query, $value)
|
||||
{
|
||||
return is_string($value) ? $value : '';
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine if the grammar supports savepoints.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function supportsSavepoints()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the SQL statement to define a savepoint.
|
||||
*
|
||||
* @param string $name
|
||||
* @return string
|
||||
*/
|
||||
public function compileSavepoint($name)
|
||||
{
|
||||
return 'SAVEPOINT '.$name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the SQL statement to execute a savepoint rollback.
|
||||
*
|
||||
* @param string $name
|
||||
* @return string
|
||||
*/
|
||||
public function compileSavepointRollBack($name)
|
||||
{
|
||||
return 'ROLLBACK TO SAVEPOINT '.$name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap a value in keyword identifiers.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Expression|string $value
|
||||
* @param bool $prefixAlias
|
||||
* @return string
|
||||
*/
|
||||
public function wrap($value, $prefixAlias = false)
|
||||
{
|
||||
if ($this->isExpression($value)) {
|
||||
return $this->getValue($value);
|
||||
}
|
||||
|
||||
// If the value being wrapped has a column alias we will need to separate out
|
||||
// the pieces so we can wrap each of the segments of the expression on its
|
||||
// own, and then join these both back together using the "as" connector.
|
||||
if (stripos($value, ' as ') !== false) {
|
||||
return $this->wrapAliasedValue($value, $prefixAlias);
|
||||
}
|
||||
|
||||
// If the given value is a JSON selector we will wrap it differently than a
|
||||
// traditional value. We will need to split this path and wrap each part
|
||||
// wrapped, etc. Otherwise, we will simply wrap the value as a string.
|
||||
if ($this->isJsonSelector($value)) {
|
||||
return $this->wrapJsonSelector($value);
|
||||
}
|
||||
|
||||
return $this->wrapSegments(explode('.', $value));
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap the given JSON selector.
|
||||
*
|
||||
* @param string $value
|
||||
* @return string
|
||||
*
|
||||
* @throws \RuntimeException
|
||||
*/
|
||||
protected function wrapJsonSelector($value)
|
||||
{
|
||||
throw new RuntimeException('This database engine does not support JSON operations.');
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap the given JSON selector for boolean values.
|
||||
*
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function wrapJsonBooleanSelector($value)
|
||||
{
|
||||
return $this->wrapJsonSelector($value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap the given JSON boolean value.
|
||||
*
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function wrapJsonBooleanValue($value)
|
||||
{
|
||||
return $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Split the given JSON selector into the field and the optional path and wrap them separately.
|
||||
*
|
||||
* @param string $column
|
||||
* @return array
|
||||
*/
|
||||
protected function wrapJsonFieldAndPath($column)
|
||||
{
|
||||
$parts = explode('->', $column, 2);
|
||||
|
||||
$field = $this->wrap($parts[0]);
|
||||
|
||||
$path = count($parts) > 1 ? ', '.$this->wrapJsonPath($parts[1], '->') : '';
|
||||
|
||||
return [$field, $path];
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap the given JSON path.
|
||||
*
|
||||
* @param string $value
|
||||
* @param string $delimiter
|
||||
* @return string
|
||||
*/
|
||||
protected function wrapJsonPath($value, $delimiter = '->')
|
||||
{
|
||||
$value = preg_replace("/([\\\\]+)?\\'/", "''", $value);
|
||||
|
||||
return '\'$."'.str_replace($delimiter, '"."', $value).'"\'';
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine if the given string is a JSON selector.
|
||||
*
|
||||
* @param string $value
|
||||
* @return bool
|
||||
*/
|
||||
protected function isJsonSelector($value)
|
||||
{
|
||||
return Str::contains($value, '->');
|
||||
}
|
||||
|
||||
/**
|
||||
* Concatenate an array of segments, removing empties.
|
||||
*
|
||||
* @param array $segments
|
||||
* @return string
|
||||
*/
|
||||
protected function concatenate($segments)
|
||||
{
|
||||
return implode(' ', array_filter($segments, function ($value) {
|
||||
return (string) $value !== '';
|
||||
}));
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove the leading boolean from a statement.
|
||||
*
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function removeLeadingBoolean($value)
|
||||
{
|
||||
return preg_replace('/and |or /i', '', $value, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the grammar specific operators.
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function getOperators()
|
||||
{
|
||||
return $this->operators;
|
||||
}
|
||||
}
|
||||
+305
@@ -0,0 +1,305 @@
|
||||
<?php
|
||||
|
||||
namespace Illuminate\Database\Query\Grammars;
|
||||
|
||||
use Illuminate\Database\Query\Builder;
|
||||
use Illuminate\Support\Str;
|
||||
|
||||
class MySqlGrammar extends Grammar
|
||||
{
|
||||
/**
|
||||
* The grammar specific operators.
|
||||
*
|
||||
* @var string[]
|
||||
*/
|
||||
protected $operators = ['sounds like'];
|
||||
|
||||
/**
|
||||
* Add a "where null" clause to the query.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereNull(Builder $query, $where)
|
||||
{
|
||||
if ($this->isJsonSelector($where['column'])) {
|
||||
[$field, $path] = $this->wrapJsonFieldAndPath($where['column']);
|
||||
|
||||
return '(json_extract('.$field.$path.') is null OR json_type(json_extract('.$field.$path.')) = \'NULL\')';
|
||||
}
|
||||
|
||||
return parent::whereNull($query, $where);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a "where not null" clause to the query.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereNotNull(Builder $query, $where)
|
||||
{
|
||||
if ($this->isJsonSelector($where['column'])) {
|
||||
[$field, $path] = $this->wrapJsonFieldAndPath($where['column']);
|
||||
|
||||
return '(json_extract('.$field.$path.') is not null AND json_type(json_extract('.$field.$path.')) != \'NULL\')';
|
||||
}
|
||||
|
||||
return parent::whereNotNull($query, $where);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 Str::replaceFirst('insert', 'insert ignore', $this->compileInsert($query, $values));
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "JSON contains" statement into SQL.
|
||||
*
|
||||
* @param string $column
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function compileJsonContains($column, $value)
|
||||
{
|
||||
[$field, $path] = $this->wrapJsonFieldAndPath($column);
|
||||
|
||||
return 'json_contains('.$field.', '.$value.$path.')';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "JSON length" statement into SQL.
|
||||
*
|
||||
* @param string $column
|
||||
* @param string $operator
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function compileJsonLength($column, $operator, $value)
|
||||
{
|
||||
[$field, $path] = $this->wrapJsonFieldAndPath($column);
|
||||
|
||||
return 'json_length('.$field.$path.') '.$operator.' '.$value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the random statement into SQL.
|
||||
*
|
||||
* @param string $seed
|
||||
* @return string
|
||||
*/
|
||||
public function compileRandom($seed)
|
||||
{
|
||||
return 'RAND('.$seed.')';
|
||||
}
|
||||
|
||||
/**
|
||||
* 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' : 'lock in share mode';
|
||||
}
|
||||
|
||||
return $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile an insert statement into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $values
|
||||
* @return string
|
||||
*/
|
||||
public function compileInsert(Builder $query, array $values)
|
||||
{
|
||||
if (empty($values)) {
|
||||
$values = [[]];
|
||||
}
|
||||
|
||||
return parent::compileInsert($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)->map(function ($value, $key) {
|
||||
if ($this->isJsonSelector($key)) {
|
||||
return $this->compileJsonUpdateColumn($key, $value);
|
||||
}
|
||||
|
||||
return $this->wrap($key).' = '.$this->parameter($value);
|
||||
})->implode(', ');
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile an "upsert" 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->compileInsert($query, $values).' on duplicate key update ';
|
||||
|
||||
$columns = collect($update)->map(function ($value, $key) {
|
||||
return is_numeric($key)
|
||||
? $this->wrap($value).' = values('.$this->wrap($value).')'
|
||||
: $this->wrap($key).' = '.$this->parameter($value);
|
||||
})->implode(', ');
|
||||
|
||||
return $sql.$columns;
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepare a JSON column being updated using the JSON_SET function.
|
||||
*
|
||||
* @param string $key
|
||||
* @param mixed $value
|
||||
* @return string
|
||||
*/
|
||||
protected function compileJsonUpdateColumn($key, $value)
|
||||
{
|
||||
if (is_bool($value)) {
|
||||
$value = $value ? 'true' : 'false';
|
||||
} elseif (is_array($value)) {
|
||||
$value = 'cast(? as json)';
|
||||
} else {
|
||||
$value = $this->parameter($value);
|
||||
}
|
||||
|
||||
[$field, $path] = $this->wrapJsonFieldAndPath($key);
|
||||
|
||||
return "{$field} = json_set({$field}{$path}, {$value})";
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile an update statement without joins into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param string $table
|
||||
* @param string $columns
|
||||
* @param string $where
|
||||
* @return string
|
||||
*/
|
||||
protected function compileUpdateWithoutJoins(Builder $query, $table, $columns, $where)
|
||||
{
|
||||
$sql = parent::compileUpdateWithoutJoins($query, $table, $columns, $where);
|
||||
|
||||
if (! empty($query->orders)) {
|
||||
$sql .= ' '.$this->compileOrders($query, $query->orders);
|
||||
}
|
||||
|
||||
if (isset($query->limit)) {
|
||||
$sql .= ' '.$this->compileLimit($query, $query->limit);
|
||||
}
|
||||
|
||||
return $sql;
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepare the bindings for an update statement.
|
||||
*
|
||||
* Booleans, integers, and doubles are inserted into JSON updates as raw values.
|
||||
*
|
||||
* @param array $bindings
|
||||
* @param array $values
|
||||
* @return array
|
||||
*/
|
||||
public function prepareBindingsForUpdate(array $bindings, array $values)
|
||||
{
|
||||
$values = collect($values)->reject(function ($value, $column) {
|
||||
return $this->isJsonSelector($column) && is_bool($value);
|
||||
})->map(function ($value) {
|
||||
return is_array($value) ? json_encode($value) : $value;
|
||||
})->all();
|
||||
|
||||
return parent::prepareBindingsForUpdate($bindings, $values);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a delete query that does not use joins.
|
||||
*
|
||||
* @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);
|
||||
|
||||
// When using MySQL, delete statements may contain order by statements and limits
|
||||
// so we will compile both of those here. Once we have finished compiling this
|
||||
// we will return the completed SQL statement so it will be executed for us.
|
||||
if (! empty($query->orders)) {
|
||||
$sql .= ' '.$this->compileOrders($query, $query->orders);
|
||||
}
|
||||
|
||||
if (isset($query->limit)) {
|
||||
$sql .= ' '.$this->compileLimit($query, $query->limit);
|
||||
}
|
||||
|
||||
return $sql;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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->wrapJsonFieldAndPath($value);
|
||||
|
||||
return 'json_unquote(json_extract('.$field.$path.'))';
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap the given JSON selector for boolean values.
|
||||
*
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function wrapJsonBooleanSelector($value)
|
||||
{
|
||||
[$field, $path] = $this->wrapJsonFieldAndPath($value);
|
||||
|
||||
return 'json_extract('.$field.$path.')';
|
||||
}
|
||||
}
|
||||
+412
@@ -0,0 +1,412 @@
|
||||
<?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 = [
|
||||
'=', '<', '>', '<=', '>=', '<>', '!=',
|
||||
'like', 'not like', 'between', 'ilike', 'not ilike',
|
||||
'~', '&', '|', '#', '<<', '>>', '<<=', '>>=',
|
||||
'&&', '@>', '<@', '?', '?|', '?&', '||', '-', '@?', '@@', '#-',
|
||||
'is distinct from', 'is not distinct from',
|
||||
];
|
||||
|
||||
/**
|
||||
* {@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->wrap($where['column']),
|
||||
$where['operator'],
|
||||
$this->parameter($where['value'])
|
||||
);
|
||||
}
|
||||
|
||||
return parent::whereBasic($query, $where);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where date" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereDate(Builder $query, $where)
|
||||
{
|
||||
$value = $this->parameter($where['value']);
|
||||
|
||||
return $this->wrap($where['column']).'::date '.$where['operator'].' '.$value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where time" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereTime(Builder $query, $where)
|
||||
{
|
||||
$value = $this->parameter($where['value']);
|
||||
|
||||
return $this->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->parameter($where['value']);
|
||||
|
||||
return 'extract('.$type.' from '.$this->wrap($where['column']).') '.$where['operator'].' '.$value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the "select *" 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->aggregate)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (is_array($query->distinct)) {
|
||||
$select = 'select distinct on ('.$this->columnize($query->distinct).') ';
|
||||
} elseif ($query->distinct) {
|
||||
$select = 'select distinct ';
|
||||
} else {
|
||||
$select = 'select ';
|
||||
}
|
||||
|
||||
return $select.$this->columnize($columns);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "JSON contains" statement into SQL.
|
||||
*
|
||||
* @param string $column
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function compileJsonContains($column, $value)
|
||||
{
|
||||
$column = str_replace('->>', '->', $this->wrap($column));
|
||||
|
||||
return '('.$column.')::jsonb @> '.$value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "JSON length" statement into SQL.
|
||||
*
|
||||
* @param string $column
|
||||
* @param string $operator
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function compileJsonLength($column, $operator, $value)
|
||||
{
|
||||
$column = str_replace('->>', '->', $this->wrap($column));
|
||||
|
||||
return 'json_array_length(('.$column.')::json) '.$operator.' '.$value;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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->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->compileInsert($query, $values).' returning '.$this->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->joins) || isset($query->limit)) {
|
||||
return $this->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)->map(function ($value, $key) {
|
||||
$column = last(explode('.', $key));
|
||||
|
||||
if ($this->isJsonSelector($key)) {
|
||||
return $this->compileJsonUpdateColumn($column, $value);
|
||||
}
|
||||
|
||||
return $this->wrap($column).' = '.$this->parameter($value);
|
||||
})->implode(', ');
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile an "upsert" 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->compileInsert($query, $values);
|
||||
|
||||
$sql .= ' on conflict ('.$this->columnize($uniqueBy).') do update set ';
|
||||
|
||||
$columns = collect($update)->map(function ($value, $key) {
|
||||
return is_numeric($key)
|
||||
? $this->wrap($value).' = '.$this->wrapValue('excluded').'.'.$this->wrap($value)
|
||||
: $this->wrap($key).' = '.$this->parameter($value);
|
||||
})->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('->', $key);
|
||||
|
||||
$field = $this->wrap(array_shift($segments));
|
||||
|
||||
$path = '\'{"'.implode('","', $segments).'"}\'';
|
||||
|
||||
return "{$field} = jsonb_set({$field}::jsonb, {$path}, {$this->parameter($value)})";
|
||||
}
|
||||
|
||||
/**
|
||||
* 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->wrapTable($query->from);
|
||||
|
||||
$columns = $this->compileUpdateColumns($query, $values);
|
||||
|
||||
$alias = last(preg_split('/\s+as\s+/i', $query->from));
|
||||
|
||||
$selectSql = $this->compileSelect($query->select($alias.'.ctid'));
|
||||
|
||||
return "update {$table} set {$columns} where {$this->wrap('ctid')} in ({$selectSql})";
|
||||
}
|
||||
|
||||
/**
|
||||
* 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)->map(function ($value, $column) {
|
||||
return is_array($value) || ($this->isJsonSelector($column) && ! $this->isExpression($value))
|
||||
? json_encode($value)
|
||||
: $value;
|
||||
})->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->joins) || isset($query->limit)) {
|
||||
return $this->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->wrapTable($query->from);
|
||||
|
||||
$alias = last(preg_split('/\s+as\s+/i', $query->from));
|
||||
|
||||
$selectSql = $this->compileSelect($query->select($alias.'.ctid'));
|
||||
|
||||
return "delete from {$table} where {$this->wrap('ctid')} in ({$selectSql})";
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a truncate table statement into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @return array
|
||||
*/
|
||||
public function compileTruncate(Builder $query)
|
||||
{
|
||||
return ['truncate '.$this->wrapTable($query->from).' restart identity cascade' => []];
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap the given JSON selector.
|
||||
*
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function wrapJsonSelector($value)
|
||||
{
|
||||
$path = explode('->', $value);
|
||||
|
||||
$field = $this->wrapSegments(explode('.', array_shift($path)));
|
||||
|
||||
$wrappedPath = $this->wrapJsonPathAttributes($path);
|
||||
|
||||
$attribute = array_pop($wrappedPath);
|
||||
|
||||
if (! empty($wrappedPath)) {
|
||||
return $field.'->'.implode('->', $wrappedPath).'->>'.$attribute;
|
||||
}
|
||||
|
||||
return $field.'->>'.$attribute;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap the given JSON selector for boolean values.
|
||||
*
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function wrapJsonBooleanSelector($value)
|
||||
{
|
||||
$selector = str_replace(
|
||||
'->>', '->',
|
||||
$this->wrapJsonSelector($value)
|
||||
);
|
||||
|
||||
return '('.$selector.')::jsonb';
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap the given JSON boolean value.
|
||||
*
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function wrapJsonBooleanValue($value)
|
||||
{
|
||||
return "'".$value."'::jsonb";
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
: "'$attribute'";
|
||||
}, $path);
|
||||
}
|
||||
}
|
||||
+342
@@ -0,0 +1,342 @@
|
||||
<?php
|
||||
|
||||
namespace Illuminate\Database\Query\Grammars;
|
||||
|
||||
use Illuminate\Database\Query\Builder;
|
||||
use Illuminate\Support\Arr;
|
||||
use Illuminate\Support\Str;
|
||||
|
||||
class SQLiteGrammar extends Grammar
|
||||
{
|
||||
/**
|
||||
* All of the available clause operators.
|
||||
*
|
||||
* @var string[]
|
||||
*/
|
||||
protected $operators = [
|
||||
'=', '<', '>', '<=', '>=', '<>', '!=',
|
||||
'like', 'not like', 'ilike',
|
||||
'&', '|', '<<', '>>',
|
||||
];
|
||||
|
||||
/**
|
||||
* 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.')';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where date" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereDate(Builder $query, $where)
|
||||
{
|
||||
return $this->dateBasedWhere('%Y-%m-%d', $query, $where);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where day" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereDay(Builder $query, $where)
|
||||
{
|
||||
return $this->dateBasedWhere('%d', $query, $where);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where month" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereMonth(Builder $query, $where)
|
||||
{
|
||||
return $this->dateBasedWhere('%m', $query, $where);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where year" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereYear(Builder $query, $where)
|
||||
{
|
||||
return $this->dateBasedWhere('%Y', $query, $where);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where time" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereTime(Builder $query, $where)
|
||||
{
|
||||
return $this->dateBasedWhere('%H:%M:%S', $query, $where);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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->parameter($where['value']);
|
||||
|
||||
return "strftime('{$type}', {$this->wrap($where['column'])}) {$where['operator']} cast({$value} as text)";
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "JSON length" statement into SQL.
|
||||
*
|
||||
* @param string $column
|
||||
* @param string $operator
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function compileJsonLength($column, $operator, $value)
|
||||
{
|
||||
[$field, $path] = $this->wrapJsonFieldAndPath($column);
|
||||
|
||||
return 'json_array_length('.$field.$path.') '.$operator.' '.$value;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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->joins) || isset($query->limit)) {
|
||||
return $this->compileUpdateWithJoinsOrLimit($query, $values);
|
||||
}
|
||||
|
||||
return parent::compileUpdate($query, $values);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 Str::replaceFirst('insert', 'insert or ignore', $this->compileInsert($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)
|
||||
{
|
||||
$jsonGroups = $this->groupJsonColumnsForUpdate($values);
|
||||
|
||||
return collect($values)->reject(function ($value, $key) {
|
||||
return $this->isJsonSelector($key);
|
||||
})->merge($jsonGroups)->map(function ($value, $key) use ($jsonGroups) {
|
||||
$column = last(explode('.', $key));
|
||||
|
||||
$value = isset($jsonGroups[$key]) ? $this->compileJsonPatch($column, $value) : $this->parameter($value);
|
||||
|
||||
return $this->wrap($column).' = '.$value;
|
||||
})->implode(', ');
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile an "upsert" 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->compileInsert($query, $values);
|
||||
|
||||
$sql .= ' on conflict ('.$this->columnize($uniqueBy).') do update set ';
|
||||
|
||||
$columns = collect($update)->map(function ($value, $key) {
|
||||
return is_numeric($key)
|
||||
? $this->wrap($value).' = '.$this->wrapValue('excluded').'.'.$this->wrap($value)
|
||||
: $this->wrap($key).' = '.$this->parameter($value);
|
||||
})->implode(', ');
|
||||
|
||||
return $sql.$columns;
|
||||
}
|
||||
|
||||
/**
|
||||
* Group the nested JSON columns.
|
||||
*
|
||||
* @param array $values
|
||||
* @return array
|
||||
*/
|
||||
protected function groupJsonColumnsForUpdate(array $values)
|
||||
{
|
||||
$groups = [];
|
||||
|
||||
foreach ($values as $key => $value) {
|
||||
if ($this->isJsonSelector($key)) {
|
||||
Arr::set($groups, str_replace('->', '.', Str::after($key, '.')), $value);
|
||||
}
|
||||
}
|
||||
|
||||
return $groups;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "JSON" patch statement into SQL.
|
||||
*
|
||||
* @param string $column
|
||||
* @param mixed $value
|
||||
* @return string
|
||||
*/
|
||||
protected function compileJsonPatch($column, $value)
|
||||
{
|
||||
return "json_patch(ifnull({$this->wrap($column)}, json('{}')), json({$this->parameter($value)}))";
|
||||
}
|
||||
|
||||
/**
|
||||
* 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->wrapTable($query->from);
|
||||
|
||||
$columns = $this->compileUpdateColumns($query, $values);
|
||||
|
||||
$alias = last(preg_split('/\s+as\s+/i', $query->from));
|
||||
|
||||
$selectSql = $this->compileSelect($query->select($alias.'.rowid'));
|
||||
|
||||
return "update {$table} set {$columns} where {$this->wrap('rowid')} in ({$selectSql})";
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepare the bindings for an update statement.
|
||||
*
|
||||
* @param array $bindings
|
||||
* @param array $values
|
||||
* @return array
|
||||
*/
|
||||
public function prepareBindingsForUpdate(array $bindings, array $values)
|
||||
{
|
||||
$groups = $this->groupJsonColumnsForUpdate($values);
|
||||
|
||||
$values = collect($values)->reject(function ($value, $key) {
|
||||
return $this->isJsonSelector($key);
|
||||
})->merge($groups)->map(function ($value) {
|
||||
return is_array($value) ? json_encode($value) : $value;
|
||||
})->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->joins) || isset($query->limit)) {
|
||||
return $this->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->wrapTable($query->from);
|
||||
|
||||
$alias = last(preg_split('/\s+as\s+/i', $query->from));
|
||||
|
||||
$selectSql = $this->compileSelect($query->select($alias.'.rowid'));
|
||||
|
||||
return "delete from {$table} where {$this->wrap('rowid')} in ({$selectSql})";
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a truncate table statement into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @return array
|
||||
*/
|
||||
public function compileTruncate(Builder $query)
|
||||
{
|
||||
return [
|
||||
'delete from sqlite_sequence where name = ?' => [$query->from],
|
||||
'delete from '.$this->wrapTable($query->from) => [],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap the given JSON selector.
|
||||
*
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function wrapJsonSelector($value)
|
||||
{
|
||||
[$field, $path] = $this->wrapJsonFieldAndPath($value);
|
||||
|
||||
return 'json_extract('.$field.$path.')';
|
||||
}
|
||||
}
|
||||
+532
@@ -0,0 +1,532 @@
|
||||
<?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 = [
|
||||
'=', '<', '>', '<=', '>=', '!<', '!>', '<>', '!=',
|
||||
'like', 'not like', 'ilike',
|
||||
'&', '&=', '|', '|=', '^', '^=',
|
||||
];
|
||||
|
||||
/**
|
||||
* Compile a select query into SQL.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @return string
|
||||
*/
|
||||
public function compileSelect(Builder $query)
|
||||
{
|
||||
if (! $query->offset) {
|
||||
return parent::compileSelect($query);
|
||||
}
|
||||
|
||||
// If an offset is present on the query, we will need to wrap the query in
|
||||
// a big "ANSI" offset syntax block. This is very nasty compared to the
|
||||
// other database systems but is necessary for implementing features.
|
||||
if (is_null($query->columns)) {
|
||||
$query->columns = ['*'];
|
||||
}
|
||||
|
||||
return $this->compileAnsiOffset(
|
||||
$query, $this->compileComponents($query)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the "select *" 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->aggregate)) {
|
||||
return;
|
||||
}
|
||||
|
||||
$select = $query->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 "limit" type clause within the
|
||||
// SQL Server system similar to the limit keywords available in MySQL.
|
||||
if (is_numeric($query->limit) && $query->limit > 0 && $query->offset <= 0) {
|
||||
$select .= 'top '.((int) $query->limit).' ';
|
||||
}
|
||||
|
||||
return $select.$this->columnize($columns);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the "from" 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->lock)) {
|
||||
return $from.' '.$query->lock;
|
||||
}
|
||||
|
||||
if (! is_null($query->lock)) {
|
||||
return $from.' with(rowlock,'.($query->lock ? 'updlock,' : '').'holdlock)';
|
||||
}
|
||||
|
||||
return $from;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where date" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereDate(Builder $query, $where)
|
||||
{
|
||||
$value = $this->parameter($where['value']);
|
||||
|
||||
return 'cast('.$this->wrap($where['column']).' as date) '.$where['operator'].' '.$value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "where time" clause.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param array $where
|
||||
* @return string
|
||||
*/
|
||||
protected function whereTime(Builder $query, $where)
|
||||
{
|
||||
$value = $this->parameter($where['value']);
|
||||
|
||||
return 'cast('.$this->wrap($where['column']).' as time) '.$where['operator'].' '.$value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "JSON contains" statement into SQL.
|
||||
*
|
||||
* @param string $column
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function compileJsonContains($column, $value)
|
||||
{
|
||||
[$field, $path] = $this->wrapJsonFieldAndPath($column);
|
||||
|
||||
return $value.' in (select [value] from openjson('.$field.$path.'))';
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepare the binding for a "JSON contains" statement.
|
||||
*
|
||||
* @param mixed $binding
|
||||
* @return string
|
||||
*/
|
||||
public function prepareBindingForJsonContains($binding)
|
||||
{
|
||||
return is_bool($binding) ? json_encode($binding) : $binding;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile a "JSON length" statement into SQL.
|
||||
*
|
||||
* @param string $column
|
||||
* @param string $operator
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function compileJsonLength($column, $operator, $value)
|
||||
{
|
||||
[$field, $path] = $this->wrapJsonFieldAndPath($column);
|
||||
|
||||
return '(select count(*) from openjson('.$field.$path.')) '.$operator.' '.$value;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 "order by" 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 "select" that will give back the row numbers on each of the records.
|
||||
$components['columns'] .= $this->compileOver($components['orders']);
|
||||
|
||||
unset($components['orders']);
|
||||
|
||||
if ($this->queryOrderContainsSubquery($query)) {
|
||||
$query->bindings = $this->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->concatenate($components);
|
||||
|
||||
return $this->compileTableExpression($sql, $query);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the over statement for a table expression.
|
||||
*
|
||||
* @param string $orderings
|
||||
* @return string
|
||||
*/
|
||||
protected function compileOver($orderings)
|
||||
{
|
||||
return ", row_number() over ({$orderings}) as row_num";
|
||||
}
|
||||
|
||||
/**
|
||||
* 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->orders)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return Arr::first($query->orders, function ($value) {
|
||||
return $this->isExpression($value['column'] ?? null);
|
||||
}, false) !== false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Move the order bindings to be after the "select" statement to account for an order by subquery.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @return array
|
||||
*/
|
||||
protected function sortBindingsForSubqueryOrderBy($query)
|
||||
{
|
||||
return Arr::sort($query->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->compileRowConstraint($query);
|
||||
|
||||
return "select * from ({$sql}) as temp_table where row_num {$constraint} order by row_num";
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the limit / offset row constraint for a query.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @return string
|
||||
*/
|
||||
protected function compileRowConstraint($query)
|
||||
{
|
||||
$start = (int) $query->offset + 1;
|
||||
|
||||
if ($query->limit > 0) {
|
||||
$finish = (int) $query->offset + (int) $query->limit;
|
||||
|
||||
return "between {$start} and {$finish}";
|
||||
}
|
||||
|
||||
return ">= {$start}";
|
||||
}
|
||||
|
||||
/**
|
||||
* 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->limit) && $query->limit > 0 && $query->offset <= 0
|
||||
? Str::replaceFirst('delete', 'delete top ('.$query->limit.')', $sql)
|
||||
: $sql;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the random statement into SQL.
|
||||
*
|
||||
* @param string $seed
|
||||
* @return string
|
||||
*/
|
||||
public function compileRandom($seed)
|
||||
{
|
||||
return 'NEWID()';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the "limit" portions of the query.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Builder $query
|
||||
* @param int $limit
|
||||
* @return string
|
||||
*/
|
||||
protected function compileLimit(Builder $query, $limit)
|
||||
{
|
||||
return '';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile the "offset" 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->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->columns = [];
|
||||
|
||||
return $this->compileSelect($existsQuery->selectRaw('1 [exists]')->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->compileJoins($query, $query->joins);
|
||||
|
||||
return "update {$alias} set {$columns} from {$table} {$joins} {$where}";
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile an "upsert" 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->columnize(array_keys(reset($values)));
|
||||
|
||||
$sql = 'merge '.$this->wrapTable($query->from).' ';
|
||||
|
||||
$parameters = collect($values)->map(function ($record) {
|
||||
return '('.$this->parameterize($record).')';
|
||||
})->implode(', ');
|
||||
|
||||
$sql .= 'using (values '.$parameters.') '.$this->wrapTable('laravel_source').' ('.$columns.') ';
|
||||
|
||||
$on = collect($uniqueBy)->map(function ($column) use ($query) {
|
||||
return $this->wrap('laravel_source.'.$column).' = '.$this->wrap($query->from.'.'.$column);
|
||||
})->implode(' and ');
|
||||
|
||||
$sql .= 'on '.$on.' ';
|
||||
|
||||
if ($update) {
|
||||
$update = collect($update)->map(function ($value, $key) {
|
||||
return is_numeric($key)
|
||||
? $this->wrap($value).' = '.$this->wrap('laravel_source.'.$value)
|
||||
: $this->wrap($key).' = '.$this->parameter($value);
|
||||
})->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->wrapJsonFieldAndPath($value);
|
||||
|
||||
return 'json_value('.$field.$path.')';
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap the given JSON boolean value.
|
||||
*
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
protected function wrapJsonBooleanValue($value)
|
||||
{
|
||||
return "'".$value."'";
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap a table in keyword identifiers.
|
||||
*
|
||||
* @param \Illuminate\Database\Query\Expression|string $table
|
||||
* @return string
|
||||
*/
|
||||
public function wrapTable($table)
|
||||
{
|
||||
if (! $this->isExpression($table)) {
|
||||
return $this->wrapTableValuedFunction(parent::wrapTable($table));
|
||||
}
|
||||
|
||||
return $this->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;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user