TYPO3 Core

<?php

/***************************************************************

/**

* TYPO3 SQL parser

*

*

* 107: class t3lib_sqlparser

*

*

*

*

*

*

*

* TOTAL FUNCTIONS: 35

* (This index is automatically created/updated by the extension "extdeveval")

*/

/**

* TYPO3 SQL parser class.

*

class t3lib_sqlparser {

// Parser:

/*************************************

*

* SQL Parsing, full queries

$result = array();

// Finding starting keyword of string:

$keyword = $this->nextPart($_parseString, '^(SELECT|UPDATE|INSERT[[:space:]]+INTO|DELETE[[:space:]]+FROM|EXPLAIN|DROP[[:space:]]+TABLE|CREATE[[:space:]]+TABLE|CREATE[[:space:]]+DATABASE|ALTER[[:space:]]+TABLE|TRUNCATE[[:space:]]+TABLE)[[:space:]]+');

case 'SELECT':

// Parsing SELECT query:

$result = $this->parseSELECT($parseString);

$result = $this->parseTRUNCATETABLE($parseString);

break;

default:

break;

}

// Removing SELECT:

$parseString = $this->trimSQL($parseString);

// Init output variable:

$result = array();

// Select fields:

$result['SELECT'] = $this->parseFieldList($parseString, '^(FROM)[[:space:]]+');

// Continue if string is not ended:

// Get table list:

$result['FROM'] = $this->parseFromTables($parseString, '^(WHERE)[[:space:]]+');

// If there are more than just the tables (a WHERE clause that would be...)

// Get WHERE clause:

$result['WHERE'] = $this->parseWhereClause($parseString, '^(GROUP[[:space:]]+BY|ORDER[[:space:]]+BY|LIMIT)[[:space:]]+', $parameterReferences);

// If the WHERE clause parsing was stopped by GROUP BY, ORDER BY or LIMIT, then proceed with parsing:

// GROUP BY parsing:

$result['GROUPBY'] = $this->parseFieldList($parseString, '^(ORDER[[:space:]]+BY|LIMIT)[[:space:]]+');

// ORDER BY parsing:

$result['ORDERBY'] = $this->parseFieldList($parseString, '^(LIMIT)[[:space:]]+');

// LIMIT parsing:

$result['LIMIT'] = $parseString;

} else {

}

}

}

}

// Store current parseString in the result array for possible further processing (e.g., subquery support by DBAL)

$result['parseString'] = $parseString;

// Removing UPDATE

$parseString = $this->trimSQL($parseString);

// Init output variable:

$result = array();

$result['TABLE'] = $this->nextPart($parseString, '^([[:alnum:]_]+)[[:space:]]+');

// Continue if string is not ended:

$comma = TRUE;

// Get field/value pairs:

$value = $this->getValue($parseString);

$result['FIELDS'][$fieldName] = $value;

}

// WHERE

$result['WHERE'] = $this->parseWhereClause($parseString);

// Should be no more content now:

}

// Return result:

// Removing INSERT

$parseString = $this->trimSQL($parseString);

// Init output variable:

$result = array();

// Get table:

$result['TABLE'] = $this->nextPart($parseString, '^([[:alnum:]_]+)([[:space:]]+|\()');

// Get values/fieldnames (depending...)

return $this->parse_error;

}

if (preg_match('/^,/', $parseString)) {

$result['EXTENDED'] = '1';

while ($this->nextPart($parseString, '^(,)') === ',') {

$result['VALUES_ONLY'][] = $this->getValue($parseString, 'IN');

return $this->parse_error;

}

}

}

$result['FIELDS'] = array();

do {

return $this->parse_error;

}

$insertValues = array();

foreach ($fieldNames as $k => $fN) {

if (preg_match('/^[[:alnum:]_]+$/', $fN)) {

if (!isset($insertValues[$fN])) {

$insertValues[$fN] = $values[$k];

if (isset($values[$k + 1])) {

return $this->parseError('Too many values in list!', $parseString);

}

} else {

$result['EXTENDED'] = '1';

}

// Should be no more content now:

}

// Return result

// Removing DELETE

$parseString = $this->trimSQL($parseString);

// Init output variable:

$result = array();

// Get table:

$result['TABLE'] = $this->nextPart($parseString, '^([[:alnum:]_]+)[[:space:]]+');

// WHERE

$result['WHERE'] = $this->parseWhereClause($parseString);

// Should be no more content now:

}

// Return result:

// Removing EXPLAIN

$parseString = $this->trimSQL($parseString);

// Init output variable:

$result = $this->parseSELECT($parseString);

$result['type'] = 'EXPLAIN';

}

// Removing CREATE TABLE

$parseString = $this->trimSQL($parseString);

// Init output variable:

$result = array();

$result['type'] = 'CREATETABLE';

// Get table:

// While the parseString is not yet empty:

case 'PRIMARYKEY':

break;

case 'UNIQUE':

case 'UNIQUEKEY':

break;

case 'KEY':

$result['KEYS'][$keyName] = $this->getValue($parseString, '_LIST', 'INDEX');

break;

}

$result['FIELDS'][$fieldName]['definition'] = $this->parseFieldDef($parseString);

// Finding delimiter:

$delim = $this->nextPart($parseString, '^(,|\))');

break;

}

}

// Finding what is after the table definition - table type in MySQL

$result['tableType'] = $parseString;

$parseString = '';

}

// Should be no more content now:

}

return $result;

// Removing ALTER TABLE

$parseString = $this->trimSQL($parseString);

// Init output variable:

$result = array();

return $this->parseError('No end backquote found!', $parseString);

}

// Getting field:

if (t3lib_div::inList('ADDPRIMARYKEY,DROPPRIMARYKEY,ENGINE', $actionKey) || $fieldKey = $this->nextPart($parseString, '^([[:alnum:]_]+)[[:space:]]+')) {

case 'ADD':

$result['FIELD'] = $fieldKey;

$result['definition'] = $this->parseFieldDef($parseString);

break;

case 'DROP':

case 'RENAME':

break;

case 'CHANGE':

$result['FIELD'] = $fieldKey;

$result['definition'] = $this->parseFieldDef($parseString);

break;

case 'ADDKEY':

case 'ADDUNIQUE':

$result['KEY'] = $fieldKey;

$result['fields'] = $this->getValue($parseString, '_LIST', 'INDEX');

break;

case 'DROPKEY':

$result['KEY'] = $fieldKey;

break;

case 'DROPPRIMARYKEY':

break;

case 'DEFAULTCHARACTERSET':

$result['charset'] = $fieldKey;

$result['engine'] = $this->nextPart($parseString, '^=[[:space:]]*([[:alnum:]]+)[[:space:]]+', TRUE);

break;

}

// Should be no more content now:

}

return $result;

// Removing DROP TABLE

$parseString = $this->trimSQL($parseString);

// Init output variable:

$result = array();

$result['type'] = 'DROPTABLE';

// IF EXISTS

// Get table:

$result['TABLE'] = $this->nextPart($parseString, '^([[:alnum:]_]+)[[:space:]]+');

// Should be no more content now:

}

return $result;

/**

* Parsing CREATE DATABASE query

// Removing CREATE DATABASE

$parseString = $this->trimSQL($parseString);

// Init output variable:

$result = array();

// Get table:

$result['DATABASE'] = $this->nextPart($parseString, '^([[:alnum:]_]+)[[:space:]]+');

// Should be no more content now:

}

return $result;

/**

* Parsing TRUNCATE TABLE query

}

/**************************************

*

* SQL Parsing, helper functions for parts of queries

*/

public function parseFieldList(&$parseString, $stopRegex = '') {

// Prepare variables:

$parseString = $this->trimSQL($parseString);

while (strlen($parseString)) {

// Checking if we are inside / outside parenthesis (in case of a function like count(), max(), min() etc...):

// Accumulate function content until next () parenthesis:

$stack[$pnt]['func_content.'][] = array(

'level' => $level,

);

// Detecting ( or )

case '(':

$level++;

break;

case ')':

$level--;

}

break;

}

// Looking for a flow-control construct (only known constructs supported)

if (preg_match('/^case([[:space:]][[:alnum:]\*._]+)?[[:space:]]when/i', $parseString)) {

}

} else {

// Looking for a known function (only known functions supported)

$stack[$pnt]['type'] = 'function';

$stack[$pnt]['function'] = $func;

} else {

// Otherwise, look for regular fieldname:

if (($fieldName = $this->nextPart($parseString, '^([[:alnum:]\*._]+)(,|[[:space:]]+)')) !== '') {

$stack[$pnt]['type'] = 'field';

// Explode fieldname into field and table:

$stack[$pnt]['table'] = $tableField[0];

$stack[$pnt]['field'] = $tableField[1];

} else {

$stack[$pnt]['field'] = $tableField[0];

}

} else {

}

}

}

}

// After a function or field we look for "AS" alias and a comma to separate to the next field in the list:

// Looking for "AS" alias:

$stack[$pnt]['as_keyword'] = $as;

}

// Looking for "ASC" or "DESC" keywords (for ORDER BY)

$stack[$pnt]['sortDir'] = $sDir;

}

// Looking for stop-keywords:

return $stack;

}

// Looking for comma (since the stop-keyword did not trigger a return...)

}

// Increasing pointer:

// Check recursivity brake:

$loopExit++;

}

}

$this->lastStopKeyWord = '';

$this->parse_error = '';

// $parseString is continously shortend by the process and we keep parsing it till it is zero:

while (strlen($parseString)) {

// Looking for the table:

// Looking for stop-keywords before fetching potential table alias:

if ($stopRegex && ($this->lastStopKeyWord = $this->nextPart($parseString, $stopRegex))) {

return $stack;

}

if (!preg_match('/^(LEFT|RIGHT|JOIN|INNER)[[:space:]]+/i', $parseString)) {

}

// Looking for JOIN

$joinCnt = 0;

$stack[$pnt]['JOIN'][$joinCnt]['type'] = $join;

if ($stack[$pnt]['JOIN'][$joinCnt]['withTable'] = $this->nextPart($parseString, '^([[:alnum:]_]+)[[:space:]]+', 1)) {

if (!preg_match('/^ON[[:space:]]+/i', $parseString)) {

}

}

$joinCnt++;

// Looking for stop-keywords:

if ($stopRegex && $this->lastStopKeyWord = $this->nextPart($parseString, $stopRegex)) {

return $stack;

}

$this->lastStopKeyWord = '';

$this->parse_error = '';

// $parseString is continously shortend by the process and we keep parsing it till it is zero:

while (strlen($parseString)) {

// Look for next parenthesis level:

// Find "modifier", eg. "NOT or !"

$stack[$level][$pnt[$level]]['modifier'] = trim($this->nextPart($parseString, '^(!|NOT[[:space:]]+)'));

// See if condition is EXISTS with a subquery

if (preg_match('/^EXISTS[[:space:]]*[(]/i', $parseString)) {

$stack[$level][$pnt[$level]]['func']['type'] = $this->nextPart($parseString, '^(EXISTS)[[:space:]]*');

$stack[$level][$pnt[$level]]['func']['subquery'] = $this->parseSELECT($parseString, $parameterReferences);

// Seek to new position in parseString after parsing of the subquery

$parseString = $stack[$level][$pnt[$level]]['func']['subquery']['parseString'];

unset($stack[$level][$pnt[$level]]['func']['subquery']['parseString']);

if (!$this->nextPart($parseString, '^([)])')) {

return 'No ) parenthesis at end of subquery';

if (preg_match('/^LOCATE[[:space:]]*[(]/i', $parseString)) {

$stack[$level][$pnt[$level]]['func']['type'] = $this->nextPart($parseString, '^(LOCATE)[[:space:]]*');

$stack[$level][$pnt[$level]]['func']['substr'] = $this->getValue($parseString);

if (!$this->nextPart($parseString, '^(,)')) {

return $this->parseError('No comma found as expected in parseWhereClause()', $parseString);

$stack[$level][$pnt[$level]]['func']['table'] = '';

$stack[$level][$pnt[$level]]['func']['field'] = $tableField[0];

}

return $this->parseError('No field name found as expected in parseWhereClause()', $parseString);

if ($this->nextPart($parseString, '^(,)')) {

$stack[$level][$pnt[$level]]['func']['pos'] = $this->getValue($parseString);

}

if (!$this->nextPart($parseString, '^([)])')) {

return $this->parseError('No ) parenthesis at end of function', $parseString);

} elseif (preg_match('/^IFNULL[[:space:]]*[(]/i', $parseString)) {

$stack[$level][$pnt[$level]]['func']['type'] = $this->nextPart($parseString, '^(IFNULL)[[:space:]]*');

if ($fieldName = $this->nextPart($parseString, '^([[:alnum:]\*._]+)[[:space:]]*')) {

// Parse field name into field and table:

$stack[$level][$pnt[$level]]['func']['table'] = '';

$stack[$level][$pnt[$level]]['func']['field'] = $tableField[0];

}

return $this->parseError('No field name found as expected in parseWhereClause()', $parseString);

if ($this->nextPart($parseString, '^(,)')) {

$stack[$level][$pnt[$level]]['func']['default'] = $this->getValue($parseString);

}

if (!$this->nextPart($parseString, '^([)])')) {

return $this->parseError('No ) parenthesis at end of function', $parseString);

} elseif (preg_match('/^FIND_IN_SET[[:space:]]*[(]/i', $parseString)) {

$stack[$level][$pnt[$level]]['func']['type'] = $this->nextPart($parseString, '^(FIND_IN_SET)[[:space:]]*');

if ($str = $this->getValue($parseString)) {

$stack[$level][$pnt[$level]]['func']['str'] = $str;

if ($fieldName = $this->nextPart($parseString, '^,[[:space:]]*([[:alnum:]._]+)[[:space:]]*', TRUE)) {

}

if (!$this->nextPart($parseString, '^([)])')) {

return $this->parseError('No ) parenthesis at end of function', $parseString);

} else {

return $this->parseError('No item to look for found as expected in parseWhereClause()', $parseString);

}

// - "&" (boolean AND)

// - "+" (addition)

// - "-" (substraction)

// Parse field name into field and table:

$tableField = explode('.', $fieldName, 2);

$stack[$level][$pnt[$level]]['table'] = $tableField[0];

$stack[$level][$pnt[$level]]['field'] = $tableField[1];

$stack[$level][$pnt[$level]]['table'] = '';

$stack[$level][$pnt[$level]]['field'] = $tableField[0];

} else {

return $this->parseError('No field name found as expected in parseWhereClause()', $parseString);

// See if the value is calculated:

$stack[$level][$pnt[$level]]['calc'] = $this->nextPart($parseString, '^(' . $calcOperators . ')');

}

}

}

$stack[$level][$pnt[$level]]['comparator'] = $this->nextPart($parseString, '^(' . implode('|', $comparatorPatterns) . ')');

if (strlen($stack[$level][$pnt[$level]]['comparator'])) {

if (preg_match('/^CONCAT[[:space:]]*\(/', $parseString)) {

// Look for ending parenthesis:

$this->nextPart($parseString, '([)])');

$stack[$level][$pnt[$level]]['value'] = $values;

// Finished, increase pointer:

$pnt[$level]++;

}

// Checking if the current level is ended, in that case do stack management:

// Make recursivity check:

$loopExit++;

// Looking for stop-keywords:

if ($stopRegex && $this->lastStopKeyWord = $this->nextPart($parseString, $stopRegex)) {

return $stack[0];

} else {

return $this->parseError('No operator, but parsing not finished in parseWhereClause().', $parseString);

$result = array();

// Field type:

// Looking for value:

// Looking for keywords

$result['featureIndex'][$keywordCmp]['keyword'] = $keyword;

case 'DEFAULT':

$result['featureIndex'][$keywordCmp]['value'] = $this->getValue($parseString);

break;

}

}

} else {

}

return $result;

}

/************************************

*

* Parsing: Helper functions

*/

protected function nextPart(&$parseString, $regex, $trimAll = FALSE) {

$reg = array();

return $reg[1];

}

// No match found

}

$value = array('?');

$parameterReferences['?'][] = &$value;

if (isset($parameterReferences[$parameter])) {

// Use the same reference as last time we encountered this parameter

$value = &$parameterReferences[$parameter];

protected function getValue(&$parseString, $comparator = '', $mode = '') {

$value = '';

$listValues = array();

$listValues[] = $this->getValue($parseString);

if ($mode === 'INDEX') {

// Remove any length restriction on INDEX definition

$this->nextPart($parseString, '^([(]\d+[)])');

}

}

$kVals = array();

$kVals[] = $vArr[0];

}

return $kVals;

} else {

return $listValues;

}

// Quote?

case '"':

break;

case "'":

break;

default:

$reg = array();

$value = array($reg[1]);

}

break;

*/

protected function getValueInQuotes(&$parseString, $quote) {

$buffer = '';

$reg = array();

preg_match('/\\\\$/', $v, $reg);

} else {

return $this->parseStripslashes($buffer);

}

}

* @return string Error message.

*/

protected function parseError($msg, $restQuery) {

return $this->parse_error;

}

* @return string Output string

*/

protected function trimSQL($str) {

}

/*************************

*

* Compiling queries

* @see parseSQL()

*/

public function compileSQL($components) {

case 'SELECT':

$query = $this->compileSELECT($components);

break;

$query = $this->compileDELETE($components);

break;

case 'EXPLAIN':

break;

case 'DROPTABLE':

break;

case 'CREATETABLE':

$query = $this->compileCREATETABLE($components);

$limit = $components['LIMIT'];