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_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_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_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_handle_unrecognized_kw_generously():
sql = "SELECT * FROM sessions WHERE session = 1 AND "
suggestions = suggest_type(sql, sql)
expected = Column(table_refs=((None, "sessions", None, False), ),
qualifiable=True)
assert expected in set(suggestions)
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_lparen_suggests_cols_and_funcs():
suggestion = suggest_type("SELECT MAX( FROM tbl", "SELECT MAX(")
assert set(suggestion) == set([
Column(table_refs=((None, "tbl", None, False), ), qualifiable=True),
Function(schema=None),
Keyword("("),
])
def get_completions(self, document, complete_event, smart_completion=None):
word_before_cursor = document.get_word_before_cursor(WORD=True)
if smart_completion is None:
smart_completion = self.smart_completion
# If smart_completion is off then match any word that starts with
# 'word_before_cursor'.
if not smart_completion:
matches = self.find_matches(
word_before_cursor, self.all_completions, mode="strict"
)
completions = [m.completion for m in matches]
return sorted(completions, key=operator.attrgetter("text"))
matches = []
suggestions = suggest_type(document.text, document.text_before_cursor)
for suggestion in suggestions:
suggestion_type = type(suggestion)
_logger.debug("Suggestion type: %r", suggestion_type)
# Map suggestion type to method
# e.g. 'table' -> self.get_table_matches
matcher = self.suggestion_matchers[suggestion_type]
matches.extend(matcher(self, suggestion, word_before_cursor))
# Sort matches so highest priorities are first
matches = sorted(matches, key=operator.attrgetter("priority"), reverse=True)
return [m.completion for m in matches]
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_suggest_columns_after_multiple_joins():
sql = """select * from t1
inner join t2 ON
t1.id = t2.t1_id
inner join t3 ON
t2.id = t3."""
suggestions = suggest_type(sql, sql)
assert Column(table_refs=((None, "t3", None, False), )) in set(suggestions)
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_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_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_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_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_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_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_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_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_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_function_arguments_with_alias_given():
suggestions = suggest_type("SELECT avg(x. FROM tbl x, tbl2 y",
"SELECT avg(x.")
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_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_after_as(expression):
suggestions = suggest_type(expression, expression)
assert set(suggestions) == set()
def test_keyword_after_alter(sql):
assert Keyword("ALTER") in set(suggest_type(sql, sql))
def test_column_keyword_suggests_columns(sql):
suggestions = suggest_type(sql, sql)
assert set(suggestions) == set(
[Column(table_refs=((None, "foo", None, False), ))])
def test_ignore_leading_double_quotes(sql):
suggestions = suggest_type(sql, sql)
assert FromClauseItem(schema=None) in set(suggestions)
def test_leading_parenthesis(sql):
# No assertion for now; just make sure it doesn't crash
suggest_type(sql, sql)
