sql-testing-tools 0.2.3__tar.gz → 0.2.4__tar.gz

sql_testing_tools-0.2.4/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.2
+Name: sql_testing_tools
+Version: 0.2.4
+Description-Content-Type: text/markdown
+Requires-Dist: sqlparse>=0.5.1
+Requires-Dist: requests>=2.32.3
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+
+A library that normalizes simple SQL queries and compares them first by equality of the normalized string and then using the cosette API. 
+
+### [Beta in Development!]
+ [![Build and Test](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-build.yml/badge.svg)](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-build.yml)
+ [![Build and Test](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-unittests.yml/badge.svg)](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-unittests.yml)
+
+- Submit bug reports and features requests at: https://github.com/ValentinHerrmann/sql_testing_tools
+- PyPi-Package available at: https://pypi.org/project/sql-testing-tools/ 
+
+
+
+### Getting started
+
+Use the following code to import the SQL Testing Tools to your project:
+``` python
+# ensure to always use the latest version of sql_testing_tools
+import os
+os.system('pip install -U sql_testing_tools')
+
+# import sql_testing_tools
+import sql_testing_tools.BaseAccess as Ba
+import sql_testing_tools.Helper as He
+```
+
+On global level of your test class, set the SQLite database you want to use (bases must be located in the repository of the test class, no DBs contained in sql_testing_tools).
+``` python
+import unittest 
+class TestClass(unittest.TestCase):
+    Ba.setDBName("databases/ladepunkte.db") 
+```
+
+The following methods are available for use in test methods:
+``` python
+try:
+    Ba.runAndGetStringTable_fromFile("sqlfile.sql")
+except Exception as e:
+    # the execution failed 
+    # (usually due to syntax or database errors)
+    self.fail(e)
+
+# (optional) set the files to be compared. The sql strings will 
+# be normalized and used for all following methods (to improve 
+# performance), until new  files are set. Arguments that are
+# None or "" are ignored and the sql string remains the same.
+# Raises an Exception if one of the files is empty.
+setup("sqlfile.sql","solution.sql")
+
+# All following methods call setup(sql,sol) before executing 
+# anything else. Call without arguments to keep the last 
+# normalized sql strings (and improve performance).
+# Each check was successfull if "" is returned. Returns a 
+# German error message if not.
+# Each method compares the normalized string between the start
+# keyword and the next keyword or ;
+
+res = He.checkColumns() # starts to search at keyword "SELECT"
+res = He.checkTables() # starts to search at keyword "FROM"
+res = He.checkCondition() # starts to search at keyword "WHERE"
+res = He.checkOrder() # starts to search at keyword "ORDER BY"
+res = He.checkGroup() # starts to search at keyword "GROUP BY"
+
+# can not be called with new sql files
+res = checkKeywords("startKeyword",["end","keywords"]) 
+
+# compares equality of the full normalized sql strings and if 
+# not equal uses the Cosette API (cosette.cs.washington.edu)
+# for comparison. A file 'cosette_apikey.txt' with only the 
+# apikey in it on root level of the test repository is required 
+# to use this feature. If not existant, only the string comparison
+# is performed.
+# Warning: Cosette is not maintained!
+res = checkEquality()
+```
+
+
+
+
+
+
+
+
+
+### Changelog
+
+##### V0.2.4
+- Added more check methods for single parts of queries: checkColumns, checkTables, checkCondition, checkOrder, checkGroup, checkKeywords
+
+##### V 0.2.3
+- fix: ASC/DESC in ORDER BY (also with multiple columns and order directions), no direction treated as ASC
+- Verified that ; and whitespaces, linebreaks at end of query are ignored
+
+##### V 0.2.2 
+- Support LIKE
+- Support '<=' and '>=' (geq and leq)
+
+##### V 0.2.1
+- Support LIMIT
+  
+##### V 0.1.9 + 0.2.0
+- Support ORDER BY
+
+##### V 0.1.8
+- Fixed linebreak problems: Linebreaks are now converted into whitespaces before parsing where tokens
+
+##### V 0.1.6 + V 0.1.7
+- Fixed import error to ensure imports working in different environments
+
+##### V 0.1.4 + V 0.1.5
+- Chained conditions (with AND,OR and Paranthesises) in WHERE statement
+- Aggregate Functions
+
+##### V 0.1.3
+- SELECT: columns with our without table prefix
+- FROM: one or more table from DB; no queries as tables!
+- WHERE: single conditions; no Paranthesises!
+- GROUP BY one or more columns
+

sql_testing_tools-0.2.4/README.md

@@ -0,0 +1,117 @@
+A library that normalizes simple SQL queries and compares them first by equality of the normalized string and then using the cosette API. 
+
+### [Beta in Development!]
+ [![Build and Test](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-build.yml/badge.svg)](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-build.yml)
+ [![Build and Test](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-unittests.yml/badge.svg)](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-unittests.yml)
+
+- Submit bug reports and features requests at: https://github.com/ValentinHerrmann/sql_testing_tools
+- PyPi-Package available at: https://pypi.org/project/sql-testing-tools/ 
+
+
+
+### Getting started
+
+Use the following code to import the SQL Testing Tools to your project:
+``` python
+# ensure to always use the latest version of sql_testing_tools
+import os
+os.system('pip install -U sql_testing_tools')
+
+# import sql_testing_tools
+import sql_testing_tools.BaseAccess as Ba
+import sql_testing_tools.Helper as He
+```
+
+On global level of your test class, set the SQLite database you want to use (bases must be located in the repository of the test class, no DBs contained in sql_testing_tools).
+``` python
+import unittest 
+class TestClass(unittest.TestCase):
+    Ba.setDBName("databases/ladepunkte.db") 
+```
+
+The following methods are available for use in test methods:
+``` python
+try:
+    Ba.runAndGetStringTable_fromFile("sqlfile.sql")
+except Exception as e:
+    # the execution failed 
+    # (usually due to syntax or database errors)
+    self.fail(e)
+
+# (optional) set the files to be compared. The sql strings will 
+# be normalized and used for all following methods (to improve 
+# performance), until new  files are set. Arguments that are
+# None or "" are ignored and the sql string remains the same.
+# Raises an Exception if one of the files is empty.
+setup("sqlfile.sql","solution.sql")
+
+# All following methods call setup(sql,sol) before executing 
+# anything else. Call without arguments to keep the last 
+# normalized sql strings (and improve performance).
+# Each check was successfull if "" is returned. Returns a 
+# German error message if not.
+# Each method compares the normalized string between the start
+# keyword and the next keyword or ;
+
+res = He.checkColumns() # starts to search at keyword "SELECT"
+res = He.checkTables() # starts to search at keyword "FROM"
+res = He.checkCondition() # starts to search at keyword "WHERE"
+res = He.checkOrder() # starts to search at keyword "ORDER BY"
+res = He.checkGroup() # starts to search at keyword "GROUP BY"
+
+# can not be called with new sql files
+res = checkKeywords("startKeyword",["end","keywords"]) 
+
+# compares equality of the full normalized sql strings and if 
+# not equal uses the Cosette API (cosette.cs.washington.edu)
+# for comparison. A file 'cosette_apikey.txt' with only the 
+# apikey in it on root level of the test repository is required 
+# to use this feature. If not existant, only the string comparison
+# is performed.
+# Warning: Cosette is not maintained!
+res = checkEquality()
+```
+
+
+
+
+
+
+
+
+
+### Changelog
+
+##### V0.2.4
+- Added more check methods for single parts of queries: checkColumns, checkTables, checkCondition, checkOrder, checkGroup, checkKeywords
+
+##### V 0.2.3
+- fix: ASC/DESC in ORDER BY (also with multiple columns and order directions), no direction treated as ASC
+- Verified that ; and whitespaces, linebreaks at end of query are ignored
+
+##### V 0.2.2 
+- Support LIKE
+- Support '<=' and '>=' (geq and leq)
+
+##### V 0.2.1
+- Support LIMIT
+  
+##### V 0.1.9 + 0.2.0
+- Support ORDER BY
+
+##### V 0.1.8
+- Fixed linebreak problems: Linebreaks are now converted into whitespaces before parsing where tokens
+
+##### V 0.1.6 + V 0.1.7
+- Fixed import error to ensure imports working in different environments
+
+##### V 0.1.4 + V 0.1.5
+- Chained conditions (with AND,OR and Paranthesises) in WHERE statement
+- Aggregate Functions
+
+##### V 0.1.3
+- SELECT: columns with our without table prefix
+- FROM: one or more table from DB; no queries as tables!
+- WHERE: single conditions; no Paranthesises!
+- GROUP BY one or more columns
+

{sql_testing_tools-0.2.3 → sql_testing_tools-0.2.4}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name='sql_testing_tools',
-    version='0.2.3',
+    version='0.2.4',
     packages=find_packages(),
     install_requires=[
         'sqlparse>=0.5.1',

{sql_testing_tools-0.2.3 → sql_testing_tools-0.2.4}/sql_testing_tools/Helper.py

@@ -12,6 +12,21 @@ from sqlparse.sql import Identifier, IdentifierList, Where, Comparison, Function
 from sqlparse.tokens import Keyword, DML, Name, Wildcard
 
 
+sql = ""
+sol = ""
+bd = None
+
+def setup(sqlPath,solPath):
+    global sql, sol, bd    
+    if(bd == None):
+        bd = Ba.getTableDict()
+    if(sqlPath and sqlPath != ""):
+        sql = normalizeSQLQuery(Ba.getSQLFromFile(sqlPath), bd)
+    if(solPath and solPath != ""):
+        sol = normalizeSQLQuery(Ba.getSQLFromFile(solPath), bd)
+    if(sql=='' or sol==''):
+        raise Exception("\n\nSQL-Datei ist leer. Aufgabe wurde noch nicht bearbeitet.")
+    
 
 def normalizeSQLQuery(query, baseDict):
     try:
@@ -75,7 +90,6 @@ def normalizeSQLQuery(query, baseDict):
 
     return " ".join(formatted_query)
 
-
 def findTableForColumn(data_dict, target_value, relevantTables):
     l = []
     for key, value_list in data_dict.items():
@@ -90,7 +104,6 @@ def findTableForColumn(data_dict, target_value, relevantTables):
                     l.append(key)
     return l
 
-
 def getTableScheme(table_name: str, tableDict: dict):
     tab = tableDict[table_name]
 
@@ -136,10 +149,52 @@ def buildAndSendCosetteRequest(baseDict, sql, sol):
     return ("ERR", err)
 
 
-def checkColumns(sqlPath, solPath):
-    bd = Ba.getTableDict()
-    sql = normalizeSQLQuery(Ba.getSQLFromFile(sqlPath), bd)
-    sol = normalizeSQLQuery(Ba.getSQLFromFile(solPath), bd)
+def checkKeywords(startWord:str, endWords:list):
+    global sql,sol
+
+    if(startWord not in sol or startWord not in sql):
+        return ""
+
+    if(startWord in sql):
+        start = str.find(sql, startWord)
+        end = -1
+        for kw in endWords:
+            if(str.find(sql, kw) != -1):
+                end = str.find(sql, kw)
+                break
+        if(end == -1):
+            end = len(sql)
+
+        submission = str.strip(sql[start:end])
+        print("'"+submission+"'")
+
+        start = str.find(sol, startWord)
+        end = -1
+        
+        for kw in endWords:
+            if(str.find(sol, kw) != -1):
+                end = str.find(sol, kw)
+                break
+        if(end == -1):
+            end = len(sol)
+
+        solution = str.strip(sol[start:end])
+        print("'"+solution+"'")
+
+        if submission == solution:
+            return ""
+    return "Der '"+startWord+"' Teil der SQL-Abfrage ist nicht korrekt (oder nicht automatisch überprüfbar)."
+
+
+
+
+def checkColumns(sqlPath="", solPath=""):
+    global sql,sol
+    setup(sqlPath, solPath)
+    return checkKeywords("SELECT", ["FROM", "WHERE", "GROUP BY", "ORDER BY", "LIMIT", ";", "HAVING"])
+
+
+
 
     if("SELECT" in sql and "FROM" in sql):
         start = str.find(sql, "SELECT")
@@ -156,11 +211,13 @@ def checkColumns(sqlPath, solPath):
             return ""
     return "Ausgegebene Spalten sind nicht korrekt (oder nicht automatisch überprüfbar)."
 
+def checkTables(sqlPath="", solPath=""):
+    global sql,sol
+    setup(sqlPath, solPath)
+    return checkKeywords("FROM", ["FROM", "WHERE", "GROUP BY", "ORDER BY", "LIMIT", ";", "HAVING"])
+
+
 
-def checkTables(sqlPath, solPath):
-    bd = Ba.getTableDict()
-    sql = normalizeSQLQuery(Ba.getSQLFromFile(sqlPath), bd)
-    sol = normalizeSQLQuery(Ba.getSQLFromFile(solPath), bd)
 
     if("SELECT" in sql and "FROM" in sql):
         endFromKeywords = ["WHERE", "GROUP", "ORDER", "LIMIT", ";"]
@@ -196,13 +253,61 @@ def checkTables(sqlPath, solPath):
             return ""
     return "Verwendete Tabellen sind nicht korrekt (oder nicht automatisch überprüfbar)."
 
+def checkCondition(sqlPath="", solPath=""):
+    global sql,sol
+    setup(sqlPath, solPath)
+    return checkKeywords("WHERE", ["GROUP BY", "ORDER BY", "LIMIT", ";", "HAVING"])
 
-def checkEquality(sqlPath, solPath):
-    bd = Ba.getTableDict()
-    sql = normalizeSQLQuery(Ba.getSQLFromFile(sqlPath), bd)
-    sol = normalizeSQLQuery(Ba.getSQLFromFile(solPath), bd)
-    if(sql=='' or sol==''):
-        return "\n\nSQL-Datei ist leer. Aufgabe wurde noch nicht bearbeitet."
+def checkOrder(sqlPath="", solPath=""):
+    global sql,sol
+    setup(sqlPath, solPath)
+    return checkKeywords("ORDER BY", ["WHERE", "GROUP BY", "ORDER BY", "LIMIT", ";", "HAVING"])
+
+
+
+    if("ORDER BY" in sql):
+        endFromKeywords = ["WHERE", "GROUP", "LIMIT", ";"]
+
+        start = str.find(sql, "ORDER BY")
+        end = -1
+
+
+        for keyword in endFromKeywords:
+            if(str.find(sql, keyword) != -1):
+                end = str.find(sql, keyword)
+                break
+        if(end == -1):
+            end = len(sql)
+
+        submission = str.strip(sql[start:end])
+        print("'"+submission+"'")
+
+        start = str.find(sol, "ORDER BY")
+        end = -1
+        
+        for keyword in endFromKeywords:
+            if(str.find(sol, keyword) != -1):
+                end = str.find(sol, keyword)
+                break
+        if(end == -1):
+            end = len(sol)
+
+        solution = str.strip(sol[start:end])
+        print("'"+solution+"'")
+
+        if submission == solution:
+            return ""
+    return "Die Sortierung ist nicht korrekt (oder nicht automatisch überprüfbar)."
+
+def checkGroup(sqlPath="", solPath=""):
+    global sql,sol
+    setup(sqlPath, solPath)
+    return checkKeywords("GROUP BY", ["WHERE", "ORDER BY", "LIMIT", ";", "HAVING"])
+
+
+def checkEquality(sqlPath="", solPath=""):
+    global sql,sol
+    setup(sqlPath, solPath)
 
     if(sql==sol):
         return ""

sql_testing_tools-0.2.4/sql_testing_tools.egg-info/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.2
+Name: sql_testing_tools
+Version: 0.2.4
+Description-Content-Type: text/markdown
+Requires-Dist: sqlparse>=0.5.1
+Requires-Dist: requests>=2.32.3
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+
+A library that normalizes simple SQL queries and compares them first by equality of the normalized string and then using the cosette API. 
+
+### [Beta in Development!]
+ [![Build and Test](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-build.yml/badge.svg)](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-build.yml)
+ [![Build and Test](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-unittests.yml/badge.svg)](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-unittests.yml)
+
+- Submit bug reports and features requests at: https://github.com/ValentinHerrmann/sql_testing_tools
+- PyPi-Package available at: https://pypi.org/project/sql-testing-tools/ 
+
+
+
+### Getting started
+
+Use the following code to import the SQL Testing Tools to your project:
+``` python
+# ensure to always use the latest version of sql_testing_tools
+import os
+os.system('pip install -U sql_testing_tools')
+
+# import sql_testing_tools
+import sql_testing_tools.BaseAccess as Ba
+import sql_testing_tools.Helper as He
+```
+
+On global level of your test class, set the SQLite database you want to use (bases must be located in the repository of the test class, no DBs contained in sql_testing_tools).
+``` python
+import unittest 
+class TestClass(unittest.TestCase):
+    Ba.setDBName("databases/ladepunkte.db") 
+```
+
+The following methods are available for use in test methods:
+``` python
+try:
+    Ba.runAndGetStringTable_fromFile("sqlfile.sql")
+except Exception as e:
+    # the execution failed 
+    # (usually due to syntax or database errors)
+    self.fail(e)
+
+# (optional) set the files to be compared. The sql strings will 
+# be normalized and used for all following methods (to improve 
+# performance), until new  files are set. Arguments that are
+# None or "" are ignored and the sql string remains the same.
+# Raises an Exception if one of the files is empty.
+setup("sqlfile.sql","solution.sql")
+
+# All following methods call setup(sql,sol) before executing 
+# anything else. Call without arguments to keep the last 
+# normalized sql strings (and improve performance).
+# Each check was successfull if "" is returned. Returns a 
+# German error message if not.
+# Each method compares the normalized string between the start
+# keyword and the next keyword or ;
+
+res = He.checkColumns() # starts to search at keyword "SELECT"
+res = He.checkTables() # starts to search at keyword "FROM"
+res = He.checkCondition() # starts to search at keyword "WHERE"
+res = He.checkOrder() # starts to search at keyword "ORDER BY"
+res = He.checkGroup() # starts to search at keyword "GROUP BY"
+
+# can not be called with new sql files
+res = checkKeywords("startKeyword",["end","keywords"]) 
+
+# compares equality of the full normalized sql strings and if 
+# not equal uses the Cosette API (cosette.cs.washington.edu)
+# for comparison. A file 'cosette_apikey.txt' with only the 
+# apikey in it on root level of the test repository is required 
+# to use this feature. If not existant, only the string comparison
+# is performed.
+# Warning: Cosette is not maintained!
+res = checkEquality()
+```
+
+
+
+
+
+
+
+
+
+### Changelog
+
+##### V0.2.4
+- Added more check methods for single parts of queries: checkColumns, checkTables, checkCondition, checkOrder, checkGroup, checkKeywords
+
+##### V 0.2.3
+- fix: ASC/DESC in ORDER BY (also with multiple columns and order directions), no direction treated as ASC
+- Verified that ; and whitespaces, linebreaks at end of query are ignored
+
+##### V 0.2.2 
+- Support LIKE
+- Support '<=' and '>=' (geq and leq)
+
+##### V 0.2.1
+- Support LIMIT
+  
+##### V 0.1.9 + 0.2.0
+- Support ORDER BY
+
+##### V 0.1.8
+- Fixed linebreak problems: Linebreaks are now converted into whitespaces before parsing where tokens
+
+##### V 0.1.6 + V 0.1.7
+- Fixed import error to ensure imports working in different environments
+
+##### V 0.1.4 + V 0.1.5
+- Chained conditions (with AND,OR and Paranthesises) in WHERE statement
+- Aggregate Functions
+
+##### V 0.1.3
+- SELECT: columns with our without table prefix
+- FROM: one or more table from DB; no queries as tables!
+- WHERE: single conditions; no Paranthesises!
+- GROUP BY one or more columns
+

sql_testing_tools-0.2.3/PKG-INFO

@@ -1,50 +0,0 @@
-Metadata-Version: 2.2
-Name: sql_testing_tools
-Version: 0.2.3
-Description-Content-Type: text/markdown
-Requires-Dist: sqlparse>=0.5.1
-Requires-Dist: requests>=2.32.3
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: requires-dist
-
-A library that normalizes simple SQL queries and compares them first by equality of the normalized string and then using the cosette API. 
-
-
-
-### [Beta in Development!]
- [![Build and Test](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-build.yml/badge.svg)](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-build.yml)
- [![Build and Test](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-unittests.yml/badge.svg)](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-unittests.yml)
-
-Submit bug reports and features requests at: https://github.com/ValentinHerrmann/sql_testing_tools
-
-### V 0.2.3
-- fix: ASC/DESC in ORDER BY (also with multiple columns and order directions), no direction treated as ASC
-- Verified that ; and whitespaces, linebreaks at end of query are ignored
-
-### V 0.2.2 
-- Support LIKE
-- Support '<=' and '>=' (geq and leq)
-
-### V 0.2.1
-- Support LIMIT
-  
-### V 0.1.9 + 0.2.0
-- Support ORDER BY
-
-### V 0.1.8
-- Fixed linebreak problems: Linebreaks are now converted into whitespaces before parsing where tokens
-
-### V 0.1.6 + V 0.1.7
-- Fixed import error to ensure imports working in different environments
-
-### V 0.1.4 + V 0.1.5
-- Chained conditions (with AND,OR and Paranthesises) in WHERE statement
-- Aggregate Functions
-
-### V 0.1.3
-- SELECT: columns with our without table prefix
-- FROM: one or more table from DB; no queries as tables!
-- WHERE: single conditions; no Paranthesises!
-- GROUP BY one or more columns
-

sql_testing_tools-0.2.3/README.md

@@ -1,40 +0,0 @@
-A library that normalizes simple SQL queries and compares them first by equality of the normalized string and then using the cosette API. 
-
-
-
-### [Beta in Development!]
- [![Build and Test](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-build.yml/badge.svg)](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-build.yml)
- [![Build and Test](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-unittests.yml/badge.svg)](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-unittests.yml)
-
-Submit bug reports and features requests at: https://github.com/ValentinHerrmann/sql_testing_tools
-
-### V 0.2.3
-- fix: ASC/DESC in ORDER BY (also with multiple columns and order directions), no direction treated as ASC
-- Verified that ; and whitespaces, linebreaks at end of query are ignored
-
-### V 0.2.2 
-- Support LIKE
-- Support '<=' and '>=' (geq and leq)
-
-### V 0.2.1
-- Support LIMIT
-  
-### V 0.1.9 + 0.2.0
-- Support ORDER BY
-
-### V 0.1.8
-- Fixed linebreak problems: Linebreaks are now converted into whitespaces before parsing where tokens
-
-### V 0.1.6 + V 0.1.7
-- Fixed import error to ensure imports working in different environments
-
-### V 0.1.4 + V 0.1.5
-- Chained conditions (with AND,OR and Paranthesises) in WHERE statement
-- Aggregate Functions
-
-### V 0.1.3
-- SELECT: columns with our without table prefix
-- FROM: one or more table from DB; no queries as tables!
-- WHERE: single conditions; no Paranthesises!
-- GROUP BY one or more columns
-

sql_testing_tools-0.2.3/sql_testing_tools.egg-info/PKG-INFO

@@ -1,50 +0,0 @@
-Metadata-Version: 2.2
-Name: sql_testing_tools
-Version: 0.2.3
-Description-Content-Type: text/markdown
-Requires-Dist: sqlparse>=0.5.1
-Requires-Dist: requests>=2.32.3
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: requires-dist
-
-A library that normalizes simple SQL queries and compares them first by equality of the normalized string and then using the cosette API. 
-
-
-
-### [Beta in Development!]
- [![Build and Test](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-build.yml/badge.svg)](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-build.yml)
- [![Build and Test](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-unittests.yml/badge.svg)](https://github.com/ValentinHerrmann/sql_testing_tools/actions/workflows/python-unittests.yml)
-
-Submit bug reports and features requests at: https://github.com/ValentinHerrmann/sql_testing_tools
-
-### V 0.2.3
-- fix: ASC/DESC in ORDER BY (also with multiple columns and order directions), no direction treated as ASC
-- Verified that ; and whitespaces, linebreaks at end of query are ignored
-
-### V 0.2.2 
-- Support LIKE
-- Support '<=' and '>=' (geq and leq)
-
-### V 0.2.1
-- Support LIMIT
-  
-### V 0.1.9 + 0.2.0
-- Support ORDER BY
-
-### V 0.1.8
-- Fixed linebreak problems: Linebreaks are now converted into whitespaces before parsing where tokens
-
-### V 0.1.6 + V 0.1.7
-- Fixed import error to ensure imports working in different environments
-
-### V 0.1.4 + V 0.1.5
-- Chained conditions (with AND,OR and Paranthesises) in WHERE statement
-- Aggregate Functions
-
-### V 0.1.3
-- SELECT: columns with our without table prefix
-- FROM: one or more table from DB; no queries as tables!
-- WHERE: single conditions; no Paranthesises!
-- GROUP BY one or more columns
-