Updated instructions, bulid drivers, bug fixes

reconstruct/ast.py

@@ -617,6 +617,7 @@ class join(ast_node):
         self.join_conditions = []
         # self.tmp_name = 'join_' + base62uuid(4)
         # self.datasource = TableInfo(self.tmp_name, [], self.context)
+        
     def append(self, tbls, __alias = ''):
         alias = lambda t : t + ' ' + __alias if len(__alias) else t
         if type(tbls) is join:
@@ -661,8 +662,11 @@ class join(ast_node):
                     self.have_sep = True
                     j = join(self, node[keys[0]])
                     tablename = f' {keys[0]} {j}'
-                    if len(keys) > 1 and keys[1].lower() == 'on':
-                        tablename += f' on {expr(self, node[keys[1]])}' 
+                    if len(keys) > 1 :
+                        if keys[1].lower() == 'on':
+                            tablename += f' ON {expr(self, node[keys[1]])}' 
+                        elif keys[1].lower() == 'using':
+                            tablename += f' USING {expr(self, node[keys[1]])}'
                     self.joins.append((tablename, self.have_sep))
                     self.tables += j.tables
                     self.tables_dir = {**self.tables_dir, **j.tables_dir}
@@ -731,8 +735,9 @@ class join(ast_node):
 class filter(ast_node):
     name = 'where'
     def produce(self, node):
-        self.add(expr(self, node).sql)
-    
+        filter_expr = expr(self, node)
+        self.add(filter_expr.sql)
+        self.datasource.join_conditions += filter_expr.join_conditions
         
 class create_table(ast_node):
     name = 'create_table'

reconstruct/expr.py

@@ -12,6 +12,11 @@ from engine.types import *
 
 class expr(ast_node):
     name='expr'
+    valid_joincond = {
+        0 : ('and', 'eq', 'not'),
+        1 : ('or', 'neq', 'not'),
+        2 : ('', '', '')
+    }
     @property
     def udf_decltypecall(self):
         return self._udf_decltypecall if self._udf_decltypecall else self.sql
@@ -46,6 +51,7 @@ class expr(ast_node):
         self.node = node
         self.supress_undefined = supress_undefined
         if(type(parent) is expr):
+            self.next_valid = parent.next_valid
             self.inside_agg = parent.inside_agg
             self.is_udfexpr = parent.is_udfexpr
             self.is_agg_func = parent.is_agg_func
@@ -53,6 +59,8 @@ class expr(ast_node):
             self.c_code = parent.c_code
             self.builtin_vars = parent.builtin_vars
         else:
+            self.join_conditions = []
+            self.next_valid = 0
             self.is_agg_func = False
             self.is_udfexpr = type(parent) is udf
             self.root : expr = self
@@ -92,9 +100,18 @@ class expr(ast_node):
             else:
                 if len(node) > 1:
                     print(f'Parser Error: {node} has more than 1 dict entry.')
-                
+
+                is_joincond = False
                 for key, val in node.items():
                     key = key.lower()
+                    if key not in self.valid_joincond[self.next_valid]:
+                        self.next_valid = 2
+                    else:
+                        if key == self.valid_joincond[self.next_valid][2]:
+                            self.next_valid = not self.next_valid
+                        elif key == self.valid_joincond[self.next_valid][1]:
+                            self.next_valid = 2
+                            is_joincond = True
                     if key in self.operators:
                         if key in builtin_func:
                             if self.is_agg_func:
@@ -200,6 +217,9 @@ class expr(ast_node):
                     else:
                         print(f'Undefined expr: {key}{val}')
                 
+                if (is_joincond and len(self.children) == 2
+                    and all([c.is_ColExpr for c in self.children])) :
+                    self.root.join_conditions.append((c.raw_col for c in self.children))
                     
         if type(node) is str:
             if self.is_udfexpr:
@@ -342,9 +362,11 @@ class expr(ast_node):
                             exec(f'loc["{b}"] = lambda : "{b}"')
                     
             x = self.c_code if c_code is None else c_code
+            from engine.utils import escape_qoutes
             if decltypestr:
-                return eval('f\'' + self.udf_decltypecall + '\'')
-            return eval('f\'' + self.sql + '\'')
+                return eval('f\'' + escape_qoutes(self.udf_decltypecall) + '\'')
+            self.sql.replace("'", "\\'")
+            return eval('f\'' + escape_qoutes(self.sql) + '\'')
         if self.is_recursive_call_inudf or (self.need_decltypestr and self.is_udfexpr) or gettype:
             return call
         else: