sql-testing-tools 0.1.9__tar.gz → 0.2.0__tar.gz

{sql_testing_tools-0.1.9 → sql_testing_tools-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: sql_testing_tools
-Version: 0.1.9
+Version: 0.2.0
 Description-Content-Type: text/markdown
 Requires-Dist: sqlparse>=0.5.1
 Requires-Dist: requests>=2.32.3
@@ -15,8 +15,8 @@ A library that normalizes simple SQL queries and compares them first by equality
  [![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)
 
-### V 0.1.9
-- Support GROUP BY
+### 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

{sql_testing_tools-0.1.9 → sql_testing_tools-0.2.0}/README.md

@@ -5,8 +5,8 @@ A library that normalizes simple SQL queries and compares them first by equality
  [![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)
 
-### V 0.1.9
-- Support GROUP BY
+### 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

{sql_testing_tools-0.1.9 → sql_testing_tools-0.2.0}/setup.py

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

sql_testing_tools-0.2.0/sql_testing_tools/BaseAccess.py

@@ -0,0 +1,171 @@
+import sqlite3
+import os
+#from importlib import resources
+
+
+__db=""
+
+def setDBName(path: str):
+    global __db
+    print("Setting DB to: " + path)
+    __db = path
+    #with resources.path('sql_testing_tools', path) as db_path:
+    #    __db = str(db_path)
+    #    print(__db)
+
+
+#setDBName("databases/bayern.db")
+
+def run(sql: str):
+    con = sqlite3.connect(__db)
+    cur = con.cursor()
+    cur.execute(sql)
+    con.commit()
+    return cur
+
+def runFromFile(path: str):
+    sql = getSQLFromFile(path)
+    if not sql:
+        raise Exception("\nSQL-Datei ist leer. Aufgabe wurde noch nicht bearbeitet.")
+
+
+    if sql.lower().find("drop") != -1:
+        raise Exception("Guter Versuch, aber die Datenbank wird bei jedem Upload zurückgesetzt ;)")
+
+    try:
+        res = run(sql)
+    except Exception as e:
+        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 []
+
+    return headers, rows
+
+
+def runAndGetStringTable_fromFile(path: str, count: int = 5, maxLineLength: int = 85):
+    try:
+        headers, rows = runFromFile(path)
+        resultCount = len(rows)
+        rows = rows[:count]
+        s = ""
+
+        matrix = [] #[[]*(len(rows)+1)]*len(headers)
+
+        for col in range(len(headers)):
+            matrix.append([])
+            matrix[-1].append(headers[col])
+
+        if rows is not None:
+            for col in range(len(matrix)):
+                for row in range(0, len(rows)):
+                    if len(rows[row]) > col:
+                        matrix[col].append(rows[row][col])
+
+            for col in range(len(matrix)):
+                maxLength = 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)
+
+            normalizedRows = []
+            spacing = "  "
+            spacingLength = len(spacing) * (len(matrix[0]) - 1)
+
+            lineLength = sum([len(x[0]) for x in matrix]) + spacingLength
+            
+            
+
+            if lineLength > maxLineLength:
+                valLength = lineLength - spacingLength
+                maxColLength = int(maxLineLength/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] + ".."
+                        else:
+                            matrix[col][row] = matrix[col][row][:maxColLength]
+
+
+            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])*"-")
+
+            s = "\n".join(normalizedRows[:count+2])
+            s += "\n" + normalizedRows[1]
+
+            if (resultCount > count):
+                s += "\n... " + str(resultCount - 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:
+        raise ex
+
+def getSQLFromFile(path: str):
+    try:
+        with open(path, "r") as f:
+            s = f.read()
+            if not s:
+                raise Exception("\nSQL-Datei ist leer. Aufgabe wurde noch nicht bearbeitet.")
+            return s
+    except FileNotFoundError:
+        raise Exception(f"\nSQL-Datei nicht gefunden! Überprüfe, dass der Name korrekt ist ({path.split('/')[-1]}) und die Datei nicht gelöscht oder in einen Unterordner verschoben wurde.")
+
+
+
+def getWorkingDir():
+    return os.getcwd()
+
+
+def getWorkingDirFiles():
+    return os.listdir()
+
+def mapDatabaseTypes(t):
+    # Map SQLite types to Python types
+    type_mapping = {
+        "INTEGER": "int",
+        "TEXT": "str",
+        "VARCHAR": "str",
+        "REAL": "float",
+        "BLOB": "bytes",
+        "NUMERIC": "float",
+        "DOUBLE": "float"
+    }
+    t = t.upper()
+    t = type_mapping.get(t, t)
+
+    if "INT" in t:
+        t = "int"
+    elif "VARCHAR" in t:
+        t = "str"
+    elif "CHAR" in t:
+        t = "str"
+
+    return t
+
+
+
+
+def getTableDict():
+    res = run("SELECT name FROM sqlite_master WHERE type='table';")
+    tables = res.fetchall()
+
+    table_dict = {}
+    for table in tables:
+        res = run(f"PRAGMA table_info({table[0]})")
+        r = res.fetchall()
+        if table[0] == "sqlite_sequence":
+            continue
+        table_dict[table[0]] = [[c[1], mapDatabaseTypes(c[2])] for c in r]
+
+    return table_dict

sql_testing_tools-0.2.0/sql_testing_tools/Helper.py

@@ -0,0 +1,214 @@
+try:
+    import BaseAccess as Ba
+    import TokenProcessing as Tp
+except ImportError:
+    from . import BaseAccess as Ba
+    from . import TokenProcessing as Tp
+
+import requests
+import sqlparse
+
+from sqlparse.sql import Identifier, IdentifierList, Where, Comparison, Function, Parenthesis
+from sqlparse.tokens import Keyword, DML, Name, Wildcard
+
+
+
+def normalizeSQLQuery(query, baseDict):
+    try:
+        query = query.replace("\"", "'")
+        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.")
+
+    formatted_query = []
+    alias_map = {}
+
+    # First pass to process FROM clause and populate alias_map
+    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':
+            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 = []
+
+    # Second pass to process SELECT, WHERE, GROUP BY, and ORDER BY clauses
+    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 (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 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)):
+            if isinstance(token, Function):
+                token = IdentifierList([token])
+            formatted_query.append(Tp._select(token, alias_map, baseDict))
+        else:
+            formatted_query.append(str(token))
+
+    return " ".join(formatted_query)
+
+
+def findTableForColumn(data_dict, target_value, relevantTables):
+    l = []
+    for key, value_list in data_dict.items():
+        if key.lower() in relevantTables:
+            for sublist in value_list:
+                if sublist and sublist[0].lower() == target_value.lower():
+                    l.append(key)
+    if len(l) == 0:
+        for key, value_list in data_dict.items():
+            for sublist in value_list:
+                if sublist and sublist[0].lower() == target_value.lower():
+                    l.append(key)
+    return l
+
+
+def getTableScheme(table_name: str, tableDict: dict):
+    tab = tableDict[table_name]
+
+    # Format the schema
+    schema = "(" + ",".join([f"{col[0]}:{col[1]}" for col in tab]) + ")"
+    return schema
+
+def getCosetteKeyFromFile():
+    try:
+        with open("cosette_apikey.txt", "r") as f:
+            return f.read()
+    except FileNotFoundError:
+        return "NOKEY"
+
+def buildAndSendCosetteRequest(baseDict, sql, sol):
+
+    err = ""
+    for i in range(2):
+        try:
+            apiKey=getCosetteKeyFromFile()
+
+
+            schema = ""
+            for tab in baseDict.keys():
+                schema += f"schema sch{tab}{getTableScheme(tab, baseDict)};\n"
+            for tab in baseDict.keys():
+                schema += f"table {tab}(sch{tab});\n"
+
+            q1 = "query q1\n`"+sql+"`;\n"
+            q2 = "query q2\n`"+sol+"`;\n"
+
+            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)
+
+            print(r.text)
+            return (r.json()['result'],r.text)
+            #return r.json()['result']
+
+        except Exception as e:
+            err = str(e)
+    return ("ERR", err)
+
+
+def checkColumns(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):
+        start = str.find(sql, "SELECT")
+        end = str.find(sql, "FROM")
+        submission = str.strip(sql[start:end])
+        print("'"+submission+"'")
+
+        start = str.find(sol, "SELECT")
+        end = str.find(sol, "FROM")
+        solution = str.strip(sol[start:end])
+        print("'"+solution+"'")
+
+        if submission == solution:
+            return ""
+    return "Ausgegebene Spalten sind nicht korrekt (oder nicht automatisch überprüfbar)."
+
+
+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", ";"]
+
+        start = str.find(sql, "FROM")
+        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, "FROM")
+        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 "Verwendete Tabellen sind nicht korrekt (oder nicht automatisch überprüfbar)."
+
+
+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."
+
+    if(sql==sol):
+        return ""
+
+    result = buildAndSendCosetteRequest(bd, sql, sol)
+
+    if(result[0] == "ERR"):
+        return "\n\nFehler bei der automatischen Überprüfung der Abgabe. Es kann keine Aussage über die Korrektheit der Abgabe getroffen werden."
+    elif(result[0] != "EQ"):
+        return "\n\nDie Abgabe stimmt nicht mit der Musterlösung überein."
+    return ""
+
+

sql_testing_tools-0.2.0/sql_testing_tools/TokenProcessing.py

@@ -0,0 +1,369 @@
+import sqlparse
+from sqlparse.sql import Identifier, IdentifierList, Where, Comparison, Function, Parenthesis
+from sqlparse.tokens import Keyword, DML, Name, Wildcard, Whitespace, Newline
+
+try:
+    import Helper as He
+except ImportError:
+    from . import Helper as He
+
+        
+#####################################
+#####################################
+
+def _identifier(identifier, alias_map, baseDict: 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())
+                if len(tables) == 1:
+                    alias_map[tables[0].lower()] = tables[0]
+                    return f"{tables[0].lower()}.{identifier.get_real_name().lower()}"
+                else:
+                    return f"{identifier.get_real_name().lower()}"
+        return str(identifier)
+
+        
+#####################################
+#####################################
+
+
+def _select(select, alias_map, baseDict: dict, insideFunction=False):
+    select_tokens = []
+    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()}")
+        elif isinstance(token, Identifier):
+            if insideFunction:
+                select_tokens.append(_identifier(token, alias_map, baseDict).lower())
+            else:
+                select_tokens.append(f"{_identifier(token, alias_map,  baseDict).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()})")
+            for par in token.tokens:
+                if isinstance(par, Identifier):
+                    select_tokens.append(par.get_name().lower()+"(")
+                if isinstance(par, Parenthesis):
+                    select_tokens[-1] += _select(par, alias_map, baseDict, True)+") as funcResult" 
+        elif token.ttype is Wildcard:
+            select_tokens.append("*")
+        else:
+            continue
+    select_tokens.sort()
+    return ",".join(select_tokens)
+
+
+#####################################
+#####################################
+
+
+def _from(from_, alias_map, baseDict: dict):
+    from_tokens = []
+    if hasattr(from_, 'tokens'):
+        for token in from_.tokens:
+            if isinstance(token, IdentifierList):
+                for identifier in token.get_identifiers():
+                    alias_map[identifier.get_real_name().lower()] = identifier.get_alias() or identifier.get_real_name()
+                    from_tokens.append(f"{identifier.get_real_name().lower()} {alias_map[identifier.get_real_name().lower()].lower()}")
+            elif isinstance(token, Identifier):
+                alias_map[token.get_real_name().lower()] = token.get_alias() or token.get_real_name()
+                from_tokens.append(f"{token.get_real_name().lower()} {alias_map[token.get_real_name().lower()].lower()}")
+            elif token.ttype is not None and token.ttype is Name:
+                alias_map[token.value.lower()] = token.value.lower()
+                from_tokens.append(f"{token.value.lower()} {alias_map[token.value.lower()].lower()}")
+            else:
+                continue
+    from_tokens.sort()
+    return ",".join(from_tokens)
+
+
+#####################################
+#####################################
+
+
+def _groupby(groupby_, alias_map, baseDict: dict):
+    groupby_tokens = []
+    if(isinstance(groupby_, Identifier)):
+        groupby_tokens.append(_identifier(groupby_, alias_map, baseDict).lower())
+    elif isinstance(groupby_, IdentifierList):
+        for identifier in groupby_.get_identifiers():
+            groupby_tokens.append(_identifier(identifier, alias_map, baseDict).lower())
+    groupby_tokens.sort()
+    return ",".join(groupby_tokens)
+
+def _orderby(orderby_, alias_map, baseDict: dict):
+    orderby_tokens = []
+    if isinstance(orderby_, Identifier):
+        orderby_tokens.append(_identifier(orderby_, alias_map, baseDict).lower())
+    elif isinstance(orderby_, IdentifierList):
+        for identifier in orderby_.get_identifiers():
+            orderby_tokens.append(_identifier(identifier, alias_map, baseDict).lower())
+   # orderby_tokens.sort()
+    return ",".join(orderby_tokens)
+
+def _condition(token, alias_map, baseDict: dict):
+    left, operator, right = [t for t in token.tokens if not t.is_whitespace]
+
+    flipAllowed = True
+    leftLiteral = False
+    rightLiteral = False
+
+    if is_value(right):
+        flipAllowed = False
+        rightLiteral = True
+
+    if is_value(left):
+        left, right = right, left
+        if operator.value == ">":
+            operator.value = "<"
+        elif operator.value == "<":
+            operator.value = ">"
+        leftLiteral = rightLiteral
+        rightLiteral = True
+        flipAllowed = False
+
+    left = _identifier(left, alias_map, baseDict)
+    right = _identifier(right, alias_map, baseDict)
+
+    if flipAllowed and left.lower() >= right.lower():
+        left, right = right, left
+        if operator.value == ">":
+            operator = "<"
+        elif operator.value == "<":
+            operator = ">"
+
+    return f"{left if leftLiteral else left.lower()} {operator} {right if rightLiteral else right.lower()}"
+
+def is_value(token):
+    return token.ttype in (sqlparse.tokens.Token.Literal.Number.Integer,
+                            sqlparse.tokens.Token.Literal.Number.Float,
+                            sqlparse.tokens.Token.Literal.String.Single,
+                            sqlparse.tokens.Token.Literal.String.Symbol)
+
+
+
+#####################################
+#####################################
+
+
+def _paranthesis(parenthesis, alias_map, baseDict: dict):
+    toks = []
+
+    bracketsRequired = True
+    closeBracketsAfterNext = False
+
+    and_count = sum(1 for token in parenthesis.tokens if token.ttype is Keyword and token.value == "AND")  # Zähle "AND"-Tokens
+    or_count = sum(1 for token in parenthesis.tokens if token.ttype is Keyword and token.value == "OR")  # Zähle "AND"-Tokens
+
+
+    if(and_count==1 and or_count == 0):
+        val = _2element_par(parenthesis, alias_map, baseDict, "AND")
+        return val
+    elif(and_count==0 and or_count == 1):
+        val = _2element_par(parenthesis, alias_map, baseDict, "OR")
+        return val
+
+
+
+
+
+
+    for token in parenthesis.tokens:
+        if isinstance(token, Comparison):
+            toks.append(_condition(token, alias_map, baseDict))
+        elif isinstance(token, Parenthesis):
+            toks.append(_paranthesis(token, alias_map, baseDict))
+
+        elif token.ttype is Keyword: #AND,OR
+            if token.value == "AND":
+                pass
+            elif token.value == "OR":
+                pass
+            elif token.value == "NOT":
+                pass
+
+        elif token.value == '(':
+            toks.append(token.value)
+        else:
+            continue
+    x = parenthesis.flatten()
+    return " ".join(toks)
+
+
+def _2element_par(parenthesis, alias_map, baseDict: dict, keyword):
+    toks = []
+
+    for token in parenthesis.tokens:
+        if isinstance(token, Comparison):
+            toks.append(_condition(token, alias_map, baseDict))
+        elif isinstance(token, Parenthesis):
+            toks.append(_paranthesis(token, alias_map, baseDict))
+    toks = toks.sort()
+    fill = (" "+keyword+" ")
+    return fill.join(toks)
+
+
+def count_keywordValues(tokens, values):
+    return len([token for token in tokens if token.ttype is Keyword and token.value.upper() in values])
+
+
+def find_index_of_keyword(tokens, keyword):
+    for index, token in enumerate(tokens):
+        if token.ttype is Keyword and token.value.upper() == keyword:
+            return index
+    return -1  # Wenn kein AND-Token gefunden wird
+
+
+def _where(where, alias_map, baseDict: dict):
+    conditions = []
+    current_condition = []
+
+
+
+    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_string = " ".join([str(token) for token in where_tokens])
+
+    and_count = where_string.upper().count(" AND ")
+    or_count  = where_string.upper().count(" OR ")
+
+    # No AND / OR
+    if and_count + or_count == 0:
+        return _where_simpleCondition(where, alias_map, baseDict)
+
+    # 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 ")
+    
+    # ANDs and ORs
+
+
+    # count keywords on top level
+    top_and_count = count_keywordValues(where_tokens, ["AND"])
+    top_or_count = count_keywordValues(where_tokens, ["OR"])
+
+    # 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)
+    else:
+        where_tokens = _where_addBracketsAroundAND(where, alias_map, baseDict)
+        return _where(Where(where_tokens), alias_map, baseDict)
+
+def _where_addBracketsAroundAND(where, alias_map, baseDict: 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):
+    cond = []
+    for tok in where_tokens:
+        if isinstance(tok, Comparison):
+            cond.append(_condition(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
+    return "".join(cond)
+
+def _where_sameStrengthKeywords(where_tokens, alias_map, baseDict: dict, keyword: str):
+    cond = []
+    for tok in where_tokens:
+        if isinstance(tok, Comparison):
+            cond.append(_condition(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
+    cond.sort()
+    return keyword.join(cond)
+
+def _where_twoConditionsOnTopLevel(where, alias_map, baseDict: dict, keyword, isParanthesis):
+    current_condition = []
+    for tok in where.tokens:
+        if isinstance(tok, Comparison):
+            current_condition.append(_condition(tok, alias_map, baseDict))
+        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)
+
+
+
+
+# def _where_xx(where, alias_map, baseDict: dict):
+#     where_tokens = []
+#     for token in where.tokens:
+
+#         if isinstance(token, Comparison):
+#             left, operator, right = [t for t in token.tokens if not t.is_whitespace]
+#             left = _identifier(left, alias_map, baseDict)
+#             right = _identifier(right, alias_map, baseDict)
+#             if left.lower() >= right.lower():
+#                 left, right = right, left
+#                 if operator.value == ">":
+#                     operator = "<"
+#                 elif operator.value == "<":
+#                     operator = ">"
+
+#             where_tokens.append(f"{left.lower()} {operator} {right.lower()}")
+#         elif token.ttype is Keyword:
+#             where_tokens.append(token.value.upper())
+#         elif token.is_whitespace or (token.ttype is Keyword and token.value.upper() == "WHERE"):
+#             continue
+#         else:
+#             where_tokens.append(str(token))
+#     return " ".join(where_tokens)
+

sql_testing_tools-0.2.0/sql_testing_tools/__init__.py

@@ -0,0 +1,3 @@
+from .BaseAccess import *
+from .Helper import *
+

{sql_testing_tools-0.1.9 → sql_testing_tools-0.2.0}/sql_testing_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: sql_testing_tools
-Version: 0.1.9
+Version: 0.2.0
 Description-Content-Type: text/markdown
 Requires-Dist: sqlparse>=0.5.1
 Requires-Dist: requests>=2.32.3
@@ -15,8 +15,8 @@ A library that normalizes simple SQL queries and compares them first by equality
  [![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)
 
-### V 0.1.9
-- Support GROUP BY
+### 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

{sql_testing_tools-0.1.9 → sql_testing_tools-0.2.0}/sql_testing_tools.egg-info/SOURCES.txt

@@ -1,5 +1,9 @@
 README.md
 setup.py
+sql_testing_tools/BaseAccess.py
+sql_testing_tools/Helper.py
+sql_testing_tools/TokenProcessing.py
+sql_testing_tools/__init__.py
 sql_testing_tools.egg-info/PKG-INFO
 sql_testing_tools.egg-info/SOURCES.txt
 sql_testing_tools.egg-info/dependency_links.txt

sql_testing_tools-0.2.0/sql_testing_tools.egg-info/top_level.txt

@@ -0,0 +1 @@
+sql_testing_tools

sql_testing_tools-0.1.9/sql_testing_tools.egg-info/top_level.txt

@@ -1 +0,0 @@
-