sql-testing-tools 0.2.11__tar.gz → 0.2.13__tar.gz

{sql_testing_tools-0.2.11/sql_testing_tools.egg-info → sql_testing_tools-0.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql_testing_tools
-Version: 0.2.11
+Version: 0.2.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: sqlparse>=0.5.1
@@ -135,6 +135,14 @@ res = checkEquality()
 
 ### Changelog
 
+##### V 0.2.13
+- Acccept `COUNT(colname)`, too (instead of just `COUNT(*)`)
+
+##### V 0.2.12
+- fixed bug when having only one colum selected
+- fixed bug with nested conditions 
+- fixed memory problem with huge cross products (used to lead to build failed)
+
 ##### V 0.2.11
 - fixed irrelevant equality order if both sides aren't literals
 

{sql_testing_tools-0.2.11 → sql_testing_tools-0.2.13}/README.md

@@ -123,6 +123,14 @@ res = checkEquality()
 
 ### Changelog
 
+##### V 0.2.13
+- Acccept `COUNT(colname)`, too (instead of just `COUNT(*)`)
+
+##### V 0.2.12
+- fixed bug when having only one colum selected
+- fixed bug with nested conditions 
+- fixed memory problem with huge cross products (used to lead to build failed)
+
 ##### V 0.2.11
 - fixed irrelevant equality order if both sides aren't literals
 

{sql_testing_tools-0.2.11 → sql_testing_tools-0.2.13}/setup.py

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

{sql_testing_tools-0.2.11 → sql_testing_tools-0.2.13}/sql_testing_tools/BaseAccess.py

@@ -26,22 +26,23 @@ dbMap = {
 }
 
 __db=""
+dbiu = 'dbiu.'
 
 def setDBName(database):
     global __db
 
-    if isinstance(database, str) and database.startswith("dbiu."):
-        dbVersion = dbMap.get(database)
+    if isinstance(database, str) and database.startswith(dbiu):
+        db_version = dbMap.get(database)
     elif isinstance(database, int):
-        dbVersion = database
-        database = "dbiu."+str(database)
+        db_version = database
+        database = dbiu+str(database)
     elif isinstance(database, str):
-        dbVersion = None
+        db_version = None
     else:
         raise Exception("Invalid database selected")
         
-    if(dbVersion is not None):
-        os.system('pip install dbiu_databases=='+str(dbVersion))
+    if(db_version is not None):
+        os.system('pip install dbiu_databases=='+str(db_version))
         try:
             import dbiu_databases
         except ImportError:
@@ -51,7 +52,7 @@ def setDBName(database):
 
     
 def run(sql: str):
-    if __db.startswith("dbiu.") and not __db.endswith(".db"):
+    if __db.startswith(dbiu) and not __db.endswith(".db"):
         with importlib.resources.path('dbiu_databases', "base.db") as db_path:
             return __run(sql, db_path)
     else:
@@ -64,7 +65,7 @@ def __run(sql: str, db: str):
         con.commit()
         return cur
 
-def runFromFile(path: str):
+def runFromFile(path: str, limit: int = None):
     sql = getSQLFromFile(path)
     if not sql:
         raise Exception("\nSQL-Datei ist leer. Aufgabe wurde noch nicht bearbeitet.")
@@ -79,15 +80,19 @@ def runFromFile(path: str):
         raise Exception(f"\n\nSyntax-Fehler in der SQL-Abfrage:\n{str(e)}")
 
     headers = [h[0] for h in res.description] if res.description else []
-    rows = res.fetchall() if res else []
+    if limit:
+        rows = res.fetchmany(limit)
+    else:
+        rows = res.fetchall() if res else []
 
     return headers, rows
 
 
-def runAndGetStringTable_fromFile(path: str, count: int = 5, maxLineLength: int = 85):
+def runAndGetStringTable_fromFile(path: str, count: int = 5, max_line_length: int = 85):
     try:
-        headers, rows = runFromFile(path)
-        resultCount = len(rows)
+        limit = 1000
+        headers, rows = runFromFile(path, limit)
+        result_count = len(rows)
         rows = rows[:count]
         s = ""
 
@@ -104,52 +109,51 @@ def runAndGetStringTable_fromFile(path: str, count: int = 5, maxLineLength: int
                         matrix[col].append(rows[row][col])
 
             for col in range(len(matrix)):
-                maxLength = max([len(str(x)) for x in matrix[col]])
+                max_length = max([len(str(x)) for x in matrix[col]])
 
                 for row in range(0, len(matrix[col])):
-                    matrix[col][row] = str(matrix[col][row]).ljust(maxLength)
+                    matrix[col][row] = str(matrix[col][row]).ljust(max_length)
 
-            normalizedRows = []
+            normalized_rows = []
             spacing = "  "
-            spacingLength = len(spacing) * (len(matrix[0]) - 1)
+            spacing_length = len(spacing) * (len(matrix[0]) - 1)
 
-            lineLength = sum([len(x[0]) for x in matrix]) + spacingLength
+            line_length = sum([len(x[0]) for x in matrix]) + spacing_length
             
             
 
-            if lineLength > maxLineLength:
-                valLength = lineLength - spacingLength
-                maxColLength = int(maxLineLength/len(matrix))
+            if line_length > max_line_length:
+                max_col_length = int(max_line_length/len(matrix))
 
                 for col in range(len(matrix)):
                     for row in range(0, len(matrix[col])):
-                        cutContent = len(matrix[col][row].strip()) > maxColLength
-                        if cutContent:
-                            matrix[col][row] = matrix[col][row][:maxColLength-2] + ".."
+                        cut_content = len(matrix[col][row].strip()) > max_col_length
+                        if cut_content:
+                            matrix[col][row] = matrix[col][row][:max_col_length-2] + ".."
                         else:
-                            matrix[col][row] = matrix[col][row][:maxColLength]
+                            matrix[col][row] = matrix[col][row][:max_col_length]
 
 
             for row in range(min(count+1, len(matrix[0]))):
-                normalizedRows.append(spacing.join([str(matrix[col][row]) for col in range(len(matrix))]))
-            normalizedRows.insert(1, len(normalizedRows[0])*"-")
+                normalized_rows.append(spacing.join([str(matrix[col][row]) for col in range(len(matrix))]))
+            normalized_rows.insert(1, len(normalized_rows[0])*"-")
 
-            s = "\n".join(normalizedRows[:count+2])
-            s += "\n" + normalizedRows[1]
+            s = "\n".join(normalized_rows[:count+2])
+            s += "\n" + normalized_rows[1]
 
-            if (resultCount > count):
-                s += "\n... " + str(resultCount - count) + " weitere Zeilen"
+            if (result_count > count):
+                if result_count == limit:
+                    s += "\n... mehr als " + str(limit) + " Zeilen"
+                else:
+                    s += "\n... " + str(result_count - count) + " weitere Zeilen"
             else:
                 s += "\n... keine weiteren Zeilen"
-
-        #longestLineInS = 85 # max([len(x.replace("\t", "    ")) for x in s.split("\n")])
-
-        #s = "-" * longestLineInS + "\n" + s + "\n" + "-" * longestLineInS
         s = "\n\nDiese Meldung sagt nichts über die Korrektheit der Abgabe aus!\nDie ersten " + str(
             count) + " Zeilen des Ergebnisses der SQL-Abfrage:\n\n" + s
 
         return s.replace("None", "NULL")
     except Exception as ex:
+        print(ex)
         raise ex
 
 def getSQLFromFile(path: str):

{sql_testing_tools-0.2.11 → sql_testing_tools-0.2.13}/sql_testing_tools/Helper.py

@@ -15,26 +15,37 @@ from sqlparse.tokens import Keyword, DML, Name, Wildcard
 sql = ""
 sol = ""
 bd = None
+kw_sel = 'SELECT'
+kw_frm = 'FROM'
+kw_by = ' BY'
+kw_grp = 'GROUP' + kw_by
+kw_ord = 'ORDER' + kw_by
+kw_whr = 'WHERE'
+kw_lim = 'LIMIT'
+kw_hav = 'HAVING'
+semcol = ';'
 
-def setup(sqlPath,solPath):
+
+
+def setup(sql_path,sol_path):
     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_path and sql_path != ""):
+        sql = normalizeSQLQuery(Ba.getSQLFromFile(sql_path), bd)
+    if(sol_path and sol_path != ""):
+        sol = normalizeSQLQuery(Ba.getSQLFromFile(sol_path), bd)
     if(sql=='' or sol==''):
-        raise Exception("\n\nSQL-Datei ist leer. Aufgabe wurde noch nicht bearbeitet.")
+        raise AssertionError("\n\nSQL-Datei ist leer. Aufgabe wurde noch nicht bearbeitet.")
     
 
-def normalizeSQLQuery(query, baseDict):
+def normalizeSQLQuery(query, base_dict):
     try:
-        query = query.replace("\"", "'")
+        query = query.replace("\"", "'").replace("\n", " ").replace("\r", " ").replace("\t", " ").replace("  ", " ").strip()
         parsed = sqlparse.parse(query)[0]
         parsed.tokens = [token for token in parsed.tokens if not token.is_whitespace]
     except Exception as e:
-        raise Exception(f"\nSyntax-Fehler in der SQL-Abfrage.")
+        raise AssertionError(f"\nFehler beim Parsen der SQL-Abfrage: {str(e)}")
 
     formatted_query = []
     alias_map = {}
@@ -43,16 +54,15 @@ def normalizeSQLQuery(query, baseDict):
     for token in parsed.tokens:
         if token.is_whitespace:
             continue
-        elif token.ttype is Keyword and token.value.upper() == 'FROM':
-            formatted_query.append('FROM')
-            pass
-        elif isinstance(token, Identifier) and formatted_query and formatted_query[-1] == 'FROM':
+        elif token.ttype is Keyword and token.value.upper() == kw_frm:
+            formatted_query.append(kw_frm)
+        elif isinstance(token, Identifier) and formatted_query and formatted_query[-1] == kw_frm:
             il = IdentifierList([token])
-            formatted_query.append(Tp._from(il, alias_map, baseDict))
-            Tp._from(il, alias_map, baseDict)
-        elif isinstance(token, IdentifierList) and formatted_query and formatted_query[-1] == 'FROM':
-            formatted_query.append(Tp._from(token, alias_map, baseDict))
-            Tp._from(token, alias_map, baseDict)
+            formatted_query.append(Tp._from(il, alias_map, base_dict))
+            Tp._from(il, alias_map, base_dict)
+        elif isinstance(token, IdentifierList) and formatted_query and formatted_query[-1] == kw_frm:
+            formatted_query.append(Tp._from(token, alias_map, base_dict))
+            Tp._from(token, alias_map, base_dict)
 
     formatted_query = []
 
@@ -60,40 +70,40 @@ def normalizeSQLQuery(query, baseDict):
     for token in parsed.tokens:
         if token.is_whitespace:
             continue
-        elif token.ttype is DML and token.value.upper() == 'SELECT':
-            formatted_query.append('SELECT')
-        elif token.ttype is Keyword and token.value.upper() == 'FROM':
-            formatted_query.append('FROM')  
-        elif token.ttype is Keyword and token.value.upper() == 'GROUP BY':
-            formatted_query.append('GROUP BY')
-        elif token.ttype is Keyword and token.value.upper() == 'ORDER BY':
-            formatted_query.append('ORDER BY')
-        elif token.ttype is Keyword and token.value.upper() == 'LIMIT':
-            formatted_query.append('LIMIT')
-        elif (isinstance(token, IdentifierList) or isinstance(token, Identifier)) and formatted_query and formatted_query[-1] == 'FROM':
-            formatted_query.append(Tp._from(token, alias_map, baseDict))
-        elif (isinstance(token, IdentifierList) or isinstance(token, Identifier)) and formatted_query and formatted_query[-1] == 'GROUP BY':
-            formatted_query.append(Tp._groupby(token, alias_map, baseDict))
-        elif (isinstance(token, IdentifierList) or isinstance(token, Identifier)) and formatted_query and formatted_query[-1] == 'ORDER BY':
-            formatted_query.append(Tp._orderby(token, alias_map, baseDict))
+        elif token.ttype is DML and token.value.upper() == kw_sel:
+            formatted_query.append(kw_sel)
+        elif token.ttype is Keyword and token.value.upper() == kw_frm:
+            formatted_query.append(kw_frm)  
+        elif token.ttype is Keyword and token.value.upper() == kw_grp:
+            formatted_query.append(kw_grp)
+        elif token.ttype is Keyword and token.value.upper() == kw_ord:
+            formatted_query.append(kw_ord)
+        elif token.ttype is Keyword and token.value.upper() == kw_lim:
+            formatted_query.append(kw_lim)
+        elif (isinstance(token, IdentifierList) or isinstance(token, Identifier)) and formatted_query and formatted_query[-1] == kw_frm:
+            formatted_query.append(Tp._from(token, alias_map, base_dict))
+        elif (isinstance(token, IdentifierList) or isinstance(token, Identifier)) and formatted_query and formatted_query[-1] == kw_grp:
+            formatted_query.append(Tp._groupby(token, alias_map, base_dict))
+        elif (isinstance(token, IdentifierList) or isinstance(token, Identifier)) and formatted_query and formatted_query[-1] == kw_ord:
+            formatted_query.append(Tp._orderby(token, alias_map, base_dict))
         elif isinstance(token, Where):
-            formatted_query.append('WHERE')
-            formatted_query.append(Tp._where(token, alias_map, baseDict))
-        elif formatted_query and formatted_query[-1] == 'SELECT' and (isinstance(token, IdentifierList) or isinstance(token, Function) or isinstance(token, Identifier)):
+            formatted_query.append(kw_whr)
+            formatted_query.append(Tp._where(token, alias_map, base_dict))
+        elif formatted_query and formatted_query[-1] == kw_sel and (isinstance(token, IdentifierList) or isinstance(token, Function) or isinstance(token, Identifier)):
             if isinstance(token, Function):
                 token = IdentifierList([token])
-            formatted_query.append(Tp._select(token, alias_map, baseDict))
-        elif formatted_query and formatted_query[-1] == 'LIMIT':
+            formatted_query.append(Tp._select(token, alias_map, base_dict))
+        elif formatted_query and formatted_query[-1] == kw_lim:
             formatted_query.append(Tp._limit(token))
         else:
             formatted_query.append(str(token))
 
     return " ".join(formatted_query)
 
-def findTableForColumn(data_dict, target_value, relevantTables):
+def find_table_for_column(data_dict, target_value, relevant_tables):
     l = []
     for key, value_list in data_dict.items():
-        if key.lower() in relevantTables:
+        if key.lower() in relevant_tables:
             for sublist in value_list:
                 if sublist and sublist[0].lower() == target_value.lower():
                     l.append(key)
@@ -104,8 +114,8 @@ def findTableForColumn(data_dict, target_value, relevantTables):
                     l.append(key)
     return l
 
-def getTableScheme(table_name: str, tableDict: dict):
-    tab = tableDict[table_name]
+def getTableScheme(table_name: str, table_dict: dict):
+    tab = table_dict[table_name]
 
     # Format the schema
     schema = "(" + ",".join([f"{col[0]}:{col[1]}" for col in tab]) + ")"
@@ -118,18 +128,18 @@ def getCosetteKeyFromFile():
     except FileNotFoundError:
         return "NOKEY"
 
-def buildAndSendCosetteRequest(baseDict, sql, sol):
+def buildAndSendCosetteRequest(base_dict, sql, sol):
 
     err = ""
-    for i in range(2):
+    for _ in range(2):
         try:
-            apiKey=getCosetteKeyFromFile()
+            api_key=getCosetteKeyFromFile()
 
 
             schema = ""
-            for tab in baseDict.keys():
-                schema += f"schema sch{tab}{getTableScheme(tab, baseDict)};\n"
-            for tab in baseDict.keys():
+            for tab in base_dict.keys():
+                schema += f"schema sch{tab}{getTableScheme(tab, base_dict)};\n"
+            for tab in base_dict.keys():
                 schema += f"table {tab}(sch{tab});\n"
 
             q1 = "query q1\n`"+sql+"`;\n"
@@ -138,29 +148,25 @@ def buildAndSendCosetteRequest(baseDict, sql, sol):
             cosette = "-- random Kommentar\n" + schema + q1 + q2 + "verify q1 q2;\n"
             print(cosette)
 
-            r = requests.post("https://demo.cosette.cs.washington.edu/solve",data={"api_key": apiKey, "query": cosette}, verify=False)
+            r = requests.post("https://demo.cosette.cs.washington.edu/solve",data={"api_key": api_key, "query": cosette}, verify=False)
 
             print(r.text)
             return (r.json()['result'],r.text)
-            #return r.json()['result']
-
         except Exception as e:
             err = str(e)
     return ("ERR", err)
 
 
-def checkKeywords(startWord:str, endWords:list):
-    #global sql,sol
+def check_keywords(start_word:str, end_words:list):
+    start_word = start_word.lower()
 
-    startWord = startWord.lower()
-
-    if(startWord not in sol.lower() and startWord not in sql.lower()):
+    if(start_word not in sol.lower() and start_word not in sql.lower()):
         return ""
 
-    if(startWord in sql.lower()):
-        start = sql.lower().find(startWord) + len(startWord)
+    if(start_word in sql.lower()):
+        start = sql.lower().find(start_word) + len(start_word)
         end = -1
-        for kw in endWords:
+        for kw in end_words:
             index = sql.lower().find(kw.lower(), start)
             if -1 < index < end or end == -1:
                 end = index
@@ -168,12 +174,11 @@ def checkKeywords(startWord:str, endWords:list):
             end = len(sql)
 
         submission = str.strip(sql[start:end])
-        #print("'"+submission+"'")
 
-        start = sol.lower().find(startWord) + len(startWord)
+        start = sol.lower().find(start_word) + len(start_word)
         end = -1
         
-        for kw in endWords:
+        for kw in end_words:
             index = sol.lower().find(kw.lower(), start)
             if -1 < index < end or end == -1:
                 end = index
@@ -184,45 +189,54 @@ def checkKeywords(startWord:str, endWords:list):
 
         if submission == solution:
             return ""
-    return "Der '"+startWord+"' Teil der SQL-Abfrage ist nicht korrekt (oder nicht automatisch überprüfbar)."
+    return "Der '"+start_word+"' 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"])
+def checkColumns(sql_path="", sol_path=""):
+    setup(sql_path, sol_path)
+    return check_keywords(kw_sel+" ", [kw_frm, kw_whr, kw_grp, kw_ord, kw_lim, semcol, kw_hav])
 
 
-def checkTables(sqlPath="", solPath=""):
-    #global sql,sol
-    setup(sqlPath, solPath)
-    return checkKeywords("FROM ", ["SELECT", "WHERE", "GROUP BY", "ORDER BY", "LIMIT", ";", "HAVING"])
+def checkTables(sql_path="", sol_path=""):
+    setup(sql_path, sol_path)
+    return check_keywords(kw_frm+" ", [kw_sel, kw_whr, kw_grp, kw_ord, kw_lim, semcol, kw_hav])
 
 
-def checkCondition(sqlPath="", solPath=""):
-    #global sql,sol
-    setup(sqlPath, solPath)
-    return checkKeywords("WHERE ", ["SELECT", "FROM", "GROUP BY", "ORDER BY", "LIMIT", ";", "HAVING"])
+def checkCondition(sql_path="", sol_path=""):
+    setup(sql_path, sol_path)
+    return check_keywords(kw_whr+" ", [kw_sel, kw_frm, kw_grp, kw_ord, kw_lim, semcol, kw_hav])
 
 
-def checkOrder(sqlPath="", solPath=""):
-    #global sql,sol
-    setup(sqlPath, solPath)
-    return checkKeywords("ORDER BY ", ["SELECT", "WHERE", "GROUP BY", "FROM", "LIMIT", ";", "HAVING"])
+def checkOrder(sql_path="", sol_path=""):
+    setup(sql_path, sol_path)
+    return check_keywords(kw_ord+" ", [kw_sel, kw_whr, kw_grp, kw_frm, kw_lim, semcol, kw_hav])
 
 
-def checkGroup(sqlPath="", solPath=""):
-    #global sql, sol
-    setup(sqlPath, solPath)
-    return checkKeywords("GROUP BY ", ["SELECT", "WHERE", "FROM BY", "ORDER BY", "LIMIT", ";", "HAVING"])
+def checkGroup(sql_path="", sol_path=""):
+    setup(sql_path, sol_path)
+    return check_keywords(kw_grp+" ", [kw_sel, kw_whr, kw_grp, kw_ord, kw_lim, semcol, kw_hav])
 
 
-def checkEquality(sqlPath="", solPath=""):
-    #global sql, sol
-    setup(sqlPath, solPath)
+def checkEquality(sql_path="", sol_path=""):
+    setup(sql_path, sol_path)
 
     if sql == sol:
         return ""
+    
+    
+    sql_build_fail = ""
+    sol_build_fail = ""
+    try:
+        Ba.runAndGetStringTable_fromFile(sql_path)
+    except Exception as e:
+        sql_build_fail = str(e)
+    try:
+        Ba.runAndGetStringTable_fromFile(sol_path)
+    except Exception as e:
+        sol_build_fail = str(e)
+        
+    if(sql_build_fail != "" or sol_build_fail != ""):
+        return "\n\nFehler beim Ausführen der Abfrage. Vermutlich enthält die Abfrage Syntaxfehler:\n" + sql_build_fail + "\n" + sol_build_fail
 
     result = buildAndSendCosetteRequest(bd, sql, sol)
 

{sql_testing_tools-0.2.11 → sql_testing_tools-0.2.13}/sql_testing_tools/TokenProcessing.py

@@ -11,12 +11,12 @@ except ImportError:
 #####################################
 #####################################
 
-def _identifier(identifier, alias_map, baseDict: dict):
+def _identifier(identifier, alias_map, base_dict: dict):
         if isinstance(identifier, Identifier):
             if identifier.get_real_name() and identifier.get_parent_name() and identifier.get_parent_name().lower() in alias_map.keys():
                 return f"{alias_map[identifier.get_parent_name().lower()].lower()}.{identifier.get_real_name().lower()}"
             elif identifier.get_real_name():
-                tables = He.findTableForColumn(baseDict, identifier.get_real_name(), alias_map.keys())
+                tables = He.find_table_for_column(base_dict, identifier.get_real_name(), alias_map.keys())
                 if len(tables) == 1:
                     alias_map[tables[0].lower()] = tables[0]
                     return f"{tables[0].lower()}.{identifier.get_real_name().lower()}"
@@ -29,24 +29,33 @@ def _identifier(identifier, alias_map, baseDict: dict):
 #####################################
 
 
-def _select(select, alias_map, baseDict: dict, insideFunction=False):
+def _select(select, alias_map, base_dict: dict, insideFunction=False):
     select_tokens = []
+    if isinstance(select, Identifier):
+        if insideFunction:
+            select_tokens.append(_identifier(select, alias_map, base_dict).lower())
+        else:
+            select_tokens.append(f"{_identifier(select, alias_map,  base_dict).lower()} as {select.get_real_name().lower()}")
     for token in select.tokens:
         if isinstance(token, IdentifierList):
             for identifier in token.get_identifiers():
-                select_tokens.append(f"{_identifier(identifier, alias_map, baseDict).lower()} as {identifier.get_real_name().lower()}")
+                select_tokens.append(f"{_identifier(identifier, alias_map, base_dict).lower()} as {identifier.get_real_name().lower()}")
         elif isinstance(token, Identifier):
             if insideFunction:
-                select_tokens.append(_identifier(token, alias_map, baseDict).lower())
+                select_tokens.append(_identifier(token, alias_map, base_dict).lower())
             else:
-                select_tokens.append(f"{_identifier(token, alias_map,  baseDict).lower()} as {token.get_real_name().lower()}")
+                select_tokens.append(f"{_identifier(token, alias_map,  base_dict).lower()} as {token.get_real_name().lower()}")
         elif isinstance(token, Function):
-            #select_tokens.append(f"{token.get_name().lower()}({_identifier(token.get_parameters(), alias_map, baseDict).lower()})")
+            is_count = False
             for par in token.tokens:
                 if isinstance(par, Identifier):
                     select_tokens.append(par.get_name().lower()+"(")
+                    is_count = par.get_name().lower() == "count"
                 if isinstance(par, Parenthesis):
-                    select_tokens[-1] += _select(par, alias_map, baseDict, True)+") as funcResult" 
+                    select_ident = _select(par, alias_map, base_dict, True)
+                    if is_count and not any(tok.value.upper() == "DISTINCT" for tok in par.tokens):
+                        select_ident = "*"
+                    select_tokens[-1] += select_ident +") as funcResult" 
         elif token.ttype is Wildcard:
             select_tokens.append("*")
         else:
@@ -59,7 +68,7 @@ def _select(select, alias_map, baseDict: dict, insideFunction=False):
 #####################################
 
 
-def _from(from_, alias_map, baseDict: dict):
+def _from(from_, alias_map, base_dict: dict):
     from_tokens = []
     if hasattr(from_, 'tokens'):
         for token in from_.tokens:
@@ -83,32 +92,32 @@ def _from(from_, alias_map, baseDict: dict):
 #####################################
 
 
-def _groupby(groupby_, alias_map, baseDict: dict):
+def _groupby(groupby_, alias_map, base_dict: dict):
     groupby_tokens = []
     if(isinstance(groupby_, Identifier)):
-        groupby_tokens.append(_identifier(groupby_, alias_map, baseDict).lower())
+        groupby_tokens.append(_identifier(groupby_, alias_map, base_dict).lower())
     elif isinstance(groupby_, IdentifierList):
         for identifier in groupby_.get_identifiers():
-            groupby_tokens.append(_identifier(identifier, alias_map, baseDict).lower())
+            groupby_tokens.append(_identifier(identifier, alias_map, base_dict).lower())
     groupby_tokens.sort()
     return ",".join(groupby_tokens)
 
-def _orderby(orderby_, alias_map, baseDict: dict):
+def _orderby(orderby_, alias_map, base_dict: dict):
     orderby_tokens = []
     if isinstance(orderby_, Identifier):
         if len(orderby_.tokens) > 0 and orderby_.tokens[-1].ttype==Keyword.Order:
             for tok in orderby_.tokens:
                 if isinstance(tok, Identifier):
-                    orderby_tokens.append(_identifier(tok, alias_map, baseDict).lower())
+                    orderby_tokens.append(_identifier(tok, alias_map, base_dict).lower())
                 if tok.ttype==Keyword.Order:
                     orderby_tokens[-1] += (" "+tok.value)
         else:
-            orderby_tokens.append(_identifier(orderby_, alias_map, baseDict).lower())
+            orderby_tokens.append(_identifier(orderby_, alias_map, base_dict).lower())
             orderby_tokens[-1] += " ASC"
     elif isinstance(orderby_, IdentifierList):
         for tok in orderby_.tokens:
             if isinstance(tok, Identifier):
-                orderby_tokens.append(_identifier(tok, alias_map, baseDict).lower())
+                orderby_tokens.append(_identifier(tok, alias_map, base_dict).lower())
     #elif isinstance(orderby_, Order):
     #    pass
    # orderby_tokens.sort()
@@ -133,7 +142,7 @@ def replace_not_with_parenthesis(where_tokens):
             i += 1
     return new_tokens
 
-def _condition(token, alias_map, baseDict: dict):
+def _condition(token, alias_map, base_dict: dict):
     left, operator, right = [t for t in token.tokens if not t.is_whitespace]
 
     flipAllowed = True
@@ -158,8 +167,8 @@ def _condition(token, alias_map, baseDict: dict):
         rightLiteral = True
         flipAllowed = False
 
-    left = _identifier(left, alias_map, baseDict)
-    right = _identifier(right, alias_map, baseDict)
+    left = _identifier(left, alias_map, base_dict)
+    right = _identifier(right, alias_map, base_dict)
 
     if operator.value.strip() in ("!=", "<>"):
         return f"(NOT {left.lower()} LIKE {right})"
@@ -195,7 +204,7 @@ def is_value(token):
 #####################################
 
 
-def _paranthesis(parenthesis, alias_map, baseDict: dict):
+def _paranthesis(parenthesis, alias_map, base_dict: dict):
     toks = []
 
     bracketsRequired = True
@@ -206,10 +215,10 @@ def _paranthesis(parenthesis, alias_map, baseDict: dict):
 
 
     if(and_count==1 and or_count == 0):
-        val = _2element_par(parenthesis, alias_map, baseDict, "AND")
+        val = _2element_par(parenthesis, alias_map, base_dict, "AND")
         return val
     elif(and_count==0 and or_count == 1):
-        val = _2element_par(parenthesis, alias_map, baseDict, "OR")
+        val = _2element_par(parenthesis, alias_map, base_dict, "OR")
         return val
 
 
@@ -219,9 +228,9 @@ def _paranthesis(parenthesis, alias_map, baseDict: dict):
 
     for token in parenthesis.tokens:
         if isinstance(token, Comparison):
-            toks.append(_condition(token, alias_map, baseDict))
+            toks.append(_condition(token, alias_map, base_dict))
         elif isinstance(token, Parenthesis):
-            toks.append(_paranthesis(token, alias_map, baseDict))
+            toks.append(_paranthesis(token, alias_map, base_dict))
 
         elif token.ttype is Keyword: #AND,OR
             if token.value == "AND":
@@ -239,14 +248,14 @@ def _paranthesis(parenthesis, alias_map, baseDict: dict):
     return " ".join(toks)
 
 
-def _2element_par(parenthesis, alias_map, baseDict: dict, keyword):
+def _2element_par(parenthesis, alias_map, base_dict: dict, keyword):
     toks = []
 
     for token in parenthesis.tokens:
         if isinstance(token, Comparison):
-            toks.append(_condition(token, alias_map, baseDict))
+            toks.append(_condition(token, alias_map, base_dict))
         elif isinstance(token, Parenthesis):
-            toks.append(_paranthesis(token, alias_map, baseDict))
+            toks.append(_paranthesis(token, alias_map, base_dict))
     toks = toks.sort()
     fill = (" "+keyword+" ")
     return fill.join(toks)
@@ -263,13 +272,8 @@ def find_index_of_keyword(tokens, keyword):
     return -1  # Wenn kein AND-Token gefunden wird
 
 
-def _where(where, alias_map, baseDict: dict):
-    conditions = []
-    current_condition = []
-
-
-
-    isParanthesis = isinstance(where, Parenthesis)
+def _where(where, alias_map, base_dict: dict):
+    is_paranthesis = 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 = replace_not_with_parenthesis(where_tokens)
@@ -282,11 +286,11 @@ def _where(where, alias_map, baseDict: dict):
 
     # No AND / OR
     if and_count + or_count == 0:
-        return _where_simpleCondition(where, alias_map, baseDict)
+        return _where_simpleCondition(where, alias_map, base_dict)
 
     # only ANDs / only ORs
     elif and_count == 0 or or_count == 0:
-        return _where_sameStrengthKeywords(where_tokens, alias_map, baseDict, " AND " if and_count > 0 else " OR ")
+        return _where_sameStrengthKeywords(where_tokens, alias_map, base_dict, " AND " if and_count > 0 else " OR ")
     
     # ANDs and ORs
 
@@ -298,96 +302,56 @@ def _where(where, alias_map, baseDict: dict):
     # two conditions on top level
     if top_and_count + top_or_count == 1:
         keyword = " AND " if top_and_count == 1 else " OR "
-        return _where_twoConditionsOnTopLevel(where, alias_map, baseDict, keyword, isParanthesis)
+        return _where_twoConditionsOnTopLevel(where, alias_map, base_dict, keyword, is_paranthesis)
     else:
-        where_tokens = _where_addBracketsAroundAND(where, alias_map, baseDict)
-        return _where(Where(where_tokens), alias_map, baseDict)
+        where_tokens = _where_addBracketsAroundAND(where, alias_map, base_dict)
+        return _where(Where(where_tokens), alias_map, base_dict)
 
-def _where_addBracketsAroundAND(where, alias_map, baseDict: dict):
+def _where_addBracketsAroundAND(where, alias_map, base_dict: dict):
     index = find_index_of_keyword(where.tokens, "AND")
     par = Parenthesis(where.tokens[index-2:index+3])
     where_tokens = where.tokens[:index-2] + [par] + where.tokens[index+3:]
     return where_tokens
 
 
-
-    # for token in where.tokens:
-    #     if token.is_whitespace or (token.ttype is Keyword and token.value.upper() == "WHERE"):
-    #         continue
-
-    #     if token.ttype is Keyword and token.value.upper() in ('AND', 'OR'):
-    #         if current_condition:
-    #             conditions.append(''.join(str(t) for t in current_condition).strip())
-    #             current_condition = []
-    #         conditions.append(token.value.upper())
-    #     else:
-    #         current_condition.append(token)
-
-    # if current_condition:
-    #     conditions.append(''.join(str(t) for t in current_condition).strip())
-
-    # sorted_conditions = []
-    # current_group = []
-    # last_connector = ""
-
-    # if "OR" not in conditions:
-    #     for condition in conditions:
-    #         if condition == 'AND':
-    #             pass
-    #         else:
-    #             current_group.append(condition)
-
-    #     if current_group:
-    #         sorted_conditions.extend(sorted(current_group))
-
-    #     return " AND ".join(sorted_conditions)
-    # else:
-    #     return " ".join(conditions)
-
-    #     where_index = query.upper().find('WHERE')
-        
-    #     normalized_query = query[:where_index + 5] + ' ' + ' '.join(sorted_conditions)
-
-
-
-def _where_simpleCondition(where_tokens, alias_map, baseDict: dict):
+def _where_simpleCondition(where_tokens, alias_map, base_dict: 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))
+            cond.append(_condition(tok, alias_map, base_dict))
         elif isinstance(tok, Parenthesis):
             for _tok in tok.tokens:
                 if isinstance(_tok, Comparison):
-                    cond.append(_condition(_tok, alias_map, baseDict))
+                    cond.append(_condition(_tok, alias_map, base_dict))
                 elif isinstance(_tok, Parenthesis):
                     tok = _tok
     return "".join(cond)
 
-def _where_sameStrengthKeywords(where_tokens, alias_map, baseDict: dict, keyword: str):
+def _where_sameStrengthKeywords(where_tokens, alias_map, base_dict: dict, keyword: str):
     cond = []
     for tok in where_tokens:
         if isinstance(tok, Comparison):
-            cond.append(_where_simpleCondition([tok], alias_map, baseDict))
+            cond.append(_where_simpleCondition([tok], alias_map, base_dict))
         elif isinstance(tok, Parenthesis):
-            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 ""))
+            is_not = tok.tokens[0].ttype == Keyword and tok.tokens[0].value.upper() == "NOT"
+            cond.append(("(" if is_not else "") + _where(tok, alias_map, base_dict) + (")" if is_not else ""))
     cond.sort()
     return keyword.join(cond)
 
-def _where_twoConditionsOnTopLevel(where, alias_map, baseDict: dict, keyword, isParanthesis):
+def _where_twoConditionsOnTopLevel(where, alias_map, base_dict: dict, keyword, is_paranthesis):
     current_condition = []
     for tok in where.tokens:
         if isinstance(tok, Comparison):
-            current_condition.append(_condition(tok, alias_map, baseDict))
+            current_condition.append(_condition(tok, alias_map, base_dict))
         elif isinstance(tok, Parenthesis):
-            current_condition.append(_where(tok, alias_map, baseDict))
-        current_condition.sort()
-        if keyword == " AND " or isParanthesis:
-            return "(" + keyword.join(current_condition) + ")"
-        else:
-            return keyword.join(current_condition)
+            current_condition.append('(' + _where(tok, alias_map, base_dict) + ')')
+    current_condition.sort()
+    if keyword == " AND " or is_paranthesis:
+        return "(" + keyword.join(current_condition) + ")"
+    else:
+        return keyword.join(current_condition)
 
 
 def _limit(limit):

{sql_testing_tools-0.2.11 → sql_testing_tools-0.2.13/sql_testing_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql_testing_tools
-Version: 0.2.11
+Version: 0.2.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: sqlparse>=0.5.1
@@ -135,6 +135,14 @@ res = checkEquality()
 
 ### Changelog
 
+##### V 0.2.13
+- Acccept `COUNT(colname)`, too (instead of just `COUNT(*)`)
+
+##### V 0.2.12
+- fixed bug when having only one colum selected
+- fixed bug with nested conditions 
+- fixed memory problem with huge cross products (used to lead to build failed)
+
 ##### V 0.2.11
 - fixed irrelevant equality order if both sides aren't literals