def test_suggest_tables_views_schemas_and_functions():
expressions = ['SELECT * FROM ']
for expression in expressions:
suggestions = suggest_type(expression, expression)
assert set(suggestions) == set(
[FromClauseItem(schema=None),
Schema()])
def test_table_comma_suggests_tables_and_schemas():
suggestions = suggest_type('SELECT a, b FROM tbl1, ', \
'SELECT a, b FROM tbl1, ')
assert set(suggestions) == set([
FromClauseItem(schema=None),
Schema(),
])
def test_sub_select_table_name_completion():
expression = 'SELECT * FROM (SELECT * FROM '
suggestion = suggest_type(expression, expression)
assert set(suggestion) == set([
FromClauseItem(schema=None),
Schema(),
])
def test_sub_select_table_name_completion_with_outer_table(expression):
suggestion = suggest_type(expression, expression)
tbls = tuple([(None, 'foo', None, False)])
assert set(suggestion) == set([
FromClauseItem(schema=None, table_refs=tbls),
Schema(),
])
def test_suggests_tables_views_and_schemas(expression):
suggestions = suggest_type(expression, expression)
assert set(suggestions) == set([
Table(schema=None),
View(schema=None),
Schema(),
])
def test_into_suggests_tables_and_schemas():
suggestion = suggest_type('INSERT INTO ', 'INSERT INTO ')
assert set(suggestion) == set([
Table(schema=None),
View(schema=None),
Schema(),
])
def test_suggest_after_join_with_one_table(expression):
suggestions = suggest_type(expression, expression)
tables = ((None, 'foo', None, False), )
assert set(suggestions) == set([
FromClauseItem(schema=None, table_refs=tables),
Join(((None, 'foo', None, False), ), None),
Schema(),
])
def test_suggest_after_join_with_two_tables(expression):
suggestions = suggest_type(expression, expression)
tables = tuple([(None, 'foo', None, False), (None, 'bar', None, False)])
assert set(suggestions) == set([
FromClauseItem(schema=None, table_refs=tables),
Join(tables, None),
Schema(),
])
def test_join_suggests_tables_and_schemas(tbl_alias, join_type):
text = 'SELECT * FROM abc {0} {1} JOIN '.format(tbl_alias, join_type)
suggestion = suggest_type(text, text)
tbls = tuple([(None, 'abc', tbl_alias or None, False)])
assert set(suggestion) == set([
FromClauseItem(schema=None, table_refs=tbls),
Schema(),
Join(tbls, None),
])
def test_suggests_tables_views_and_schemas():
expressions = ['INSERT INTO ', 'COPY ', 'UPDATE ', 'DESCRIBE ']
for expression in expressions:
suggestions = suggest_type(expression, expression)
assert set(suggestions) == set([
Table(schema=None),
View(schema=None),
Schema(),
])
def test_left_join_with_comma():
text = 'select * from foo f left join bar b,'
suggestions = suggest_type(text, text)
# tbls should also include (None, 'bar', 'b', False)
# but there's a bug with commas
tbls = tuple([(None, 'foo', 'f', False)])
assert set(suggestions) == set([
FromClauseItem(schema=None, table_refs=tbls),
Schema(),
])
def test_2_statements_1st_current():
suggestions = suggest_type('select * from ; select * from b',
'select * from ')
assert set(suggestions) == set([
FromClauseItem(schema=None),
Schema(),
])
suggestions = suggest_type('select from a; select * from b', 'select ')
assert set(suggestions) == cols_etc('a', last_keyword='SELECT')
def test_suggest_after_join_with_one_table():
expressions = ['SELECT * FROM foo JOIN ', 'SELECT * FROM foo JOIN bar']
for expression in expressions:
suggestions = suggest_type(expression, expression)
tables = ((None, 'foo', None, False), )
assert set(suggestions) == set([
FromClauseItem(schema=None, table_refs=tables),
Join(((None, 'foo', None, False), ), None),
Schema(),
])
def test_cast_operator_suggests_types():
texts = [
'SELECT x::',
'SELECT x::y',
'SELECT (x + y)::',
]
for text in texts:
assert set(suggest_type(text, text)) == set(
[Datatype(schema=None),
Table(schema=None),
Schema()])
def test_3_statements_2nd_current(self):
suggestions = suggest_type('select * from a; select * from ; select * from c', \
'select * from a; select * from ')
assert set(suggestions) == set([
FromClauseItem(schema=None),
Schema(),
])
suggestions = suggest_type('select * from a; select from b; select * from c', \
'select * from a; select ')
assert set(suggestions) == self.cols_etc('b', last_keyword='SELECT')
def test_sub_select_table_name_completion_with_outer_table():
expressions = [
'SELECT * FROM foo WHERE EXISTS (SELECT * FROM ',
'SELECT * FROM foo WHERE bar AND NOT EXISTS (SELECT * FROM ',
]
for expression in expressions:
suggestion = suggest_type(expression, expression)
tbls = tuple([(None, 'foo', None, False)])
assert set(suggestion) == set([
FromClauseItem(schema=None, table_refs=tbls),
Schema(),
])
def test_join_suggests_tables_and_schemas():
join_types = ('', 'INNER', 'LEFT', 'RIGHT OUTER',)
tbl_aliases = ('', 'foo',)
for join_type in join_types:
for tbl_alias in tbl_aliases:
text = 'SELECT * FROM abc {0} {1} JOIN '.format(tbl_alias, join_type)
suggestion = suggest_type(text, text)
tbls = tuple([(None, 'abc', tbl_alias or None, False)])
assert set(suggestion) == set([
FromClauseItem(schema=None, table_refs=tbls),
Schema(),
Join(tbls, None),
])
def test_suggest_after_join_with_two_tables():
expressions = [
'SELECT * FROM foo JOIN bar on bar.barid = foo.barid JOIN ',
'SELECT * FROM foo JOIN bar USING (barid) JOIN '
]
for expression in expressions:
suggestions = suggest_type(expression, expression)
tables = tuple([(None, 'foo', None, False), (None, 'bar', None, False)])
assert set(suggestions) == set([
FromClauseItem(schema=None, table_refs=tables),
Join(tables, None),
Schema(),
])
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_identifier_suggests_types_in_parentheses():
texts = [
'CREATE TABLE foo (bar ',
'CREATE TABLE foo (bar DOU',
'CREATE TABLE foo (bar INT, baz ',
'CREATE TABLE foo (bar INT, baz TEXT, qux ',
'CREATE FUNCTION foo (bar ',
'CREATE FUNCTION foo (bar INT, baz ',
'SELECT * FROM foo() AS bar (baz ',
'SELECT * FROM foo() AS bar (baz INT, qux ',
# make sure this doesnt trigger special completion
'CREATE TABLE foo (dt d',
]
for text in texts:
assert set(suggest_type(text, text)) == set(
[Datatype(schema=None),
Table(schema=None),
Schema()])
def test_alter_column_type_suggests_types():
q = 'ALTER TABLE foo ALTER COLUMN bar TYPE '
assert set(suggest_type(q, q)) == set(
[Datatype(schema=None),
Table(schema=None),
Schema()])
def test_suggest_tables_views_schemas_and_functions(expression):
suggestions = suggest_type(expression, expression)
assert set(suggestions) == set([FromClauseItem(schema=None), Schema()])
def test_drop_schema_suggests_schemas():
sql = 'DROP SCHEMA '
assert suggest_type(sql, sql) == (Schema(), )
def test_cast_operator_suggests_types(text):
assert set(suggest_type(text, text)) == set(
[Datatype(schema=None),
Table(schema=None),
Schema()])
def test_identifier_suggests_types_in_parentheses(text):
assert set(suggest_type(text, text)) == set(
[Datatype(schema=None),
Table(schema=None),
Schema()])
def test_truncate_suggests_tables_and_schemas():
suggestions = suggest_type('TRUNCATE ', 'TRUNCATE ')
assert set(suggestions) == set([Table(schema=None), Schema()])