def test_describe_table():
suggestions = suggest_type("\\dt", "\\dt ")
assert sorted_dicts(suggestions) == sorted_dicts([
{
"type": "table",
"schema": []
},
{
"type": "view",
"schema": []
},
{
"type": "schema"
},
])
def test_list_or_show_create_tables():
suggestions = suggest_type("\\dt+", "\\dt+ ")
assert sorted_dicts(suggestions) == sorted_dicts([
{
"type": "table",
"schema": []
},
{
"type": "view",
"schema": []
},
{
"type": "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 sorted_dicts(suggestion) == sorted_dicts([
{
"type": "table",
"schema": []
},
{
"type": "view",
"schema": []
},
{
"type": "schema"
},
])
def test_cross_join():
text = "select * from v1 cross join v2 JOIN v1.id, "
suggestions = suggest_type(text, text)
assert sorted_dicts(suggestions) == sorted_dicts([
{
"type": "table",
"schema": []
},
{
"type": "view",
"schema": []
},
{
"type": "schema"
},
])
def test_table_comma_suggests_tables_and_schemas():
suggestions = suggest_type("SELECT a, b FROM tbl1, ",
"SELECT a, b FROM tbl1, ")
assert sorted_dicts(suggestions) == sorted_dicts([
{
"type": "table",
"schema": []
},
{
"type": "view",
"schema": []
},
{
"type": "schema"
},
])
def test_import_first_argument():
test_cases = [
# text, expecting_arg_idx
[".import ", 1],
[".import ./da", 1],
[".import ./data.csv ", 2],
[".import ./data.csv t", 2],
[".import ./data.csv `t", 2],
['.import ./data.csv "t', 2],
]
for text, expecting_arg_idx in test_cases:
suggestions = suggest_type(text, text)
if expecting_arg_idx == 1:
assert suggestions == [{"type": "file_name"}]
else:
assert suggestions == [{"type": "table", "schema": []}]
def test_where_suggests_columns_functions(expression):
suggestions = suggest_type(expression, expression)
assert sorted_dicts(suggestions) == sorted_dicts([
{
"type": "alias",
"aliases": ["tabl"]
},
{
"type": "column",
"tables": [(None, "tabl", None)]
},
{
"type": "function",
"schema": []
},
{
"type": "keyword"
},
])
def test_col_comma_suggests_cols():
suggestions = suggest_type("SELECT a, b, FROM tbl", "SELECT a, b,")
assert sorted_dicts(suggestions) == sorted_dicts([
{
"type": "alias",
"aliases": ["tbl"]
},
{
"type": "column",
"tables": [(None, "tbl", None)]
},
{
"type": "function",
"schema": []
},
{
"type": "keyword"
},
])
def test_select_suggests_cols_with_visible_table_scope():
suggestions = suggest_type("SELECT FROM tabl", "SELECT ")
assert sorted_dicts(suggestions) == sorted_dicts([
{
"type": "alias",
"aliases": ["tabl"]
},
{
"type": "column",
"tables": [(None, "tabl", None)]
},
{
"type": "function",
"schema": []
},
{
"type": "keyword"
},
])
def test_select_suggests_cols_and_funcs():
suggestions = suggest_type("SELECT ", "SELECT ")
assert sorted_dicts(suggestions) == sorted_dicts([
{
"type": "alias",
"aliases": []
},
{
"type": "column",
"tables": []
},
{
"type": "function",
"schema": []
},
{
"type": "keyword"
},
])
def test_dot_suggests_cols_of_a_table_or_schema_qualified_table():
suggestions = suggest_type("SELECT tabl. FROM tabl", "SELECT tabl.")
assert sorted_dicts(suggestions) == sorted_dicts([
{
"type": "column",
"tables": [(None, "tabl", None)]
},
{
"type": "table",
"schema": "tabl"
},
{
"type": "view",
"schema": "tabl"
},
{
"type": "function",
"schema": "tabl"
},
])
def test_partially_typed_col_name_suggests_col_names():
suggestions = suggest_type("SELECT * FROM tabl WHERE col_n",
"SELECT * FROM tabl WHERE col_n")
assert sorted_dicts(suggestions) == sorted_dicts([
{
"type": "alias",
"aliases": ["tabl"]
},
{
"type": "column",
"tables": [(None, "tabl", None)]
},
{
"type": "function",
"schema": []
},
{
"type": "keyword"
},
])
def test_where_equals_any_suggests_columns_or_keywords():
text = "SELECT * FROM tabl WHERE foo = ANY("
suggestions = suggest_type(text, text)
assert sorted_dicts(suggestions) == sorted_dicts([
{
"type": "alias",
"aliases": ["tabl"]
},
{
"type": "column",
"tables": [(None, "tabl", None)]
},
{
"type": "function",
"schema": []
},
{
"type": "keyword"
},
])
def test_sub_select_col_name_completion():
suggestions = suggest_type("SELECT * FROM (SELECT FROM abc",
"SELECT * FROM (SELECT ")
assert sorted_dicts(suggestions) == sorted_dicts([
{
"type": "alias",
"aliases": ["abc"]
},
{
"type": "column",
"tables": [(None, "abc", None)]
},
{
"type": "function",
"schema": []
},
{
"type": "keyword"
},
])
def test_join_alias_dot_suggests_cols2(sql):
suggestions = suggest_type(sql, sql)
assert sorted_dicts(suggestions) == sorted_dicts([
{
"type": "column",
"tables": [(None, "def", "d")]
},
{
"type": "table",
"schema": "d"
},
{
"type": "view",
"schema": "d"
},
{
"type": "function",
"schema": "d"
},
])
def test_dot_suggests_cols_of_an_alias():
suggestions = suggest_type("SELECT t1. FROM tabl1 t1, tabl2 t2",
"SELECT t1.")
assert sorted_dicts(suggestions) == sorted_dicts([
{
"type": "table",
"schema": "t1"
},
{
"type": "view",
"schema": "t1"
},
{
"type": "column",
"tables": [(None, "tabl1", "t1")]
},
{
"type": "function",
"schema": "t1"
},
])
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 sorted_dicts(suggestions) == sorted_dicts([
{
"type": "column",
"tables": [(None, "tabl2", "t2")]
},
{
"type": "table",
"schema": "t2"
},
{
"type": "view",
"schema": "t2"
},
{
"type": "function",
"schema": "t2"
},
])
def test_sub_select_dot_col_name_completion():
suggestions = suggest_type("SELECT * FROM (SELECT t. FROM tabl t",
"SELECT * FROM (SELECT t.")
assert sorted_dicts(suggestions) == sorted_dicts([
{
"type": "column",
"tables": [(None, "tabl", "t")]
},
{
"type": "table",
"schema": "t"
},
{
"type": "view",
"schema": "t"
},
{
"type": "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 suggestions == [
{
"type": "column",
"tables": [(None, "foo", "f")]
},
{
"type": "table",
"schema": "f"
},
{
"type": "view",
"schema": "f"
},
{
"type": "function",
"schema": "f"
},
]
def test_source_is_file(expression):
suggestions = suggest_type(expression, expression)
assert suggestions == [{"type": "file_name"}]
def test_distinct_suggests_cols():
suggestions = suggest_type("SELECT DISTINCT ", "SELECT DISTINCT ")
assert suggestions == [{"type": "column", "tables": []}]
def test_after_as(expression):
suggestions = suggest_type(expression, expression)
assert set(suggestions) == set()
def test_insert_into_lparen_comma_suggests_cols():
suggestions = suggest_type("INSERT INTO abc (id,", "INSERT INTO abc (id,")
assert suggestions == [{"type": "column", "tables": [(None, "abc", None)]}]
def test_handle_pre_completion_comma_gracefully(text):
suggestions = suggest_type(text, text)
assert iter(suggestions)
def test_drop_schema_qualified_table_suggests_only_tables():
text = "DROP TABLE schema_name.table_name"
suggestions = suggest_type(text, text)
assert suggestions == [{"type": "table", "schema": "schema_name"}]
def test_specials_not_included_after_initial_token():
suggestions = suggest_type("create table foo (dt d",
"create table foo (dt d")
assert sorted_dicts(suggestions) == sorted_dicts([{"type": "keyword"}])
def test_create_db_with_template():
suggestions = suggest_type("create database foo with template ",
"create database foo with template ")
assert sorted_dicts(suggestions) == sorted_dicts([{"type": "database"}])
def test_on_suggests_tables_right_side(sql):
suggestions = suggest_type(sql, sql)
assert suggestions == [{"type": "alias", "aliases": ["abc", "bcd"]}]
def test_on_suggests_aliases(sql):
suggestions = suggest_type(sql, sql)
assert suggestions == [{"type": "alias", "aliases": ["a", "b"]}]
def test_sub_select_partial_text_suggests_keyword(expression):
suggestion = suggest_type(expression, expression)
assert suggestion == [{"type": "keyword"}]
