miniDB_project23

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "python.analysis.extraPaths": [
+        "./miniDB"
+    ]
+}

mdb.py

@@ -41,7 +41,6 @@ def in_paren(qsplit, ind):
 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.
-
     This can and will be used recursively
     '''
 
@@ -95,16 +94,39 @@ def create_query_plan(query, keywords, action):
 
     if action=='create table':
         args = dic['create table'][dic['create table'].index('('):dic['create table'].index(')')+1]
+        #print("\n")
         dic['create table'] = dic['create table'].removesuffix(args).strip()
+
+        # 4 primary key
         arg_nopk = args.replace('primary key', '')[1:-1]
         arglist = [val.strip().split(' ') for val in arg_nopk.split(',')]
-        dic['column_names'] = ','.join([val[0] for val in arglist])
-        dic['column_types'] = ','.join([val[1] for val in arglist])
+
+        # 4 unique columns
+        arg_nounique = args.replace('unique', '')[1:-1]
+        arglist1 = [val.strip().split(' ') for val in arg_nounique.split(',')]
+
+        dic['column_names'] = ','.join([val[0] for val in arglist1])
+        dic['column_types'] = ','.join([val[1] for val in arglist1])
+
         if 'primary key' in args:
+            #print("primary here")
             arglist = args[1:-1].split(' ')
-            dic['primary key'] = arglist[arglist.index('primary')-2]
+
+            dic['primary key'] = arglist[arglist.index('primary')-2] # -2 tp find key's name, -1 to find key's data type  e.g string/ integer
         else:
             dic['primary key'] = None
+
+        # handle unique columns
+        if 'unique' in args:
+            arglist1 = args[1:-1].split(' ')
+            indx_lst = [idx for idx, value in enumerate(arglist1) if value == 'unique' or value == 'unique,']
+
+            dic['unique'] = ','.join(arglist1[n-2] for n in indx_lst) 
+        else:
+            dic['unique'] = None
+        #print("\n")
+        #print(dic)
+        #print("\n")
 
     if action=='import': 
         dic = {'import table' if key=='import' else key: val for key, val in dic.items()}
@@ -175,7 +197,8 @@ def interpret(query):
                      'unlock table': ['unlock table', 'force'],
                      'delete from': ['delete from', 'where'],
                      'update table': ['update table', 'set', 'where'],
-                     'create index': ['create index', 'on', 'using'],
+                     #'create index': ['create index', 'on', 'using'],
+                     'create index': ['create index', 'on', 'column', 'using'],
                      'drop index': ['drop index'],
                      'create view' : ['create view', 'as']
                      }
@@ -205,9 +228,7 @@ def execute_dic(dic):
 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:
-
     lsdb - list databases
     lstb - list tables
     cdb - change/create database
@@ -295,4 +316,4 @@ def remove_db(db_name):
                 if isinstance(result,Table):
                     result.show()
         except Exception:
-            print(traceback.format_exc())
+            print(traceback.format_exc())

miniDB/btree.py

@@ -15,7 +15,7 @@ def __init__(self, b, values=None, ptrs=None,left_sibling=None, right_sibling=No
         self.parent = parent # the index of a buckets parent
         self.is_leaf = is_leaf # a boolean value signaling whether the node is a leaf or not
 
-
+    
     def find(self, value, return_ops=False):
         '''
         Returns the index of the next node to search for a value if the node is not a leaf (a ptrs of the available ones).
@@ -28,10 +28,20 @@ def find(self, value, return_ops=False):
         ops = 0 # number of operations (<>= etc). Used for benchmarking
         if self.is_leaf: #
             return
-
+
+        '''
+        if (isinstance(value, int)):
+            value = float(value)
+        '''
+        #print(value)
         # for each value in the node, if the user supplied value is smaller, return the btrees value index
         # else (no value in the node is larger) return the last ptr
+        #print(self.values)
+        #for index, existing_val in enumerate(self.values):
+            #print("existing val: ", existing_val)
+            #print("index: ", index)
         for index, existing_val in enumerate(self.values):
+            #print("existing val: ", existing_val)
             ops+=1
             if value is None or existing_val is None:
                 continue
@@ -221,8 +231,6 @@ def split(self, node_id):
                 self.split(node.parent)
 
 
-
-
     def show(self):
         '''
         Show important info for each node (sort by level - root first, then left to right).
@@ -288,9 +296,18 @@ def find(self, operator, value):
             operator: string. The provided evaluation operator.
             value: float. The value being searched for.
         '''
+
+        '''
+        if (isinstance(value, int)):
+            value = float(value)
+        '''   
         results = []
+
+
         # find the index of the node that the element should exist in
         leaf_idx, ops = self._search(value, True)
+        #print("leaf idx: ",leaf_idx)
+        #print("ops: ", ops)
         target_node = self.nodes[leaf_idx]
 
         if operator == '=':
@@ -343,6 +360,7 @@ def find(self, operator, value):
                 target_node = self.nodes[target_node.left_sibling]
                 results.extend(target_node.ptrs)
 
+
         # print the number of operations (usefull for benchamrking)
         # print(f'With BTree -> {ops} comparison operations')
         return results