sql-testing-tools 0.2.8__tar.gz → 0.2.10__tar.gz

{sql_testing_tools-0.2.8 → sql_testing_tools-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: sql_testing_tools
-Version: 0.2.8
+Version: 0.2.10
 Description-Content-Type: text/markdown
 Requires-Dist: sqlparse>=0.5.1
 Requires-Dist: requests>=2.32.3
@@ -136,8 +136,15 @@ res = checkEquality()
 
 ### Changelog
 
-##### V 0.2.7
-- Convert 
+##### V 0.2.10
+- fixed part checks if keywords are in wrong order
+
+##### V 0.2.9
+- added NOT support
+- improved Parentheses handling
+
+##### V 0.2.8
+- ignore case in '=' string comparison and convert to LIKE (if no '%', '_' in String)
 
 ##### V 0.2.7
 - Normalize String unequality: ...<>..., ...!=..., ...NOT LIKE... --> NOT...LIKE...

{sql_testing_tools-0.2.8 → sql_testing_tools-0.2.10}/README.md

@@ -126,8 +126,15 @@ res = checkEquality()
 
 ### Changelog
 
-##### V 0.2.7
-- Convert 
+##### V 0.2.10
+- fixed part checks if keywords are in wrong order
+
+##### V 0.2.9
+- added NOT support
+- improved Parentheses handling
+
+##### V 0.2.8
+- ignore case in '=' string comparison and convert to LIKE (if no '%', '_' in String)
 
 ##### V 0.2.7
 - Normalize String unequality: ...<>..., ...!=..., ...NOT LIKE... --> NOT...LIKE...

{sql_testing_tools-0.2.8 → sql_testing_tools-0.2.10}/setup.py

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

{sql_testing_tools-0.2.8 → sql_testing_tools-0.2.10}/sql_testing_tools/Helper.py

@@ -152,34 +152,35 @@ def buildAndSendCosetteRequest(baseDict, sql, sol):
 def checkKeywords(startWord:str, endWords:list):
     global sql,sol
 
-    if(startWord not in sol and startWord not in sql):
+    startWord = startWord.lower()
+
+    if(startWord not in sol.lower() and startWord not in sql.lower()):
         return ""
 
-    if(startWord in sql):
-        start = str.find(sql, startWord)
+    if(startWord in sql.lower()):
+        start = sql.lower().find(startWord) + len(startWord)
         end = -1
         for kw in endWords:
-            if(str.find(sql, kw) != -1):
-                end = str.find(sql, kw)
-                break
+            index = sql.lower().find(kw.lower(), start)
+            if -1 < index < end or end == -1:
+                end = index
         if(end == -1):
             end = len(sql)
 
         submission = str.strip(sql[start:end])
-        print("'"+submission+"'")
+        #print("'"+submission+"'")
 
-        start = str.find(sol, startWord)
+        start = sol.lower().find(startWord) + len(startWord)
         end = -1
         
         for kw in endWords:
-            if(str.find(sol, kw) != -1):
-                end = str.find(sol, kw)
-                break
+            index = sol.lower().find(kw.lower(), start)
+            if -1 < index < end or end == -1:
+                end = index
         if(end == -1):
             end = len(sol)
 
         solution = str.strip(sol[start:end])
-        print("'"+solution+"'")
 
         if submission == solution:
             return ""
@@ -189,31 +190,31 @@ def checkKeywords(startWord:str, endWords:list):
 def checkColumns(sqlPath="", solPath=""):
     global sql,sol
     setup(sqlPath, solPath)
-    return checkKeywords("SELECT", ["FROM", "WHERE", "GROUP BY", "ORDER BY", "LIMIT", ";", "HAVING"])
+    return checkKeywords("SELECT ", ["FROM", "WHERE", "GROUP BY", "ORDER BY", "LIMIT", ";", "HAVING"])
 
 
 def checkTables(sqlPath="", solPath=""):
     global sql,sol
     setup(sqlPath, solPath)
-    return checkKeywords("FROM", ["FROM", "WHERE", "GROUP BY", "ORDER BY", "LIMIT", ";", "HAVING"])
+    return checkKeywords("FROM ", ["SELECT", "WHERE", "GROUP BY", "ORDER BY", "LIMIT", ";", "HAVING"])
 
 
 def checkCondition(sqlPath="", solPath=""):
     global sql,sol
     setup(sqlPath, solPath)
-    return checkKeywords("WHERE", ["GROUP BY", "ORDER BY", "LIMIT", ";", "HAVING"])
+    return checkKeywords("WHERE ", ["SELECT", "FROM", "GROUP BY", "ORDER BY", "LIMIT", ";", "HAVING"])
 
 
 def checkOrder(sqlPath="", solPath=""):
     global sql,sol
     setup(sqlPath, solPath)
-    return checkKeywords("ORDER BY", ["WHERE", "GROUP BY", "ORDER BY", "LIMIT", ";", "HAVING"])
+    return checkKeywords("ORDER BY ", ["SELECT", "WHERE", "GROUP BY", "FROM", "LIMIT", ";", "HAVING"])
 
 
 def checkGroup(sqlPath="", solPath=""):
-    global sql,sol
+    global sql, sol
     setup(sqlPath, solPath)
-    return checkKeywords("GROUP BY", ["WHERE", "ORDER BY", "LIMIT", ";", "HAVING"])
+    return checkKeywords("GROUP BY ", ["SELECT", "WHERE", "FROM BY", "ORDER BY", "LIMIT", ";", "HAVING"])
 
 
 def checkEquality(sqlPath="", solPath=""):

{sql_testing_tools-0.2.8 → sql_testing_tools-0.2.10}/sql_testing_tools/TokenProcessing.py

@@ -1,8 +1,7 @@
 import sqlparse
-from sqlparse.sql import Identifier, IdentifierList, Where, Comparison, Function, Parenthesis
+from sqlparse.sql import Identifier, IdentifierList, Where, Comparison, Function, Parenthesis, Token
 from sqlparse.tokens import Keyword, DML, Name, Wildcard, Whitespace, Newline
 
-
 try:
     import Helper as He
 except ImportError:
@@ -115,6 +114,25 @@ def _orderby(orderby_, alias_map, baseDict: dict):
    # orderby_tokens.sort()
     return ",".join(orderby_tokens)
 
+def replace_not_with_parenthesis(where_tokens):
+    new_tokens = []
+    i = 0
+    while i < len(where_tokens):
+        if where_tokens[i].ttype is Keyword and where_tokens[i].value.upper() == "NOT":
+            if i + 1 < len(where_tokens):
+                not_token = where_tokens[i]
+                next_token = where_tokens[i + 1]
+                parenthesis = Parenthesis([not_token, Token(Whitespace, ' '), next_token])
+                new_tokens.append(parenthesis)
+                i += 2  # Skip the next token as it is already added inside the parenthesis
+            else:
+                new_tokens.append(where_tokens[i])
+                i += 1
+        else:
+            new_tokens.append(where_tokens[i])
+            i += 1
+    return new_tokens
+
 def _condition(token, alias_map, baseDict: dict):
     left, operator, right = [t for t in token.tokens if not t.is_whitespace]
 
@@ -143,11 +161,11 @@ def _condition(token, alias_map, baseDict: dict):
     left = _identifier(left, alias_map, baseDict)
     right = _identifier(right, alias_map, baseDict)
 
-    if operator.value in ("!=", "<>"):
-        return f"NOT {left.lower()} LIKE {right}"
-    if operator.value in ("NOT LIKE"):
-        return f"NOT {left.lower()} LIKE {right}"
-    if operator.value in ("=") and "%" not in right and "_" not in right:
+    if operator.value.strip() in ("!=", "<>"):
+        return f"(NOT {left.lower()} LIKE {right})"
+    if operator.value.lower().strip() == "not like":
+        return f"(NOT {left.lower()} LIKE {right})"
+    if operator.value.strip() == "=" and "%" not in right and "_" not in right:
         return f"{left.lower()} LIKE {right}"
 
 
@@ -163,7 +181,7 @@ def _condition(token, alias_map, baseDict: dict):
         elif operator.value == "<=":
             operator = ">="
 
-    return f"{left if leftLiteral else left.lower()} {operator} {right if rightLiteral else right.lower()}"
+    return f"{left if leftLiteral else left.lower()} {operator.value.upper()} {right if rightLiteral else right.lower()}"
 
 def is_value(token):
     return token.ttype in (sqlparse.tokens.Token.Literal.Number.Integer,
@@ -253,11 +271,14 @@ def _where(where, alias_map, baseDict: dict):
 
     isParanthesis = isinstance(where, Parenthesis)
     
-    where_tokens = [token for token in where.tokens if (token.ttype is not Whitespace and token.ttype is not Newline)and token.value != "WHERE"]    
+    where_tokens = [token for token in where.tokens if (token.ttype is not Whitespace and token.ttype is not Newline) and token.value != "WHERE"]
+    where_tokens = replace_not_with_parenthesis(where_tokens)
+
+    # No parentheses in where_string!
     where_string = " ".join([str(token) for token in where_tokens])
 
     and_count = where_string.upper().count(" AND ")
-    or_count  = where_string.upper().count(" OR ")
+    or_count = where_string.upper().count(" OR ")
 
     # No AND / OR
     if and_count + or_count == 0:
@@ -332,6 +353,8 @@ def _where_addBracketsAroundAND(where, alias_map, baseDict: dict):
 def _where_simpleCondition(where_tokens, alias_map, baseDict: dict):
     cond = []
     for tok in where_tokens:
+        if tok.ttype == Keyword and tok.value.upper() == "NOT":
+            cond.append("NOT ")
         if isinstance(tok, Comparison):
             cond.append(_condition(tok, alias_map, baseDict))
         elif isinstance(tok, Parenthesis):
@@ -346,13 +369,10 @@ def _where_sameStrengthKeywords(where_tokens, alias_map, baseDict: dict, keyword
     cond = []
     for tok in where_tokens:
         if isinstance(tok, Comparison):
-            cond.append(_condition(tok, alias_map, baseDict))
+            cond.append(_where_simpleCondition([tok], alias_map, baseDict))
         elif isinstance(tok, Parenthesis):
-            for _tok in tok.tokens:
-                if isinstance(_tok, Comparison):
-                    cond.append(_condition(_tok, alias_map, baseDict))
-                elif isinstance(_tok, Parenthesis):
-                    tok = _tok
+            isNot = tok.tokens[0].ttype == Keyword and tok.tokens[0].value.upper() == "NOT"
+            cond.append(("(" if isNot else "") + _where(tok, alias_map, baseDict) + (")" if isNot else ""))
     cond.sort()
     return keyword.join(cond)
 

{sql_testing_tools-0.2.8 → sql_testing_tools-0.2.10}/sql_testing_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: sql_testing_tools
-Version: 0.2.8
+Version: 0.2.10
 Description-Content-Type: text/markdown
 Requires-Dist: sqlparse>=0.5.1
 Requires-Dist: requests>=2.32.3
@@ -136,8 +136,15 @@ res = checkEquality()
 
 ### Changelog
 
-##### V 0.2.7
-- Convert 
+##### V 0.2.10
+- fixed part checks if keywords are in wrong order
+
+##### V 0.2.9
+- added NOT support
+- improved Parentheses handling
+
+##### V 0.2.8
+- ignore case in '=' string comparison and convert to LIKE (if no '%', '_' in String)
 
 ##### V 0.2.7
 - Normalize String unequality: ...<>..., ...!=..., ...NOT LIKE... --> NOT...LIKE...