def test_2_statements_2nd_current():
suggestions = suggest_type('select * from a; select * from ',
'select * from a; select * from ')
assert set(suggestions) == set([
Table(schema=None),
View(schema=None),
Function(schema=None, filter='is_set_returning'),
Schema(),
])
suggestions = suggest_type('select * from a; select from b',
'select * from a; select ')
assert set(suggestions) == set([
Column(tables=((None, 'b', None, False), )),
Function(schema=None),
Keyword()
])
# Should work even if first statement is invalid
suggestions = suggest_type('select * from; select * from ',
'select * from; select * from ')
assert set(suggestions) == set([
Table(schema=None),
View(schema=None),
Function(schema=None, filter='is_set_returning'),
Schema(),
])
def test_d_dot_suggests_schema_qualified_tables_or_views():
suggestions = suggest_type('\d myschema.', '\d myschema.')
assert set(suggestions) == set([
Table(schema='myschema'),
View(schema='myschema'),
])
suggestions = suggest_type('\d myschema.xxx', '\d myschema.xxx')
assert set(suggestions) == set([
Table(schema='myschema'),
View(schema='myschema'),
])
def test_d_suggests_tables_views_and_schemas():
suggestions = suggest_type('\d ', '\d ')
assert set(suggestions) == set([
Schema(),
Table(schema=None),
View(schema=None),
])
suggestions = suggest_type('\d xxx', '\d xxx')
assert set(suggestions) == set([
Schema(),
Table(schema=None),
View(schema=None),
])
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_alter_column_type_suggests_types():
q = "ALTER TABLE foo ALTER COLUMN bar TYPE "
assert set(suggest_type(q, q)) == {
Datatype(schema=None),
Table(schema=None),
Schema(),
}
def test_dot_suggests_cols_of_an_alias(sql):
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(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_an_alias_where(sql):
suggestions = suggest_type(sql, sql)
assert set(suggestions) == {
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 test_join_alias_dot_suggests_cols1(sql):
suggestions = suggest_type(sql, sql)
assert set(suggestions) == set([
Column(tables=((None, 'abc', 'a', False), )),
Table(schema='a'),
View(schema='a'),
Function(schema='a'),
])
def test_dot_suggests_cols_of_a_table_or_schema_qualified_table():
suggestions = suggest_type("SELECT tabl. FROM tabl", "SELECT tabl.")
assert set(suggestions) == {
Column(table_refs=((None, "tabl", None, False),)),
Table(schema="tabl"),
View(schema="tabl"),
Function(schema="tabl"),
}
def test_sub_select_table_name_completion(expression):
suggestion = suggest_type(expression, expression)
assert set(suggestion) == set([
Table(schema=None),
View(schema=None),
Function(schema=None, filter='is_set_returning'),
Schema(),
])
def test_suggest_qualified_tables_views_and_set_returning_functions(
expression):
suggestions = suggest_type(expression, expression)
assert set(suggestions) == set([
Table(schema='sch'),
View(schema='sch'),
Function(schema='sch', filter='is_set_returning'),
])
def test_suggest_tables_views_schemas_and_set_returning_functions(expression):
suggestions = suggest_type(expression, expression)
assert set(suggestions) == set([
Table(schema=None),
View(schema=None),
Function(schema=None, filter='is_set_returning'),
Schema(),
])
def test_join_alias_dot_suggests_cols2(sql):
suggestion = suggest_type(sql, sql)
assert set(suggestion) == {
Column(table_refs=((None, "def", "d", False),)),
Table(schema="d"),
View(schema="d"),
Function(schema="d"),
}
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_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) == {
Column(table_refs=((None, "foo", "f", False),)),
Table(schema="f"),
View(schema="f"),
Function(schema="f"),
}
def test_left_join_with_comma():
text = 'select * from foo f left join bar b,'
suggestions = suggest_type(text, text)
assert set(suggestions) == set([
Table(schema=None),
View(schema=None),
Function(schema=None, filter='is_set_returning'),
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)
assert set(suggestion) == set([
Table(schema=None),
View(schema=None),
Function(schema=None, filter='is_set_returning'),
Schema(),
])
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_table_comma_suggests_tables_and_schemas():
suggestions = suggest_type('SELECT a, b FROM tbl1, ',
'SELECT a, b FROM tbl1, ')
assert set(suggestions) == set([
Table(schema=None),
View(schema=None),
Function(schema=None, filter='is_set_returning'),
Schema(),
])
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_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_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_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) == {
Column(table_refs=((None, "tabl2", "t2", False),)),
Table(schema="t2"),
View(schema="t2"),
Function(schema="t2"),
}
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_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_function_arguments_with_alias_given():
suggestions = suggest_type("SELECT avg(x. FROM tbl x, tbl2 y", "SELECT avg(x.")
assert set(suggestions) == {
Column(
table_refs=(TableReference(None, "tbl", "x", False),),
local_tables=(),
qualifiable=False,
),
Table(schema="x"),
View(schema="x"),
Function(schema="x"),
}
