def test_select_suggests_cols_and_funcs(): suggestions = suggest_type('SELECT ', 'SELECT ') assert set(suggestions) == set([ Column(table_refs=(), qualifiable=True), Function(schema=None), Keyword('SELECT'), ])
def test_keyword_after_alter(): sqls = [ 'ALTER ', 'ALTER TABLE foo ALTER ', ] for sql in sqls: assert Keyword('ALTER') in set(suggest_type(sql, sql))
def test_statements_in_function_body(text): suggestions = suggest_type(text, text[:text.find(' ') + 1]) assert set(suggestions) == set([ Column(table_refs=((None, 'foo', None, False), ), qualifiable=True), Function(schema=None), Keyword('SELECT'), ])
def test_col_comma_suggests_cols(): suggestions = suggest_type('SELECT a, b, FROM tbl', 'SELECT a, b,') assert set(suggestions) == set([ Column(table_refs=((None, 'tbl', None, False), ), qualifiable=True), Function(schema=None), Keyword('SELECT'), ])
def test_distinct_suggests_cols(text): suggestions = suggest_type(text, text) assert set(suggestions) == set([ Column(table_refs=(), local_tables=(), qualifiable=True), Function(schema=None), Keyword('DISTINCT') ])
def test_distinct_and_order_by_suggestions_with_aliases(): test_args = [( 'SELECT DISTINCT FROM tbl x JOIN tbl1 y', 'SELECT DISTINCT', 'SELECT', ), ( 'SELECT * FROM tbl x JOIN tbl1 y ORDER BY ', 'SELECT * FROM tbl x JOIN tbl1 y ORDER BY ', 'ORDER BY', )] for arg in test_args: text = arg[0] text_before = arg[1] last_keyword = arg[2] suggestions = suggest_type(text, text_before) assert set(suggestions) == set([ Column(table_refs=( TableReference(None, 'tbl', 'x', False), TableReference(None, 'tbl1', 'y', False), ), local_tables=(), qualifiable=True), Function(schema=None), Keyword(last_keyword) ])
def test_sub_select_col_name_completion(): suggestions = suggest_type('SELECT * FROM (SELECT FROM abc', 'SELECT * FROM (SELECT ') assert set(suggestions) == set([ Column(table_refs=((None, 'abc', None, False), ), qualifiable=True), Function(schema=None), Keyword('SELECT'), ])
def test_sub_select_partial_text_suggests_keyword(): expressions = [ 'SELECT * FROM (S', 'SELECT * FROM foo WHERE EXISTS (S', 'SELECT * FROM foo WHERE bar AND NOT EXISTS (S', ] for expression in expressions: suggestion = suggest_type(expression, expression) assert suggestion == (Keyword(), )
def test_alias_suggests_keywords(): texts = [ 'SELECT foo ', 'SELECT foo FROM bar ', 'SELECT foo AS bar ', 'SELECT foo bar ', 'SELECT * FROM foo AS bar ', 'SELECT * FROM foo bar ', 'SELECT foo FROM (SELECT bar ' ] for text in texts: suggestions = suggest_type(text, text) assert suggestions == (Keyword(), )
def test_named_query_completion(): test_args = [('\\ns abc SELECT ', 'SELECT ', [ Column(table_refs=(), qualifiable=True), Function(schema=None), Keyword('SELECT') ]), ('\\ns abc SELECT foo ', 'SELECT foo ', (Keyword(), )), ('\\ns abc SELECT t1. FROM tabl1 t1', 'SELECT t1.', [ Table(schema='t1'), View(schema='t1'), Column(table_refs=((None, 'tabl1', 't1', False), )), Function(schema='t1') ])] for arg in test_args: text = arg[0] before = arg[1] expected = arg[2] suggestions = suggest_type(text, before) assert set(expected) == set(suggestions)
def test_distinct_suggests_cols(): texts = ['SELECT DISTINCT ', 'INSERT INTO foo SELECT DISTINCT '] for text in texts: suggestions = suggest_type(text, text) assert set(suggestions) == set([ Column(table_refs=(), local_tables=(), qualifiable=True), Function(schema=None), Keyword('DISTINCT') ])
def cols_etc(self, table, schema=None, alias=None, is_function=False, parent=None, \ last_keyword=None): """Returns the expected select-clause suggestions for a single-table select.""" return set([ Column(table_refs=(TableReference(schema, table, alias, is_function),), \ qualifiable=True), Function(schema=parent), Keyword(last_keyword) ])
def test_statements_in_function_body(): texts = [ \ ''' CREATE OR REPLACE FUNCTION func() RETURNS setof int AS $$ SELECT FROM foo; SELECT 2 FROM bar; $$ language sql; ''', \ '''create function func2(int, varchar) RETURNS text language sql AS $func$ SELECT 2 FROM bar; SELECT FROM foo; $func$ ''', ''' CREATE OR REPLACE FUNCTION func() RETURNS setof int AS $func$ SELECT 3 FROM foo; SELECT 2 FROM bar; $$ language sql; create function func2(int, varchar) RETURNS text language sql AS $func$ SELECT 2 FROM bar; SELECT FROM foo; $func$ ''', ''' SELECT * FROM baz; CREATE OR REPLACE FUNCTION func() RETURNS setof int AS $func$ SELECT FROM foo; SELECT 2 FROM bar; $$ language sql; create function func2(int, varchar) RETURNS text language sql AS $func$ SELECT 3 FROM bar; SELECT FROM foo; $func$ SELECT * FROM qux; ''' \ ] for text in texts: suggestions = suggest_type(text, text[:text.find(' ') + 1]) assert set(suggestions) == set([ Column(table_refs=((None, 'foo', None, False), ), qualifiable=True), Function(schema=None), Keyword('SELECT'), ])
def test_distinct_and_order_by_suggestions_with_aliases( text, text_before, last_keyword): suggestions = suggest_type(text, text_before) assert set(suggestions) == set([ Column(table_refs=( TableReference(None, 'tbl', 'x', False), TableReference(None, 'tbl1', 'y', False), ), local_tables=(), qualifiable=True), Function(schema=None), Keyword(last_keyword) ])
def test_2_statements_2nd_current(): suggestions = suggest_type('select * from a; select * from ', \ 'select * from a; select * from ') assert set(suggestions) == set([ FromClauseItem(schema=None), Schema(), ]) suggestions = suggest_type('select * from a; select from b', \ 'select * from a; select ') assert set(suggestions) == set([ Column(table_refs=((None, 'b', None, False), ), qualifiable=True), Function(schema=None), Keyword('SELECT') ]) # Should work even if first statement is invalid suggestions = suggest_type('select * from; select * from ', \ 'select * from; select * from ') assert set(suggestions) == set([ FromClauseItem(schema=None), Schema(), ])
def test_statements_with_cursor_before_function_body(text): suggestions = suggest_type(text, '') assert set(suggestions) == set([ Keyword(), ])
def test_invalid_sql(): # issue 317 text = 'selt *' suggestions = suggest_type(text, text) assert suggestions == (Keyword(), )
def test_sub_select_partial_text_suggests_keyword(expression): suggestion = suggest_type(expression, expression) assert suggestion == (Keyword(), )
def test_specials_included_for_initial_completion(): initial_texts = ('', ' ', '\t \t', '\n') for initial_text in initial_texts: suggestions = suggest_type(initial_text, initial_text) assert set(suggestions) == set([Keyword(), Special()])
def test_statements_with_cursor_before_function_body(self): texts = self.functions for text in texts: suggestions = suggest_type(text, '') assert set(suggestions) == set([Keyword(), Special()])
def test_statements_with_cursor_after_function_body(self): texts = self.functions for text in texts: suggestions = suggest_type(text, text[:text.find('; ') + 1]) assert set(suggestions) == set([Keyword(), Special()])
def test_specials_included_for_initial_completion(initial_text): suggestions = suggest_type(initial_text, initial_text) assert set(suggestions) == \ set([Keyword(), Special()])
def test_alias_suggests_keywords(text): suggestions = suggest_type(text, text) assert suggestions == (Keyword(), )
@pytest.mark.parametrize('text', [ 'SELECT * FROM foo where created > now() - ', 'select * from foo where bar ', ]) def test_suggest_where_keyword(text): # https://github.com/dbcli/mycli/issues/135 suggestions = suggest_type(text, text) assert set(suggestions) == cols_etc('foo', last_keyword='WHERE') @pytest.mark.parametrize( 'text, before, expected', [('\\ns abc SELECT ', 'SELECT ', [ Column(table_refs=(), qualifiable=True), Function(schema=None), Keyword('SELECT') ]), ('\\ns abc SELECT foo ', 'SELECT foo ', (Keyword(), )), ('\\ns abc SELECT t1. FROM tabl1 t1', 'SELECT t1.', [ Table(schema='t1'), View(schema='t1'), Column(table_refs=((None, 'tabl1', 't1', False), )), Function(schema='t1') ])]) def test_named_query_completion(text, before, expected): suggestions = suggest_type(text, before) assert set(expected) == set(suggestions) def test_select_suggests_fields_from_function(): suggestions = suggest_type('SELECT FROM func()', 'SELECT ') assert set(suggestions) == cols_etc('func',
def test_statements_with_cursor_after_function_body(text): suggestions = suggest_type(text, text[:text.find('; ') + 1]) assert set(suggestions) == set([ Keyword(), ])
def test_keyword_after_alter(sql): assert Keyword('ALTER') in set(suggest_type(sql, sql))