mirror of
https://github.com/apache/superset.git
synced 2026-06-03 06:39:25 +00:00
[format] Using Black (#7769)
This commit is contained in:
John Bodley
@@ -20,88 +20,86 @@ from superset import sql_parse
|
||||
|
||||
|
||||
class SupersetTestCase(unittest.TestCase):
|
||||
|
||||
def extract_tables(self, query):
|
||||
sq = sql_parse.ParsedQuery(query)
|
||||
return sq.tables
|
||||
|
||||
def test_simple_select(self):
|
||||
query = 'SELECT * FROM tbname'
|
||||
self.assertEquals({'tbname'}, self.extract_tables(query))
|
||||
query = "SELECT * FROM tbname"
|
||||
self.assertEquals({"tbname"}, self.extract_tables(query))
|
||||
|
||||
query = 'SELECT * FROM tbname foo'
|
||||
self.assertEquals({'tbname'}, self.extract_tables(query))
|
||||
query = "SELECT * FROM tbname foo"
|
||||
self.assertEquals({"tbname"}, self.extract_tables(query))
|
||||
|
||||
query = 'SELECT * FROM tbname AS foo'
|
||||
self.assertEquals({'tbname'}, self.extract_tables(query))
|
||||
query = "SELECT * FROM tbname AS foo"
|
||||
self.assertEquals({"tbname"}, self.extract_tables(query))
|
||||
|
||||
# underscores
|
||||
query = 'SELECT * FROM tb_name'
|
||||
self.assertEquals({'tb_name'},
|
||||
self.extract_tables(query))
|
||||
query = "SELECT * FROM tb_name"
|
||||
self.assertEquals({"tb_name"}, self.extract_tables(query))
|
||||
|
||||
# quotes
|
||||
query = 'SELECT * FROM "tbname"'
|
||||
self.assertEquals({'tbname'}, self.extract_tables(query))
|
||||
self.assertEquals({"tbname"}, self.extract_tables(query))
|
||||
|
||||
# unicode encoding
|
||||
query = 'SELECT * FROM "tb_name" WHERE city = "Lübeck"'
|
||||
self.assertEquals({'tb_name'}, self.extract_tables(query))
|
||||
self.assertEquals({"tb_name"}, self.extract_tables(query))
|
||||
|
||||
# schema
|
||||
self.assertEquals(
|
||||
{'schemaname.tbname'},
|
||||
self.extract_tables('SELECT * FROM schemaname.tbname'))
|
||||
{"schemaname.tbname"},
|
||||
self.extract_tables("SELECT * FROM schemaname.tbname"),
|
||||
)
|
||||
|
||||
self.assertEquals(
|
||||
{'schemaname.tbname'},
|
||||
self.extract_tables('SELECT * FROM "schemaname"."tbname"'))
|
||||
{"schemaname.tbname"},
|
||||
self.extract_tables('SELECT * FROM "schemaname"."tbname"'),
|
||||
)
|
||||
|
||||
self.assertEquals(
|
||||
{'schemaname.tbname'},
|
||||
self.extract_tables('SELECT * FROM schemaname.tbname foo'))
|
||||
{"schemaname.tbname"},
|
||||
self.extract_tables("SELECT * FROM schemaname.tbname foo"),
|
||||
)
|
||||
|
||||
self.assertEquals(
|
||||
{'schemaname.tbname'},
|
||||
self.extract_tables('SELECT * FROM schemaname.tbname AS foo'))
|
||||
{"schemaname.tbname"},
|
||||
self.extract_tables("SELECT * FROM schemaname.tbname AS foo"),
|
||||
)
|
||||
|
||||
# cluster
|
||||
self.assertEquals(
|
||||
{'clustername.schemaname.tbname'},
|
||||
self.extract_tables('SELECT * FROM clustername.schemaname.tbname'))
|
||||
{"clustername.schemaname.tbname"},
|
||||
self.extract_tables("SELECT * FROM clustername.schemaname.tbname"),
|
||||
)
|
||||
|
||||
# Ill-defined cluster/schema/table.
|
||||
self.assertEquals(
|
||||
set(),
|
||||
self.extract_tables('SELECT * FROM schemaname.'))
|
||||
self.assertEquals(set(), self.extract_tables("SELECT * FROM schemaname."))
|
||||
|
||||
self.assertEquals(
|
||||
set(),
|
||||
self.extract_tables('SELECT * FROM clustername.schemaname.'))
|
||||
set(), self.extract_tables("SELECT * FROM clustername.schemaname.")
|
||||
)
|
||||
|
||||
self.assertEquals(set(), self.extract_tables("SELECT * FROM clustername.."))
|
||||
|
||||
self.assertEquals(
|
||||
set(),
|
||||
self.extract_tables('SELECT * FROM clustername..'))
|
||||
|
||||
self.assertEquals(
|
||||
set(),
|
||||
self.extract_tables('SELECT * FROM clustername..tbname'))
|
||||
set(), self.extract_tables("SELECT * FROM clustername..tbname")
|
||||
)
|
||||
|
||||
# quotes
|
||||
query = 'SELECT field1, field2 FROM tb_name'
|
||||
self.assertEquals({'tb_name'}, self.extract_tables(query))
|
||||
query = "SELECT field1, field2 FROM tb_name"
|
||||
self.assertEquals({"tb_name"}, self.extract_tables(query))
|
||||
|
||||
query = 'SELECT t1.f1, t2.f2 FROM t1, t2'
|
||||
self.assertEquals({'t1', 't2'}, self.extract_tables(query))
|
||||
query = "SELECT t1.f1, t2.f2 FROM t1, t2"
|
||||
self.assertEquals({"t1", "t2"}, self.extract_tables(query))
|
||||
|
||||
def test_select_named_table(self):
|
||||
query = 'SELECT a.date, a.field FROM left_table a LIMIT 10'
|
||||
self.assertEquals(
|
||||
{'left_table'}, self.extract_tables(query))
|
||||
query = "SELECT a.date, a.field FROM left_table a LIMIT 10"
|
||||
self.assertEquals({"left_table"}, self.extract_tables(query))
|
||||
|
||||
def test_reverse_select(self):
|
||||
query = 'FROM t1 SELECT field'
|
||||
self.assertEquals({'t1'}, self.extract_tables(query))
|
||||
query = "FROM t1 SELECT field"
|
||||
self.assertEquals({"t1"}, self.extract_tables(query))
|
||||
|
||||
def test_subselect(self):
|
||||
query = """
|
||||
@@ -113,8 +111,7 @@ class SupersetTestCase(unittest.TestCase):
|
||||
) sub, s2.t2
|
||||
WHERE sub.resolution = 'NONE'
|
||||
"""
|
||||
self.assertEquals({'s1.t1', 's2.t2'},
|
||||
self.extract_tables(query))
|
||||
self.assertEquals({"s1.t1", "s2.t2"}, self.extract_tables(query))
|
||||
|
||||
query = """
|
||||
SELECT sub.*
|
||||
@@ -125,7 +122,7 @@ class SupersetTestCase(unittest.TestCase):
|
||||
) sub
|
||||
WHERE sub.resolution = 'NONE'
|
||||
"""
|
||||
self.assertEquals({'s1.t1'}, self.extract_tables(query))
|
||||
self.assertEquals({"s1.t1"}, self.extract_tables(query))
|
||||
|
||||
query = """
|
||||
SELECT * FROM t1
|
||||
@@ -136,25 +133,24 @@ class SupersetTestCase(unittest.TestCase):
|
||||
WHERE ROW(5*t2.s1,77)=
|
||||
(SELECT 50,11*s1 FROM t4)));
|
||||
"""
|
||||
self.assertEquals({'t1', 't2', 't3', 't4'},
|
||||
self.extract_tables(query))
|
||||
self.assertEquals({"t1", "t2", "t3", "t4"}, self.extract_tables(query))
|
||||
|
||||
def test_select_in_expression(self):
|
||||
query = 'SELECT f1, (SELECT count(1) FROM t2) FROM t1'
|
||||
self.assertEquals({'t1', 't2'}, self.extract_tables(query))
|
||||
query = "SELECT f1, (SELECT count(1) FROM t2) FROM t1"
|
||||
self.assertEquals({"t1", "t2"}, self.extract_tables(query))
|
||||
|
||||
def test_union(self):
|
||||
query = 'SELECT * FROM t1 UNION SELECT * FROM t2'
|
||||
self.assertEquals({'t1', 't2'}, self.extract_tables(query))
|
||||
query = "SELECT * FROM t1 UNION SELECT * FROM t2"
|
||||
self.assertEquals({"t1", "t2"}, self.extract_tables(query))
|
||||
|
||||
query = 'SELECT * FROM t1 UNION ALL SELECT * FROM t2'
|
||||
self.assertEquals({'t1', 't2'}, self.extract_tables(query))
|
||||
query = "SELECT * FROM t1 UNION ALL SELECT * FROM t2"
|
||||
self.assertEquals({"t1", "t2"}, self.extract_tables(query))
|
||||
|
||||
query = 'SELECT * FROM t1 INTERSECT ALL SELECT * FROM t2'
|
||||
self.assertEquals({'t1', 't2'}, self.extract_tables(query))
|
||||
query = "SELECT * FROM t1 INTERSECT ALL SELECT * FROM t2"
|
||||
self.assertEquals({"t1", "t2"}, self.extract_tables(query))
|
||||
|
||||
def test_select_from_values(self):
|
||||
query = 'SELECT * FROM VALUES (13, 42)'
|
||||
query = "SELECT * FROM VALUES (13, 42)"
|
||||
self.assertFalse(self.extract_tables(query))
|
||||
|
||||
def test_select_array(self):
|
||||
@@ -162,25 +158,25 @@ class SupersetTestCase(unittest.TestCase):
|
||||
SELECT ARRAY[1, 2, 3] AS my_array
|
||||
FROM t1 LIMIT 10
|
||||
"""
|
||||
self.assertEquals({'t1'}, self.extract_tables(query))
|
||||
self.assertEquals({"t1"}, self.extract_tables(query))
|
||||
|
||||
def test_select_if(self):
|
||||
query = """
|
||||
SELECT IF(CARDINALITY(my_array) >= 3, my_array[3], NULL)
|
||||
FROM t1 LIMIT 10
|
||||
"""
|
||||
self.assertEquals({'t1'}, self.extract_tables(query))
|
||||
self.assertEquals({"t1"}, self.extract_tables(query))
|
||||
|
||||
# SHOW TABLES ((FROM | IN) qualifiedName)? (LIKE pattern=STRING)?
|
||||
def test_show_tables(self):
|
||||
query = "SHOW TABLES FROM s1 like '%order%'"
|
||||
# TODO: figure out what should code do here
|
||||
self.assertEquals({'s1'}, self.extract_tables(query))
|
||||
self.assertEquals({"s1"}, self.extract_tables(query))
|
||||
|
||||
# SHOW COLUMNS (FROM | IN) qualifiedName
|
||||
def test_show_columns(self):
|
||||
query = 'SHOW COLUMNS FROM t1'
|
||||
self.assertEquals({'t1'}, self.extract_tables(query))
|
||||
query = "SHOW COLUMNS FROM t1"
|
||||
self.assertEquals({"t1"}, self.extract_tables(query))
|
||||
|
||||
def test_where_subquery(self):
|
||||
query = """
|
||||
@@ -188,25 +184,25 @@ class SupersetTestCase(unittest.TestCase):
|
||||
FROM t1
|
||||
WHERE regionkey = (SELECT max(regionkey) FROM t2)
|
||||
"""
|
||||
self.assertEquals({'t1', 't2'}, self.extract_tables(query))
|
||||
self.assertEquals({"t1", "t2"}, self.extract_tables(query))
|
||||
|
||||
query = """
|
||||
SELECT name
|
||||
FROM t1
|
||||
WHERE regionkey IN (SELECT regionkey FROM t2)
|
||||
"""
|
||||
self.assertEquals({'t1', 't2'}, self.extract_tables(query))
|
||||
self.assertEquals({"t1", "t2"}, self.extract_tables(query))
|
||||
|
||||
query = """
|
||||
SELECT name
|
||||
FROM t1
|
||||
WHERE regionkey EXISTS (SELECT regionkey FROM t2)
|
||||
"""
|
||||
self.assertEquals({'t1', 't2'}, self.extract_tables(query))
|
||||
self.assertEquals({"t1", "t2"}, self.extract_tables(query))
|
||||
|
||||
# DESCRIBE | DESC qualifiedName
|
||||
def test_describe(self):
|
||||
self.assertEquals({'t1'}, self.extract_tables('DESCRIBE t1'))
|
||||
self.assertEquals({"t1"}, self.extract_tables("DESCRIBE t1"))
|
||||
|
||||
# SHOW PARTITIONS FROM qualifiedName (WHERE booleanExpression)?
|
||||
# (ORDER BY sortItem (',' sortItem)*)? (LIMIT limit=(INTEGER_VALUE | ALL))?
|
||||
@@ -215,11 +211,11 @@ class SupersetTestCase(unittest.TestCase):
|
||||
SHOW PARTITIONS FROM orders
|
||||
WHERE ds >= '2013-01-01' ORDER BY ds DESC;
|
||||
"""
|
||||
self.assertEquals({'orders'}, self.extract_tables(query))
|
||||
self.assertEquals({"orders"}, self.extract_tables(query))
|
||||
|
||||
def test_join(self):
|
||||
query = 'SELECT t1.*, t2.* FROM t1 JOIN t2 ON t1.a = t2.a;'
|
||||
self.assertEquals({'t1', 't2'}, self.extract_tables(query))
|
||||
query = "SELECT t1.*, t2.* FROM t1 JOIN t2 ON t1.a = t2.a;"
|
||||
self.assertEquals({"t1", "t2"}, self.extract_tables(query))
|
||||
|
||||
# subquery + join
|
||||
query = """
|
||||
@@ -233,8 +229,7 @@ class SupersetTestCase(unittest.TestCase):
|
||||
) b
|
||||
ON a.date = b.date
|
||||
"""
|
||||
self.assertEquals({'left_table', 'right_table'},
|
||||
self.extract_tables(query))
|
||||
self.assertEquals({"left_table", "right_table"}, self.extract_tables(query))
|
||||
|
||||
query = """
|
||||
SELECT a.date, b.name FROM
|
||||
@@ -247,8 +242,7 @@ class SupersetTestCase(unittest.TestCase):
|
||||
) b
|
||||
ON a.date = b.date
|
||||
"""
|
||||
self.assertEquals({'left_table', 'right_table'},
|
||||
self.extract_tables(query))
|
||||
self.assertEquals({"left_table", "right_table"}, self.extract_tables(query))
|
||||
|
||||
query = """
|
||||
SELECT a.date, b.name FROM
|
||||
@@ -261,8 +255,7 @@ class SupersetTestCase(unittest.TestCase):
|
||||
) b
|
||||
ON a.date = b.date
|
||||
"""
|
||||
self.assertEquals({'left_table', 'right_table'},
|
||||
self.extract_tables(query))
|
||||
self.assertEquals({"left_table", "right_table"}, self.extract_tables(query))
|
||||
|
||||
query = """
|
||||
SELECT a.date, b.name FROM
|
||||
@@ -275,8 +268,7 @@ class SupersetTestCase(unittest.TestCase):
|
||||
) b
|
||||
ON a.date = b.date
|
||||
"""
|
||||
self.assertEquals({'left_table', 'right_table'},
|
||||
self.extract_tables(query))
|
||||
self.assertEquals({"left_table", "right_table"}, self.extract_tables(query))
|
||||
|
||||
# TODO: add SEMI join support, SQL Parse does not handle it.
|
||||
# query = """
|
||||
@@ -304,14 +296,13 @@ class SupersetTestCase(unittest.TestCase):
|
||||
WHERE ROW(5*t3.s1,77)=
|
||||
(SELECT 50,11*s1 FROM t4)));
|
||||
"""
|
||||
self.assertEquals({'t1', 't3', 't4', 't6'},
|
||||
self.extract_tables(query))
|
||||
self.assertEquals({"t1", "t3", "t4", "t6"}, self.extract_tables(query))
|
||||
|
||||
query = """
|
||||
SELECT * FROM (SELECT * FROM (SELECT * FROM (SELECT * FROM EmployeeS)
|
||||
AS S1) AS S2) AS S3;
|
||||
"""
|
||||
self.assertEquals({'EmployeeS'}, self.extract_tables(query))
|
||||
self.assertEquals({"EmployeeS"}, self.extract_tables(query))
|
||||
|
||||
def test_with(self):
|
||||
query = """
|
||||
@@ -321,8 +312,7 @@ class SupersetTestCase(unittest.TestCase):
|
||||
z AS (SELECT b AS c FROM t3)
|
||||
SELECT c FROM z;
|
||||
"""
|
||||
self.assertEquals({'t1', 't2', 't3'},
|
||||
self.extract_tables(query))
|
||||
self.assertEquals({"t1", "t2", "t3"}, self.extract_tables(query))
|
||||
|
||||
query = """
|
||||
WITH
|
||||
@@ -331,7 +321,7 @@ class SupersetTestCase(unittest.TestCase):
|
||||
z AS (SELECT b AS c FROM y)
|
||||
SELECT c FROM z;
|
||||
"""
|
||||
self.assertEquals({'t1'}, self.extract_tables(query))
|
||||
self.assertEquals({"t1"}, self.extract_tables(query))
|
||||
|
||||
def test_reusing_aliases(self):
|
||||
query = """
|
||||
@@ -339,22 +329,22 @@ class SupersetTestCase(unittest.TestCase):
|
||||
q2 as ( select key from src where key = '5')
|
||||
select * from (select key from q1) a;
|
||||
"""
|
||||
self.assertEquals({'src'}, self.extract_tables(query))
|
||||
self.assertEquals({"src"}, self.extract_tables(query))
|
||||
|
||||
def test_multistatement(self):
|
||||
query = 'SELECT * FROM t1; SELECT * FROM t2'
|
||||
self.assertEquals({'t1', 't2'}, self.extract_tables(query))
|
||||
query = "SELECT * FROM t1; SELECT * FROM t2"
|
||||
self.assertEquals({"t1", "t2"}, self.extract_tables(query))
|
||||
|
||||
query = 'SELECT * FROM t1; SELECT * FROM t2;'
|
||||
self.assertEquals({'t1', 't2'}, self.extract_tables(query))
|
||||
query = "SELECT * FROM t1; SELECT * FROM t2;"
|
||||
self.assertEquals({"t1", "t2"}, self.extract_tables(query))
|
||||
|
||||
def test_update_not_select(self):
|
||||
sql = sql_parse.ParsedQuery('UPDATE t1 SET col1 = NULL')
|
||||
sql = sql_parse.ParsedQuery("UPDATE t1 SET col1 = NULL")
|
||||
self.assertEquals(False, sql.is_select())
|
||||
self.assertEquals(False, sql.is_readonly())
|
||||
|
||||
def test_explain(self):
|
||||
sql = sql_parse.ParsedQuery('EXPLAIN SELECT 1')
|
||||
sql = sql_parse.ParsedQuery("EXPLAIN SELECT 1")
|
||||
|
||||
self.assertEquals(True, sql.is_explain())
|
||||
self.assertEquals(False, sql.is_select())
|
||||
@@ -377,24 +367,21 @@ class SupersetTestCase(unittest.TestCase):
|
||||
ORDER BY "sum__m_example" DESC
|
||||
LIMIT 10;"""
|
||||
self.assertEquals(
|
||||
{'my_l_table', 'my_b_table', 'my_t_table', 'inner_table'},
|
||||
self.extract_tables(query))
|
||||
{"my_l_table", "my_b_table", "my_t_table", "inner_table"},
|
||||
self.extract_tables(query),
|
||||
)
|
||||
|
||||
def test_complex_extract_tables2(self):
|
||||
query = """SELECT *
|
||||
FROM table_a AS a, table_b AS b, table_c as c
|
||||
WHERE a.id = b.id and b.id = c.id"""
|
||||
self.assertEquals(
|
||||
{'table_a', 'table_b', 'table_c'},
|
||||
self.extract_tables(query))
|
||||
self.assertEquals({"table_a", "table_b", "table_c"}, self.extract_tables(query))
|
||||
|
||||
def test_mixed_from_clause(self):
|
||||
query = """SELECT *
|
||||
FROM table_a AS a, (select * from table_b) AS b, table_c as c
|
||||
WHERE a.id = b.id and b.id = c.id"""
|
||||
self.assertEquals(
|
||||
{'table_a', 'table_b', 'table_c'},
|
||||
self.extract_tables(query))
|
||||
self.assertEquals({"table_a", "table_b", "table_c"}, self.extract_tables(query))
|
||||
|
||||
def test_nested_selects(self):
|
||||
query = """
|
||||
@@ -402,17 +389,13 @@ class SupersetTestCase(unittest.TestCase):
|
||||
from INFORMATION_SCHEMA.COLUMNS
|
||||
WHERE TABLE_SCHEMA like "%bi%"),0x7e)));
|
||||
"""
|
||||
self.assertEquals(
|
||||
{'INFORMATION_SCHEMA.COLUMNS'},
|
||||
self.extract_tables(query))
|
||||
self.assertEquals({"INFORMATION_SCHEMA.COLUMNS"}, self.extract_tables(query))
|
||||
query = """
|
||||
select (extractvalue(1,concat(0x7e,(select GROUP_CONCAT(COLUMN_NAME)
|
||||
from INFORMATION_SCHEMA.COLUMNS
|
||||
WHERE TABLE_NAME="bi_achivement_daily"),0x7e)));
|
||||
"""
|
||||
self.assertEquals(
|
||||
{'INFORMATION_SCHEMA.COLUMNS'},
|
||||
self.extract_tables(query))
|
||||
self.assertEquals({"INFORMATION_SCHEMA.COLUMNS"}, self.extract_tables(query))
|
||||
|
||||
def test_complex_extract_tables3(self):
|
||||
query = """SELECT somecol AS somecol
|
||||
@@ -434,8 +417,9 @@ class SupersetTestCase(unittest.TestCase):
|
||||
WHERE 1=1
|
||||
GROUP BY not_table.bad_col1 ,
|
||||
not_table.bad_col2 ,
|
||||
ORDER BY not_table.bad_col_3 DESC , not_table.bad_col4 ,
|
||||
not_table.bad_col5) SELECT random_col
|
||||
ORDER BY not_table.bad_col_3 DESC ,
|
||||
not_table.bad_col4 ,
|
||||
not_table.bad_col5) SELECT random_col
|
||||
FROM d
|
||||
WHERE 1=1
|
||||
UNION ALL SELECT even_more_cols
|
||||
@@ -447,9 +431,7 @@ class SupersetTestCase(unittest.TestCase):
|
||||
WHERE 2=2
|
||||
GROUP BY last_col
|
||||
LIMIT 50000;"""
|
||||
self.assertEquals(
|
||||
{'a', 'b', 'c', 'd', 'e', 'f'},
|
||||
self.extract_tables(query))
|
||||
self.assertEquals({"a", "b", "c", "d", "e", "f"}, self.extract_tables(query))
|
||||
|
||||
def test_complex_cte_with_prefix(self):
|
||||
query = """
|
||||
@@ -464,25 +446,25 @@ class SupersetTestCase(unittest.TestCase):
|
||||
GROUP BY SalesYear, SalesPersonID
|
||||
ORDER BY SalesPersonID, SalesYear;
|
||||
"""
|
||||
self.assertEquals({'SalesOrderHeader'}, self.extract_tables(query))
|
||||
self.assertEquals({"SalesOrderHeader"}, self.extract_tables(query))
|
||||
|
||||
def test_get_query_with_new_limit_comment(self):
|
||||
sql = 'SELECT * FROM ab_user --SOME COMMENT'
|
||||
sql = "SELECT * FROM ab_user --SOME COMMENT"
|
||||
parsed = sql_parse.ParsedQuery(sql)
|
||||
newsql = parsed.get_query_with_new_limit(1000)
|
||||
self.assertEquals(newsql, sql + '\nLIMIT 1000')
|
||||
self.assertEquals(newsql, sql + "\nLIMIT 1000")
|
||||
|
||||
def test_get_query_with_new_limit_comment_with_limit(self):
|
||||
sql = 'SELECT * FROM ab_user --SOME COMMENT WITH LIMIT 555'
|
||||
sql = "SELECT * FROM ab_user --SOME COMMENT WITH LIMIT 555"
|
||||
parsed = sql_parse.ParsedQuery(sql)
|
||||
newsql = parsed.get_query_with_new_limit(1000)
|
||||
self.assertEquals(newsql, sql + '\nLIMIT 1000')
|
||||
self.assertEquals(newsql, sql + "\nLIMIT 1000")
|
||||
|
||||
def test_get_query_with_new_limit(self):
|
||||
sql = 'SELECT * FROM ab_user LIMIT 555'
|
||||
sql = "SELECT * FROM ab_user LIMIT 555"
|
||||
parsed = sql_parse.ParsedQuery(sql)
|
||||
newsql = parsed.get_query_with_new_limit(1000)
|
||||
expected = 'SELECT * FROM ab_user LIMIT 1000'
|
||||
expected = "SELECT * FROM ab_user LIMIT 1000"
|
||||
self.assertEquals(newsql, expected)
|
||||
|
||||
def test_basic_breakdown_statements(self):
|
||||
@@ -493,10 +475,7 @@ class SupersetTestCase(unittest.TestCase):
|
||||
parsed = sql_parse.ParsedQuery(multi_sql)
|
||||
statements = parsed.get_statements()
|
||||
self.assertEquals(len(statements), 2)
|
||||
expected = [
|
||||
'SELECT * FROM ab_user',
|
||||
'SELECT * FROM ab_user LIMIT 1',
|
||||
]
|
||||
expected = ["SELECT * FROM ab_user", "SELECT * FROM ab_user LIMIT 1"]
|
||||
self.assertEquals(statements, expected)
|
||||
|
||||
def test_messy_breakdown_statements(self):
|
||||
@@ -510,10 +489,10 @@ class SupersetTestCase(unittest.TestCase):
|
||||
statements = parsed.get_statements()
|
||||
self.assertEquals(len(statements), 4)
|
||||
expected = [
|
||||
'SELECT 1',
|
||||
'SELECT 2',
|
||||
'SELECT * FROM ab_user',
|
||||
'SELECT * FROM ab_user LIMIT 1',
|
||||
"SELECT 1",
|
||||
"SELECT 2",
|
||||
"SELECT * FROM ab_user",
|
||||
"SELECT * FROM ab_user LIMIT 1",
|
||||
]
|
||||
self.assertEquals(statements, expected)
|
||||
|
||||
@@ -524,4 +503,4 @@ class SupersetTestCase(unittest.TestCase):
|
||||
match AS (SELECT * FROM f)
|
||||
SELECT * FROM match
|
||||
"""
|
||||
self.assertEquals({'foo'}, self.extract_tables(query))
|
||||
self.assertEquals({"foo"}, self.extract_tables(query))
|
||||
|
||||
Reference in New Issue
Block a user