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_suggests_tables_views_and_schemas(expression):
suggestions = suggest_type(expression, expression)
assert set(suggestions) == set([
Table(schema=None),
View(schema=None),
Schema(),
])
def test_distinct_and_order_by_suggestions_with_alias_given():
test_args = [
(
'SELECT DISTINCT x. FROM tbl x JOIN tbl1 y',
'SELECT DISTINCT x.'
),
(
'SELECT * FROM tbl x JOIN tbl1 y ORDER BY x.',
'SELECT * FROM tbl x JOIN tbl1 y ORDER BY x.'
)
]
for arg in test_args:
text = arg[0]
text_before = arg[1]
suggestions = suggest_type(text, text_before)
assert set(suggestions) == set([
Column(
table_refs=(TableReference(None, 'tbl', 'x', False),),
local_tables=(),
qualifiable=False
),
Table(schema='x'),
View(schema='x'),
Function(schema='x'),
])
def test_suggest_qualified_aliasable_tables_and_views():
expressions = ['UPDATE sch.']
for expression in expressions:
suggestions = suggest_type(expression, expression)
assert set(suggestions) == set([
Table(schema='sch'),
View(schema='sch'),
])
def test_suggest_qualified_tables_and_views():
expressions = ['INSERT INTO sch.', 'COPY sch.', 'DESCRIBE sch.']
for expression in expressions:
suggestions = suggest_type(expression, expression)
assert set(suggestions) == set([
Table(schema='sch'),
View(schema='sch'),
])
def test_join_alias_dot_suggests_cols2(sql):
suggestion = suggest_type(sql, sql)
assert set(suggestion) == set([
Column(table_refs=((None, 'def', 'd', False), )),
Table(schema='d'),
View(schema='d'),
Function(schema='d'),
])
def test_dot_suggests_cols_of_an_alias_where(sql):
suggestions = suggest_type(sql, sql)
assert set(suggestions) == set([
Table(schema='t1'),
View(schema='t1'),
Column(table_refs=((None, 'tabl1', 't1', False), )),
Function(schema='t1'),
])
def test_dot_suggests_cols_of_a_table_or_schema_qualified_table():
suggestions = suggest_type('SELECT tabl. FROM tabl', 'SELECT tabl.')
assert set(suggestions) == set([
Column(table_refs=((None, 'tabl', None, False), )),
Table(schema='tabl'),
View(schema='tabl'),
Function(schema='tabl'),
])
def get_from_clause_item_matches(self, suggestion, word_before_cursor):
alias = self.generate_aliases
s = suggestion
t_sug = Table(s.schema, s.table_refs, s.local_tables)
v_sug = View(s.schema, s.table_refs)
f_sug = Function(s.schema, s.table_refs, usage='from')
return (self.get_table_matches(t_sug, word_before_cursor, alias) +
self.get_view_matches(v_sug, word_before_cursor, alias) +
self.get_function_matches(f_sug, word_before_cursor, alias))
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_outer_table_reference_in_exists_subquery_suggests_columns():
q = 'SELECT * FROM foo f WHERE EXISTS (SELECT 1 FROM bar WHERE f.'
suggestions = suggest_type(q, q)
assert set(suggestions) == set([
Column(table_refs=((None, 'foo', 'f', False), )),
Table(schema='f'),
View(schema='f'),
Function(schema='f'),
])
def test_sub_select_dot_col_name_completion():
suggestions = suggest_type('SELECT * FROM (SELECT t. FROM tabl t', \
'SELECT * FROM (SELECT t.')
assert set(suggestions) == set([
Column(table_refs=((None, 'tabl', 't', False), )),
Table(schema='t'),
View(schema='t'),
Function(schema='t'),
])
def test_dot_col_comma_suggests_cols_or_schema_qualified_table():
suggestions = suggest_type('SELECT t1.a, t2. FROM tabl1 t1, tabl2 t2', \
'SELECT t1.a, t2.')
assert set(suggestions) == set([
Column(table_refs=((None, 'tabl2', 't2', False), )),
Table(schema='t2'),
View(schema='t2'),
Function(schema='t2'),
])
def test_cast_operator_suggests_schema_qualified_types():
texts = [
'SELECT foo::bar.',
'SELECT foo::bar.baz',
'SELECT (x + y)::bar.',
]
for text in texts:
assert set(suggest_type(text, text)) == set(
[Datatype(schema='bar'),
Table(schema='bar')])
def test_join_alias_dot_suggests_cols1(sql):
suggestions = suggest_type(sql, sql)
tables = ((None, 'abc', 'a', False), (None, 'def', 'd', False))
assert set(suggestions) == set([
Column(table_refs=((None, 'abc', 'a', False), )),
Table(schema='a'),
View(schema='a'),
Function(schema='a'),
JoinCondition(table_refs=tables, parent=(None, 'abc', 'a', False))
])
def test_distinct_and_order_by_suggestions_with_alias_given(text, text_before):
suggestions = suggest_type(text, text_before)
assert set(suggestions) == set([
Column(table_refs=(TableReference(None, 'tbl', 'x', False), ),
local_tables=(),
qualifiable=False),
Table(schema='x'),
View(schema='x'),
Function(schema='x'),
])
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_join_alias_dot_suggests_cols2():
sqls = [
'SELECT * FROM abc a JOIN def d ON a.id = d.',
'SELECT * FROM abc a JOIN def d ON a.id = d.id AND a.id2 = d.',
]
for sql in sqls:
suggestion = suggest_type(sql, sql)
assert set(suggestion) == set([
Column(table_refs=((None, 'def', 'd', False), )),
Table(schema='d'),
View(schema='d'),
Function(schema='d'),
])
def test_dot_suggests_cols_of_an_alias(self):
sqls = [
'SELECT t1. FROM tabl1 t1',
'SELECT t1. FROM tabl1 t1, tabl2 t2',
'SELECT t1. FROM "tabl1" t1',
'SELECT t1. FROM "tabl1" t1, "tabl2" t2',
]
for sql in sqls:
suggestions = suggest_type(sql, 'SELECT t1.')
assert set(suggestions) == set([
Table(schema='t1'),
View(schema='t1'),
Column(table_refs=((None, 'tabl1', 't1', False),)),
Function(schema='t1'),
])
def test_dot_suggests_cols_of_an_alias_where():
sqls = [
'SELECT * FROM tabl1 t1 WHERE t1.',
'SELECT * FROM tabl1 t1, tabl2 t2 WHERE t1.',
'SELECT * FROM "tabl1" t1 WHERE t1.',
'SELECT * FROM "tabl1" t1, tabl2 t2 WHERE t1.',
]
for sql in sqls:
suggestions = suggest_type(sql, sql)
assert set(suggestions) == set([
Table(schema='t1'),
View(schema='t1'),
Column(table_refs=((None, 'tabl1', 't1', False), )),
Function(schema='t1'),
])
def test_join_alias_dot_suggests_cols1():
sqls = [
'SELECT * FROM abc a JOIN def d ON a.',
'SELECT * FROM abc a JOIN def d ON a.id = d.id AND a.',
]
for sql in sqls:
suggestions = suggest_type(sql, sql)
tables = ((None, 'abc', 'a', False), (None, 'def', 'd', False))
assert set(suggestions) == set([
Column(table_refs=((None, 'abc', 'a', False),)),
Table(schema='a'),
View(schema='a'),
Function(schema='a'),
JoinCondition(table_refs=tables, parent=(None, 'abc', 'a', False))
])
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_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_truncate_suggests_tables_and_schemas():
suggestions = suggest_type('TRUNCATE ', 'TRUNCATE ')
assert set(suggestions) == set([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_cast_operator_suggests_types(text):
assert set(suggest_type(text, text)) == set(
[Datatype(schema=None),
Table(schema=None),
Schema()])
def test_cast_operator_suggests_schema_qualified_types(text):
assert set(suggest_type(text, text)) == set(
[Datatype(schema='bar'), Table(schema='bar')])
def test_drop_schema_qualified_table_suggests_only_tables():
text = 'DROP TABLE schema_name.table_name'
suggestions = suggest_type(text, text)
assert suggestions == (Table(schema='schema_name'), )
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_qualified_tables():
suggestions = suggest_type('TRUNCATE sch.', 'TRUNCATE sch.')
assert set(suggestions) == set([Table(schema='sch')])