| Current File : /home/pacjaorg/public_html/nsa/libraries/vendor/joomla/database/src/Sqlsrv/SqlsrvQuery.php |
<?php
/**
* Part of the Joomla Framework Database Package
*
* @copyright Copyright (C) 2005 - 2021 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Database\Sqlsrv;
use Joomla\Database\DatabaseInterface;
use Joomla\Database\DatabaseQuery;
use Joomla\Database\Query\QueryElement;
/**
* SQL Server Query Building Class.
*
* @since 1.0
*/
class SqlsrvQuery extends DatabaseQuery
{
/**
* The list of zero or null representation of a datetime.
*
* @var array
* @since 2.0.0
*/
protected $nullDatetimeList = ['1900-01-01 00:00:00'];
/**
* Magic function to convert the query to a string.
*
* @return string The completed query.
*
* @since 1.0
*/
public function __toString()
{
// For the moment if we are given a query string we can't effectively process limits, fix this later
if ($this->sql)
{
return $this->sql;
}
$query = '';
switch ($this->type)
{
case 'select':
// Add required aliases for offset or fixGroupColumns method
$columns = $this->fixSelectAliases();
$query = (string) $this->select;
if ($this->group)
{
$this->fixGroupColumns($columns);
}
$query .= (string) $this->from;
if ($this->join)
{
// Special case for joins
foreach ($this->join as $join)
{
$query .= (string) $join;
}
}
if ($this->where)
{
$query .= (string) $this->where;
}
if ($this->selectRowNumber === null)
{
if ($this->group)
{
$query .= (string) $this->group;
}
if ($this->having)
{
$query .= (string) $this->having;
}
if ($this->merge)
{
// Special case for merge
foreach ($this->merge as $idx => $element)
{
$query .= (string) $element . ' AS merge_' . (int) ($idx + 1);
}
}
}
if ($this->order)
{
$query .= (string) $this->order;
}
else
{
$query .= PHP_EOL . '/*ORDER BY (SELECT 0)*/';
}
$query = $this->processLimit($query, $this->limit, $this->offset);
if ($this->alias !== null)
{
$query = '(' . $query . ') AS ' . $this->alias;
}
break;
case 'querySet':
$query = $this->querySet;
if ($query->order || $query->limit || $query->offset)
{
// If ORDER BY or LIMIT statement exist then parentheses is required for the first query
$query = PHP_EOL . "SELECT * FROM ($query) AS merge_0";
}
if ($this->merge)
{
// Special case for merge
foreach ($this->merge as $idx => $element)
{
$query .= (string) $element . ' AS merge_' . (int) ($idx + 1);
}
}
if ($this->order)
{
$query .= (string) $this->order;
}
$query = $this->processLimit($query, $this->limit, $this->offset);
break;
case 'insert':
$query .= (string) $this->insert;
// Set method
if ($this->set)
{
$query .= (string) $this->set;
}
elseif ($this->values)
{
// Columns-Values method
if ($this->columns)
{
$query .= (string) $this->columns;
}
$elements = $this->insert->getElements();
$tableName = array_shift($elements);
$query .= 'VALUES ';
$query .= (string) $this->values;
if ($this->autoIncrementField)
{
$query = 'SET IDENTITY_INSERT ' . $tableName . ' ON;' . $query . 'SET IDENTITY_INSERT ' . $tableName . ' OFF;';
}
if ($this->where)
{
$query .= (string) $this->where;
}
}
break;
case 'delete':
$query .= (string) $this->delete;
$query .= (string) $this->from;
if ($this->join)
{
// Special case for joins
foreach ($this->join as $join)
{
$query .= (string) $join;
}
}
if ($this->where)
{
$query .= (string) $this->where;
}
if ($this->order)
{
$query .= (string) $this->order;
}
break;
case 'update':
if ($this->join)
{
$tmpUpdate = $this->update;
$tmpFrom = $this->from;
$this->update = null;
$this->from = null;
$updateElem = $tmpUpdate->getElements();
$updateArray = explode(' ', $updateElem[0]);
// Use table alias if exists
$this->update(end($updateArray));
$this->from($updateElem[0]);
$query .= (string) $this->update;
$query .= (string) $this->set;
$query .= (string) $this->from;
$this->update = $tmpUpdate;
$this->from = $tmpFrom;
// Special case for joins
foreach ($this->join as $join)
{
$query .= (string) $join;
}
}
else
{
$query .= (string) $this->update;
$query .= (string) $this->set;
}
if ($this->where)
{
$query .= (string) $this->where;
}
if ($this->order)
{
$query .= (string) $this->order;
}
break;
default:
$query = parent::__toString();
break;
}
return $query;
}
/**
* Casts a value to a char.
*
* Ensure that the value is properly quoted before passing to the method.
*
* Usage:
* $query->select($query->castAs('CHAR', 'a'));
*
* @param string $type The type of string to cast as.
* @param string $value The value to cast as a char.
* @param string $length The value to cast as a char.
*
* @return string SQL statement to cast the value as a char type.
*
* @since 1.0
*/
public function castAs(string $type, string $value, ?string $length = null)
{
switch (strtoupper($type))
{
case 'CHAR':
if (!$length)
{
$length = '10';
}
return 'CAST(' . $value . ' as NVARCHAR(' . $length . '))';
case 'INT':
return 'CAST(' . $value . ' AS INT)';
}
return parent::castAs($type, $value, $length);
}
/**
* Gets the function to determine the length of a character string.
*
* @param string $field A value.
* @param string|null $operator Comparison operator between charLength integer value and $condition
* @param string|null $condition Integer value to compare charLength with.
*
* @return string The required char length call.
*
* @since 1.0
*/
public function charLength($field, $operator = null, $condition = null)
{
$statement = 'DATALENGTH(' . $field . ')';
if ($operator !== null && $condition !== null)
{
$statement .= ' ' . $operator . ' ' . $condition;
}
return $statement;
}
/**
* Concatenates an array of column names or values.
*
* @param string[] $values An array of values to concatenate.
* @param string|null $separator As separator to place between each value.
*
* @return string The concatenated values.
*
* @since 1.0
*/
public function concatenate($values, $separator = null)
{
if ($separator !== null)
{
return '(' . implode('+' . $this->quote($separator) . '+', $values) . ')';
}
return '(' . implode('+', $values) . ')';
}
/**
* Gets the current date and time.
*
* @return string
*
* @since 1.0
*/
public function currentTimestamp()
{
return 'GETDATE()';
}
/**
* Get the length of a string in bytes.
*
* @param string $value The string to measure.
*
* @return integer
*
* @since 1.0
*/
public function length($value)
{
return 'LEN(' . $value . ')';
}
/**
* Add a grouping column to the GROUP clause of the query.
*
* Usage:
* $query->group('id');
*
* @param mixed $columns A string or array of ordering columns.
*
* @return SqlsrvQuery Returns this object to allow chaining.
*
* @since 1.5.0
*/
public function group($columns)
{
if (!($this->db instanceof DatabaseInterface))
{
throw new \RuntimeException('JLIB_DATABASE_ERROR_INVALID_DB_OBJECT');
}
// Transform $columns into an array for filtering purposes
\is_string($columns) && $columns = explode(',', str_replace(' ', '', $columns));
// Get the _formatted_ FROM string and remove everything except `table AS alias`
$fromStr = str_replace(['[', ']'], '', str_replace('#__', $this->db->getPrefix(), str_replace('FROM ', '', (string) $this->from)));
// Start setting up an array of alias => table
list($table, $alias) = preg_split("/\sAS\s/i", $fromStr);
$tmpCols = $this->db->getTableColumns(trim($table));
$cols = [];
foreach ($tmpCols as $name => $type)
{
$cols[] = $alias . '.' . $name;
}
// Now we need to get all tables from any joins
// Go through all joins and add them to the tables array
foreach ($this->join as $join)
{
$joinTbl = str_replace(
'#__',
$this->db->getPrefix(),
str_replace(
']',
'',
preg_replace("/.*(#.+\sAS\s[^\s]*).*/i", '$1', (string) $join)
)
);
list($table, $alias) = preg_split("/\sAS\s/i", $joinTbl);
$tmpCols = $this->db->getTableColumns(trim($table));
foreach ($tmpCols as $name => $tmpColType)
{
$cols[] = $alias . '.' . $name;
}
}
$selectStr = str_replace('SELECT ', '', (string) $this->select);
// Remove any functions (e.g. COUNT(), SUM(), CONCAT())
$selectCols = preg_replace("/([^,]*\([^\)]*\)[^,]*,?)/", '', $selectStr);
// Remove any "as alias" statements
$selectCols = preg_replace("/(\sas\s[^,]*)/i", '', $selectCols);
// Remove any extra commas
$selectCols = preg_replace('/,{2,}/', ',', $selectCols);
// Remove any trailing commas and all whitespaces
$selectCols = trim(str_replace(' ', '', preg_replace('/,?$/', '', $selectCols)));
// Get an array to compare against
$selectCols = explode(',', $selectCols);
// Find all alias.* and fill with proper table column names
foreach ($selectCols as $key => $aliasColName)
{
if (preg_match("/.+\*/", $aliasColName, $match))
{
// Grab the table alias minus the .*
$aliasStar = preg_replace("/(.+)\.\*/", '$1', $aliasColName);
// Unset the array key
unset($selectCols[$key]);
// Get the table name
$tableColumns = preg_grep("/{$aliasStar}\.+/", $cols);
$columns = array_merge($columns, $tableColumns);
}
}
// Finally, get a unique string of all column names that need to be included in the group statement
$columns = array_unique(array_merge($columns, $selectCols));
$columns = implode(',', $columns);
// Recreate it every time, to ensure we have checked _all_ select statements
$this->group = new QueryElement('GROUP BY', $columns);
return $this;
}
/**
* Aggregate function to get input values concatenated into a string, separated by delimiter
*
* Usage:
* $query->groupConcat('id', ',');
*
* @param string $expression The expression to apply concatenation to, this may be a column name or complex SQL statement.
* @param string $separator The delimiter of each concatenated value
*
* @return string Input values concatenated into a string, separated by delimiter
*
* @since 2.0.0
*/
public function groupConcat($expression, $separator = ',')
{
return 'string_agg(' . $expression . ', ' . $this->quote($separator) . ')';
}
/**
* Get the function to return a random floating-point value
*
* Usage:
* $query->rand();
*
* @return string
*
* @since 1.5.0
*/
public function rand()
{
return ' NEWID() ';
}
/**
* Find a value in a varchar used like a set.
*
* Ensure that the value is an integer before passing to the method.
*
* Usage:
* $query->findInSet((int) $parent->id, 'a.assigned_cat_ids')
*
* @param string $value The value to search for.
* @param string $set The set of values.
*
* @return string A representation of the MySQL find_in_set() function for the driver.
*
* @since 1.5.0
*/
public function findInSet($value, $set)
{
return "CHARINDEX(',$value,', ',' + $set + ',') > 0";
}
/**
* Add required aliases to columns for select statement in subquery.
*
* @return array[] Array of columns with added missing aliases.
*
* @since 2.0.0
*/
protected function fixSelectAliases()
{
$operators = [
'+' => '',
'-' => '',
'*' => '',
'/' => '',
'%' => '',
'&' => '',
'|' => '',
'~' => '',
'^' => '',
];
// Split into array and remove comments
$columns = $this->splitSqlExpression(implode(',', $this->select->getElements()));
foreach ($columns as $i => $column)
{
$size = \count($column);
if ($size == 0)
{
continue;
}
if ($size > 2 && strcasecmp($column[$size - 2], 'AS') === 0)
{
// Alias exists, replace it to uppercase
$columns[$i][$size - 2] = 'AS';
continue;
}
if ($i == 0 && stripos(' DISTINCT ALL ', " $column[0] ") !== false)
{
// This words are reserved, they are not column names
array_shift($column);
$size--;
}
$lastWord = strtoupper($column[$size - 1]);
$length = \strlen($lastWord);
$lastChar = $lastWord[$length - 1];
if ($lastChar == '*')
{
// Skip on wildcard
continue;
}
if ($lastChar == ')'
|| ($size == 1 && $lastChar == "'")
|| $lastWord[0] == '@'
|| $lastWord == 'NULL'
|| $lastWord == 'END'
|| is_numeric($lastWord))
{
/*
* Ends with:
* - SQL function
* - single static value like 'only '+'string'
* - @@var
* - NULL
* - CASE ... END
* - Numeric
*/
$columns[$i][] = 'AS';
$columns[$i][] = $this->quoteName('columnAlias' . $i);
continue;
}
if ($size == 1)
{
continue;
}
$lastChar2 = substr($column[$size - 2], -1);
// Check if column ends with '- a.x' or '- a. x'
if (isset($operators[$lastChar2]) || ($size > 2 && $lastChar2 === '.' && isset($operators[substr($column[$size - 3], -1)])))
{
// Ignore plus signs if column start with them
if ($size != 2 || ltrim($column[0], '+') !== '' || $column[1][0] === "'")
{
// If operator exists before last word then alias is required for subquery
$columns[$i][] = 'AS';
$columns[$i][] = $this->quoteName('columnAlias' . $i);
continue;
}
}
elseif ($column[$size - 1][0] !== '.' && $lastChar2 !== '.')
{
// If columns is like name name2 then second word is alias.
// Add missing AS before the alias, exception for 'a. x' and 'a .x'
array_splice($columns[$i], -1, 0, 'AS');
}
}
$selectColumns = [];
foreach ($columns as $i => $column)
{
$selectColumns[$i] = implode(' ', $column);
}
$this->select = new QueryElement('SELECT', $selectColumns);
return $columns;
}
/**
* Add missing columns names to GROUP BY clause.
*
* @param array[] $selectColumns Array of columns from splitSqlExpression method.
*
* @return $this
*
* @since 2.0.0
*/
protected function fixGroupColumns($selectColumns)
{
// Cache tables columns
static $cacheCols = [];
// Known columns of all included tables
$knownColumnsByAlias = [];
$iquotes = ['"' => '', '[' => '', "'" => ''];
$nquotes = ['"', '[', ']'];
// Aggregate functions
$aFuncs = [
'AVG(',
'CHECKSUM_AGG(',
'COUNT(',
'COUNT_BIG(',
'GROUPING(',
'GROUPING_ID(',
'MIN(',
'MAX(',
'SUM(',
'STDEV(',
'STDEVP(',
'VAR(',
'VARP(',
];
// Aggregated columns
$filteredColumns = [];
// Aliases found in SELECT statement
$knownAliases = [];
$wildcardTables = [];
foreach ($selectColumns as $i => $column)
{
$size = \count($column);
if ($size === 0)
{
continue;
}
if ($i == 0 && stripos(' DISTINCT ALL ', " $column[0] ") !== false)
{
// These words are reserved, they are not column names
array_shift($selectColumns[0]);
array_shift($column);
$size--;
}
if ($size > 2 && $column[$size - 2] === 'AS')
{
// Save and remove AS alias
$alias = $column[$size - 1];
if (isset($iquotes[$alias[0]]))
{
$alias = substr($alias, 1, -1);
}
// Remove alias
$selectColumns[$i] = $column = \array_slice($column, 0, -2);
if ($size === 3 || ($size === 4 && strpos('+-*/%&|~^', $column[0][0]) !== false))
{
$lastWord = $column[$size - 3];
if ($lastWord[0] === "'" || $lastWord === 'NULL' || is_numeric($lastWord))
{
unset($selectColumns[$i]);
continue;
}
}
// Remember pair alias => column expression
$knownAliases[$alias] = implode(' ', $column);
}
$aggregated = false;
foreach ($column as $j => $block)
{
if (substr($block, -2) === '.*')
{
// Found column ends with .*
if (isset($iquotes[$block[0]]))
{
// Quoted table
$wildcardTables[] = substr($block, 1, -3);
}
else
{
$wildcardTables[] = substr($block, 0, -2);
}
}
elseif (str_ireplace($aFuncs, '', $block) != $block)
{
$aggregated = true;
}
if ($block[0] === "'")
{
// Shrink static strings which could contain column name
$column[$j] = "''";
}
}
if (!$aggregated)
{
// Without aggregated columns and aliases
$filteredColumns[] = implode(' ', $selectColumns[$i]);
}
// Without aliases and static strings
$selectColumns[$i] = implode(' ', $column);
}
// If select statement use table.* expression
if ($wildcardTables)
{
// Split FROM statement into list of tables
$tables = $this->splitSqlExpression(implode(',', $this->from->getElements()));
foreach ($tables as $i => $table)
{
$table = implode(' ', $table);
// Exclude subquery from the FROM clause
if (strpos($table, '(') === false)
{
// Unquote
$table = str_replace($nquotes, '', $table);
$table = str_replace('#__', $this->db->getPrefix(), $table);
$table = explode(' ', $table);
$alias = end($table);
$table = $table[0];
// Chek if exists a wildcard with current alias table?
if (\in_array($alias, $wildcardTables, true))
{
if (!isset($cacheCols[$table]))
{
$cacheCols[$table] = $this->db->getTableColumns($table);
}
if ($this->join || $table != $alias)
{
foreach ($cacheCols[$table] as $name => $type)
{
$knownColumnsByAlias[$alias][] = $alias . '.' . $name;
}
}
else
{
foreach ($cacheCols[$table] as $name => $type)
{
$knownColumnsByAlias[$alias][] = $name;
}
}
}
}
}
// Now we need to get all tables from any joins
// Go through all joins and add them to the tables array
if ($this->join)
{
foreach ($this->join as $join)
{
// Unquote and replace prefix
$joinTbl = str_replace($nquotes, '', (string) $join);
$joinTbl = str_replace('#__', $this->db->getPrefix(), $joinTbl);
// Exclude subquery
if (preg_match('/JOIN\s+(\w+)(?:\s+AS)?(?:\s+(\w+))?/i', $joinTbl, $matches))
{
$table = $matches[1];
$alias = $matches[2] ?? $table;
// Chek if exists a wildcard with current alias table?
if (\in_array($alias, $wildcardTables, true))
{
if (!isset($cacheCols[$table]))
{
$cacheCols[$table] = $this->db->getTableColumns($table);
}
foreach ($cacheCols[$table] as $name => $type)
{
$knownColumnsByAlias[$alias][] = $alias . '.' . $name;
}
}
}
}
}
}
$selectExpression = implode(',', $selectColumns);
// Split into the right columns
$groupColumns = $this->splitSqlExpression(implode(',', $this->group->getElements()));
// Remove column aliases from GROUP statement - SQLSRV does not support it
foreach ($groupColumns as $i => $column)
{
$groupColumns[$i] = implode(' ', $column);
$column = str_replace($nquotes, '', $groupColumns[$i]);
if (isset($knownAliases[$column]))
{
// Be sure that this is not a valid column name
if (!preg_match('/\b' . preg_quote($column, '/') . '\b/', $selectExpression))
{
// Replace column alias by column expression
$groupColumns[$i] = $knownAliases[$column];
}
}
}
// Find all alias.* and fill with proper table column names
foreach ($filteredColumns as $i => $column)
{
if (substr($column, -2) === '.*')
{
unset($filteredColumns[$i]);
// Extract alias.* columns into GROUP BY statement
$groupColumns = array_merge($groupColumns, $knownColumnsByAlias[substr($column, 0, -2)]);
}
}
$groupColumns = array_merge($groupColumns, $filteredColumns);
if ($this->order)
{
// Remove direction suffixes
$dir = [" DESC\v", " ASC\v"];
$orderColumns = $this->splitSqlExpression(implode(',', $this->order->getElements()));
foreach ($orderColumns as $i => $column)
{
$column = implode(' ', $column);
$orderColumns[$i] = $column = trim(str_ireplace($dir, '', "$column\v"), "\v");
if (isset($knownAliases[str_replace($nquotes, '', $column)]))
{
unset($orderColumns[$i]);
}
if (str_ireplace($aFuncs, '', $column) != $column)
{
// Do not add aggregate expression
unset($orderColumns[$i]);
}
}
$groupColumns = array_merge($groupColumns, $orderColumns);
}
// Get a unique string of all column names that need to be included in the group statement
$this->group = new QueryElement('GROUP BY', array_unique($groupColumns));
return $this;
}
/**
* Split a string of sql expression into an array of individual columns.
* Single line or line end comments and multi line comments are stripped off.
* Always return at least one column.
*
* @param string $string Input string of sql expression like select expression.
*
* @return array[] The columns from the input string separated into an array.
*
* @since 2.0.0
*/
protected function splitSqlExpression($string)
{
// Append whitespace as equivalent to the last comma
$string .= ' ';
$colIdx = 0;
$start = 0;
$open = false;
$openC = 0;
$comment = false;
$endString = '';
$length = \strlen($string);
$columns = [];
$column = [];
$current = '';
$previous = null;
$operators = [
'+' => '',
'-' => '',
'*' => '',
'/' => '',
'%' => '',
'&' => '',
'|' => '',
'~' => '',
'^' => '',
];
$addBlock = function ($block) use (&$column, &$colIdx)
{
if (isset($column[$colIdx]))
{
$column[$colIdx] .= $block;
}
else
{
$column[$colIdx] = $block;
}
};
for ($i = 0; $i < $length; $i++)
{
$current = substr($string, $i, 1);
$current2 = substr($string, $i, 2);
$current3 = substr($string, $i, 3);
$lenEndString = \strlen($endString);
$testEnd = substr($string, $i, $lenEndString);
if ($current == '[' || $current == '"' || $current == "'" || $current2 == '--'
|| ($current2 == '/*')
|| ($current == '#' && $current3 != '#__')
|| ($lenEndString && $testEnd == $endString))
{
if ($open)
{
if ($testEnd === $endString)
{
if ($comment)
{
if ($lenEndString > 1)
{
$i += ($lenEndString - 1);
}
// Move cursor after close tag of comment
$start = $i + 1;
$comment = false;
}
elseif ($current == "'" || $current == ']' || $current == '"')
{
// Check for escaped quote like '', ]] or ""
$n = 1;
while ($i + $n < $length && $string[$i + $n] == $current)
{
$n++;
}
// Jump to the last quote
$i += $n - 1;
if ($n % 2 === 0)
{
// There is only escaped quote
continue;
}
if ($n > 2)
{
// The last right close quote is not escaped
$current = $string[$i];
}
}
$open = false;
$endString = '';
}
}
else
{
$open = true;
if ($current == '#' || $current2 == '--')
{
$endString = "\n";
$comment = true;
}
elseif ($current2 == '/*')
{
$endString = '*/';
$comment = true;
}
elseif ($current == '[')
{
$endString = ']';
}
else
{
$endString = $current;
}
if ($comment && $start < $i)
{
// Add string exists before comment
$addBlock(substr($string, $start, $i - $start));
$previous = $string[$i - 1];
$start = $i;
}
}
}
elseif (!$open)
{
if ($current == '(')
{
$openC++;
$previous = $current;
}
elseif ($current == ')')
{
$openC--;
$previous = $current;
}
elseif ($current == '.')
{
if ($i === $start && $colIdx > 0 && !isset($column[$colIdx]))
{
// Remove whitespace placed before dot
$colIdx--;
}
$previous = $current;
}
elseif ($openC === 0)
{
if (ctype_space($current))
{
// Normalize whitespace
$string[$i] = ' ';
if ($start < $i)
{
// Add text placed before whitespace
$addBlock(substr($string, $start, $i - $start));
$colIdx++;
$previous = $string[$i - 1];
}
elseif (isset($column[$colIdx]))
{
if ($colIdx > 1 || !isset($operators[$previous]))
{
// There was whitespace after comment
$colIdx++;
}
}
// Move cursor forward
$start = $i + 1;
}
elseif (isset($operators[$current]) && ($current !== '*' || $previous !== '.'))
{
if ($start < $i)
{
// Add text before operator
$addBlock(substr($string, $start, $i - $start));
$colIdx++;
}
elseif (!isset($column[$colIdx]) && isset($operators[$previous]))
{
// Do not create whitespace between operators
$colIdx--;
}
// Add operator
$addBlock($current);
$previous = $current;
$colIdx++;
// Move cursor forward
$start = $i + 1;
}
else
{
$previous = $current;
}
}
}
if (($current == ',' && !$open && $openC == 0) || $i == $length - 1)
{
if ($start < $i && !$comment)
{
// Save remaining text
$addBlock(substr($string, $start, $i - $start));
}
$columns[] = $column;
// Reset values
$column = [];
$colIdx = 0;
$previous = null;
// Column saved, move cursor forward after comma
$start = $i + 1;
}
}
return $columns;
}
/**
* Method to modify a query already in string format with the needed additions to make the query limited to a particular number of
* results, or start at a particular offset.
*
* @param string $query The query in string format
* @param integer $limit The limit for the result set
* @param integer $offset The offset for the result set
*
* @return string
*
* @since 2.0.0
*/
public function processLimit($query, $limit, $offset = 0)
{
if ($offset > 0)
{
// Find a position of the last comment
$commentPos = strrpos($query, '/*ORDER BY (SELECT 0)*/');
// If the last comment belongs to this query, not previous subquery
if ($commentPos !== false && $commentPos + 2 === strripos($query, 'ORDER BY', $commentPos + 2))
{
// We can not use OFFSET without ORDER BY
$query = substr_replace($query, 'ORDER BY (SELECT 0)', $commentPos, 23);
}
$query .= PHP_EOL . 'OFFSET ' . (int) $offset . ' ROWS';
if ($limit > 0)
{
$query .= PHP_EOL . 'FETCH NEXT ' . (int) $limit . ' ROWS ONLY';
}
}
elseif ($limit > 0)
{
$position = stripos($query, 'SELECT');
$distinct = stripos($query, 'SELECT DISTINCT');
if ($position === $distinct)
{
$query = substr_replace($query, 'SELECT DISTINCT TOP ' . (int) $limit, $position, 15);
}
else
{
$query = substr_replace($query, 'SELECT TOP ' . (int) $limit, $position, 6);
}
}
return $query;
}
/**
* Add a query to UNION with the current query.
*
* Usage:
* $query->union('SELECT name FROM #__foo')
* $query->union('SELECT name FROM #__foo', true)
*
* @param DatabaseQuery|string $query The DatabaseQuery object or string to union.
* @param boolean $distinct True to only return distinct rows from the union.
*
* @return $this
*
* @since 1.0
*/
public function union($query, $distinct = true)
{
// Set up the name with parentheses, the DISTINCT flag is redundant
return $this->merge($distinct ? 'UNION SELECT * FROM ()' : 'UNION ALL SELECT * FROM ()', $query);
}
}