move to Kodus domain

Author: mindplay-dk

.travis.yml

@@ -0,0 +1,10 @@
+language: php
+
+php:
+  - 7.0
+  - 7.1
+
+before_script:
+  - 'composer install --dev --prefer-source'
+
+script: php test/test.php

README.md

@@ -0,0 +1,39 @@
+# `kodus/sql-split`
+
+A simple parser to split SQL (and/or DDL) files into individual SQL queries and strip comments.
+
+[![PHP Version](https://img.shields.io/badge/php-7.0%2B-blue.svg)](https://packagist.org/packages/kodus/sql-split)
+[![Build Status](https://travis-ci.org/kodus/sql-split.svg?branch=master)](https://travis-ci.org/kodus/sql-split)
+
+### Install via Composer
+
+    composer require kodus/sql-split
+
+### Features
+
+I designed this for use with PDO and MySQL/PostgreSQL statements.
+
+It uses a very simple recursive descent parser to minimally tokenize valid SQL - this approach ensures there
+is no ambiguity between quoted strings, keywords, comments, etc. but makes no attempt to validate SQL command
+structure or validity of the extracted statements.
+
+It supports the following SQL/DDL features:
+
+ * SQL and DDL Queries
+ * Stored procedures, functions, views, triggers, etc.
+ * PostgreSQL dollar-tags (`$$` and `$mytag$` delimiters)
+ * The MySQL `DELIMITER` command
+
+## Usage
+
+Just this:
+
+```php
+$statements = Splitter::split(file_get_contents(...));
+```
+
+This will split to individual SQL statements and (by default) strip comments.
+
+Then just loop over your `$statements` and run them via `PDO`.
+
+That's all.

composer.json

@@ -1,10 +1,23 @@
 {
+    "name": "kodus/sql-split",
+    "type": "library",
+    "description": "A simple facility to split SQL files into individual queries - supports MySQL and PostgreSQL",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Rasmus Schultz",
+            "email": "rasmus@mindplay.dk"
+        }
+    ],
     "require": {
-        "mindplay/testies": "^0.3.1"
+        "php": "^7.0"
+    },
+    "require-dev": {
+        "mindplay/testies": "^0.3.0"
     },
     "autoload": {
         "psr-4": {
-            "mindplay\\sql_parser\\": "src/"
+            "Kodus\\SQL\\": "src/"
         }
     }
 }

src/SQLSplitter.php src/Splitter.phpsrc/SQLSplitter.php renamed to src/Splitter.php

@@ -1,8 +1,11 @@
 <?php
 
-namespace mindplay\sql_parser;
+namespace Kodus\SQL;
 
-abstract class SQLSplitter
+/**
+ * This class implements comment-stripping and kerjiggers the SQL tokens back into statements.
+ */
+abstract class Splitter
 {
     /**
      * @param string $sql
@@ -12,7 +15,7 @@ abstract class SQLSplitter
      */
     public static function split(string $sql, bool $strip_comments = true)
     {
-        $tokens = SQLTokenizer::tokenize($sql);
+        $tokens = Tokenizer::tokenize($sql);
 
         if ($strip_comments) {
             $tokens = self::stripComments($tokens);

src/SQLTokenizer.php src/Tokenizer.phpsrc/SQLTokenizer.php renamed to src/Tokenizer.php

@@ -1,10 +1,20 @@
 <?php
 
-namespace mindplay\sql_parser;
+namespace Kodus\SQL;
 
 use RuntimeException;
 
-class SQLTokenizer
+/**
+ * This class implements a simple recursive descent parser for minimal tokenization
+ * of files containing one or more MySQL or PostgreSQL statements.
+ *
+ * It's used internally by {@see Splitter} which provides the main point of entry -
+ * if you want to use the tokenizer for something else, have a look at the test-suite
+ * which contains a specification demonstrating the very simple token output format.
+ *
+ * @see Splitter::split()
+ */
+class Tokenizer
 {
     /**
      * @var int

test/test.php

@@ -1,60 +1,60 @@
 <?php
 
-use mindplay\sql_parser\SQLSplitter;
-use mindplay\sql_parser\SQLTokenizer;
+use Kodus\SQL\Splitter;
+use Kodus\SQL\Tokenizer;
 
 require dirname(__DIR__) . '/vendor/autoload.php';
 
 test(
     'single statement',
     function () {
-        eq(SQLTokenizer::tokenize("SELECT 1"), [["SELECT", " ", "1"]], "unterminated");
-        eq(SQLTokenizer::tokenize("SELECT 1"), [["SELECT", " ", "1"]], "terminated");
+        eq(Tokenizer::tokenize("SELECT 1"), [["SELECT", " ", "1"]], "unterminated");
+        eq(Tokenizer::tokenize("SELECT 1"), [["SELECT", " ", "1"]], "terminated");
     }
 );
 
 test(
     'multiple statements',
     function () {
-        eq(SQLTokenizer::tokenize("SELECT 1; SELECT 2"), [["SELECT", " ", "1"], ["SELECT", " ", "2"]], "separated statements");
-        eq(SQLTokenizer::tokenize("SELECT 1; SELECT 2;"), [["SELECT", " ", "1"], ["SELECT", " ", "2"]], "terminated statements");
+        eq(Tokenizer::tokenize("SELECT 1; SELECT 2"), [["SELECT", " ", "1"], ["SELECT", " ", "2"]], "separated statements");
+        eq(Tokenizer::tokenize("SELECT 1; SELECT 2;"), [["SELECT", " ", "1"], ["SELECT", " ", "2"]], "terminated statements");
     }
 );
 
 test(
     'various tokens',
     function () {
-        eq(SQLTokenizer::tokenize("SELECT * FROM bar"), [["SELECT", " ", "*", " ", "FROM", " ", "bar"]]);
-        eq(SQLTokenizer::tokenize("SELECT `foo` FROM `bar`"), [["SELECT", " ", "`foo`", " ", "FROM", " ", "`bar`"]]);
-        eq(SQLTokenizer::tokenize("SELECT 'some\"quotes'"), [["SELECT", " ", "'some\"quotes'"]]);
-        eq(SQLTokenizer::tokenize('SELECT "more quotes" AS `bar`'), [["SELECT", " ", '"more quotes"', " ", "AS", " ", "`bar`"]]);
-        eq(SQLTokenizer::tokenize("SELECT :foo, :bat AS bar"), [["SELECT", " ", ":foo", ",", " ", ":bat", " ", "AS", " ", "bar"]]);
-        eq(SQLTokenizer::tokenize("SELECT a*b+c-d FROM tbl"), [["SELECT", " ", "a", "*", "b", "+", "c", "-", "d", " ", "FROM", " ", "tbl"]]);
-        eq(SQLTokenizer::tokenize("UPDATE foo (a, b) SET (1, 2)"), [["UPDATE", " ", "foo", " ", ["(", "a", ",", " ", "b", ")"], " ", "SET", " ", ["(", "1", ",", " ", "2", ")"]]]);
-        eq(SQLTokenizer::tokenize("SELECT (({[1,2]}))"), [["SELECT", " ", ["(", ["(", ["{", ["[", "1", ",", "2", "]"], "}"], ")"], ")"]]], "nested brackets/braces");
-        eq(SQLTokenizer::tokenize("SELECT ( [ 1 ] )"), [["SELECT", " ", ["(", " ", ["[", " ", "1", " ", "]"], " ", ")"]]], "nested brackets/braces");
-        eq(SQLTokenizer::tokenize('CREATE FUNCTION foo AS $$RETURN $1$$;'), [["CREATE", " ", "FUNCTION", " ", "foo", " ", "AS", " ", '$$RETURN $1$$']], "stored procedure");
-        eq(SQLTokenizer::tokenize('SELECT $$FOO$$; SELECT $$BAR$$'), [["SELECT", " ", '$$FOO$$'], ["SELECT", " ", '$$BAR$$']], "dollar-quoted strings");
-        eq(SQLTokenizer::tokenize("SELECT 'foo\\'\\\\'"), [["SELECT", " ", "'foo\\'\\\\'"]]);
+        eq(Tokenizer::tokenize("SELECT * FROM bar"), [["SELECT", " ", "*", " ", "FROM", " ", "bar"]]);
+        eq(Tokenizer::tokenize("SELECT `foo` FROM `bar`"), [["SELECT", " ", "`foo`", " ", "FROM", " ", "`bar`"]]);
+        eq(Tokenizer::tokenize("SELECT 'some\"quotes'"), [["SELECT", " ", "'some\"quotes'"]]);
+        eq(Tokenizer::tokenize('SELECT "more quotes" AS `bar`'), [["SELECT", " ", '"more quotes"', " ", "AS", " ", "`bar`"]]);
+        eq(Tokenizer::tokenize("SELECT :foo, :bat AS bar"), [["SELECT", " ", ":foo", ",", " ", ":bat", " ", "AS", " ", "bar"]]);
+        eq(Tokenizer::tokenize("SELECT a*b+c-d FROM tbl"), [["SELECT", " ", "a", "*", "b", "+", "c", "-", "d", " ", "FROM", " ", "tbl"]]);
+        eq(Tokenizer::tokenize("UPDATE foo (a, b) SET (1, 2)"), [["UPDATE", " ", "foo", " ", ["(", "a", ",", " ", "b", ")"], " ", "SET", " ", ["(", "1", ",", " ", "2", ")"]]]);
+        eq(Tokenizer::tokenize("SELECT (({[1,2]}))"), [["SELECT", " ", ["(", ["(", ["{", ["[", "1", ",", "2", "]"], "}"], ")"], ")"]]], "nested brackets/braces");
+        eq(Tokenizer::tokenize("SELECT ( [ 1 ] )"), [["SELECT", " ", ["(", " ", ["[", " ", "1", " ", "]"], " ", ")"]]], "nested brackets/braces");
+        eq(Tokenizer::tokenize('CREATE FUNCTION foo AS $$RETURN $1$$;'), [["CREATE", " ", "FUNCTION", " ", "foo", " ", "AS", " ", '$$RETURN $1$$']], "stored procedure");
+        eq(Tokenizer::tokenize('SELECT $$FOO$$; SELECT $$BAR$$'), [["SELECT", " ", '$$FOO$$'], ["SELECT", " ", '$$BAR$$']], "dollar-quoted strings");
+        eq(Tokenizer::tokenize("SELECT 'foo\\'\\\\'"), [["SELECT", " ", "'foo\\'\\\\'"]]);
     }
 );
 
 test(
     'comments',
     function () {
-        eq(SQLTokenizer::tokenize("-- one\nSELECT -- two\n1; -- three\n-- four"), [["-- one", "\n", "SELECT", " ", "-- two", "\n", "1"], ["-- three", "\n", "-- four"]]);
-        eq(SQLTokenizer::tokenize("/* one\ntwo */\nSELECT 1;/* three\nfour */\nSELECT 2;"), [["/* one\ntwo */", "\n", "SELECT", " ", "1"], ["/* three\nfour */", "\n", "SELECT", " ", "2"]]);
+        eq(Tokenizer::tokenize("-- one\nSELECT -- two\n1; -- three\n-- four"), [["-- one", "\n", "SELECT", " ", "-- two", "\n", "1"], ["-- three", "\n", "-- four"]]);
+        eq(Tokenizer::tokenize("/* one\ntwo */\nSELECT 1;/* three\nfour */\nSELECT 2;"), [["/* one\ntwo */", "\n", "SELECT", " ", "1"], ["/* three\nfour */", "\n", "SELECT", " ", "2"]]);
     }
 );
 
 test(
     'split statements',
     function () {
-        eq(SQLSplitter::split("SELECT 1; SELECT 2;"), ["SELECT 1", "SELECT 2"]);
-        eq(SQLSplitter::split("-- one\nSELECT -- two\n1; -- three\n-- four"), ["SELECT \n1"]);
-        eq(SQLSplitter::split("-- one\nSELECT -- two\n1; -- three\n-- four", false), ["-- one\nSELECT -- two\n1", "-- three\n-- four"]);
-        eq(SQLSplitter::split("/* one\ntwo */\nSELECT 1;/* three\nfour */\nSELECT 2;"), ["SELECT 1", "SELECT 2"]);
-        eq(SQLSplitter::split("/* one\ntwo */\nSELECT 1;\n/* three\nfour */\nSELECT 2;", false), ["/* one\ntwo */\nSELECT 1", "/* three\nfour */\nSELECT 2"]);
+        eq(Splitter::split("SELECT 1; SELECT 2;"), ["SELECT 1", "SELECT 2"]);
+        eq(Splitter::split("-- one\nSELECT -- two\n1; -- three\n-- four"), ["SELECT \n1"]);
+        eq(Splitter::split("-- one\nSELECT -- two\n1; -- three\n-- four", false), ["-- one\nSELECT -- two\n1", "-- three\n-- four"]);
+        eq(Splitter::split("/* one\ntwo */\nSELECT 1;/* three\nfour */\nSELECT 2;"), ["SELECT 1", "SELECT 2"]);
+        eq(Splitter::split("/* one\ntwo */\nSELECT 1;\n/* three\nfour */\nSELECT 2;", false), ["/* one\ntwo */\nSELECT 1", "/* three\nfour */\nSELECT 2"]);
     }
 );
 
@@ -212,7 +212,7 @@ function (string $sql) {
 
     $sql = str_replace("-----", "\n", $sql_template);
 
-    foreach (SQLSplitter::split($sql, false) as $index => $statement) {
+    foreach (Splitter::split($sql, false) as $index => $statement) {
         eq($statement, $expected_statements[$index]);
     }
 });
@@ -247,7 +247,7 @@ function (string $sql) {
 SQL;
 
 test("mysql use-case", function () use ($mysql_script, $mysql_statements) {
-    eq(SQLSplitter::split($mysql_script), array_map("trim", explode("-----", $mysql_statements)));
+    eq(Splitter::split($mysql_script), array_map("trim", explode("-----", $mysql_statements)));
 });
 
 exit(run());