Initial commit

tools/parser_sql/lexer/LexerSplitter.php

@@ -0,0 +1,93 @@
+<?php
+/**
+ * LexerSplitter.php
+ *
+ * Defines the characters, which are used to split the given SQL string.
+ * Part of PHPSQLParser.
+ *
+ * PHP version 5
+ *
+ * LICENSE:
+ * Copyright (c) 2010-2014 Justin Swanhart and André Rothe
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * @author    André Rothe <andre.rothe@phosco.info>
+ * @copyright 2010-2014 Justin Swanhart and André Rothe
+ * @license   http://www.debian.org/misc/bsd.license  BSD License (3 Clause)
+ * @version   SVN: $Id: LexerSplitter.php 842 2013-12-30 08:57:53Z phosco@gmx.de $
+ * 
+ */
+
+/**
+ * This class holds a sorted array of characters, which are used as stop token.
+ * On every part of the array the given SQL string will be split into single tokens.
+ * The array must be sorted by element size, longest first (3 chars -> 2 chars -> 1 char).
+ *
+ * @author  André Rothe <andre.rothe@phosco.info>
+ * @license http://www.debian.org/misc/bsd.license  BSD License (3 Clause)
+ *  
+ */
+class LexerSplitter {
+    protected static $splitters = array("<=>", "\r\n", "!=", ">=", "<=", "<>", "<<", ">>", ":=", "\\", "&&", "||", ":=",
+        "/*", "*/", "--", ">", "<", "|", "=", "^", "(", ")", "\t", "\n", "'", "\"", "`",
+        ",", "@", " ", "+", "-", "*", "/", ";",
+    );
+    protected $tokenSize;
+    protected $hashSet;
+
+    /**
+     * Constructor.
+     * 
+     * It initializes some fields.
+     */
+    public function __construct() {
+        $this->tokenSize = strlen(self::$splitters[0]); // should be the largest one
+        $this->hashSet = array_flip(self::$splitters);
+    }
+
+    /**
+     * Get the maximum length of a split token.
+     * 
+     * The largest element must be on position 0 of the internal $_splitters array,
+     * so the function returns the length of that token. It must be > 0.
+     * 
+     * @return int The number of characters for the largest split token.
+     */
+    public function getMaxLengthOfSplitter() {
+        return $this->tokenSize;
+    }
+
+    /**
+     * Looks into the internal split token array and compares the given token with
+     * the array content. It returns true, if the token will be found, false otherwise. 
+     *  
+     * @param String $token a string, which could be a split token. 
+     * 
+     * @return boolean true, if the given string will be a split token, false otherwise
+     */
+    public function isSplitter($token) {
+        return isset($this->hashSet[$token]);
+    }
+}

tools/parser_sql/lexer/PHPSQLLexer.php

@@ -0,0 +1,373 @@
+<?php
+/**
+ * PHPSQLLexer.php
+ *
+ * This file contains the lexer, which splits and recombines parts of the 
+ * SQL statement just before parsing.
+ * 
+ * PHP version 5
+ *
+ * LICENSE:
+ * Copyright (c) 2010-2014 Justin Swanhart and André Rothe
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * @author    André Rothe <andre.rothe@phosco.info>
+ * @copyright 2010-2014 Justin Swanhart and André Rothe
+ * @license   http://www.debian.org/misc/bsd.license  BSD License (3 Clause)
+ * @version   SVN: $Id: PHPSQLLexer.php 842 2013-12-30 08:57:53Z phosco@gmx.de $
+ * 
+ */
+
+require_once dirname(__FILE__) . '/LexerSplitter.php';
+require_once dirname(__FILE__) . '/../exceptions/InvalidParameterException.php';
+
+/**
+ * This class splits the SQL string into little parts, which the parser can
+ * use to build the result array.
+ * 
+ * @author  André Rothe <andre.rothe@phosco.info>
+ * @license http://www.debian.org/misc/bsd.license  BSD License (3 Clause)
+ *
+ */
+class PHPSQLLexer {
+    protected $splitters;
+
+    /**
+     * Constructor. 
+     * 
+     * It initializes some fields.
+     */
+    public function __construct() {
+        $this->splitters = new LexerSplitter();
+    }
+
+    /**
+     * Ends the given string $haystack with the string $needle?
+     * 
+     * @param string $haystack
+     * @param string $needle
+     * 
+     * @return boolean true, if the parameter $haystack ends with the character sequences $needle, false otherwise
+     */
+    protected function endsWith($haystack, $needle) {
+        $length = strlen($needle);
+        if ($length == 0) {
+            return true;
+        }
+
+        return substr($haystack, -$length) === $needle;
+    }
+
+    public function split($sql) {
+        if (!is_string($sql)) {
+            throw new InvalidParameterException($sql);
+        }
+
+        $tokens = array();
+        $token = "";
+
+        $splitLen = $this->splitters->getMaxLengthOfSplitter();
+        $found = false;
+        $len = strlen($sql);
+        $pos = 0;
+
+        while ($pos < $len) {
+
+            for ($i = $splitLen; $i > 0; $i--) {
+                $substr = substr($sql, $pos, $i);
+                if ($this->splitters->isSplitter($substr)) {
+
+                    if ($token !== "") {
+                        $tokens[] = $token;
+                    }
+
+                    $tokens[] = $substr;
+                    $pos += $i;
+                    $token = "";
+
+                    continue 2;
+                }
+            }
+
+            $token .= $sql[$pos];
+            $pos++;
+        }
+
+        if ($token !== "") {
+            $tokens[] = $token;
+        }
+
+        $tokens = $this->concatEscapeSequences($tokens);
+        $tokens = $this->balanceBackticks($tokens);
+        $tokens = $this->concatColReferences($tokens);
+        $tokens = $this->balanceParenthesis($tokens);
+        $tokens = $this->concatComments($tokens);
+        $tokens = $this->concatUserDefinedVariables($tokens);
+
+        return $tokens;
+    }
+
+    protected function concatUserDefinedVariables($tokens) {
+        $i = 0;
+        $cnt = count($tokens);
+        $userdef = false;
+
+        while ($i < $cnt) {
+
+            if (!isset($tokens[$i])) {
+                $i++;
+
+                continue;
+            }
+
+            $token = $tokens[$i];
+
+            if ($userdef !== false) {
+                $tokens[$userdef] .= $token;
+                unset($tokens[$i]);
+                if ($token !== "@") {
+                    $userdef = false;
+                }
+            }
+
+            if ($userdef === false && $token === "@") {
+                $userdef = $i;
+            }
+
+            $i++;
+        }
+
+        return array_values($tokens);
+    }
+
+    protected function concatComments($tokens) {
+
+        $i = 0;
+        $cnt = count($tokens);
+        $comment = false;
+
+        while ($i < $cnt) {
+
+            if (!isset($tokens[$i])) {
+                $i++;
+
+                continue;
+            }
+
+            $token = $tokens[$i];
+
+            if ($comment !== false) {
+                if ($inline === true && ($token === "\n" || $token === "\r\n")) {
+                    $comment = false;
+                } else {
+                    unset($tokens[$i]);
+                    $tokens[$comment] .= $token;
+                }
+                if ($inline === false && ($token === "*/")) {
+                    $comment = false;
+                }
+            }
+
+            if (($comment === false) && ($token === "--")) {
+                $comment = $i;
+                $inline = true;
+            }
+
+            if (($comment === false) && ($token === "/*")) {
+                $comment = $i;
+                $inline = false;
+            }
+
+            $i++;
+        }
+
+        return array_values($tokens);
+    }
+
+    protected function isBacktick($token) {
+        return $token === "'" || $token === "\"" || $token === "`";
+    }
+
+    protected function balanceBackticks($tokens) {
+        $i = 0;
+        $cnt = count($tokens);
+        while ($i < $cnt) {
+
+            if (!isset($tokens[$i])) {
+                $i++;
+
+                continue;
+            }
+
+            $token = $tokens[$i];
+
+            if ($this->isBacktick($token)) {
+                $tokens = $this->balanceCharacter($tokens, $i, $token);
+            }
+
+            $i++;
+        }
+
+        return $tokens;
+    }
+
+    // backticks are not balanced within one token, so we have
+    // to re-combine some tokens
+    protected function balanceCharacter($tokens, $idx, $char) {
+
+        $token_count = count($tokens);
+        $i = $idx + 1;
+        while ($i < $token_count) {
+
+            if (!isset($tokens[$i])) {
+                $i++;
+
+                continue;
+            }
+
+            $token = $tokens[$i];
+            $tokens[$idx] .= $token;
+            unset($tokens[$i]);
+
+            if ($token === $char) {
+                break;
+            }
+
+            $i++;
+        }
+
+        return array_values($tokens);
+    }
+
+    /**
+     * This function concats some tokens to a column reference.
+     * There are two different cases:
+     * 
+     * 1. If the current token ends with a dot, we will add the next token
+     * 2. If the next token starts with a dot, we will add it to the previous token 
+     *
+     */
+    protected function concatColReferences($tokens) {
+
+        $cnt = count($tokens);
+        $i = 0;
+        while ($i < $cnt) {
+
+            if (!isset($tokens[$i])) {
+                $i++;
+
+                continue;
+            }
+
+            if ($tokens[$i][0] === ".") {
+
+                // concat the previous tokens, till the token has been changed
+                $k = $i - 1;
+                $len = strlen($tokens[$i]);
+                while (($k >= 0) && ($len == strlen($tokens[$i]))) {
+                    if (!isset($tokens[$k])) { // FIXME: this can be wrong if we have schema . table . column
+                        $k--;
+
+                        continue;
+                    }
+                    $tokens[$i] = $tokens[$k] . $tokens[$i];
+                    unset($tokens[$k]);
+                    $k--;
+                }
+            }
+
+            if ($this->endsWith($tokens[$i], '.') && !is_numeric($tokens[$i])) {
+
+                // concat the next tokens, till the token has been changed
+                $k = $i + 1;
+                $len = strlen($tokens[$i]);
+                while (($k < $cnt) && ($len == strlen($tokens[$i]))) {
+                    if (!isset($tokens[$k])) {
+                        $k++;
+
+                        continue;
+                    }
+                    $tokens[$i] .= $tokens[$k];
+                    unset($tokens[$k]);
+                    $k++;
+                }
+            }
+
+            $i++;
+        }
+
+        return array_values($tokens);
+    }
+
+    protected function concatEscapeSequences($tokens) {
+        $tokenCount = count($tokens);
+        $i = 0;
+        while ($i < $tokenCount) {
+
+            if ($this->endsWith($tokens[$i], "\\")) {
+                $i++;
+                if (isset($tokens[$i])) {
+                    $tokens[$i - 1] .= $tokens[$i];
+                    unset($tokens[$i]);
+                }
+            }
+            $i++;
+        }
+
+        return array_values($tokens);
+    }
+
+    protected function balanceParenthesis($tokens) {
+        $token_count = count($tokens);
+        $i = 0;
+        while ($i < $token_count) {
+            if ($tokens[$i] !== '(') {
+                $i++;
+
+                continue;
+            }
+            $count = 1;
+            for ($n = $i + 1; $n < $token_count; $n++) {
+                $token = $tokens[$n];
+                if ($token === '(') {
+                    $count++;
+                }
+                if ($token === ')') {
+                    $count--;
+                }
+                $tokens[$i] .= $token;
+                unset($tokens[$n]);
+                if ($count === 0) {
+                    $n++;
+
+                    break;
+                }
+            }
+            $i = $n;
+        }
+
+        return array_values($tokens);
+    }
+}

tools/parser_sql/lexer/index.php

@@ -0,0 +1,35 @@
+<?php
+/**
+ * 2007-2019 PrestaShop and Contributors
+ *
+ * NOTICE OF LICENSE
+ *
+ * This source file is subject to the Open Software License (OSL 3.0)
+ * that is bundled with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * https://opensource.org/licenses/OSL-3.0
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@prestashop.com so we can send you a copy immediately.
+ *
+ * DISCLAIMER
+ *
+ * Do not edit or add to this file if you wish to upgrade PrestaShop to newer
+ * versions in the future. If you wish to customize PrestaShop for your
+ * needs please refer to https://www.prestashop.com for more information.
+ *
+ * @author    PrestaShop SA <contact@prestashop.com>
+ * @copyright 2007-2019 PrestaShop SA and Contributors
+ * @license   https://opensource.org/licenses/OSL-3.0 Open Software License (OSL 3.0)
+ * International Registered Trademark & Property of PrestaShop SA
+ */
+
+header("Expires: Mon, 26 Jul 1997 05:00:00 GMT");
+header("Last-Modified: ".gmdate("D, d M Y H:i:s")." GMT");
+
+header("Cache-Control: no-store, no-cache, must-revalidate");
+header("Cache-Control: post-check=0, pre-check=0", false);
+header("Pragma: no-cache");
+
+header("Location: ../");
+exit;