sql-testing-tools 0.2.10__py3-none-any.whl → 0.2.12__py3-none-any.whl

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,9 +52,7 @@ def setDBName(database):
 
     
 def run(sql: str):
-    global __db
-
-    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:
@@ -66,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.")
@@ -81,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 = ""
 
@@ -106,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/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)