kaqing 2.0.58__py3-none-any.whl → 2.0.60__py3-none-any.whl

adam/sql/sql_completer.py

@@ -9,6 +9,10 @@ from adam.sql.term_completer import TermCompleter
 
 columns = TermCompleter(['id', 'x.', 'y.', 'z.'])
 
+def fr(*args):
+    for arg in args:
+        pass
+
 class SqlCompleter(Completer):
     # <select_statement> ::= SELECT <select_list>
     #                      FROM <table_expression>
@@ -137,6 +141,7 @@ class SqlCompleter(Completer):
         self.dml = dml
         self.tables = tables
         self.debug = debug
+        self.machine = self.automata()
 
     def get_completions(
         self, document: Document, complete_event: CompleteEvent
@@ -155,14 +160,14 @@ class SqlCompleter(Completer):
             state = self.traverse_tokens(text, statement.tokens)
             if self.debug:
                 print('\n  =>', state)
-            if state == 'dml_incomplete':
+            if state == '':
                 completer = TermCompleter(['select', 'insert', 'delete', 'update'])
 
             elif state == 'select_':
                 completer = TermCompleter(['*'])
             elif state == 'select_a':
                 completer = TermCompleter(['from'])
-            elif state == 'select_a,':
+            elif state == 'select_a_comma_':
                 completer = TermCompleter(['*'])
             elif state == 'select_a_':
                 completer = TermCompleter(['from'])
@@ -172,11 +177,11 @@ class SqlCompleter(Completer):
                 completer = TermCompleter(['as', 'where', 'inner', 'left', 'right', 'full', 'group', 'limit'])
             elif state == "select_from_x_as_x_":
                 completer = TermCompleter(['where', 'inner', 'left', 'right', 'full', 'group', 'limit'])
-            elif state == "select_from_x,":
+            elif state == "select_from_x_comma_":
                 completer = TermCompleter(self.tables())
             elif state == "select_from_x_as_":
                 completer = TermCompleter(['x', 'y', 'z'])
-            elif state == "select_from_x_as_x,":
+            elif state == "select_from_x_as_x_comma_":
                 completer = TermCompleter(self.tables())
             elif state == "select_where_":
                 completer = columns
@@ -184,21 +189,27 @@ class SqlCompleter(Completer):
                 completer = TermCompleter(['=', '<', '<=', '>', '>=', '<>', 'like', 'not', 'in'])
             elif state == "select_where_a_not_":
                 completer = TermCompleter(['like', 'in'])
+            elif state == "select_where_a_in":
+                completer = TermCompleter(['('])
+            elif state == "select_where_a_in_lp_":
+                completer = TermCompleter(["'", ')'])
+            elif state == "select_where_a_in_lp_a_comma_":
+                completer = TermCompleter(["'"])
             elif state == "select_where_a_op":
                 completer = TermCompleter(["'"])
             elif state == "select_where_sc_":
                 completer = TermCompleter(['and', 'or', 'group', 'limit'])
             elif state == "select_where_sc_limit_":
                 completer = TermCompleter(['1'])
-            elif state == "select_from_x_group_":
+            elif state == "select_group_":
                 completer = TermCompleter(['by'])
-            elif state == "select_from_x_group_by_":
+            elif state == "select_group_by_":
                 completer = columns
-            elif state == "select_from_x_group_by_a,":
+            elif state == "select_group_by_a_comma_":
                 completer = columns
-            elif state == "select_from_x_group_by_a_":
+            elif state == "select_group_by_a_":
                 completer = TermCompleter(['limit'])
-            elif state == "select_from_x_group_by_a_limit_":
+            elif state == "select_group_by_a_limit_":
                 completer = TermCompleter(['1'])
             elif state == "select_from_x_inner_":
                 completer = TermCompleter(['join'])
@@ -214,7 +225,7 @@ class SqlCompleter(Completer):
                 completer = TermCompleter(['='])
             elif state == "select_x_join_y_on_a_op":
                 completer = columns
-            elif state == "select_x_join_y_on_a_opb_":
+            elif state == "select_x_join_y_on_a_op_b_":
                 completer = TermCompleter(['where', 'group', 'limit'])
             elif state == "select_from_x_left_":
                 completer = TermCompleter(['outer', 'join'])
@@ -237,9 +248,9 @@ class SqlCompleter(Completer):
                 completer = TermCompleter(['values(', 'select'])
             elif state == "insert_into_x_lp_":
                 completer = columns
-            elif state == "insert_into_x_lp_a,":
+            elif state == "insert_into_x_lp_a_comma_":
                 completer = columns
-            elif state == "insert_into_x_lp_a_rp_":
+            elif state == "insert_into_x_lp_a_rp__":
                 completer = TermCompleter(['values(', 'select'])
             elif state == "insert_values":
                 completer = TermCompleter(['('])
@@ -250,13 +261,13 @@ class SqlCompleter(Completer):
                 completer = TermCompleter(self.tables())
             elif state == "update_x_":
                 completer = TermCompleter(['set'])
-            elif state in ["update_x_set_", "update_x_set_sc,"]:
+            elif state in ["update_set_", "update_set_sc_comma_"]:
                 completer = columns
-            elif state == "update_x_set_a":
+            elif state == "update_set_a":
                 completer = TermCompleter(['='])
-            elif state == "update_x_set_a_op":
+            elif state == "update_set_a_op":
                 completer = TermCompleter(["'"])
-            elif state == "update_x_set_sc_":
+            elif state == "update_set_sc_":
                 completer = TermCompleter(['where'])
             elif state == "update_where_":
                 completer = columns
@@ -284,8 +295,201 @@ class SqlCompleter(Completer):
             for c in completer.get_completions(document, complete_event):
                 yield c
 
-    def traverse_tokens(self, text: str, tokens: list[Token], state: str = None, indent=0):
-        # state: str = None
+    def automata(self):
+        y = [
+            '                                > select           > select',
+            'select_                         > name|*           > select_a',
+            'select_a                        > ,                > select_a_comma_',
+            'select_a_comma_                 > name|*           > select_a',
+            'select_a_                       > from             > select_from',
+            'select_from_                    > name             > select_from_x',
+            'select_from_x                   > ,                > select_from_x_comma_',
+            'select_from_x_comma_            > name             > select_from_x',
+            'select_from_x_',
+            'select_from_x_as_x_             > ,                > select_from_x_comma_',
+            '-                               > as               > select_from_x_as',
+            '-                               > where            > select_where',
+            '-                               > limit            > select_where_sc_limit',
+            '-                               > group            > select_group',
+            '-                               > group by         > select_group_by',
+            '-                               > inner            > select_from_x_inner',
+            '-                               > inner join       > select_join',
+            '-                               > left             > select_from_x_left',
+            '-                               > left join        > select_join',
+            '-                               > left outer join  > select_join',
+            '-                               > right            > select_from_x_right',
+            '-                               > right join       > select_join',
+            '-                               > right outer join > select_join',
+            '-                               > full             > select_from_x_full',
+            '-                               > full outer join  > select_join',
+            'select_from_x_as_               > name             > select_from_x_as_x',
+            'select_from_x_as_x              > ,                > select_from_x_as_x_comma_',
+            'select_from_x_as_x_comma_       > name             > select_from_x_as_x',
+            'select_where_                   > name             > select_where_a',
+            'select_where_a                  > comparison       > select_where_a_op',
+            'select_where_a_                 > comparison       > select_where_a_op',
+            '-                               > not              > select_where_a_not',
+            '-                               > in               > select_where_a_in',
+            'select_where_a_not_             > comparison       > select_where_a_not_op',
+            '-                               > in               > select_where_a_in',
+            'select_where_a_in               > (                > select_where_a_in_lp_',
+            'select_where_a_in_lp_           > name|single      > select_where_a_in_lp_a',
+            'select_where_a_in_lp_a          > ,                > select_where_a_in_lp_a_comma_',
+            '-                               > )                > select_where_sc',
+            'select_where_a_in_lp_a_comma_   > name|single      > select_where_a_in_lp_a',
+            'select_where_a_not_op           > name|single      > select_where_sc',
+            'select_where_a_op               > name|single      > select_where_sc',
+            'select_where_sc_                > and|or           > select_where',
+            '-                               > group            > select_group',
+            '-                               > group by         > select_group_by',
+            '-                               > limit            > select_where_sc_limit',
+            'select_group_                   > by               > select_group_by',
+            'select_group_by_                > name             > select_group_by_a',
+            'select_group_by_a               > ,                > select_group_by_a_comma_',
+            'select_group_by_a_comma_        > name             > select_group_by_a',
+            'select_group_by_a_              > limit            > select_where_sc_limit',
+            'select_where_sc_limit           > _                > select_where_sc_limit_',
+            'select_where_x_inner_           > join             > select_join',
+            'select_join_                    > name             > select_x_join_y',
+            'select_from_x_left_             > join             > select_join',
+            '-                               > outer            > select_from_x_left_outer',
+            'select_from_x_left_outer_       > join             > select_join',
+            'select_from_x_                  > left outer join  > select_join',
+            'select_from_x_right_            > join             > select_join',
+            '-                               > outer            > select_from_x_right_outer',
+            'select_from_x_right_outer_      > join             > select_join',
+            'select_from_x_full_             > join             > select_join',
+            '-                               > outer            > select_from_x_full_outer',
+            'select_from_x_full_outer_       > join             > select_join',
+            'select_x_join_y                 > ,                > select_x_join_y_comma_',
+            'select_x_join_y_comma_          > name             > select_x_join_y',
+            'select_x_join_y_                > on               > select_x_join_y_on',
+            'select_x_join_y_on_             > name             > select_x_join_y_on_a',
+            'select_x_join_y_on_a            > comparison       > select_x_join_y_on_a_op',
+            'select_x_join_y_on_a_op         > name|single      > select_x_join_y_on_a_op_b',
+            'select_x_join_y_on_a_op_b       > ,                > select_x_join_y_on_',
+            'select_x_join_y_on_a_op_b_      > and|or           > select_join',
+            '-                               > where            > select_where',
+            '-                               > group            > select_group',
+            '-                               > group by         > select_group_by',
+            '-                               > limit            > select_where_sc_limit',
+
+
+            '                                > insert           > insert',
+            'insert_                         > into             > insert_into',
+            'insert_into_                    > name             > insert_into_x',
+            'insert_into_x                   > (                > insert_into_x_lp_',
+            'insert_into_x_                  > (                > insert_into_x_lp_',
+            '-                               > values           > insert_values',
+            'insert_into_x_lp_               > name             > insert_into_x_lp_a',
+            'insert_into_x_lp_a              > ,                > insert_into_x_lp_a_comma_',
+            '-                               > )                > insert_into_x_lp_a_rp_',
+            'insert_into_x_lp_a_comma_       > name             > insert_into_x_lp_a',
+            'insert_into_x_lp_a_rp__         > values           > insert_values',
+            '-                               > select           > select',
+            'insert_values                   > (                > insert_values_lp_',
+            'insert_values_lp_               > name|single      > insert_values_lp_v',
+            'insert_values_lp_v              > ,                > insert_values_lp_v_comma_',
+            'insert_values_lp_v_comma_       > name|single      > insert_values_lp_v',
+
+
+            '                                > update           > update',
+            'update_                         > name             > update_x',
+            'update_x_                       > set              > update_set',
+            'update_set_                     > name             > update_set_a',
+            'update_set_a                    > comparison       > update_set_a_op',
+            'update_set_a_op                 > name|single      > update_set_sc',
+            'update_set_sc                   > ,                > update_set_sc_comma_',
+            'update_set_sc_comma_            > name             > update_set_a',
+            'update_set_sc_                  > ,                > update_set_sc_comma_',
+            '-                               > where            > update_where',
+            'update_where_                   > name             > update_where_a',
+            'update_where_a                  > comparison       > update_where_a_op',
+            'update_where_a_op               > name|single      > update_where_sc',
+            'update_where_sc_                > and|or           > update_where',
+
+
+            '                                > delete           > delete',
+            'delete_                         > from             > delete_from',
+            'delete_from_                    > name             > delete_from_x',
+            'delete_from_x_                  > where            > delete_where',
+            'delete_where_                   > name             > delete_where_a',
+            'delete_where_a                  > comparison       > delete_where_a_op',
+            'delete_where_a_op               > name|single      > delete_where_sc',
+            'delete_where_sc_                > and|or           > delete_where',
+        ]
+
+        def add_space_transition(from_s: str):
+            # add whitespace transition if a state with trailing whitespace is found from from states, for example, select > _ > select_
+            if from_s.endswith('_') and not from_s.endswith('_comma_') and not from_s.endswith('_lp_') and not from_s.endswith('_rp_'):
+                if self.debug:
+                    print(f'{from_s[:-1]} > _ = {to_s}')
+                machine[f'{from_s[:-1]} > _'] = from_s
+
+        machine: dict[str, str] = {}
+
+        from_ss_to_add = []
+        from_ss = ['']
+        token = None
+        tokens = []
+        to_s = None
+        for l in y:
+            tks = l.split('>')
+            if l.startswith('-'):
+                token = tks[1].strip(' ')
+                if len(tks) > 2:
+                    to_s = tks[2].strip(' ')
+                    for from_s in from_ss:
+                        tokens = [token]
+                        if '|' in token:
+                            tokens = token.strip(' ').split('|')
+
+                        for t in tokens:
+                            if self.debug:
+                                print(f'{from_s} > {t} = {to_s}')
+                            machine[f'{from_s} > {t}'] = to_s
+            else:
+                if len(tks) == 1:
+                    from_s = tks[0].strip(' ')
+                    add_space_transition(from_s)
+                    from_ss_to_add.append(f'{from_s}')
+                    continue
+
+                from_ss = []
+                from_ss.extend(from_ss_to_add)
+                from_ss_to_add = []
+                from_ss.append(f'{tks[0].strip(" ")}')
+                for from_s in from_ss:
+                    add_space_transition(from_s)
+                    token = tks[1].strip(' ')
+                    tokens = [token]
+                    if len(tks) > 2:
+                        to_s = tks[2].strip(' ')
+
+                        if '|' in token:
+                            tokens = token.split('|')
+
+                        for t in tokens:
+                            if self.debug:
+                                print(f'{from_s} > {t} = {to_s}')
+                            machine[f'{from_s} > {t}'] = to_s
+
+        return machine
+
+    def traverse_tokens(self, text: str, tokens: list[Token], state: str = '', indent=0):
+        keywords = [
+            'select', 'from', 'as', 'not', 'in', 'where',
+            'and', 'or', 'group', 'by', 'group by', 'limit',
+            'inner join', 'on', 'left', 'right', 'full', 'outer', 'left outer join',
+            'left join', 'right outer join', 'right join', 'full join', 'full outer join',
+
+            'insert', 'into', 'values',
+
+            'update', 'where', 'set',
+
+            'delete'
+        ]
+
         for token in tokens:
             if self.debug:
                 if token.ttype == T.Whitespace:
@@ -300,404 +504,33 @@ class SqlCompleter(Completer):
                     else:
                         print(f'{token.value}:{typ} ', end='')
                 # print("  " * indent + f"Token: {token.value}, Type: {token.ttype}@{token.ttype.__class__}")
-            node: str = None
+
             if token.is_group:
                 state = self.traverse_tokens(text, token.tokens, state, indent + 1)
             else:
-                if not state:
-                    if token.ttype == T.Keyword.DML and token.value.lower() == 'select':
-                        state = 'select'
-                    if token.ttype == T.Keyword.DML and token.value.lower() == 'insert':
-                        state = 'insert'
-                    if token.ttype == T.Keyword.DML and token.value.lower() == 'update':
-                        state = 'update'
-                    if token.ttype == T.Keyword.DML and token.value.lower() == 'delete':
-                        state = 'delete'
-                    elif token.ttype == T.Name:
-                        state = 'dml_incomplete'
-
-                elif state == 'select':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_'
-                elif state == 'select_':
-                    if token.ttype == T.Name or token.ttype == T.Wildcard:
-                        state = 'select_a'
-                elif state == 'select_a':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_a_'
-                    elif token.ttype == T.Punctuation and token.value == ',':
-                        state = 'select_a,'
-                elif state == 'select_a,':
-                    if token.ttype == T.Name or token.ttype == T.Wildcard:
-                        state = 'select_a'
-                elif state == 'select_a_':
-                    if token.ttype == T.Keyword and token.value.lower() == 'from':
-                        state = 'select_from'
-                elif state == 'select_from':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_from_'
-                elif state == 'select_from_':
-                    if token.ttype == T.Name:
-                        state = 'select_from_x'
-                elif state == 'select_from_x':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_from_x_'
-                    elif token.ttype == T.Punctuation and token.value == ',':
-                        state = 'select_from_x,'
-                elif state == 'select_from_x,':
-                    if token.ttype == T.Name:
-                        state = 'select_from_x'
-                elif state in ['select_from_x_', 'select_from_x_as_x_']:
-                    if token.ttype == T.Punctuation and token.value == ',':
-                        state = 'select_from_x,'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'as':
-                        state = 'select_from_x_as'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'where':
-                        state = 'select_where'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'limit':
-                        state = 'select_where_sc_limit'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'group':
-                        state = 'select_from_x_group'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'group by':
-                        state = 'select_from_x_group_by'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'inner':
-                        state = 'select_from_x_inner'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'inner join':
-                        state = 'select_join'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'left':
-                        state = 'select_from_x_left'
-                    elif token.ttype == T.Keyword and token.value.lower() in ['left join', 'left outer join']:
-                        state = 'select_join'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'right':
-                        state = 'select_from_x_right'
-                    elif token.ttype == T.Keyword and token.value.lower() in ['right join', 'right outer join']:
-                        state = 'select_join'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'full':
-                        state = 'select_from_x_full'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'full outer join':
-                        state = 'select_join'
-                elif state == 'select_from_x_as':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_from_x_as_'
-                elif state == 'select_from_x_as_':
-                    if token.ttype == T.Name:
-                        state = 'select_from_x_as_x'
-                elif state == 'select_from_x_as_x':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_from_x_as_x_'
-                    elif token.ttype == T.Punctuation and token.value == ',':
-                        state = 'select_from_x_as_x,'
-                elif state == 'select_from_x_as_x,':
-                    if token.ttype == T.Name:
-                        state = 'select_from_x'
-                elif state == 'select_where':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_where_'
-                elif state == 'select_where_':
-                    if token.ttype == T.Name:
-                        state = 'select_where_a'
-                elif state == 'select_where_a':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_where_a_'
-                    elif token.ttype == T.Operator.Comparison:
-                        state = 'select_where_a_op'
-                elif state == 'select_where_a_':
-                    if token.ttype == T.Operator.Comparison:
-                        state = 'select_where_a_op'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'not':
-                        state = 'select_where_a_not'
-                elif state == 'select_where_a_not':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_where_a_not_'
-                elif state == 'select_where_a_not_':
-                    if token.ttype == T.Operator.Comparison:
-                        state = 'select_where_a_not_op'
-                elif state == 'select_where_a_not_op':
-                    if token.ttype in [T.Literal.String.Single, T.Name]:
-                        state = 'select_where_sc'
-                elif state == 'select_where_a_op':
-                    if token.ttype in [T.Literal.String.Single, T.Name]:
-                        state = 'select_where_sc'
-                elif state == 'select_where_sc':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_where_sc_'
-                elif state == 'select_where_sc_':
-                    if token.ttype == T.Keyword and token.value.lower() in ['and', 'or']:
-                        state = 'select_where'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'group':
-                        state = 'select_from_x_group'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'group by':
-                        state = 'select_from_x_group_by'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'limit':
-                        state = 'select_where_sc_limit'
-                elif state == 'select_from_x_group':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_from_x_group_'
-                elif state == 'select_from_x_group_':
-                    if token.ttype == T.Keyword and token.value.lower() == 'by':
-                        state = 'select_from_x_group_by'
-                elif state == 'select_from_x_group_by':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_from_x_group_by_'
-                elif state == 'select_from_x_group_by_':
-                    if token.ttype == T.Name:
-                        state = 'select_from_x_group_by_a'
-                elif state == 'select_from_x_group_by_a':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_from_x_group_by_a_'
-                    elif token.ttype == T.Punctuation and token.value == ',':
-                        state = 'select_from_x_group_by_a,'
-                elif state == 'select_from_x_group_by_a,':
-                    if token.ttype == T.Name:
-                        state = 'select_from_x_group_by_a'
-                elif state == 'select_from_x_group_by_a_':
-                    if token.ttype == T.Keyword and token.value.lower() == 'limit':
-                        state = 'select_where_sc_limit'
-                elif state == 'select_where_sc_limit':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_where_sc_limit_'
-                elif state == 'select_from_x_inner':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_from_x_inner_'
-                elif state == 'select_from_x_inner_':
-                    if token.ttype == T.Keyword and token.value.lower() == 'join':
-                        state = 'select_join'
-                elif state == 'select_join':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_join_'
-                elif state == 'select_join_':
-                    if token.ttype == T.Name:
-                        state = 'select_x_join_y'
-
-                elif state == 'select_from_x_left':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_from_x_left_'
-                elif state == 'select_from_x_left_':
-                    if token.ttype == T.Keyword and token.value.lower() == 'join':
-                        state = 'select_join'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'outer':
-                        state = 'select_from_x_left_outer'
-                elif state == 'select_from_x_left_outer':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_from_x_left_outer_'
-                elif state == 'select_from_x_left_outer_':
-                    if token.ttype == T.Keyword and token.value.lower() == 'join':
-                        state = 'select_join_'
-
-                elif state == 'select_from_x_right':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_from_x_right_'
-                elif state == 'select_from_x_right_':
-                    if token.ttype == T.Keyword and token.value.lower() == 'join':
-                        state = 'select_join'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'outer':
-                        state = 'select_from_x_right_outer'
-                elif state == 'select_from_x_right_outer':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_from_x_right_outer_'
-                elif state == 'select_from_x_right_outer_':
-                    if token.ttype == T.Keyword and token.value.lower() == 'join':
-                        state = 'select_join_'
-
-                elif state == 'select_from_x_full':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_from_x_full_'
-                elif state == 'select_from_x_full_':
-                    if token.ttype == T.Keyword and token.value.lower() == 'outer':
-                        state = 'select_from_x_full_outer'
-                elif state == 'select_from_x_full_outer':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_from_x_full_outer_'
-                elif state == 'select_from_x_full_outer_':
-                    if token.ttype == T.Keyword and token.value.lower() == 'join':
-                        state = 'select_join_'
-
-                elif state == 'select_x_join_y':
-                    if token.ttype == T.Punctuation and token.value == ',':
-                        state = 'select_x_join_y,'
-                    elif token.ttype == T.Text.Whitespace:
-                        state = 'select_x_join_y_'
-                elif state == 'select_x_join_y,':
-                    if token.ttype == T.Name:
-                        state = 'select_x_join_y'
-                elif state == 'select_x_join_y_':
-                    if token.ttype == T.Keyword and token.value.lower() == 'on':
-                        state = 'select_x_join_y_on'
-                elif state == 'select_x_join_y_on':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_x_join_y_on_'
-                elif state == 'select_x_join_y_on_':
-                    if token.ttype == T.Name:
-                        state = 'select_x_join_y_on_a'
-                elif state == 'select_x_join_y_on_a':
-                    if token.ttype == T.Operator.Comparison:
-                        state = 'select_x_join_y_on_a_op'
-                elif state == 'select_x_join_y_on_a_op':
-                    if token.ttype in [T.Literal.String.Single, T.Name]:
-                        state = 'select_x_join_y_on_a_opb'
-                elif state == 'select_x_join_y_on_a_opb':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'select_x_join_y_on_a_opb_'
-                    elif token.ttype == T.Punctuation and token.value == ',':
-                        state = 'select_x_join_y_on_'
-                elif state == 'select_x_join_y_on_a_opb_':
-                    if token.ttype == T.Keyword and token.value.lower() in ['and', 'or']:
-                        state = 'select_join'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'where':
-                        state = 'select_where'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'group':
-                        state = 'select_from_x_group'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'group by':
-                        state = 'select_from_x_group_by'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'limit':
-                        state = 'select_where_sc_limit'
-
-                elif state == 'insert':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'insert_'
-                elif state == 'insert_':
-                    if token.ttype == T.Keyword and token.value.lower() == 'into':
-                        state = 'insert_into'
-                elif state == 'insert_into':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'insert_into_'
-                elif state == 'insert_into_':
-                    if token.ttype == T.Name:
-                        state = 'insert_into_x'
-                elif state == 'insert_into_x':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'insert_into_x_'
-                    elif token.ttype == T.Punctuation and token.value == '(':
-                        state = 'insert_into_x_lp_'
-                elif state == 'insert_into_x_':
-                    if token.ttype == T.Punctuation and token.value == '(':
-                        state = 'insert_into_x_lp_'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'values':
-                        state = 'insert_values'
-                elif state == 'insert_into_x_lp_':
-                    if token.ttype == T.Name:
-                        state = 'insert_into_x_lp_a'
-                elif state == 'insert_into_x_lp_a':
-                    if token.ttype == T.Punctuation and token.value == ',':
-                        state = 'insert_into_x_lp_a,'
-                    elif token.ttype == T.Punctuation and token.value == ')':
-                        state = 'insert_into_x_lp_a_rp'
-                elif state == 'insert_into_x_lp_a,':
-                    if token.ttype == T.Name:
-                        state = 'insert_into_x_lp_a'
-                elif state == 'insert_into_x_lp_a_rp':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'insert_into_x_lp_a_rp_'
-                elif state == 'insert_into_x_lp_a_rp_':
-                    if token.ttype == T.Keyword and token.value.lower() == 'values':
-                        state = 'insert_values'
-                    elif token.ttype == T.Keyword.DML and token.value.lower() == 'select':
-                        state = 'select_'
-                elif state == 'insert_values':
-                    if token.ttype == T.Punctuation and token.value == '(':
-                        state = 'insert_values_lp_'
-                elif state == 'insert_values_lp_':
-                    if token.ttype in [T.Literal.String.Single, T.Name]:
-                        state = 'insert_values_lp_v'
-                elif state == 'insert_values_lp_v':
-                    if token.ttype == T.Punctuation and token.value == ',':
-                        state = 'insert_values_lp_v,'
-                elif state == 'insert_values_lp_v,':
-                    if token.ttype in [T.Literal.String.Single, T.Name]:
-                        state = 'insert_values_lp_v'
-
-                elif state == 'update':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'update_'
-                elif state == 'update_':
-                    if token.ttype == T.Name:
-                        state = 'update_x'
-                elif state == 'update_x':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'update_x_'
-                elif state == 'update_x_':
-                    if token.ttype == T.Keyword and token.value.lower() == 'set':
-                        state = 'update_x_set'
-                elif state == 'update_x_set':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'update_x_set_'
-                elif state == 'update_x_set_':
-                    if token.ttype == T.Name:
-                        state = 'update_x_set_a'
-                elif state == 'update_x_set_a':
-                    if token.ttype == T.Operator.Comparison:
-                        state = 'update_x_set_a_op'
-                elif state == 'update_x_set_a_op':
-                    if token.ttype in [T.Literal.String.Single, T.Name]:
-                        state = 'update_x_set_sc'
-                elif state == 'update_x_set_sc':
-                    if token.ttype == T.Punctuation and token.value == ',':
-                        state = 'update_x_set_sc,'
-                    elif token.ttype == T.Text.Whitespace:
-                        state = 'update_x_set_sc_'
-                elif state == 'update_x_set_sc,':
-                    if token.ttype == T.Name:
-                        state = 'update_x_set_a'
-                elif state == 'update_x_set_sc_':
-                    if token.ttype == T.Punctuation and token.value == ',':
-                        state = 'update_x_set_sc,'
-                    elif token.ttype == T.Keyword and token.value.lower() == 'where':
-                        state = 'update_where'
-                elif state == 'update_where':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'update_where_'
-                elif state == 'update_where_':
-                    if token.ttype == T.Name:
-                        state = 'update_where_a'
-                elif state == 'update_where_a':
-                    if token.ttype == T.Operator.Comparison:
-                        state = 'update_where_a_op'
-                elif state == 'update_where_a_op':
-                    if token.ttype in [T.Literal.String.Single, T.Name]:
-                        state = 'update_where_sc'
-                elif state == 'update_where_sc':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'update_where_sc_'
-                elif state == 'update_where_sc_':
-                    if token.ttype == T.Keyword and token.value.lower() in ['and', 'or']:
-                        state = 'update_where'
-
-                elif state == 'delete':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'delete_'
-                elif state == 'delete_':
-                    if token.ttype == T.Keyword and token.value.lower() == 'from':
-                        state = 'delete_from'
-                elif state == 'delete_from':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'delete_from_'
-                elif state == 'delete_from_':
-                    if token.ttype == T.Name:
-                        state = 'delete_from_x'
-                elif state == 'delete_from_x':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'delete_from_x_'
-                elif state == 'delete_from_x_':
-                    if token.ttype == T.Keyword and token.value.lower() == 'where':
-                        state = 'delete_where'
-                elif state == 'delete_where':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'delete_where_'
-                elif state == 'delete_where_':
-                    if token.ttype == T.Name:
-                        state = 'delete_where_a'
-                elif state == 'delete_where_a':
-                    if token.ttype == T.Operator.Comparison:
-                        state = 'delete_where_a_op'
-                elif state == 'delete_where_a_op':
-                    if token.ttype in [T.Literal.String.Single, T.Name]:
-                        state = 'delete_where_sc'
-                elif state == 'delete_where_sc':
-                    if token.ttype == T.Text.Whitespace:
-                        state = 'delete_where_sc_'
-                elif state == 'delete_where_sc_':
-                    if token.ttype == T.Keyword and token.value.lower() in ['and', 'or']:
-                        state = 'delete_where'
+                it = ''
+                if (t := token.value.lower()) in keywords:
+                    it = t
+                elif token.ttype == T.Text.Whitespace:
+                    it = '_'
+                elif token.ttype in [T.Name, T.Literal.String.Single]:
+                    it = 'name'
+                elif token.ttype == T.Wildcard:
+                    it = '*'
+                elif token.ttype == T.Punctuation:
+                    if token.value == ',':
+                        it = ','
+                    elif token.value == '(':
+                        it = '('
+                    elif token.value == ')':
+                        it = ')'
+                elif token.ttype == T.Operator.Comparison:
+                    it = 'comparison'
+
+                try:
+                    state = self.machine[f'{state} > {it}']
+                except:
+                    pass
 
         return state
 

adam/sql/term_completer.py

@@ -52,7 +52,7 @@ class TermCompleter(WordCompleter):
                 return word.startswith(word_before_cursor)
 
         for a in words:
-            if word_before_cursor in ['(', ',', '=']:
+            if word_before_cursor in ['(', ',', '=', 'in', "',"]:
                 display = self.display_dict.get(a, a)
                 display_meta = self.meta_dict.get(a, "")
                 yield Completion(

adam/version.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-__version__ = "2.0.58"  #: the working version
+__version__ = "2.0.60"  #: the working version
 __release__ = "1.0.0"  #: the release version

{kaqing-2.0.58.dist-info → kaqing-2.0.60.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaqing
-Version: 2.0.58
+Version: 2.0.60
 Summary: UNKNOWN
 Home-page: UNKNOWN
 License: UNKNOWN

{kaqing-2.0.58.dist-info → kaqing-2.0.60.dist-info}/RECORD

@@ -14,7 +14,7 @@ adam/repl_commands.py,sha256=WA90Rl27Juctzr3U3kfCDk5N-oYMKlfWbZeafUgk7k0,4723
 adam/repl_session.py,sha256=uIogcvWBh7wd8QQ-p_JgLsyJ8YJgINw5vOd6JIsd7Vo,472
 adam/repl_state.py,sha256=nZO5CucSIGz68f4JreadGphRzMXPUzkTn-4XcoJJOug,8643
 adam/utils.py,sha256=2DoWsrcaioFFH0-RjT30qelVRPUJqCGTfz_ucfE7F8g,7406
-adam/version.py,sha256=sRDlhsVJoL9FZXAovHXEN5knQt5JzVhfRzS7ln7cVCw,139
+adam/version.py,sha256=7RCo3Cs2toI4G2hj9yiTT2E6QyGRwyVOhEKHJscEMPM,139
 adam/checks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 adam/checks/check.py,sha256=Qopr3huYcMu2bzQgb99dEUYjFzkjKHRI76S6KA9b9Rk,702
 adam/checks/check_context.py,sha256=FEHkQ32jY1EDopQ2uYWqy9v7aEEX1orLpJWhopwAlh4,402
@@ -164,8 +164,8 @@ adam/k8s_utils/services.py,sha256=EOJJGACVbbRvu5T3rMKqIJqgYic1_MSJ17EA0TJ6UOk,31
 adam/k8s_utils/statefulsets.py,sha256=5g7KxGRHgEewT8rnZneDTaJDylUf-dHH2edWJEoorr8,4667
 adam/k8s_utils/volumes.py,sha256=RIBmlOSWM3V3QVXLCFT0owVOyh4rGG1ETp521a-6ndo,1137
 adam/sql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-adam/sql/sql_completer.py,sha256=eYkW0WYV0mEMUgGcKvxTRbI6vO-q3rJ7dUWjqaOGfHc,35888
-adam/sql/term_completer.py,sha256=VCCMPUzvh_9lwIOwqQmeijM0V2JPADkBbNV4HQIqDCw,2538
+adam/sql/sql_completer.py,sha256=2TPR618K4qXuucMylYkLL8kK65znReLsG1lK_Kn1FVQ,27188
+adam/sql/term_completer.py,sha256=17fuRyW2Uk-CoKySAh0S_UEzRQu9a-NxWII8jQnpAPU,2550
 adam/sso/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 adam/sso/authenticator.py,sha256=BCm16L9zf5aLU47-sTCnudn2zLPwd8M2wwRminJfsqw,615
 adam/sso/authn_ad.py,sha256=fDW8UR3WWykny5Awa5dQjjBUSFzIDz4aMn-lwXoABl8,5857
@@ -176,8 +176,8 @@ adam/sso/idp.py,sha256=fvcwUw_URTgsO6ySaqTIw0zQT2qRO1IPSGhf6rPtybo,5804
 adam/sso/idp_login.py,sha256=QAtCUeDTVWliJy40RK_oac8Vgybr13xH8wzeBoxPaa8,1754
 adam/sso/idp_session.py,sha256=9BUHNRf70u4rVKrVY1HKPOEmOviXvkjam8WJxmXSKIM,1735
 adam/sso/sso_config.py,sha256=5N8WZgIJQBtHUy585XLRWKjpU87_v6QluyNK9E27D5s,2459
-kaqing-2.0.58.dist-info/METADATA,sha256=xsAw0gTa9oAjL1-qk8Wahz9ZNL-iSMis6RLHaUtwl9o,132
-kaqing-2.0.58.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-kaqing-2.0.58.dist-info/entry_points.txt,sha256=SkzhuQJUWsXOzHeZ5TgQ2c3_g53UGK23zzJU_JTZOZI,39
-kaqing-2.0.58.dist-info/top_level.txt,sha256=8_2PZkwBb-xDcnc8a2rAbQeJhXKXskc7zTP7pSPa1fw,5
-kaqing-2.0.58.dist-info/RECORD,,
+kaqing-2.0.60.dist-info/METADATA,sha256=cnP96Te83vGdPiqpG7o2ODMyH-EoxHfWT-2jjb6BS2Q,132
+kaqing-2.0.60.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+kaqing-2.0.60.dist-info/entry_points.txt,sha256=SkzhuQJUWsXOzHeZ5TgQ2c3_g53UGK23zzJU_JTZOZI,39
+kaqing-2.0.60.dist-info/top_level.txt,sha256=8_2PZkwBb-xDcnc8a2rAbQeJhXKXskc7zTP7pSPa1fw,5
+kaqing-2.0.60.dist-info/RECORD,,