ΣΔΒΔ - P20009, P20007, P20004 #226

New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Open
dimitrisstyl7 wants to merge 104 commits into DataStories-UniPi:master from dimitrisstyl7:master
code_summary.md
Large diffs are not rendered by default.
mdb.py
            
                      Original file line number
                      Diff line number
                      Diff line change
                  
    @@ -5,10 +5,13 @@
  
    import readline

    import traceback

    import shutil

    sys.path.append('miniDB')

    from database import Database

    from table import Table

    from miniDB.database import Database

    from miniDB.table import Table

    from miniDB.query_plans import multiple_query_plans

    from miniDB.evaluate_query_plans import evaluate_query_plans

    # art font is "big"

    art = '''

                 _         _  _____   ____  

    @@ -20,6 +23,7 @@
  
    '''   

    def search_between(s, first, last):

        '''

        Search in 's' for the substring that is between 'first' and 'last'

    @@ -37,7 +41,6 @@ def in_paren(qsplit, ind):
  
        '''

        return qsplit[:ind].count('(')>qsplit[:ind].count(')')

    def create_query_plan(query, keywords, action):

        '''

        Given a query, the set of keywords that we expect to pe present and the overall action, return the query plan for this query.

    @@ -66,8 +69,6 @@ def create_query_plan(query, keywords, action):
  
                ql.pop(i+1)

                kw_positions.append(i)

            i+=1

        for i in range(len(kw_in_query)-1):

            dic[kw_in_query[i]] = ' '.join(ql[kw_positions[i]+1:kw_positions[i+1]])

    @@ -78,6 +79,9 @@ def create_query_plan(query, keywords, action):
  
        if action=='select':

            dic = evaluate_from_clause(dic)

            if dic['where'] is not None:

                dic = evaluate_where_clause(dic)

            if dic['distinct'] is not None:

                dic['select'] = dic['distinct']

                dic['distinct'] = True

    @@ -96,16 +100,26 @@ def create_query_plan(query, keywords, action):
  
        if action=='create table':

            args = dic['create table'][dic['create table'].index('('):dic['create table'].index(')')+1]

            dic['create table'] = dic['create table'].removesuffix(args).strip()

            arg_nopk = args.replace('primary key', '')[1:-1]

            arglist = [val.strip().split(' ') for val in arg_nopk.split(',')]

            temp_args = args.replace('primary key', '')[1:-1] # remove primary key and parentheses

            temp_args = temp_args.replace('unique', '') # remove unique

            arglist = [val.strip().split(' ') for val in temp_args.split(',')]

            dic['column_names'] = ','.join([val[0] for val in arglist])

            dic['column_types'] = ','.join([val[1] for val in arglist])

            if 'primary key' in args:

                arglist = args[1:-1].split(' ')

                dic['primary key'] = arglist[arglist.index('primary')-2]

            else:

                dic['primary key'] = None

            if 'unique' in args:

                arglist = args[1:-1].split(',')

                arglist = [val.strip().split(' ') for val in arglist]

                column_names = [val[0] for val in arglist if len(val)>2 and val[2]=='unique']

                dic['unique_columns'] = ','.join(column_names)

            else:

                dic['unique_columns'] = None

        if action=='import': 

            dic = {'import table' if key=='import' else key: val for key, val in dic.items()}

    @@ -121,9 +135,29 @@ def create_query_plan(query, keywords, action):
  
            else:

                dic['force'] = False

        return dic

        if action=='delete from':

            if dic['where'] is not None:

                dic = evaluate_where_clause(dic)

            else:

                dic['where'] = None

        if action=='update':

            if dic['where'] is not None:

                dic = evaluate_where_clause(dic)

            else:

                dic['where'] = None

        if action=='create index':

            # Check if 'on' clause is not None and if is of the form 'table_name (column_name)'

            if dic['on'] is not None and '(' in dic['on'] and ')' in dic['on'] and dic['on'].count('(') == dic['on'].count(')') == 1:

                on_clause = dic['on'].split('(')

                table_name = on_clause[0].strip()

                column_name = on_clause[1][:-1].strip()

                dic['on'] = { 'table_name': table_name, 'column_name': column_name }

            else:

                raise ValueError('\nWrong syntax: "on" clause must be of the form "table_name (column_name)"\n')

        return dic

    def evaluate_from_clause(dic):

        '''

    @@ -148,7 +182,11 @@ def evaluate_from_clause(dic):
  
                join_dic['join'] = 'inner'

                join_dic['left'] = ' '.join(from_split[:join_idx])

            join_dic['right'] = ' '.join(from_split[join_idx+1:on_idx])

            join_dic['on'] = ''.join(from_split[on_idx+1:])

            and_idx = [i+on_idx+1 for i,word in enumerate(from_split[on_idx+1:]) if word=='and']

            if and_idx:

                join_dic['on'] = {'and':{'left':' '.join(from_split[on_idx+1:and_idx[0]]),'right':' '.join(from_split[and_idx[0]+1:])}}

            else:

                join_dic['on'] = ''.join(from_split[on_idx+1:])

            if join_dic['left'].startswith('(') and join_dic['left'].endswith(')'):

                join_dic['left'] = interpret(join_dic['left'][1:-1].strip())

    @@ -160,6 +198,144 @@ def evaluate_from_clause(dic):
  
        return dic

    def evaluate_where_clause(dic):

        '''

        Evaluate the part of the query (argument or subquery) that is supplied as the 'where' argument.

        '''

        def convert_list_to_dict(lst):

            '''

            Converting the list of dictionaries to the desired dictionary,

            where each key ('OPR') will later be replaced with an operator ('and' or 'or').

            '''

            if len(lst) == 1:

                return {'OPR': lst[0]}

            else:

                return {'OPR': {'left': lst[0]['left'], 'right': convert_list_to_dict(lst[1:])}}

        def build_list(oprt_idx, where_split):

            '''

            Building a list of dictionaries, where each dictionary contains

            the left and right sides of the operator ('and' or 'or').

            '''

            if oprt_idx:

                oprt_dic = {}

                if ' '.join(where_split[:oprt_idx[0]]).startswith('not '):

                    oprt_dic['left'] = ' '.join(where_split[:oprt_idx[0]])

                else:

                    oprt_dic['left'] = ' '.join(where_split[oprt_idx[0]-1:oprt_idx[0]])

                    if oprt_dic['left'] == ')':

                        pos  = where_split[:oprt_idx[0]].index('(')

                        oprt_dic['left'] = ' '.join(where_split[pos:oprt_idx[0]])

                    if ' '.join(where_split[:oprt_idx[0]]).__contains__('between'):

                        btwn_idx = where_split[:oprt_idx[0]].index('between')

                        if not in_paren(where_split, btwn_idx):

                            raise ValueError(f'\nWrong syntax: "between" clause must be in parentheses.\n')

                oprt_dic['left'] = evaluate_where_clause( { 'where':  oprt_dic['left'] } )['where']

                oprt_dic['right'] = ' '.join(where_split[oprt_idx[0]+1:])

                oprt_dic['right'] = evaluate_where_clause( { 'where':  oprt_dic['right'] } )['where']

                List.append(oprt_dic)

        def put_paren_in_oprt_and(where_split):

            '''

            Placing parentheses around the 'and' operator, if it is not already within parentheses, when an 'or' operator exists,

            helps ensure the proper priority of the operators ('and' and 'or'). This also works for some 'between' clauses, 

            but it is recommended to always put parentheses around the 'between' clause.

            '''

            def find_idx():

                '''

                Finding the indices of the 'and' and 'or' operators.

                '''

                and_idx = [i for i,word in enumerate(where_split) if word=='and' and not in_paren(where_split,i)]

                or_idx = [i for i,word in enumerate(where_split) if word=='or' and not in_paren(where_split,i)]

                oprt_idx = and_idx + or_idx

                oprt_idx.sort()

                return oprt_idx, and_idx, or_idx

            oprt_idx, and_idx, or_idx = find_idx()

            previous_and = False

            idx_for_paren = 0

            while len(oprt_idx) > 0 and and_idx and or_idx:

                idx = oprt_idx.pop(0)

                if where_split[idx] == 'and' and not previous_and:

                    previous_and = True

                    where_split.insert(idx_for_paren, '(')

                    if len(oprt_idx) == 0:

                        where_split.append(')')

                        break

                    elif where_split[idx+2] == 'not':

                        where_split.insert(idx+4, ')')

                    else:

                        where_split.insert(idx+3, ')')

                    oprt_idx, and_idx, or_idx = find_idx()

                elif where_split[idx] == 'and' and previous_and:

                    where_split.pop(idx-1)

                    where_split.insert(idx+1, ')')

                else:

                    previous_and = False

                    idx_for_paren = idx+1

            return where_split

        where_split = put_paren_in_oprt_and(dic['where'].split(' '))

        '''

        not/between/and/or operators not in parentheses.

        '''

        not_idx = [i for i, word in enumerate(where_split) if word == 'not' and not in_paren(where_split, i)]

        btwn_idx = [i for i, word in enumerate(where_split) if word == 'between' and not in_paren(where_split, i)]

        oprt_idx = [i for i,word in enumerate(where_split) if (word=='or' or word=='and') and not in_paren(where_split,i)] # oprt_idx contains the indices of operators 'and' and 'or'.

        '''

        Checking if the 'where' clause is within parentheses or if it starts with

        'not' operator outside of parentheses and is followed by parentheses.

        '''

        if not oprt_idx and (where_split[0] == '(' or where_split[0] == 'not' and where_split[1] == '(') and where_split[-1] == ')':

            if not_idx:

                dic['where'] = { 'not': evaluate_where_clause( { 'where': ' '.join(where_split).removeprefix('not ') } )['where'] }

                return dic

            else:

                dic['where'] = evaluate_where_clause( { 'where': ' '.join(where_split[1:-1]) } )['where']

                return dic

        if btwn_idx and len(oprt_idx) == 1:

            '''

            If the 'between' operator exists and there is only one operator ('and'),

            evaluate the 'between' clause and return the result.

            '''

            if len(where_split) < 5:

                raise Exception('\nWrong syntax of "between" clause.\n')

            dic['where'] = { 'column': where_split[btwn_idx[0]-1], 'between': evaluate_where_clause( { 'where':  ' '.join(where_split[btwn_idx[0]+1:]) } )['where'] }

            return dic

        if oprt_idx:

            '''

            If there are operators ('and' or 'or'), we build a list of dictionaries and then convert it into a dictionary.

            The 'OPR' string is used as a placeholder for the actual operator and then is replaced with the correct operator.

            '''

            List = []

            build_list(oprt_idx, where_split)

            oprt_dic = str(convert_list_to_dict(List))

            oprt_words = [where_split[i] for i in oprt_idx]

            '''

            Replace the 'OPR' string with the actual operator ('and' or 'or').

            '''

            oprt_dic = oprt_dic.replace('OPR', oprt_words[0], 1)

            dic['where'] = dict(eval(oprt_dic))

            return dic

        if not_idx:

            '''

            If the simple 'not' operator exists, create a dictionary with the 'not' operator

            where the key is 'not' and the value is the right side of the 'not' operator.

            '''

            dic['where'] = {'not': where_split[not_idx[0]+1]}

            return dic

        dic['where'] = ''.join(where_split)

        return dic

    def interpret(query):

        '''

        Interpret the query.

    @@ -174,12 +350,13 @@ def interpret(query):
  
                         'lock table': ['lock table', 'mode'],

                         'unlock table': ['unlock table', 'force'],

                         'delete from': ['delete from', 'where'],

                         'update table': ['update table', 'set', 'where'],

                         'update': ['update', 'set', 'where'],

                         'create index': ['create index', 'on', 'using'],

                         'drop index': ['drop index'],

                         'create view' : ['create view', 'as']

                         }

        if query[-1]!=';':

            query+=';'

    @@ -196,14 +373,14 @@ def execute_dic(dic):
  
        Execute the given dictionary

        '''

        for key in dic.keys():

            if isinstance(dic[key],dict):

            if isinstance(dic[key], dict) and key == 'from':

                dic[key] = execute_dic(dic[key])

        action = list(dic.keys())[0].replace(' ','_')

        return getattr(db, action)(*dic.values())

    def interpret_meta(command):

        """

        '''

        Interpret meta commands. These commands are used to handle DB stuff, something that can not be easily handled with mSQL given the current architecture.

        The available meta commands are:

    @@ -212,7 +389,7 @@ def interpret_meta(command):
  
        lstb - list tables

        cdb - change/create database

        rmdb - delete database

        """

        '''

        action = command.split(' ')[0].removesuffix(';')

        db_name = db._name if search_between(command, action,';')=='' else search_between(command, action,';')

    @@ -251,9 +428,8 @@ def remove_db(db_name):
  
        dbname = os.getenv('DB')

        db = Database(dbname, load=True)

        #db.print_statistics() # uncomment to print statistics

        if fname is not None:

            for line in open(fname, 'r').read().splitlines():

                if line.startswith('--'): continue

    @@ -280,19 +456,37 @@ def remove_db(db_name):
  
                    line+=';'

            except (KeyboardInterrupt, EOFError):

                print('\nbye!')

                try:

                    db.calculate_tables_statistics() # calculate statistics before exiting.

                except:

                    pass # if the database is not loaded or does not exist, do not calculate statistics.

                break

            try:

                if line=='exit':

                if line=='exit;':

                    print('\nbye!')

                    try:

                        db.calculate_tables_statistics() # calculate statistics before exiting.

                    except:

                        pass # if the database is not loaded or does not exist, do not calculate statistics.

                    break

                if line.split(' ')[0].removesuffix(';') in ['lsdb', 'lstb', 'cdb', 'rmdb']:

                    interpret_meta(line)

                elif line.startswith('explain'):

                    dic = interpret(line.removeprefix('explain '))

                    pprint(dic, sort_dicts=False)

                else:

                    dic = interpret(line)

                    if 'select' in dic.keys() and not (isinstance(dic['from'],str) and dic['from'].startswith('meta')):

                        queries, is_valid = multiple_query_plans(dic)

                        if(is_valid):

                            dic = evaluate_query_plans(db,queries)

                    result = execute_dic(dic)

                    if isinstance(result,Table):

                        result.show()

            except Exception:

            except Exception as e:

                print(traceback.format_exc())

                print(e)
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

ΣΔΒΔ - P20009, P20007, P20004 #226

Uh oh!

Diff view

Diff view

There are no files selected for viewing

Uh oh!

Uh oh!

ΣΔΒΔ - P20009, P20007, P20004 #226

Are you sure you want to change the base?

Uh oh!

ΣΔΒΔ - P20009, P20007, P20004 #226

Uh oh!

Uh oh!

Diff view

Diff view

There are no files selected for viewing

Uh oh!

Uh oh!
