t3lib_sqlparser Class Reference

Inherited by t3lib_sqlengine.

List of all members.

Public Member Functions
	parseSQL ($parseString)
	Parses any single SQL query.
	parseSELECT ($parseString)
	Parsing SELECT query.
	parseUPDATE ($parseString)
	Parsing UPDATE query.
	parseINSERT ($parseString)
	Parsing INSERT query.
	parseDELETE ($parseString)
	Parsing DELETE query.
	parseEXPLAIN ($parseString)
	Parsing EXPLAIN query.
	parseCREATETABLE ($parseString)
	Parsing CREATE TABLE query.
	parseALTERTABLE ($parseString)
	Parsing ALTER TABLE query.
	parseDROPTABLE ($parseString)
	Parsing DROP TABLE query.
	parseFieldList (&$parseString, $stopRegex='')
	Parsing the fields in the "SELECT [$selectFields] FROM" part of a query into an array.
	parseFromTables (&$parseString, $stopRegex='')
	Parsing the tablenames in the "FROM [$parseString] WHERE" part of a query into an array.
	parseWhereClause (&$parseString, $stopRegex='')
	Parsing the WHERE clause fields in the "WHERE [$parseString] ..." part of a query into a multidimensional array.
	parseFieldDef (&$parseString, $stopRegex='')
	Parsing the WHERE clause fields in the "WHERE [$parseString] ..." part of a query into a multidimensional array.
	nextPart (&$parseString, $regex, $trimAll=FALSE)
	Strips of a part of the parseString and returns the matching part.
	getValue (&$parseString, $comparator='')
	Finds value in beginning of $parseString, returns result and strips it of parseString.
Public Attributes
	$parse_error = ''
	$lastStopKeyWord = ''

---

Member Function Documentation

t3lib_sqlparser::getValue (  &$  parseString, $  comparator = '' )

Finds value in beginning of $parseString, returns result and strips it of parseString. Parameters: string  The parseString, eg. "(0,1,2,3) ..." or "('asdf','qwer') ..." or "1234 ..." or "'My string value here' ..." string  The comparator used before. If "NOT IN" or "IN" then the value is expected to be a list of values. Otherwise just an integer (un-quoted) or string (quoted) Returns: string The value (string/integer). Otherwise an array with error message in first key (0) Strip slashes function used for parsing NOTICE: If a query being parsed was prepared for another database than MySQL this function should probably be changed Parameters: string  Input string Returns: string Output string Add slashes function used for compiling queries NOTICE: If a query being parsed was prepared for another database than MySQL this function should probably be changed Parameters: string  Input string Returns: string Output string Setting the internal error message value, $this->parse_error and returns that value. Parameters: string  Input error message string  Remaining query to parse. Returns: string Error message. Trimming SQL as preparation for parsing. ";" in the end is stripped of. White space is trimmed away around the value A single space-char is added in the end Parameters: string  Input string Returns: string Output string Compiles an SQL query from components Parameters: array  Array of SQL query components Returns: string SQL query See also: parseSQL() Compiles a SELECT statement from components array Parameters: array  Array of SQL query components Returns: string SQL SELECT query See also: parseSELECT() Compiles an UPDATE statement from components array Parameters: array  Array of SQL query components Returns: string SQL UPDATE query See also: parseUPDATE() Compiles an INSERT statement from components array Parameters: array  Array of SQL query components Returns: string SQL INSERT query See also: parseINSERT() Compiles an DELETE statement from components array Parameters: array  Array of SQL query components Returns: string SQL DELETE query See also: parseDELETE() Compiles a CREATE TABLE statement from components array Parameters: array  Array of SQL query components Returns: string SQL CREATE TABLE query See also: parseCREATETABLE() Compiles an ALTER TABLE statement from components array Parameters: array  Array of SQL query components Returns: string SQL ALTER TABLE query See also: parseALTERTABLE() Compiles a "SELECT [output] FROM..:" field list based on input array (made with ->parseFieldList()) Can also compile field lists for ORDER BY and GROUP BY. Parameters: array  Array of select fields, (made with ->parseFieldList()) Returns: string Select field string See also: parseFieldList() Compiles a "FROM [output] WHERE..:" table list based on input array (made with ->parseFromTables()) Parameters: array  Array of table names, (made with ->parseFromTables()) Returns: string Table name string See also: parseFromTables() Implodes an array of WHERE clause configuration into a WHERE clause. NOTICE: MIGHT BY A TEMPORARY FUNCTION. Use for debugging only! Parameters: array  WHERE clause configuration Returns: string WHERE clause as string. See also: explodeWhereClause() Compile field definition Parameters: array  Field definition parts Returns: string Field definition string Check parsability of input SQL part string; Will parse and re-compile after which it is compared Parameters: string  Part definition of string; "SELECT" = fieldlist (also ORDER BY and GROUP BY), "FROM" = table list, "WHERE" = Where clause. string  SQL string to verify parsability of Returns: mixed Returns array with string 1 and 2 if error, otherwise false Compare two query strins by stripping away whitespace. Parameters: string  SQL String 1 string  SQL string 2 boolean  If true, the strings are compared insensitive to case Returns: mixed Returns array with string 1 and 2 if error, otherwise false Performs the ultimate test of the parser: Direct a SQL query in; You will get it back (through the parsed and re-compiled) if no problems, otherwise the script will print the error and exit Parameters: string  SQL query Returns: string Query if all is well, otherwise exit. Definition at line 999 of file class.t3lib_sqlparser.php.

t3lib_sqlparser::nextPart (  &$  parseString, $  regex, $  trimAll = FALSE )

Strips of a part of the parseString and returns the matching part. Helper function for the parsing methods. Parameters: string  Parse string; if $regex finds anything the value of the first () level will be stripped of the string in the beginning. Further $parseString is left-trimmed (on success). Notice; parsestring is passed by reference. string  Regex to find a matching part in the beginning of the string. Rules: You MUST start the regex with "^" (finding stuff in the beginning of string) and the result of the first parenthesis is what will be returned to you (and stripped of the string). Eg. '^(AND|OR|&&)[[:space:]]+' will return AND, OR or && if found and having one of more whitespaces after it, plus shorten $parseString with that match and any space after (by ltrim()) boolean  If set the full match of the regex is stripped of the beginning of the string! Returns: string The value of the first parenthesis level of the REGEX. Definition at line 985 of file class.t3lib_sqlparser.php. Referenced by parseSQL(). { if (eregi($regex,$parseString.' ', $reg)) { // Adding space char because [[:space:]]+ is often a requirement in regex's $parseString = ltrim(substr($parseString,strlen($reg[$trimAll?0:1]))); return $reg[1]; } }

t3lib_sqlparser::parseALTERTABLE (  $  parseString  )

Parsing ALTER TABLE query. Parameters: string  SQL string starting with ALTER TABLE Returns: mixed Returns array with components of ALTER TABLE query on success, otherwise an error message string. See also: compileALTERTABLE() Definition at line 503 of file class.t3lib_sqlparser.php. Referenced by parseSQL(). { // Removing ALTER TABLE $parseString = $this->trimSQL($parseString); $parseString = eregi_replace('^ALTER[[:space:]]+TABLE[[:space:]]+','',$parseString); // Init output variable: $result = array(); $result['type'] = 'ALTERTABLE'; // Get table: $result['TABLE'] = $this->nextPart($parseString, '^([[:alnum:]_]+)[[:space:]]+'); if ($result['TABLE']) { if ($result['action'] = $this->nextPart($parseString, '^(CHANGE|DROP[[:space:]]+KEY|DROP[[:space:]]+PRIMARY[[:space:]]+KEY|ADD[[:space:]]+KEY|ADD[[:space:]]+PRIMARY[[:space:]]+KEY|DROP|ADD|RENAME)([[:space:]]+|\()')) { $actionKey = strtoupper(ereg_replace('[[:space:]]','',$result['action'])); // Getting field: if (t3lib_div::inList('ADDPRIMARYKEY,DROPPRIMARYKEY',$actionKey) || $fieldKey = $this->nextPart($parseString, '^([[:alnum:]_]+)[[:space:]]+')) { switch($actionKey) { case 'ADD': $result['FIELD'] = $fieldKey; $result['definition'] = $this->parseFieldDef($parseString); if ($this->parse_error) { return $this->parse_error; } break; case 'DROP': case 'RENAME': $result['FIELD'] = $fieldKey; break; case 'CHANGE': $result['FIELD'] = $fieldKey; if ($result['newField'] = $this->nextPart($parseString, '^([[:alnum:]_]+)[[:space:]]+')) { $result['definition'] = $this->parseFieldDef($parseString); if ($this->parse_error) { return $this->parse_error; } } else return $this->parseError('No NEW field name found',$parseString); break; case 'ADDKEY': case 'ADDPRIMARYKEY': $result['KEY'] = $fieldKey; $result['fields'] = $this->getValue($parseString,'_LIST'); if ($this->parse_error) { return $this->parse_error; } break; case 'DROPKEY': $result['KEY'] = $fieldKey; break; case 'DROPPRIMARYKEY': // ??? todo! break; } } else return $this->parseError('No field name found',$parseString); } else return $this->parseError('No action CHANGE, DROP or ADD found!',$parseString); } else return $this->parseError('No table found!',$parseString); // Should be no more content now: if ($parseString) { return $this->parseError('Still content in clause after parsing!',$parseString); } return $result; }

t3lib_sqlparser::parseCREATETABLE (  $  parseString  )

Parsing CREATE TABLE query. Parameters: string  SQL string starting with CREATE TABLE Returns: mixed Returns array with components of CREATE TABLE query on success, otherwise an error message string. See also: compileCREATETABLE() Definition at line 431 of file class.t3lib_sqlparser.php. Referenced by parseSQL(). { // Removing CREATE TABLE $parseString = $this->trimSQL($parseString); $parseString = eregi_replace('^CREATE[[:space:]]+TABLE[[:space:]]+','',$parseString); // Init output variable: $result = array(); $result['type'] = 'CREATETABLE'; // Get table: $result['TABLE'] = $this->nextPart($parseString, '^([[:alnum:]_]+)[[:space:]]*\(',TRUE); if ($result['TABLE']) { // While the parseString is not yet empty: while(strlen($parseString)>0) { if ($key = $this->nextPart($parseString, '^(KEY|PRIMARY KEY)([[:space:]]+|\()')) { // Getting key $key = strtoupper(ereg_replace('[[:space:]]','',$key)); switch($key) { case 'PRIMARYKEY': $result['KEYS'][$key] = $this->getValue($parseString,'_LIST'); if ($this->parse_error) { return $this->parse_error; } break; case 'KEY': if ($keyName = $this->nextPart($parseString, '^([[:alnum:]_]+)([[:space:]]+|\()')) { $result['KEYS'][$keyName] = $this->getValue($parseString,'_LIST'); if ($this->parse_error) { return $this->parse_error; } } else return $this->parseError('No keyname found',$parseString); break; } } elseif ($fieldName = $this->nextPart($parseString, '^([[:alnum:]_]+)[[:space:]]+')) { // Getting field: $result['FIELDS'][$fieldName]['definition'] = $this->parseFieldDef($parseString); if ($this->parse_error) { return $this->parse_error; } } // Finding delimiter: $delim = $this->nextPart($parseString, '^(,|\))'); if (!$delim) { return $this->parseError('No delimiter found',$parseString); } elseif ($delim==')') { break; } } // Finding what is after the table definition - table type in MySQL if ($delim==')') { if ($this->nextPart($parseString, '^(TYPE[[:space:]]*=)')) { $result['tableType'] = $parseString; $parseString = ''; } } else return $this->parseError('No fieldname found!',$parseString); // Getting table type } else return $this->parseError('No table found!',$parseString); // Should be no more content now: if ($parseString) { return $this->parseError('Still content in clause after parsing!',$parseString); } return $result; }

t3lib_sqlparser::parseDELETE (  $  parseString  )

Parsing DELETE query. Parameters: string  SQL string with DELETE query to parse Returns: mixed Returns array with components of DELETE query on success, otherwise an error message string. See also: compileDELETE() Definition at line 371 of file class.t3lib_sqlparser.php. Referenced by parseSQL(). { // Removing DELETE $parseString = $this->trimSQL($parseString); $parseString = eregi_replace('^DELETE[[:space:]]+FROM[[:space:]]+','',$parseString); // Init output variable: $result = array(); $result['type'] = 'DELETE'; // Get table: $result['TABLE'] = $this->nextPart($parseString, '^([[:alnum:]_]+)[[:space:]]+'); if ($result['TABLE']) { // WHERE if ($this->nextPart($parseString,'^(WHERE)')) { $result['WHERE'] = $this->parseWhereClause($parseString); if ($this->parse_error) { return $this->parse_error; } } } else return $this->parseError('No table found!',$parseString); // Should be no more content now: if ($parseString) { return $this->parseError('Still content in clause after parsing!',$parseString); } // Return result: return $result; }

t3lib_sqlparser::parseDROPTABLE (  $  parseString  )

Parsing DROP TABLE query. Parameters: string  SQL string starting with DROP TABLE Returns: mixed Returns array with components of DROP TABLE query on success, otherwise an error message string. Definition at line 572 of file class.t3lib_sqlparser.php. Referenced by parseSQL(). { // Removing DROP TABLE $parseString = $this->trimSQL($parseString); $parseString = eregi_replace('^DROP[[:space:]]+TABLE[[:space:]]+','',$parseString); // Init output variable: $result = array(); $result['type'] = 'DROPTABLE'; // IF EXISTS $result['ifExists'] = $this->nextPart($parseString, '^(IF[[:space:]]+EXISTS[[:space:]]+)'); // Get table: $result['TABLE'] = $this->nextPart($parseString, '^([[:alnum:]_]+)[[:space:]]+'); if ($result['TABLE']) { // Should be no more content now: if ($parseString) { return $this->parseError('Still content in clause after parsing!',$parseString); } return $result; } else return $this->parseError('No table found!',$parseString); }

t3lib_sqlparser::parseEXPLAIN (  $  parseString  )

Parsing EXPLAIN query. Parameters: string  SQL string with EXPLAIN query to parse Returns: mixed Returns array with components of EXPLAIN query on success, otherwise an error message string. See also: parseSELECT() Definition at line 409 of file class.t3lib_sqlparser.php. Referenced by parseSQL(). { // Removing EXPLAIN $parseString = $this->trimSQL($parseString); $parseString = eregi_replace('^EXPLAIN[[:space:]]+','',$parseString); // Init output variable: $result = $this->parseSELECT($parseString); if (is_array($result)) { $result['type'] = 'EXPLAIN'; } return $result; }

t3lib_sqlparser::parseFieldDef (  &$  parseString, $  stopRegex = '' )

Parsing the WHERE clause fields in the "WHERE [$parseString] ..." part of a query into a multidimensional array. The success of this parsing determines if that part of the query is supported by TYPO3. Parameters: string  WHERE clause to parse. NOTICE: passed by reference! string  Regular expressing to STOP parsing, eg. '^(GROUP BY|ORDER BY|LIMIT)([[:space:]]*)' Returns: mixed If successful parsing, returns an array, otherwise an error string. Definition at line 924 of file class.t3lib_sqlparser.php. Referenced by t3lib_sqlengine::processAccordingToConfig(). { // Prepare variables: $parseString = $this->trimSQL($parseString); $this->lastStopKeyWord = ''; $this->parse_error = ''; $result = array(); // Field type: if ($result['fieldType'] = $this->nextPart($parseString,'^(int|smallint|tinyint|mediumint|double|varchar|char|text|tinytext|mediumtext|blob|tinyblob|mediumblob|longblob)([[:space:]]+|\()')) { // Looking for value: if (substr($parseString,0,1)=='(') { $parseString = substr($parseString,1); if ($result['value'] = $this->nextPart($parseString,'^([^)]*)')) { $parseString = ltrim(substr($parseString,1)); } else return $this->parseError('No end-parenthesis for value found!',$parseString); } // Looking for keywords while($keyword = $this->nextPart($parseString,'^(DEFAULT|NOT[[:space:]]+NULL|AUTO_INCREMENT|UNSIGNED)([[:space:]]+|,|\))')) { $keywordCmp = strtoupper(ereg_replace('[[:space:]]*','',$keyword)); $result['featureIndex'][$keywordCmp]['keyword'] = $keyword; switch($keywordCmp) { case 'DEFAULT': $result['featureIndex'][$keywordCmp]['value'] = $this->getValue($parseString); break; } } } else return $this->parseError('Field type unknown!',$parseString); return $result; }

t3lib_sqlparser::parseFieldList (  &$  parseString, $  stopRegex = '' )

Parsing the fields in the "SELECT [$selectFields] FROM" part of a query into an array. The output from this function can be compiled back into a field list with ->compileFieldList() Will detect the keywords "DESC" and "ASC" after the table name; thus is can be used for parsing the more simply ORDER BY and GROUP BY field lists as well! Parameters: string  The string with fieldnames, eg. "title, uid AS myUid, max(tstamp), count(*)" etc. NOTICE: passed by reference! string  Regular expressing to STOP parsing, eg. '^(FROM)([[:space:]]*)' Returns: array If successful parsing, returns an array, otherwise an error string. See also: compileFieldList() Definition at line 631 of file class.t3lib_sqlparser.php. { // Prepare variables: $parseString = $this->trimSQL($parseString); $this->lastStopKeyWord = ''; $this->parse_error = ''; $stack = array(); // Contains the parsed content $pnt = 0; // Pointer to positions in $stack $level = 0; // Indicates the parenthesis level we are at. $loopExit = 0; // Recursivity brake. // $parseString is continously shortend by the process and we keep parsing it till it is zero: while (strlen($parseString)) { // Checking if we are inside / outside parenthesis (in case of a function like count(), max(), min() etc...): if ($level>0) { // Inside parenthesis here (does NOT detect if values in quotes are used, the only token is ")" or "("): // Accumulate function content until next () parenthesis: $funcContent = $this->nextPart($parseString,'^([^()]*.)'); $stack[$pnt]['func_content.'][] = array( 'level' => $level, 'func_content' => substr($funcContent,0,-1) ); $stack[$pnt]['func_content'].= $funcContent; // Detecting ( or ) switch(substr($stack[$pnt]['func_content'],-1)) { case '(': $level++; break; case ')': $level--; if (!$level) { // If this was the last parenthesis: $stack[$pnt]['func_content'] = substr($stack[$pnt]['func_content'],0,-1); $parseString = ltrim($parseString); // Remove any whitespace after the parenthesis. } break; } } else { // Outside parenthesis, looking for next field: // Looking for a known function (only known functions supported) $func = $this->nextPart($parseString,'^(count|max|min|floor|sum|avg)[[:space:]]*\('); if ($func) { $parseString = trim(substr($parseString,1)); // Strip of "(" $stack[$pnt]['type'] = 'function'; $stack[$pnt]['function'] = $func; $level++; // increse parenthesis level counter. } else { // Otherwise, look for regular fieldname: if ($fieldName = $this->nextPart($parseString,'^([[:alnum:]\*._]+)(,|[[:space:]]+)')) { $stack[$pnt]['type'] = 'field'; // Explode fieldname into field and table: $tableField = explode('.',$fieldName,2); if (count($tableField)==2) { $stack[$pnt]['table'] = $tableField[0]; $stack[$pnt]['field'] = $tableField[1]; } else { $stack[$pnt]['table'] = ''; $stack[$pnt]['field'] = $tableField[0]; } } else { return $this->parseError('No field name found as expected',$parseString); } } } // After a function or field we look for "AS" alias and a comma to separate to the next field in the list: if (!$level) { // Looking for "AS" alias: if ($as = $this->nextPart($parseString,'^(AS)[[:space:]]+')) { $stack[$pnt]['as'] = $this->nextPart($parseString,'^([[:alnum:]_]+)(,|[[:space:]]+)'); $stack[$pnt]['as_keyword'] = $as; } // Looking for "ASC" or "DESC" keywords (for ORDER BY) if ($sDir = $this->nextPart($parseString,'^(ASC|DESC)([[:space:]]+|,)')) { $stack[$pnt]['sortDir'] = $sDir; } // Looking for stop-keywords: if ($stopRegex && $this->lastStopKeyWord = $this->nextPart($parseString, $stopRegex)) { $this->lastStopKeyWord = strtoupper(ereg_replace('[[:space:]]*','',$this->lastStopKeyWord)); return $stack; } // Looking for comma (since the stop-keyword did not trigger a return...) if (strlen($parseString) && !$this->nextPart($parseString,'^(,)')) { return $this->parseError('No comma found as expected',$parseString); } // Increasing pointer: $pnt++; } // Check recursivity brake: $loopExit++; if ($loopExit>500) { return $this->parseError('More than 500 loops, exiting prematurely...',$parseString); } } // Return result array: return $stack; }

t3lib_sqlparser::parseFromTables (  &$  parseString, $  stopRegex = '' )

Parsing the tablenames in the "FROM [$parseString] WHERE" part of a query into an array. The success of this parsing determines if that part of the query is supported by TYPO3. Parameters: string  list of tables, eg. "pages, tt_content" or "pages A, pages B". NOTICE: passed by reference! string  Regular expressing to STOP parsing, eg. '^(WHERE)([[:space:]]*)' Returns: array If successful parsing, returns an array, otherwise an error string. See also: compileFromTables() Definition at line 749 of file class.t3lib_sqlparser.php. Referenced by t3lib_sqlengine::exec_SELECTquery(). { // Prepare variables: $parseString = $this->trimSQL($parseString); $this->lastStopKeyWord = ''; $this->parse_error = ''; $stack = array(); // Contains the parsed content $pnt = 0; // Pointer to positions in $stack $loopExit = 0; // Recursivity brake. // $parseString is continously shortend by the process and we keep parsing it till it is zero: while (strlen($parseString)) { // Looking for the table: if ($stack[$pnt]['table'] = $this->nextPart($parseString,'^([[:alnum:]_]+)(,|[[:space:]]+)')) { if ($as = $this->nextPart($parseString,'^(AS)[[:space:]]+')) { $stack[$pnt]['as'] = $this->nextPart($parseString,'^([[:alnum:]_]+)(,|[[:space:]]+)'); $stack[$pnt]['as_keyword'] = $as; } } else return $this->parseError('No table name found as expected!',$parseString); // Looking for JOIN if ($join = $this->nextPart($parseString,'^(JOIN|LEFT[[:space:]]+JOIN)[[:space:]]+')) { $stack[$pnt]['JOIN']['type'] = $join; if ($stack[$pnt]['JOIN']['withTable'] = $this->nextPart($parseString,'^([[:alnum:]_]+)[[:space:]]+ON[[:space:]]+',1)) { $field1 = $this->nextPart($parseString,'^([[:alnum:]_.]+)[[:space:]]*=[[:space:]]*',1); $field2 = $this->nextPart($parseString,'^([[:alnum:]_.]+)[[:space:]]+'); if ($field1 && $field2) { $stack[$pnt]['JOIN']['ON'] = array($field1,$field2); } else return $this->parseError('No join fields found!',$parseString); } else return $this->parseError('No join table found!',$parseString); } // Looking for stop-keywords: if ($stopRegex && $this->lastStopKeyWord = $this->nextPart($parseString, $stopRegex)) { $this->lastStopKeyWord = strtoupper(ereg_replace('[[:space:]]*','',$this->lastStopKeyWord)); return $stack; } // Looking for comma: if (strlen($parseString) && !$this->nextPart($parseString,'^(,)')) { return $this->parseError('No comma found as expected',$parseString); } // Increasing pointer: $pnt++; // Check recursivity brake: $loopExit++; if ($loopExit>500) { return $this->parseError('More than 500 loops, exiting prematurely...',$parseString); } } // Return result array: return $stack; }

t3lib_sqlparser::parseINSERT (  $  parseString  )

Parsing INSERT query. Parameters: string  SQL string with INSERT query to parse Returns: mixed Returns array with components of INSERT query on success, otherwise an error message string. See also: compileINSERT() Definition at line 311 of file class.t3lib_sqlparser.php. Referenced by parseSQL(). { // Removing INSERT $parseString = $this->trimSQL($parseString); $parseString = eregi_replace('^INSERT[[:space:]]+INTO[[:space:]]+','',$parseString); // Init output variable: $result = array(); $result['type'] = 'INSERT'; // Get table: $result['TABLE'] = $this->nextPart($parseString, '^([[:alnum:]_]+)([[:space:]]+|\()'); if ($result['TABLE']) { if ($this->nextPart($parseString,'^(VALUES)[[:space:]]+')) { // In this case there are no field names mentioned in the SQL! // Get values/fieldnames (depending...) $result['VALUES_ONLY'] = $this->getValue($parseString,'IN'); if ($this->parse_error) { return $this->parse_error; } } else { // There are apparently fieldnames listed: $fieldNames = $this->getValue($parseString,'_LIST'); if ($this->parse_error) { return $this->parse_error; } if ($this->nextPart($parseString,'^(VALUES)[[:space:]]+')) { // "VALUES" keyword binds the fieldnames to values: $values = $this->getValue($parseString,'IN'); // Using the "getValue" function to get the field list... if ($this->parse_error) { return $this->parse_error; } foreach($fieldNames as $k => $fN) { if (ereg('^[[:alnum:]_]+$',$fN)) { if (isset($values[$k])) { if (!isset($result['FIELDS'][$fN])) { $result['FIELDS'][$fN] = $values[$k]; } else return $this->parseError('Fieldname ("'.$fN.'") already found in list!',$parseString); } else return $this->parseError('No value set!',$parseString); } else return $this->parseError('Invalid fieldname ("'.$fN.'")',$parseString); } if (isset($values[$k+1])) { return $this->parseError('Too many values in list!',$parseString); } } else return $this->parseError('VALUES keyword expected',$parseString); } } else return $this->parseError('No table found!',$parseString); // Should be no more content now: if ($parseString) { return $this->parseError('Still content after parsing!',$parseString); } // Return result return $result; }

t3lib_sqlparser::parseSELECT (  $  parseString  )

Parsing SELECT query. Parameters: string  SQL string with SELECT query to parse Returns: mixed Returns array with components of SELECT query on success, otherwise an error message string. See also: compileSELECT() Definition at line 188 of file class.t3lib_sqlparser.php. Referenced by parseSQL(). { // Removing SELECT: $parseString = $this->trimSQL($parseString); $parseString = eregi_replace('^SELECT[[:space:]]+','',$parseString); // Init output variable: $result = array(); $result['type'] = 'SELECT'; // Looking for STRAIGHT_JOIN keyword: $result['STRAIGHT_JOIN'] = $this->nextPart($parseString, '^(STRAIGHT_JOIN)[[:space:]]+'); // Select fields: $result['SELECT'] = $this->parseFieldList($parseString, '^(FROM)[[:space:]]+'); if ($this->parse_error) { return $this->parse_error; } // Continue if string is not ended: if ($parseString) { // Get table list: $result['FROM'] = $this->parseFromTables($parseString, '^(WHERE)[[:space:]]+'); if ($this->parse_error) { return $this->parse_error; } // If there are more than just the tables (a WHERE clause that would be...) if ($parseString) { // Get WHERE clause: $result['WHERE'] = $this->parseWhereClause($parseString, '^(GROUP[[:space:]]+BY|ORDER[[:space:]]+BY|LIMIT)[[:space:]]+'); if ($this->parse_error) { return $this->parse_error; } // If the WHERE clause parsing was stopped by GROUP BY, ORDER BY or LIMIT, then proceed with parsing: if ($this->lastStopKeyWord) { // GROUP BY parsing: if ($this->lastStopKeyWord == 'GROUPBY') { $result['GROUPBY'] = $this->parseFieldList($parseString, '^(ORDER[[:space:]]+BY|LIMIT)[[:space:]]+'); if ($this->parse_error) { return $this->parse_error; } } // ORDER BY parsing: if ($this->lastStopKeyWord == 'ORDERBY') { $result['ORDERBY'] = $this->parseFieldList($parseString, '^(LIMIT)[[:space:]]+'); if ($this->parse_error) { return $this->parse_error; } } // LIMIT parsing: if ($this->lastStopKeyWord == 'LIMIT') { if (ereg('^([0-9]+|[0-9]+[[:space:]]*,[[:space:]]*[0-9]+)$',trim($parseString))) { $result['LIMIT'] = $parseString; } else { return $this->parseError('No value for limit!',$parseString); } } } } } else return $this->parseError('No table to select from!',$parseString); // Return result: return $result; }

t3lib_sqlparser::parseSQL (  $  parseString  )

Parses any single SQL query. Parameters: string  SQL query Returns: array Result array with all the parts in - or error message string See also: compileSQL(), debug_testSQL() Definition at line 128 of file class.t3lib_sqlparser.php. References nextPart(), parseALTERTABLE(), parseCREATETABLE(), parseDELETE(), parseDROPTABLE(), parseEXPLAIN(), parseINSERT(), parseSELECT(), and parseUPDATE(). { // Prepare variables: $parseString = $this->trimSQL($parseString); $this->parse_error = ''; $result = array(); // Finding starting keyword of string: $_parseString = $parseString; // Protecting original string... $keyword = $this->nextPart($_parseString, '^(SELECT|UPDATE|INSERT[[:space:]]+INTO|DELETE[[:space:]]+FROM|EXPLAIN|DROP[[:space:]]+TABLE|CREATE[[:space:]]+TABLE|ALTER[[:space:]]+TABLE)[[:space:]]+'); $keyword = strtoupper(ereg_replace('[[:space:]]*','',$keyword)); switch($keyword) { case 'SELECT': // Parsing SELECT query: $result = $this->parseSELECT($parseString); break; case 'UPDATE': // Parsing UPDATE query: $result = $this->parseUPDATE($parseString); break; case 'INSERTINTO': // Parsing INSERT query: $result = $this->parseINSERT($parseString); break; case 'DELETEFROM': // Parsing DELETE query: $result = $this->parseDELETE($parseString); break; case 'EXPLAIN': // Parsing EXPLAIN SELECT query: $result = $this->parseEXPLAIN($parseString); break; case 'DROPTABLE': // Parsing DROP TABLE query: $result = $this->parseDROPTABLE($parseString); break; case 'ALTERTABLE': // Parsing ALTER TABLE query: $result = $this->parseALTERTABLE($parseString); break; case 'CREATETABLE': // Parsing CREATE TABLE query: $result = $this->parseCREATETABLE($parseString); break; default: return $this->parseError('"'.$keyword.'" is not a keyword',$parseString); break; } return $result; }

t3lib_sqlparser::parseUPDATE (  $  parseString  )

Parsing UPDATE query. Parameters: string  SQL string with UPDATE query to parse Returns: mixed Returns array with components of UPDATE query on success, otherwise an error message string. See also: compileUPDATE() Definition at line 257 of file class.t3lib_sqlparser.php. Referenced by parseSQL(). { // Removing UPDATE $parseString = $this->trimSQL($parseString); $parseString = eregi_replace('^UPDATE[[:space:]]+','',$parseString); // Init output variable: $result = array(); $result['type'] = 'UPDATE'; // Get table: $result['TABLE'] = $this->nextPart($parseString, '^([[:alnum:]_]+)[[:space:]]+'); // Continue if string is not ended: if ($result['TABLE']) { if ($parseString && $this->nextPart($parseString, '^(SET)[[:space:]]+')) { $comma = TRUE; // Get field/value pairs: while($comma) { if ($fieldName = $this->nextPart($parseString,'^([[:alnum:]_]+)[[:space:]]*=')) { $this->nextPart($parseString,'^(=)'); // Strip of "=" sign. $value = $this->getValue($parseString); $result['FIELDS'][$fieldName] = $value; } else return $this->parseError('No fieldname found',$parseString); $comma = $this->nextPart($parseString,'^(,)'); } // WHERE if ($this->nextPart($parseString,'^(WHERE)')) { $result['WHERE'] = $this->parseWhereClause($parseString); if ($this->parse_error) { return $this->parse_error; } } } else return $this->parseError('Query missing SET...',$parseString); } else return $this->parseError('No table found!',$parseString); // Should be no more content now: if ($parseString) { return $this->parseError('Still content in clause after parsing!',$parseString); } // Return result: return $result; }

t3lib_sqlparser::parseWhereClause (  &$  parseString, $  stopRegex = '' )

Parsing the WHERE clause fields in the "WHERE [$parseString] ..." part of a query into a multidimensional array. The success of this parsing determines if that part of the query is supported by TYPO3. Parameters: string  WHERE clause to parse. NOTICE: passed by reference! string  Regular expressing to STOP parsing, eg. '^(GROUP BY|ORDER BY|LIMIT)([[:space:]]*)' Returns: mixed If successful parsing, returns an array, otherwise an error string. Definition at line 816 of file class.t3lib_sqlparser.php. Referenced by t3lib_sqlengine::exec_DELETEquery(), t3lib_sqlengine::exec_SELECTquery(), and t3lib_sqlengine::exec_UPDATEquery(). { // Prepare variables: $parseString = $this->trimSQL($parseString); $this->lastStopKeyWord = ''; $this->parse_error = ''; $stack = array(0 => array()); // Contains the parsed content $pnt = array(0 => 0); // Pointer to positions in $stack $level = 0; // Determines parenthesis level $loopExit = 0; // Recursivity brake. // $parseString is continously shortend by the process and we keep parsing it till it is zero: while (strlen($parseString)) { // Look for next parenthesis level: $newLevel = $this->nextPart($parseString,'^([(])'); if ($newLevel=='(') { // If new level is started, manage stack/pointers: $level++; // Increase level $pnt[$level] = 0; // Reset pointer for this level $stack[$level] = array(); // Reset stack for this level } else { // If no new level is started, just parse the current level: // Find "modifyer", eg. "NOT or !" $stack[$level][$pnt[$level]]['modifier'] = trim($this->nextPart($parseString,'^(!|NOT[[:space:]]+)')); // Fieldname: if ($fieldName = $this->nextPart($parseString,'^([[:alnum:]._]+)([[:space:]]+|&|<=|>=|<|>|=|!=|IS)')) { // Parse field name into field and table: $tableField = explode('.',$fieldName,2); if (count($tableField)==2) { $stack[$level][$pnt[$level]]['table'] = $tableField[0]; $stack[$level][$pnt[$level]]['field'] = $tableField[1]; } else { $stack[$level][$pnt[$level]]['table'] = ''; $stack[$level][$pnt[$level]]['field'] = $tableField[0]; } } else { return $this->parseError('No field name found as expected',$parseString); } // See if the value is calculated. Support only for "&" (boolean AND) at the moment: $stack[$level][$pnt[$level]]['calc'] = $this->nextPart($parseString,'^(&)'); if (strlen($stack[$level][$pnt[$level]]['calc'])) { // Finding value for calculation: $stack[$level][$pnt[$level]]['calc_value'] = $this->getValue($parseString); } // Find "comparator": $stack[$level][$pnt[$level]]['comparator'] = $this->nextPart($parseString,'^(<=|>=|<|>|=|!=|NOT[[:space:]]+IN|IN|NOT[[:space:]]+LIKE|LIKE|IS)'); if (strlen($stack[$level][$pnt[$level]]['comparator'])) { // Finding value for comparator: $stack[$level][$pnt[$level]]['value'] = $this->getValue($parseString,$stack[$level][$pnt[$level]]['comparator']); if ($this->parse_error) { return $this->parse_error; } } // Finished, increase pointer: $pnt[$level]++; // Checking if the current level is ended, in that case do stack management: while ($this->nextPart($parseString,'^([)])')) { $level--; // Decrease level: $stack[$level][$pnt[$level]]['sub'] = $stack[$level+1]; // Copy stack $pnt[$level]++; // Increase pointer of the new level // Make recursivity check: $loopExit++; if ($loopExit>500) { return $this->parseError('More than 500 loops (in search for exit parenthesis), exiting prematurely...',$parseString); } } // Detecting the operator for the next level; support for AND, OR and &&): $op = $this->nextPart($parseString,'^(AND|OR|AND[[:space:]]+NOT)(\(|[[:space:]]+)'); if ($op) { $stack[$level][$pnt[$level]]['operator'] = $op; } elseif (strlen($parseString)) { // Looking for stop-keywords: if ($stopRegex && $this->lastStopKeyWord = $this->nextPart($parseString, $stopRegex)) { $this->lastStopKeyWord = strtoupper(ereg_replace('[[:space:]]*','',$this->lastStopKeyWord)); return $stack[0]; } else { return $this->parseError('No operator, but parsing not finished.',$parseString); } } } // Make recursivity check: $loopExit++; if ($loopExit>500) { return $this->parseError('More than 500 loops, exiting prematurely...',$parseString); } } // Return the stacks lowest level: return $stack[0]; }

---

Member Data Documentation

t3lib_sqlparser::$lastStopKeyWord = ''

Definition at line 110 of file class.t3lib_sqlparser.php.

t3lib_sqlparser::$parse_error = ''

Definition at line 109 of file class.t3lib_sqlparser.php.

---

The documentation for this class was generated from the following file:

• t3lib/class.t3lib_sqlparser.php

---