diff --git a/.github/workflows/run-test.yaml b/.github/workflows/run-test.yaml index bbfbdfb..ce01a55 100644 --- a/.github/workflows/run-test.yaml +++ b/.github/workflows/run-test.yaml @@ -40,6 +40,7 @@ jobs: pip install pyparsing pip install sqlean.py - name: black + if: matrix.python-version != '3.9' run: | pip install black black --check pydynamodb diff --git a/pydynamodb/connection.py b/pydynamodb/connection.py index 39d6f02..1917468 100644 --- a/pydynamodb/connection.py +++ b/pydynamodb/connection.py @@ -10,7 +10,6 @@ from .error import NotSupportedError from .util import RetryConfig, retry_api_call - if TYPE_CHECKING: from botocore.client import BaseClient diff --git a/pydynamodb/sql/ddl_alter.py b/pydynamodb/sql/ddl_alter.py index 9bd11e0..30c890b 100644 --- a/pydynamodb/sql/ddl_alter.py +++ b/pydynamodb/sql/ddl_alter.py @@ -109,6 +109,7 @@ SSESpecification.KMSMasterKeyId $$$$$$$$ TableClass STANDARD_INFREQUENT_ACCESS """ + import logging from .ddl_sql import DdlBase from .common import KeyWords, Tokens diff --git a/pydynamodb/sql/ddl_drop.py b/pydynamodb/sql/ddl_drop.py index a8ed678..14fa275 100644 --- a/pydynamodb/sql/ddl_drop.py +++ b/pydynamodb/sql/ddl_drop.py @@ -11,6 +11,7 @@ DROP GLOBAL TABLE Issues ReplicationGroup (us-east-1, us-west-2) """ + import logging from .ddl_sql import DdlBase from .common import KeyWords, Tokens diff --git a/pydynamodb/sql/dml_delete.py b/pydynamodb/sql/dml_delete.py index 3d9e78f..69daad0 100644 --- a/pydynamodb/sql/dml_delete.py +++ b/pydynamodb/sql/dml_delete.py @@ -13,6 +13,7 @@ DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks' RETURNING ALL OLD * """ + import logging from .dml_sql import DmlBase from .common import KeyWords, Tokens diff --git a/pydynamodb/sql/dml_insert.py b/pydynamodb/sql/dml_insert.py index 1b4b73a..a436bf8 100644 --- a/pydynamodb/sql/dml_insert.py +++ b/pydynamodb/sql/dml_insert.py @@ -9,6 +9,7 @@ ------------------------ INSERT INTO "Music" value {'Artist' : 'Acme Band','SongTitle' : 'PartiQL Rocks'} """ + import logging from .dml_sql import DmlBase from .common import KeyWords, Tokens diff --git a/pydynamodb/sql/dml_select.py b/pydynamodb/sql/dml_select.py index 64db217..7cde005 100644 --- a/pydynamodb/sql/dml_select.py +++ b/pydynamodb/sql/dml_select.py @@ -31,6 +31,7 @@ ConsistentRead False ReturnConsumedCapacity NONE """ + import logging import re from abc import ABCMeta diff --git a/pydynamodb/sql/dml_sql.py b/pydynamodb/sql/dml_sql.py index 42fa662..a0e08f8 100644 --- a/pydynamodb/sql/dml_sql.py +++ b/pydynamodb/sql/dml_sql.py @@ -135,14 +135,14 @@ def __escape_column(self, token: Any) -> str: def __init__(self, statement: str) -> None: super().__init__(statement) - self._where_conditions = [] + self._parsed_where_conditions = [] self._limit = None self._consistent_read = False self._return_consumed_capacity = "NONE" @property def where_conditions(self) -> List[Optional[str]]: - return self._where_conditions + return self._parsed_where_conditions @property def limit(self) -> int: @@ -166,18 +166,18 @@ def transform(self) -> Dict[str, Any]: def _construct_where_conditions(self, where_conditions: List[Any]) -> str: for condition in where_conditions: if not isinstance(condition, ParseResults): - self._where_conditions.append(str(condition)) + self._parsed_where_conditions.append(str(condition)) else: function_ = condition.get("function", None) function_with_op_ = condition.get("function_with_op", None) if function_: flatted_func_params = ",".join(condition["function_params"]) - self._where_conditions.append( + self._parsed_where_conditions.append( "%s(%s)" % (function_, flatted_func_params) ) elif function_with_op_: flatted_func_params = ",".join(condition["function_params"]) - self._where_conditions.append( + self._parsed_where_conditions.append( "%s(%s) %s %s" % ( function_with_op_, @@ -191,7 +191,7 @@ def _construct_where_conditions(self, where_conditions: List[Any]) -> str: flatted_where = " ".join( str(c) for c in flatten_list(where_conditions_) ) - self._where_conditions.append(flatted_where) + self._parsed_where_conditions.append(flatted_where) return "WHERE %s" % " ".join(self.where_conditions) diff --git a/pydynamodb/sql/dml_update.py b/pydynamodb/sql/dml_update.py index dd06d68..1a981c8 100644 --- a/pydynamodb/sql/dml_update.py +++ b/pydynamodb/sql/dml_update.py @@ -20,6 +20,7 @@ REMOVE AwardDetail.Grammys[2] WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' """ + import logging from .dml_sql import DmlBase from .json_parser import jsonArray, jsonObject diff --git a/pydynamodb/sql/json_parser.py b/pydynamodb/sql/json_parser.py index f3fe040..7fa1f70 100644 --- a/pydynamodb/sql/json_parser.py +++ b/pydynamodb/sql/json_parser.py @@ -9,31 +9,6 @@ # members optional in array and object collections # # Updated 9 Aug 2016 - use more current pyparsing constructs/idioms -# -''' -json_bnf = """ -object - { members } - {} -members - string : value - members , string : value -array - [ elements ] - [] -elements - value - elements , value -value - string - number - object - array - true - false - null -""" -''' import pyparsing as pp from pyparsing import pyparsing_common as ppc @@ -61,11 +36,6 @@ def make_keyword(kwd_str, kwd_value): jsonValue = pp.Forward().set_name("jsonValue") jsonElements = pp.DelimitedList(jsonValue).set_name(None) -# jsonArray = pp.Group(LBRACK + pp.Optional(jsonElements, []) + RBRACK) -# jsonValue << ( -# jsonString | jsonNumber | pp.Group(jsonObject) | jsonArray | TRUE | FALSE | NULL -# ) -# memberDef = pp.Group(jsonString + COLON + jsonValue).set_name("jsonMember") jsonArray = pp.Group( LBRACK + pp.Optional(jsonElements) + RBRACK, aslist=RETURN_PYTHON_COLLECTIONS diff --git a/pydynamodb/sql/parser.py b/pydynamodb/sql/parser.py index 76db3bb..e7c9cc1 100644 --- a/pydynamodb/sql/parser.py +++ b/pydynamodb/sql/parser.py @@ -12,7 +12,7 @@ from .dml_update import DmlUpdate from .dml_delete import DmlDelete from .util_sql import UtilListTables, UtilDescTable -from typing import Any, Dict, Tuple +from typing import Any, Dict, Tuple, Type, Optional _logger = logging.getLogger(__name__) # type: ignore @@ -71,8 +71,8 @@ def parser(self) -> Base: return self._parser - def _get_parse_class(self) -> Base: - _parse_class = None + def _get_parse_class(self) -> Optional[Type[Base]]: + _parse_class: Optional[Type[Base]] = None if ( self.query_type == QueryType.CREATE or self.query_type == QueryType.CREATE_GLOBAL diff --git a/pydynamodb/superset_dynamodb/helper.py b/pydynamodb/superset_dynamodb/helper.py index 4ccb918..98b9ebe 100644 --- a/pydynamodb/superset_dynamodb/helper.py +++ b/pydynamodb/superset_dynamodb/helper.py @@ -101,7 +101,7 @@ def get_config_value(config_name: str, **kwargs) -> Optional[Union[str, int]]: return kwargs[config_name] else: if config_name in SUPPORTED_QUERYDB_CONFIG: - (env_name, default_val) = SUPPORTED_QUERYDB_CONFIG[config_name] + env_name, default_val = SUPPORTED_QUERYDB_CONFIG[config_name] env_val = os.getenv(env_name, None) if env_val is None: return default_val diff --git a/pydynamodb/superset_dynamodb/pydynamodb.py b/pydynamodb/superset_dynamodb/pydynamodb.py index 3e86e83..67f25e5 100644 --- a/pydynamodb/superset_dynamodb/pydynamodb.py +++ b/pydynamodb/superset_dynamodb/pydynamodb.py @@ -92,7 +92,7 @@ def execute(self, **kwargs) -> None: cursor.execute_statement(self._statement) self._load_into_query_db(cursor.result_set) - (desc_, results_) = self._query_db.query() + desc_, results_ = self._query_db.query() self._rows.extend(results_) for d in desc_: self._metadata.update( diff --git a/pydynamodb/superset_dynamodb/querydb.py b/pydynamodb/superset_dynamodb/querydb.py index 497809c..3787f1e 100644 --- a/pydynamodb/superset_dynamodb/querydb.py +++ b/pydynamodb/superset_dynamodb/querydb.py @@ -260,8 +260,7 @@ def add_cache(self) -> None: """INSERT INTO %s (query_id, statement, created, last_updated, queried_times ) VALUES (?, ?, ?, ?, ?) - """ - % QueryDB.CACHE_TABLE, + """ % QueryDB.CACHE_TABLE, ( self.query_id, str(self.statement.api_request), diff --git a/tests/test_connection.py b/tests/test_connection.py index d5b73b0..0313159 100644 --- a/tests/test_connection.py +++ b/tests/test_connection.py @@ -8,14 +8,11 @@ class TestConnection: def test_transaction_both_read_write(self, conn): try: - sql_trans_1_ = ( - """ + sql_trans_1_ = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_str': ?, 'col_num': ? } - """ - % TESTCASE01_TABLE - ) + """ % TESTCASE01_TABLE conn.begin() with conn.cursor() as cursor: @@ -33,8 +30,7 @@ def test_transaction_both_read_write(self, conn): cursor.execute( """ SELECT * FROM %s WHERE key_partition = ? - """ - % TESTCASE01_TABLE, + """ % TESTCASE01_TABLE, ["test_trans_1"], ) @@ -46,14 +42,11 @@ def test_transaction_both_read_write(self, conn): assert len(self._query_data(cursor, "test_trans_1")) == 0 def test_transaction_one_row(self, conn): - sql_trans_2_ = ( - """ + sql_trans_2_ = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_str': ?, 'col_num': ? } - """ - % TESTCASE01_TABLE - ) + """ % TESTCASE01_TABLE conn.begin() cursor = conn.cursor() @@ -63,14 +56,11 @@ def test_transaction_one_row(self, conn): assert len(self._query_data(cursor, "test_trans_2")) == 1 def test_transaction_many_row(self, conn): - sql_trans_3_ = ( - """ + sql_trans_3_ = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_str': ?, 'col_num': ? } - """ - % TESTCASE01_TABLE - ) + """ % TESTCASE01_TABLE conn.begin() cursor = conn.cursor() @@ -89,14 +79,11 @@ def test_transaction_many_row(self, conn): assert len(self._query_data(cursor, "test_trans_3")) == 5 def test_transaction_mixed_no_trans(self, conn): - sql_trans_4_ = ( - """ + sql_trans_4_ = """ INSERT INTO "%s" VALUE { 'key_partition': ?, 'key_sort': ?, 'col_str': ?, 'col_num': ? } - """ - % TESTCASE01_TABLE - ) + """ % TESTCASE01_TABLE cursor = conn.cursor() cursor.execute(sql_trans_4_, ["test_trans_4", 0, "test case 4-0", 0]) @@ -138,14 +125,11 @@ def test_transaction_mixed_no_trans(self, conn): def test_batch_write_1(self, conn): cursor = conn.cursor() - sql_batch_1_ = ( - """ + sql_batch_1_ = """ INSERT INTO "%s" VALUE { 'key_partition': ?, 'key_sort': ?, 'col_str': ?, 'col_num': ? } - """ - % TESTCASE01_TABLE - ) + """ % TESTCASE01_TABLE conn.autocommit = False cursor.execute(sql_batch_1_, ["test_batch_1", 0, "test case 5-0", 0]) cursor.execute(sql_batch_1_, ["test_batch_1", 1, "test case 5-1", 1]) @@ -174,8 +158,7 @@ def _query_data(self, cursor, test_case): cursor.execute( """ SELECT * FROM %s WHERE key_partition = ? - """ - % TESTCASE01_TABLE, + """ % TESTCASE01_TABLE, [test_case], ) return cursor.fetchall() diff --git a/tests/test_cursor_dml.py b/tests/test_cursor_dml.py index 1f7a5b0..9c518b5 100644 --- a/tests/test_cursor_dml.py +++ b/tests/test_cursor_dml.py @@ -2,32 +2,25 @@ from pydynamodb import cursor - TESTCASE01_TABLE = "pydynamodb_test_case01" USER_TABLE = "user" class TestCursorDML: def test_writeone(self, cursor): - sql_one_row_1_0_ = ( - """ + sql_one_row_1_0_ = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_str': ?, 'col_num': ?, 'col_byte': ? } - """ - % TESTCASE01_TABLE - ) + """ % TESTCASE01_TABLE params_1_0_ = ["test_one_row_1", 0, "test case 0", 0, b"0"] cursor.execute(sql_one_row_1_0_, params_1_0_) - sql_one_row_1_1_ = ( - """ + sql_one_row_1_1_ = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_str': ?, 'col_num': ?, 'col_map': ? } - """ - % TESTCASE01_TABLE - ) + """ % TESTCASE01_TABLE params_1_1_ = [ "test_one_row_1", 1, @@ -37,14 +30,11 @@ def test_writeone(self, cursor): ] cursor.execute(sql_one_row_1_1_, params_1_1_) - sql_one_row_1_2_ = ( - """ + sql_one_row_1_2_ = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_str': ?, 'col_ss': ?, 'col_ns': ?, 'col_bs': ?, 'col_list': ? } - """ - % TESTCASE01_TABLE - ) + """ % TESTCASE01_TABLE params_1_2_ = [ "test_one_row_1", 2, @@ -56,14 +46,11 @@ def test_writeone(self, cursor): ] cursor.execute(sql_one_row_1_2_, params_1_2_) - sql_one_row_2_1_ = ( - """ + sql_one_row_2_1_ = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_nested_list': ?, 'col_nested_map': ? } - """ - % TESTCASE01_TABLE - ) + """ % TESTCASE01_TABLE params_2_1_ = [ "test_one_row_2", 1, @@ -86,8 +73,7 @@ def test_writeone(self, cursor): cursor.execute(sql_one_row_2_1_, params_2_1_) def test_writemany(self, cursor): - sql_many_rows_ = ( - """ + sql_many_rows_ = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, @@ -95,9 +81,7 @@ def test_writemany(self, cursor): 'col_num': ?, 'col_byte': ? } - """ - % TESTCASE01_TABLE - ) + """ % TESTCASE01_TABLE params_ = [ ["test_many_rows_1", 0, "test case many 0", "0", b"0"], ["test_many_rows_1", 1, "test case many 1", "1", b"1"], @@ -118,8 +102,7 @@ def test_fetchone(self, cursor): SELECT col_str, col_num, col_byte FROM %s WHERE key_partition = ? AND key_sort = ? - """ - % TESTCASE01_TABLE, + """ % TESTCASE01_TABLE, ["test_one_row_1", 0], ) assert len(cursor.description) == 3 @@ -132,8 +115,7 @@ def test_fetchone(self, cursor): """ SELECT * FROM %s WHERE key_partition = ? - """ - % TESTCASE01_TABLE, + """ % TESTCASE01_TABLE, ["test_one_row_1"], ) assert cursor.rownumber == 0 @@ -164,8 +146,7 @@ def test_fetchone(self, cursor): SELECT col_nested_list, col_nested_map FROM %s WHERE key_partition = ? AND key_sort = ? - """ - % TESTCASE01_TABLE, + """ % TESTCASE01_TABLE, ["test_one_row_2", 1], ) row = cursor.fetchone() @@ -191,8 +172,7 @@ def test_fetchmany(self, cursor): """ SELECT * FROM %s WHERE key_partition = ? - """ - % TESTCASE01_TABLE, + """ % TESTCASE01_TABLE, ["test_many_rows_1"], ) assert cursor.rownumber == 0 @@ -209,8 +189,7 @@ def test_fetchall(self, cursor): """ SELECT * FROM %s WHERE key_partition = ? - """ - % TESTCASE01_TABLE, + """ % TESTCASE01_TABLE, ["test_many_rows_1"], ) assert cursor.rownumber == 0 @@ -220,14 +199,11 @@ def test_fetchall(self, cursor): def test_unicode(self, cursor): unicode_str = "测试" - sql_unicode_row_1_0_ = ( - """ + sql_unicode_row_1_0_ = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_str': ?, 'col_num': ?, 'col_byte': ? } - """ - % TESTCASE01_TABLE - ) + """ % TESTCASE01_TABLE params_1_0_ = ["test_unicode_row_1", 0, "测试案例 0", 0, unicode_str.encode()] cursor.execute(sql_unicode_row_1_0_, params_1_0_) @@ -235,8 +211,7 @@ def test_unicode(self, cursor): """ SELECT * FROM %s WHERE key_partition = ? AND key_sort = ? - """ - % TESTCASE01_TABLE, + """ % TESTCASE01_TABLE, ["test_unicode_row_1", 0], ) rows = cursor.fetchall() @@ -245,16 +220,13 @@ def test_unicode(self, cursor): assert self._get_value_by_column_name(desc, rows[0], "col_str") == "测试案例 0" def test_update(self, cursor): - sql_update_row_1_0_ = ( - """ + sql_update_row_1_0_ = """ UPDATE %s SET col_str=? SET col_num=? WHERE key_partition=? AND key_sort=? RETURNING ALL OLD * - """ - % TESTCASE01_TABLE - ) + """ % TESTCASE01_TABLE params_1_0_ = ["test case update 0", 10, "test_one_row_1", 0] cursor.execute(sql_update_row_1_0_, params_1_0_) rows = cursor.fetchall() @@ -267,8 +239,7 @@ def test_update(self, cursor): """ SELECT col_str, col_num FROM %s WHERE key_partition = ? AND key_sort = ? - """ - % TESTCASE01_TABLE, + """ % TESTCASE01_TABLE, ["test_one_row_1", 0], ) rows = cursor.fetchall() @@ -281,26 +252,20 @@ def test_update(self, cursor): assert self._get_value_by_column_name(desc, rows[0], "col_num") == 10 def test_delete(self, cursor): - sql_delete_row_1_0_ = ( - """ + sql_delete_row_1_0_ = """ DELETE FROM %s WHERE key_partition = ? AND key_sort = ? RETURNING ALL OLD * - """ - % TESTCASE01_TABLE - ) + """ % TESTCASE01_TABLE params_1_0_ = ["test_one_row_1", 0] cursor.execute(sql_delete_row_1_0_, params_1_0_) rows = cursor.fetchall() assert len(rows) == 1 - sql_delete_row_1_0_ = ( - """ + sql_delete_row_1_0_ = """ DELETE FROM %s WHERE key_partition = ? AND key_sort = ? - """ - % TESTCASE01_TABLE - ) + """ % TESTCASE01_TABLE params_1_0_ = ["test_one_row_1", 0] cursor.execute(sql_delete_row_1_0_, params_1_0_) rows = cursor.fetchall() @@ -312,8 +277,7 @@ def test_limit_sql(self, cursor): SELECT * FROM %s WHERE key_partition = ? LIMIT 2 - """ - % TESTCASE01_TABLE, + """ % TESTCASE01_TABLE, ["test_many_rows_1"], ) assert len(cursor.fetchall()) == 2 @@ -321,14 +285,11 @@ def test_limit_sql(self, cursor): def test_insert_datetime(self, cursor): from datetime import date, datetime - sql_date_row_1_0_ = ( - """ + sql_date_row_1_0_ = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_date': ?, 'col_datetime': ? } - """ - % TESTCASE01_TABLE - ) + """ % TESTCASE01_TABLE params_1_0_ = [ "test_date_row_1", 0, @@ -340,8 +301,7 @@ def test_insert_datetime(self, cursor): """ SELECT col_date, col_datetime FROM %s WHERE key_partition = ? AND key_sort = ? - """ - % TESTCASE01_TABLE, + """ % TESTCASE01_TABLE, ["test_date_row_1", 0], ) assert cursor.fetchone() == ("2022-10-18", "2022-10-18T13:55:34") @@ -376,14 +336,11 @@ def test_get_table_metadata(self, cursor): assert metadata_["AttributeDefinitions"][1]["AttributeType"] == "N" def test_reserved_words(self, cursor): - sql_reserved_words_1 = ( - """ + sql_reserved_words_1 = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'username': ?, 'password': ?, 'default': ?, 'comment': ? } - """ - % USER_TABLE - ) + """ % USER_TABLE params_1_ = [ "test_user_row_1", 0, @@ -398,23 +355,19 @@ def test_reserved_words(self, cursor): """ SELECT username, password, "default", "comment" FROM %s WHERE key_partition=? AND key_sort=? - """ - % USER_TABLE, + """ % USER_TABLE, ["test_user_row_1", 0], ) assert cursor.fetchone() == ("admin", "admin", 1, "") - sql_reserved_words_2 = ( - """ + sql_reserved_words_2 = """ UPDATE %s SET username=? SET password=? SET "default"=? WHERE key_partition=? AND key_sort=? RETURNING ALL OLD * - """ - % USER_TABLE - ) + """ % USER_TABLE params_2_ = [ "admin1", "admin1", @@ -428,22 +381,18 @@ def test_reserved_words(self, cursor): """ SELECT username, password, "default" FROM %s WHERE key_partition=? AND key_sort=? - """ - % USER_TABLE, + """ % USER_TABLE, ["test_user_row_1", 0], ) assert cursor.fetchone() == ("admin1", "admin1", 0) - sql_reserved_words_3 = ( - """ + sql_reserved_words_3 = """ DELETE FROM %s WHERE key_partition=? AND key_sort=? RETURNING ALL OLD * - """ - % USER_TABLE - ) + """ % USER_TABLE params_3_ = [ "test_user_row_1", 0, ] - cursor.execute(sql_reserved_words_3, params_3_) \ No newline at end of file + cursor.execute(sql_reserved_words_3, params_3_) diff --git a/tests/test_cursor_dml_dict_rs.py b/tests/test_cursor_dml_dict_rs.py index 79075c2..bfe0c3d 100644 --- a/tests/test_cursor_dml_dict_rs.py +++ b/tests/test_cursor_dml_dict_rs.py @@ -5,14 +5,11 @@ class TestCursorDMLDictRs: def test_writeone(self, dict_cursor): - sql = ( - """ + sql = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_str': ?, 'col_ss': ?, 'col_ns': ?, 'col_bs': ?, 'col_list': ? } - """ - % TESTCASE05_TABLE - ) + """ % TESTCASE05_TABLE params = [ "row_1", 0, @@ -24,14 +21,11 @@ def test_writeone(self, dict_cursor): ] dict_cursor.execute(sql, params) - sql = ( - """ + sql = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_nested_list': ?, 'col_nested_map': ? } - """ - % TESTCASE05_TABLE - ) + """ % TESTCASE05_TABLE params = [ "row_1", 1, @@ -60,11 +54,11 @@ def test_select(self, dict_cursor): ret = dict_cursor.fetchall() assert len(ret) == 2 assert ret[1]["col_nested_map"] == { - "name": "test case 3", - "version": 1.0, - "list": ["Hello", "World", {1, 2, 3}, {"1", "2"}, 2], - "map": {"str": "Best", "num": 1, "chinese": "你好"}, - } + "name": "test case 3", + "version": 1.0, + "list": ["Hello", "World", {1, 2, 3}, {"1", "2"}, 2], + "map": {"str": "Best", "num": 1, "chinese": "你好"}, + } dict_cursor.execute( "SELECT col_ss, col_nested_list[4] FROM %s WHERE key_partition='row_1'" @@ -93,4 +87,4 @@ def test_select_with_function(self, dict_cursor): ret = dict_cursor.fetchall() assert len(ret) == 2 assert ret[0] == {"str": "test"} - assert ret[1] == {"name": "TEST CASE 3"} \ No newline at end of file + assert ret[1] == {"name": "TEST CASE 3"} diff --git a/tests/test_cursor_dml_select.py b/tests/test_cursor_dml_select.py index 1097057..6a394f4 100644 --- a/tests/test_cursor_dml_select.py +++ b/tests/test_cursor_dml_select.py @@ -5,14 +5,11 @@ class TestCursorDMLSelect: def test_insert_nested_data(self, cursor): - sql = ( - """ + sql = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_str': ?, 'col_list': ?, 'col_map': ? } - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE params_1 = [ "row_1", 1, @@ -36,27 +33,21 @@ def test_insert_nested_data(self, cursor): ] cursor.executemany(sql, [params_1, params_2, params_3]) - sql = ( - """ + sql = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_str': ?, 'col_obj': ? } - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE params_4 = ["row_2", 1, "Diagnostics can be enabled", {"A": "B"}] params_5 = ["row_2", 2, ["A", "B"], None] params_6 = ["row_2", 3, "Start the application that you downloaded", ["1", "2"]] cursor.executemany(sql, [params_4, params_5, params_6]) - sql = ( - """ + sql = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'size': ?, 'col_map': ? } - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE params_7 = [ "row_3", 0, @@ -79,41 +70,29 @@ def test_select_simple_columns(self, cursor): ret = cursor.fetchall() assert len(ret) == 3 - cursor.execute( - """ + cursor.execute(""" SELECT col_list FROM %s WHERE key_partition='row_1' - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE) ret = cursor.fetchall() assert len(ret) == 3 - cursor.execute( - """ + cursor.execute(""" SELECT col_list FROM %s WHERE key_partition='row_1' AND key_sort=1 - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE) ret = cursor.fetchall() assert len(ret) == 1 def test_select_nested_columns(self, cursor): - cursor.execute( - """ + cursor.execute(""" SELECT col_list[0] FROM %s WHERE key_partition='row_1' - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE) ret = cursor.fetchall() assert len(ret) == 3 assert ret == [("A",), ("C",), ("E",)] - cursor.execute( - """ + cursor.execute(""" SELECT col_list[1], col_map.A FROM %s WHERE key_partition='row_1' - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE) ret = cursor.fetchall() assert len(ret) == 3 assert [d[0] for d in cursor.description] == ["col_list[1]", "A"] @@ -121,31 +100,22 @@ def test_select_nested_columns(self, cursor): def test_reserved_word(self, cursor): try: - cursor.execute( - """ + cursor.execute(""" SELECT size FROM %s WHERE key_partition='row_3' - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE) except Exception as e: assert "Statement wasn't well formed" in str(e) - cursor.execute( - """ + cursor.execute(""" SELECT "size" FROM %s WHERE key_partition='row_3' - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE) ret = cursor.fetchall() assert len(ret) == 2 assert ret == [([100, 300, 500],), ([500, 800, 1000, 1500],)] - cursor.execute( - """ + cursor.execute(""" SELECT "size"[0] FROM %s WHERE key_partition='row_3' - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE) ret = cursor.fetchall() assert len(ret) == 2 assert cursor.description == [ @@ -153,12 +123,9 @@ def test_reserved_word(self, cursor): ] assert ret == [(100,), (500,)] - cursor.execute( - """ + cursor.execute(""" SELECT col_map."all", col_map."ALL" FROM %s WHERE key_partition='row_3' - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE) ret = cursor.fetchall() assert len(ret) == 2 assert cursor.description == [ @@ -167,12 +134,9 @@ def test_reserved_word(self, cursor): ] assert ret == [("true", None), (None, "false")] - cursor.execute( - """ + cursor.execute(""" SELECT col_map."max"[1] FROM %s WHERE key_partition='row_3' and key_sort=1 - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE) ret = cursor.fetchall() assert len(ret) == 1 assert cursor.description == [ @@ -183,14 +147,11 @@ def test_reserved_word(self, cursor): def test_function_in_columns(self, cursor): from datetime import date, datetime - sql_date_row_1_0_ = ( - """ + sql_date_row_1_0_ = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_date': ?, 'col_datetime': ?, 'col_str': ? } - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE params_1_0_ = [ "test_date_row_1", 0, @@ -210,9 +171,7 @@ def test_function_in_columns(self, cursor): """ SELECT DATE(col_date, '%Y-%m-%d'), DATETIME(col_datetime), SUBSTR(col_str, 2, 3) FROM {0} WHERE key_partition = ? AND key_sort = ? - """.format( - TESTCASE03_TABLE - ), + """.format(TESTCASE03_TABLE), ["test_date_row_1", 0], ) assert cursor.fetchone() == ( @@ -225,20 +184,15 @@ def test_function_in_columns(self, cursor): """ SELECT REPLACE(col_str, 'd', 'XX') FROM {0} WHERE key_partition = ? AND key_sort = ? - """.format( - TESTCASE03_TABLE - ), + """.format(TESTCASE03_TABLE), ["test_date_row_1", 0], ) assert cursor.fetchone() == ("abcXXEFG01234",) def test_alias_in_columns(self, cursor): - cursor.execute( - """ + cursor.execute(""" SELECT col_list[1] list, col_map.A map-a FROM %s WHERE key_partition='row_1' - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE) ret = cursor.fetchall() assert len(ret) == 3 assert [d[0] for d in cursor.description] == ["list", "map-a"] @@ -248,42 +202,31 @@ def test_alias_in_columns(self, cursor): SELECT DATE(col_date, '%Y-%m-%d') col1, DATETIME(col_datetime) col2 FROM {0} WHERE key_partition = ? AND key_sort = ? - """.format( - TESTCASE03_TABLE - ), + """.format(TESTCASE03_TABLE), ["test_date_row_1", 0], ) assert [d[0] for d in cursor.description] == ["col1", "col2"] def test_partiql_functions(self, cursor): - cursor.execute( - """ + cursor.execute(""" SELECT key_partition, key_sort, col_str FROM %s WHERE key_partition='row_1' and contains("col_str", 'BLOB') - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE) ret = cursor.fetchall() assert len(ret) == 1 assert ret[0][1] == 3 - cursor.execute( - """ + cursor.execute(""" SELECT key_partition, key_sort, col_str FROM %s WHERE key_partition='row_1' and begins_with("col_str", 'Online') - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE) ret = cursor.fetchall() assert len(ret) == 1 assert ret[0][1] == 2 - cursor.execute( - """ + cursor.execute(""" SELECT key_partition, key_sort, col_str FROM %s WHERE key_partition='row_2' and attribute_type("col_str", 'S') - """ - % TESTCASE03_TABLE - ) + """ % TESTCASE03_TABLE) ret = cursor.fetchall() assert len(ret) == 2 diff --git a/tests/test_dml_delete.py b/tests/test_dml_delete.py index 0873cc8..b619aa4 100644 --- a/tests/test_dml_delete.py +++ b/tests/test_dml_delete.py @@ -6,16 +6,19 @@ class TestDmlDelete: def test_parse_simple_case_1(self): sql = "DELETE FROM \"Music\" WHERE Artist='Acme Band'" ret = SQLParser(sql).transform() - assert ret == {"Statement": 'DELETE FROM "Music" WHERE Artist = \'Acme Band\''} + assert ret == {"Statement": "DELETE FROM \"Music\" WHERE Artist = 'Acme Band'"} sql = "DELETE FROM \"Music\" WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ret = SQLParser(sql).transform() - assert ret == {"Statement": 'DELETE FROM "Music" WHERE Artist = \'Acme Band\' AND SongTitle = \'PartiQL Rocks\''} + assert ret == { + "Statement": "DELETE FROM \"Music\" WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks'" + } sql = "delete from user where name='John Doe' and age=30" ret = SQLParser(sql).transform() - assert ret == {"Statement": "DELETE FROM \"user\" WHERE \"name\" = 'John Doe' AND age = 30"} - + assert ret == { + "Statement": 'DELETE FROM "user" WHERE "name" = \'John Doe\' AND age = 30' + } def test_parse_simple_case_2(self): sql = """ @@ -24,7 +27,9 @@ def test_parse_simple_case_2(self): AND "SongTitle" = 'PartiQL Rocks' """ ret = SQLParser(sql).transform() - assert ret == {"Statement": 'DELETE FROM "Music" WHERE "Artist" = \'Acme Band\' AND "SongTitle" = \'PartiQL Rocks\''} + assert ret == { + "Statement": 'DELETE FROM "Music" WHERE "Artist" = \'Acme Band\' AND "SongTitle" = \'PartiQL Rocks\'' + } sql = """ DELETE FROM Music @@ -33,7 +38,9 @@ def test_parse_simple_case_2(self): RETURNING ALL OLD * """ ret = SQLParser(sql).transform() - assert ret == {"Statement": "DELETE FROM \"Music\" WHERE \"Artist\" = \'Acme Band\' AND \"SongTitle\" = \'PartiQL Rocks\' RETURNING ALL OLD *"} + assert ret == { + "Statement": 'DELETE FROM "Music" WHERE "Artist" = \'Acme Band\' AND "SongTitle" = \'PartiQL Rocks\' RETURNING ALL OLD *' + } sql = """ DELETE FROM Music @@ -42,4 +49,6 @@ def test_parse_simple_case_2(self): RETURNING anything """ ret = SQLParser(sql).transform() - assert ret == {"Statement": "DELETE FROM \"Music\" WHERE \"Artist\" = \'Acme Band\' AND \"SongTitle\" = \'PartiQL Rocks\' RETURNING anything"} + assert ret == { + "Statement": 'DELETE FROM "Music" WHERE "Artist" = \'Acme Band\' AND "SongTitle" = \'PartiQL Rocks\' RETURNING anything' + } diff --git a/tests/test_dml_insert.py b/tests/test_dml_insert.py index b119db3..7348eaa 100644 --- a/tests/test_dml_insert.py +++ b/tests/test_dml_insert.py @@ -6,20 +6,23 @@ class TestDmlInsert: def test_parse_simple_case_1(self): sql = "INSERT INTO \"Music\" VALUE {'Artist' : 'Acme Band','SongTitle' : 'PartiQL Rocks'}" ret = SQLParser(sql).transform() - assert ret == {"Statement": 'INSERT INTO "Music" VALUE {\'Artist\' : \'Acme Band\',\'SongTitle\' : \'PartiQL Rocks\'}'} + assert ret == { + "Statement": "INSERT INTO \"Music\" VALUE {'Artist' : 'Acme Band','SongTitle' : 'PartiQL Rocks'}" + } sql = "insert into user value {'name': 'John Doe', 'age': 30}" ret = SQLParser(sql).transform() - assert ret == {"Statement": "INSERT INTO \"user\" VALUE {'name': 'John Doe', 'age': 30}"} + assert ret == { + "Statement": "INSERT INTO \"user\" VALUE {'name': 'John Doe', 'age': 30}" + } - sql = "insert into \"Music\" value {}" + sql = 'insert into "Music" value {}' ret = SQLParser(sql).transform() - assert ret == {"Statement": "INSERT INTO \"Music\" VALUE {}"} + assert ret == {"Statement": 'INSERT INTO "Music" VALUE {}'} - sql = "insert into \"Music\" value {values}" + sql = 'insert into "Music" value {values}' ret = SQLParser(sql).transform() - assert ret == {"Statement": "INSERT INTO \"Music\" VALUE {values}"} - + assert ret == {"Statement": 'INSERT INTO "Music" VALUE {values}'} def test_parse_simple_case_2(self): sql = """ @@ -27,12 +30,15 @@ def test_parse_simple_case_2(self): VALUE {'Artist' : 'Acme Band','SongTitle' : 'PartiQL Rocks'} """ ret = SQLParser(sql).transform() - assert ret == {"Statement": 'INSERT INTO "Music" VALUE {\'Artist\' : \'Acme Band\',\'SongTitle\' : \'PartiQL Rocks\'}'} + assert ret == { + "Statement": "INSERT INTO \"Music\" VALUE {'Artist' : 'Acme Band','SongTitle' : 'PartiQL Rocks'}" + } sql = """ INSERT INTO Music VALUE {'Artist' : ['1', '2'],'SongTitle' : {'key': '1', 'key2': '2'}} """ ret = SQLParser(sql).transform() - assert ret == {"Statement": "INSERT INTO \"Music\" VALUE {'Artist' : ['1', '2'],'SongTitle' : {'key': '1', 'key2': '2'}"} - + assert ret == { + "Statement": "INSERT INTO \"Music\" VALUE {'Artist' : ['1', '2'],'SongTitle' : {'key': '1', 'key2': '2'}" + } diff --git a/tests/test_dml_select.py b/tests/test_dml_select.py index 28ea765..8263b4e 100644 --- a/tests/test_dml_select.py +++ b/tests/test_dml_select.py @@ -192,8 +192,8 @@ def test_parse_completed_case(self): + "AND Title = 'some title' " + "AND Content[0] >= 100 " + "AND Content.DateWatched[0] <= '12/12/19' " - + "AND \"Total\" IN [500,600] " - + "OR \"Total\" BETWEEN 500 AND 600 " + + 'AND "Total" IN [500,600] ' + + 'OR "Total" BETWEEN 500 AND 600 ' + "AND Author IS NOT NULL " + "ORDER BY IssueId DESC", "ConsistentRead": False, @@ -351,4 +351,6 @@ def test_parse_dot_in_table_name(self): SELECT att1, att2 FROM "This.Pub.Issues"."Index.CreateDateIndex" """ ret = SQLParser(sql).transform() - assert ret == {"Statement": 'SELECT att1,att2 FROM "This.Pub.Issues"."Index.CreateDateIndex"'} \ No newline at end of file + assert ret == { + "Statement": 'SELECT att1,att2 FROM "This.Pub.Issues"."Index.CreateDateIndex"' + } diff --git a/tests/test_dml_update.py b/tests/test_dml_update.py index da22af4..5fa9c8a 100644 --- a/tests/test_dml_update.py +++ b/tests/test_dml_update.py @@ -6,24 +6,33 @@ class TestDmlUpdate: def test_parse_simple_case_1(self): sql = "UPDATE \"Music\" SET AwardsWon=1 WHERE Artist='Acme Band'" ret = SQLParser(sql).transform() - assert ret == {"Statement": 'UPDATE "Music" SET AwardsWon = 1 WHERE Artist = \'Acme Band\''} + assert ret == { + "Statement": "UPDATE \"Music\" SET AwardsWon = 1 WHERE Artist = 'Acme Band'" + } sql = "UPDATE Music SET AwardsWon=1 SET age=30 WHERE Artist='Acme Band'" ret = SQLParser(sql).transform() - assert ret == {"Statement": 'UPDATE "Music" SET AwardsWon = 1 SET age = 30 WHERE Artist = \'Acme Band\''} + assert ret == { + "Statement": "UPDATE \"Music\" SET AwardsWon = 1 SET age = 30 WHERE Artist = 'Acme Band'" + } sql = "update user set name='John Doe' set age=30 remove default=1 WHERE anystring = s OR anint = 1000" ret = SQLParser(sql).transform() - assert ret == {"Statement": 'UPDATE "user" SET "name" = \'John Doe\' SET age = 30 REMOVE "default" = 1 WHERE anystring = s OR anint = 1000'} + assert ret == { + "Statement": 'UPDATE "user" SET "name" = \'John Doe\' SET age = 30 REMOVE "default" = 1 WHERE anystring = s OR anint = 1000' + } sql = "UPDATE \"Music\" SET AwardDetail={'Grammys':[2020, 2018]} WHERE Artist = 'Acme Band'" ret = SQLParser(sql).transform() - assert ret == {"Statement": 'UPDATE "Music" SET AwardDetail = {\'Grammys\': [2020, 2018]} WHERE Artist = \'Acme Band\''} + assert ret == { + "Statement": "UPDATE \"Music\" SET AwardDetail = {'Grammys': [2020, 2018]} WHERE Artist = 'Acme Band'" + } sql = "UPDATE \"Music\" SET AwardsWon=1 SET AwardDetail = {'Grammys':[2020, 2018]} WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks'" ret = SQLParser(sql).transform() - assert ret == {"Statement": 'UPDATE "Music" SET AwardsWon = 1 SET AwardDetail = {\'Grammys\': [2020, 2018]} WHERE Artist = \'Acme Band\' AND SongTitle = \'PartiQL Rocks\''} - + assert ret == { + "Statement": "UPDATE \"Music\" SET AwardsWon = 1 SET AwardDetail = {'Grammys': [2020, 2018]} WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks'" + } def test_parse_simple_case_2(self): sql = """ @@ -33,7 +42,9 @@ def test_parse_simple_case_2(self): WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' """ ret = SQLParser(sql).transform() - assert ret == {"Statement": 'UPDATE "Music" SET AwardsWon = 1 SET AwardDetail = {\'Grammys\': [2020, 2018]} WHERE Artist = \'Acme Band\' AND SongTitle = \'PartiQL Rocks\''} + assert ret == { + "Statement": "UPDATE \"Music\" SET AwardsWon = 1 SET AwardDetail = {'Grammys': [2020, 2018]} WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks'" + } sql = """ UPDATE "Music" @@ -43,7 +54,9 @@ def test_parse_simple_case_2(self): RETURNING ALL OLD * """ ret = SQLParser(sql).transform() - assert ret == {"Statement": "UPDATE \"Music\" SET AwardsWon = 1 SET AwardDetail = {\'Grammys\': [2020, 2018]} WHERE Artist = \'Acme Band\' AND SongTitle = \'PartiQL Rocks\' RETURNING ALL OLD *"} + assert ret == { + "Statement": "UPDATE \"Music\" SET AwardsWon = 1 SET AwardDetail = {'Grammys': [2020, 2018]} WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks' RETURNING ALL OLD *" + } sql = """ UPDATE "Music" @@ -53,13 +66,19 @@ def test_parse_simple_case_2(self): RETURNING anything """ ret = SQLParser(sql).transform() - assert ret == {"Statement": "UPDATE \"Music\" SET AwardsWon = 1 SET AwardDetail = {\'Grammys\': [2020, 2018]} WHERE Artist = \'Acme Band\' AND SongTitle = \'PartiQL Rocks\' RETURNING anything"} + assert ret == { + "Statement": "UPDATE \"Music\" SET AwardsWon = 1 SET AwardDetail = {'Grammys': [2020, 2018]} WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks' RETURNING anything" + } def test_parse_simple_case_3(self): sql = "UPDATE \"Music\" SET AwardsWon=1 , default=1 WHERE Artist='Acme Band'" ret = SQLParser(sql).transform() - assert ret == {"Statement": "UPDATE \"Music\" SET AwardsWon = 1 , \"default\" = 1 WHERE Artist = \'Acme Band\'"} - - sql = "UPDATE \"Music\" SET AwardsWon=1, AwardDetail={\'Grammys\': [2020, 2018]}, default=1 WHERE Artist='Acme Band'" + assert ret == { + "Statement": 'UPDATE "Music" SET AwardsWon = 1 , "default" = 1 WHERE Artist = \'Acme Band\'' + } + + sql = "UPDATE \"Music\" SET AwardsWon=1, AwardDetail={'Grammys': [2020, 2018]}, default=1 WHERE Artist='Acme Band'" ret = SQLParser(sql).transform() - assert ret == {"Statement": "UPDATE \"Music\" SET AwardsWon = 1 , AwardDetail = {\'Grammys\': [2020, 2018]} , \"default\" = 1 WHERE Artist = \'Acme Band\'"} + assert ret == { + "Statement": "UPDATE \"Music\" SET AwardsWon = 1 , AwardDetail = {'Grammys': [2020, 2018]} , \"default\" = 1 WHERE Artist = 'Acme Band'" + } diff --git a/tests/test_sql_common.py b/tests/test_sql_common.py index ec83252..c1996a5 100644 --- a/tests/test_sql_common.py +++ b/tests/test_sql_common.py @@ -4,122 +4,72 @@ class TestSQLCommon: def test_get_query_type_create(self): - assert ( - get_query_type( - """ + assert get_query_type(""" CREATE TABLE Issues ( IssueId numeric PARTITION KEY, ) - """ - ) - == QueryType.CREATE - ) - assert ( - get_query_type( - """ + """) == QueryType.CREATE + assert get_query_type(""" create table issues ( issueid numeric partition key, ) - """ - ) - == QueryType.CREATE - ) + """) == QueryType.CREATE try: get_query_type("CREATE XXXXX") except LookupError as err: assert err is not None def test_get_query_type_alter(self): - assert ( - get_query_type( - """ + assert get_query_type(""" ALTER TABLE Issues ( IssueId numeric PARTITION KEY, ) - """ - ) - == QueryType.ALTER - ) - assert ( - get_query_type( - """ + """) == QueryType.ALTER + assert get_query_type(""" alter table issues ( issueid numeric partition key, )**** - """ - ) - == QueryType.ALTER - ) + """) == QueryType.ALTER try: get_query_type("ALTER XXXXX") except LookupError as err: assert err is not None def test_get_query_type_drop(self): - assert ( - get_query_type( - """ + assert get_query_type(""" DROP TABLE ISSUES - """ - ) - == QueryType.DROP - ) - assert ( - get_query_type( - """ + """) == QueryType.DROP + assert get_query_type(""" drop table issues - """ - ) - == QueryType.DROP - ) + """) == QueryType.DROP try: get_query_type("drop XXXXX") except LookupError as err: assert err is not None def test_get_query_type_list(self): - assert ( - get_query_type( - """ + assert get_query_type(""" LIST TABLES - """ - ) - == QueryType.LIST - ) - assert ( - get_query_type( - """ + """) == QueryType.LIST + assert get_query_type(""" show tables - """ - ) - == QueryType.LIST - ) + """) == QueryType.LIST try: get_query_type("show table XXXXX") except LookupError as err: assert err is not None def test_get_query_type_desc(self): - assert ( - get_query_type( - """ + assert get_query_type(""" DESC Issues - """ - ) - == QueryType.DESC - ) - assert ( - get_query_type( - """ + """) == QueryType.DESC + assert get_query_type(""" describe Issues - """ - ) - == QueryType.DESC - ) + """) == QueryType.DESC try: get_query_type("desc table XXXXX") except LookupError as err: diff --git a/tests/test_sqlalchemy_dynamodb.py b/tests/test_sqlalchemy_dynamodb.py index 991cbb1..2a80f2c 100644 --- a/tests/test_sqlalchemy_dynamodb.py +++ b/tests/test_sqlalchemy_dynamodb.py @@ -22,6 +22,7 @@ class _TestCase02(Base): col_json = Column(JSON) col_json_array = Column(JSON) + class _User(Base): __tablename__ = USER_TABLE @@ -42,15 +43,12 @@ def test_ping(self, engine): def test_basic_insert(self, engine): engine, conn = engine - sql_one_row_1_0_ = ( - """ + sql_one_row_1_0_ = """ INSERT INTO %s VALUE { 'key_partition': :pk, 'key_sort': :sk, 'col_str': :col1, 'col_num': :col2, 'col_byte': :col3 } - """ - % TESTCASE02_TABLE - ) + """ % TESTCASE02_TABLE params_1_0_ = { "pk": "test_one_row_1", "sk": 0, @@ -63,15 +61,12 @@ def test_basic_insert(self, engine): def test_batch_insert(self, engine): engine, conn = engine - sql_many_rows_ = ( - """ + sql_many_rows_ = """ INSERT INTO %s VALUE { 'key_partition': :pk, 'key_sort': :sk, 'col_str': :col1, 'col_num': :col2, 'col_byte': :col3 } - """ - % TESTCASE02_TABLE - ) + """ % TESTCASE02_TABLE params_ = [ { "pk": "test_many_rows_1", @@ -107,15 +102,12 @@ def test_batch_insert(self, engine): def test_nested_data_insert(self, engine): engine, conn = engine - sql_one_row_2_0_ = ( - """ + sql_one_row_2_0_ = """ INSERT INTO "%s" VALUE { 'key_partition': :pk, 'key_sort': :sk, 'col_str': :col1, 'col_nested': :col2, 'col_json': :col3 } - """ - % TESTCASE02_TABLE - ) + """ % TESTCASE02_TABLE nested_data = { "Key1": ["Val1-1", 1, {"Subkey1": "Val1-1"}], "Key2": {"Val2-1", "Val2-2"}, @@ -131,13 +123,10 @@ def test_nested_data_insert(self, engine): conn.execute(text(sql_one_row_2_0_), params_2_0_) rows = conn.execute( - text( - """ + text(""" SELECT col_nested, col_json FROM %s WHERE key_partition = :pk AND key_sort = :sk - """ - % TESTCASE02_TABLE - ), + """ % TESTCASE02_TABLE), {"pk": "test_one_row_2", "sk": 0}, ).fetchall() assert len(rows) == 1 @@ -160,12 +149,9 @@ def test_declarative_table_insert(self, engine): session.commit() rows = conn.execute( - text( - """ + text(""" SELECT * FROM %s WHERE key_partition = :pk - """ - % TESTCASE02_TABLE - ), + """ % TESTCASE02_TABLE), {"pk": "test_one_row_3"}, ).fetchall() assert len(rows) == 5 @@ -183,18 +169,18 @@ def test_declarative_table_update(self, engine): test_case.col_str = "test case declarative table 99" test_case.col_num = 99 test_case.col_json = {"key": "value updated"} - test_case.col_json_array = [{"key1": "value1 updated"}, {"key2": "value2 updated"}] + test_case.col_json_array = [ + {"key1": "value1 updated"}, + {"key2": "value2 updated"}, + ] session.commit() rows = conn.execute( - text( - """ + text(""" SELECT col_str, col_num, col_json, col_json_array FROM %s WHERE key_partition = :pk AND key_sort = :sk - """ - % TESTCASE02_TABLE - ), + """ % TESTCASE02_TABLE), {"pk": "test_one_row_3", "sk": 1}, ).fetchall() assert len(rows) == 1 @@ -237,27 +223,21 @@ def test_declarative_table_delete(self, engine): def test_basic_query(self, engine): engine, conn = engine rows = conn.execute( - text( - """ + text(""" SELECT * FROM %s WHERE key_partition = :pk - """ - % TESTCASE02_TABLE - ), + """ % TESTCASE02_TABLE), {"pk": "test_one_row_2"}, ).fetchall() assert len(rows) == 1 def test_basic_update(self, engine): engine, conn = engine - sql_one_row_1_0_ = ( - """ + sql_one_row_1_0_ = """ UPDATE "%s" SET col_str=:col1 SET col_num=:col2 WHERE key_partition=:pk AND key_sort=:sk - """ - % TESTCASE02_TABLE - ) + """ % TESTCASE02_TABLE params_1_0_ = { "pk": "test_one_row_1", "sk": 0, @@ -267,13 +247,10 @@ def test_basic_update(self, engine): conn.execute(text(sql_one_row_1_0_), params_1_0_) rows = conn.execute( - text( - """ + text(""" SELECT col_str FROM %s WHERE key_partition = :pk AND key_sort = :sk - """ - % TESTCASE02_TABLE - ), + """ % TESTCASE02_TABLE), {"pk": "test_one_row_1", "sk": 0}, ).fetchall() assert len(rows) == 1 @@ -288,7 +265,7 @@ def test_reflect_table(self, engine): Column("key_sort", Integer), Column("col_str", String), Column("col_num", Numeric), - Column("col_json", JSON) + Column("col_json", JSON), ) assert len(table.c) == 5 @@ -428,12 +405,9 @@ def test_reserved_word_table_insert(self, engine): session.commit() rows = conn.execute( - text( - """ + text(""" SELECT * FROM %s WHERE key_partition = :pk - """ - % USER_TABLE - ), + """ % USER_TABLE), {"pk": "test_user_row_2"}, ).fetchall() assert len(rows) == 5 @@ -443,16 +417,15 @@ def test_reserved_word_table_select(self, engine): with Session(engine) as session: user = session.scalars( - select(_User).where( - _User.key_partition == "test_user_row_2", - _User.key_sort == 2, - ) - ).one() + select(_User).where( + _User.key_partition == "test_user_row_2", + _User.key_sort == 2, + ) + ).one() assert user.username == "user2" assert user.password == "pwd2" - def test_reserved_word_table_update(self, engine): engine, conn = engine @@ -473,14 +446,11 @@ def test_reserved_word_table_update(self, engine): session.commit() rows = conn.execute( - text( - """ + text(""" SELECT username, "default", "comment" FROM %s WHERE key_partition = :pk AND key_sort = :sk - """ - % USER_TABLE - ), + """ % USER_TABLE), {"pk": "test_user_row_2", "sk": 1}, ).fetchall() assert len(rows) == 1 @@ -503,14 +473,11 @@ def test_reserved_word_table_delete(self, engine): session.commit() rows = conn.execute( - text( - """ + text(""" SELECT username, "default", "comment" FROM %s WHERE key_partition = :pk AND key_sort = :sk - """ - % USER_TABLE - ), + """ % USER_TABLE), {"pk": "test_user_row_2", "sk": 0}, ).fetchall() assert len(rows) == 0 diff --git a/tests/test_superset_dml_select.py b/tests/test_superset_dml_select.py index bd0c988..858e948 100644 --- a/tests/test_superset_dml_select.py +++ b/tests/test_superset_dml_select.py @@ -39,12 +39,9 @@ def test_parse_nested_select_case_1(self): assert parser.parser.columns[1].request_name == "col_map.A" assert parser.parser.columns[1].result_name == "A" assert parser.parser.outer_columns == '"col_list[1]", min("A"), max(A)' - assert ( - parser.parser.outer_exprs - == """AS virtual_table + assert parser.parser.outer_exprs == """AS virtual_table GROUP BY "col_list[1]","A" ORDER BY "AVG(A)" DESC""" - ) assert ret == { "Statement": "SELECT col_list[1],col_map.A FROM \"Issues\" WHERE key_partition = 'row_1'" } @@ -66,17 +63,13 @@ def test_parse_nested_select_case_2(self): ret = parser.transform() assert len(parser.parser.columns) == 3 assert ( - parser.parser.outer_columns - == """DATETIME("col_datetime", 'start of day'), + parser.parser.outer_columns == """DATETIME("col_datetime", 'start of day'), "col_str", max("col_num"), count(DISTINCT "col_num"), count("col_num"), min("col_num"), sum("col_num")""" ) - assert ( - parser.parser.outer_exprs - == """AS virtual_table + assert parser.parser.outer_exprs == """AS virtual_table GROUP BY "col_str", DATETIME("col_datetime", 'start of day') ORDER BY "MAX(col_num)" DESC LIMIT 10000""" - ) assert ret == { "Statement": "SELECT col_str,col_datetime,col_num " + "FROM \"Issues\" WHERE key_partition = 'row_1'" @@ -116,11 +109,8 @@ def test_parse_nested_select_case_4(self): assert ( parser.parser.outer_columns == "col_str_1, col_str_2, col_datetime, col_num" ) - assert ( - parser.parser.outer_exprs - == """AS virtual_table + assert parser.parser.outer_exprs == """AS virtual_table GROUP BY col_str_1""" - ) assert ( parser.parser.inner_columns == """SUBSTR(col_str, 1, 2) col_str_1, REPLACE(col_str, '-', '_') col_str_2, @@ -140,7 +130,9 @@ def test_parse_nested_select_case_4(self): """ parser = SQLParser(sql, parser_class=SupersetSelect) ret = parser.transform() - assert ret == {'Statement': 'SELECT id FROM "lakefront-ingest-stg-config-table"'} + assert ret == { + "Statement": 'SELECT id FROM "lakefront-ingest-stg-config-table"' + } assert parser.parser.inner_columns == None assert parser.parser.inner_exprs == None assert parser.parser.outer_columns == "text_split(id,'.',1)" @@ -157,8 +149,10 @@ def test_parse_nested_select_case_5(self): """ parser = SQLParser(sql, parser_class=SupersetSelect) ret = parser.transform() - assert ret == {'Statement': 'SELECT id FROM "lakefront-ingest-stg-config-table"'} + assert ret == { + "Statement": 'SELECT id FROM "lakefront-ingest-stg-config-table"' + } assert parser.parser.inner_columns == "text_split(id,'.',1)" assert parser.parser.inner_exprs == "" assert parser.parser.outer_columns == "id" - assert parser.parser.outer_exprs == "AS virtual_table\n GROUP BY id" \ No newline at end of file + assert parser.parser.outer_exprs == "AS virtual_table\n GROUP BY id" diff --git a/tests/test_superset_dynamodb.py b/tests/test_superset_dynamodb.py index 9409ede..f056cd5 100644 --- a/tests/test_superset_dynamodb.py +++ b/tests/test_superset_dynamodb.py @@ -14,14 +14,11 @@ class TestSupersetDynamoDB: def test_insert_nested_data(self, cursor): - sql = ( - """ + sql = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_list': ?, 'col_map': ? } - """ - % TESTCASE04_TABLE - ) + """ % TESTCASE04_TABLE params_1 = [ "row_1", 1, @@ -65,8 +62,7 @@ def test_insert_nested_data(self, cursor): def test_insert_flat_data(self, cursor): from datetime import date, datetime, timedelta - sql = ( - """ + sql = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_date': ?, 'col_datetime': ?, @@ -74,9 +70,7 @@ def test_insert_flat_data(self, cursor): 'col_bytes': ?, 'col_str': ?, 'col_bool': ? } - """ - % TESTCASE04_TABLE - ) + """ % TESTCASE04_TABLE date_ = date(2022, 9, 20) datetime_ = datetime(2022, 10, 20, 10, 23, 40) params_1 = ["row_2", 1, date_, datetime_, 1, 1.1, b"RP", "RP", True] @@ -172,13 +166,10 @@ def test_insert_flat_data(self, cursor): ) def test_execute_select(self, superset_cursor): - superset_cursor.execute( - """ + superset_cursor.execute(""" SELECT col_list[1] col_list, NUMBER(col_map.A) FROM %s WHERE key_partition='row_1' - """ - % TESTCASE04_TABLE - ) + """ % TESTCASE04_TABLE) ret = superset_cursor.fetchall() assert len(ret) == 6 assert [(d[0], d[1]) for d in superset_cursor.description] == [ @@ -187,66 +178,53 @@ def test_execute_select(self, superset_cursor): ] def test_execute_nested_select(self, superset_cursor): - superset_cursor.execute( - """ + superset_cursor.execute(""" SELECT "col_list_1", SUM("A") FROM ( SELECT col_list[1] col_list_1, NUMBER(col_map.A) A FROM %s WHERE key_partition='row_1' ) - """ - % TESTCASE04_TABLE - ) + """ % TESTCASE04_TABLE) ret = superset_cursor.fetchall() assert len(ret) == 1 assert ret == [("B", 21.0)] def test_execute_group_select(self, superset_cursor): - superset_cursor.execute( - """ + superset_cursor.execute(""" SELECT "col_list_1", SUM("A"), COUNT("A") FROM ( SELECT col_list[1] col_list_1, NUMBER(col_map.A) FROM %s WHERE key_partition='row_1' ) GROUP BY "col_list_1" ORDER BY "col_list_1" DESC - """ - % TESTCASE04_TABLE - ) + """ % TESTCASE04_TABLE) ret = superset_cursor.fetchall() assert len(ret) == 3 assert ret == [("F", 9.0, 2), ("D", 2.0, 1), ("B", 10.0, 3)] def test_string_functions_select_1(self, superset_cursor): - superset_cursor.execute( - """ + superset_cursor.execute(""" SELECT "col_list_1", "col_map_B_1_substr" FROM ( SELECT col_list[1] col_list_1, SUBSTR(col_map.B[1], 0, 1) col_map_B_1_substr FROM %s WHERE key_partition='row_1' ) ORDER BY "col_list_1" DESC - """ - % TESTCASE04_TABLE - ) + """ % TESTCASE04_TABLE) ret = superset_cursor.fetchall() assert len(ret) == 6 assert ret[0] == ("F", "F") - superset_cursor.execute( - """ + superset_cursor.execute(""" SELECT "col_list_1", "col_map_B_1_replace" FROM ( SELECT col_list[1] col_list_1, REPLACE(col_map.B[1], '-', '_') col_map_B_1_replace FROM %s WHERE key_partition='row_1' ) ORDER BY "col_list_1" DESC - """ - % TESTCASE04_TABLE - ) + """ % TESTCASE04_TABLE) ret = superset_cursor.fetchall() assert len(ret) == 6 assert ret[0] == ("F", "F_2") - superset_cursor.execute( - """ + superset_cursor.execute(""" SELECT "col_list_1", "col_map_B_1", SUBSTR("col_map_B_1", 1, 1), REPLACE("col_map_B_1", '-', '_') @@ -255,16 +233,13 @@ def test_string_functions_select_1(self, superset_cursor): FROM %s WHERE key_partition='row_1' ) ORDER BY "col_list_1" DESC - """ - % TESTCASE04_TABLE - ) + """ % TESTCASE04_TABLE) ret = superset_cursor.fetchall() assert len(ret) == 6 assert ret[0] == ("F", "F-2", "F", "F_2") def test_string_functions_select_2(self, superset_cursor): - superset_cursor.execute( - """ + superset_cursor.execute(""" SELECT "col_list_1", "col_list_1_trim", "col_map_B_1_upper", "col_map_B_1_lower" FROM ( SELECT col_list_1, TRIM(col_list_1) col_list_1_trim, @@ -276,15 +251,12 @@ def test_string_functions_select_2(self, superset_cursor): ) ) ORDER BY "col_list_1" DESC - """ - % TESTCASE04_TABLE - ) + """ % TESTCASE04_TABLE) ret = superset_cursor.fetchall() assert len(ret) == 6 assert ret[0] == ("F", "F", "F-2", "f-2") - superset_cursor.execute( - """ + superset_cursor.execute(""" SELECT "col_list_1", "col_list_1_replace", "col_map_B_1_upper", "col_map_B_1_lower", "col_map_B_1_substr" FROM ( SELECT col_list_1, @@ -298,17 +270,14 @@ def test_string_functions_select_2(self, superset_cursor): ) WHERE col_list_1 = 'F' ) ORDER BY "col_list_1" DESC - """ - % TESTCASE04_TABLE - ) + """ % TESTCASE04_TABLE) ret = superset_cursor.fetchall() assert len(ret) == 2 assert ret[0] == ("F", "f_2", "F-2", "f-2", "2") @pytest.mark.skipif(not has_sqlean(), reason="sqlean not available") def test_sqlean_string_functions(self, superset_cursor): - superset_cursor.execute( - """ + superset_cursor.execute(""" SELECT "col_list_1", "col_map_B_part1", "col_map_B_part2" FROM ( SELECT col_list_1, text_split(col_map_B_1, '-', 1) col_map_B_part1, @@ -319,9 +288,7 @@ def test_sqlean_string_functions(self, superset_cursor): ) WHERE col_list_1 = 'F' ) ORDER BY "col_list_1" DESC - """ - % TESTCASE04_TABLE - ) + """ % TESTCASE04_TABLE) ret = superset_cursor.fetchall() assert len(ret) == 2 assert ret[0] == ("F", "F", "2") @@ -329,13 +296,10 @@ def test_sqlean_string_functions(self, superset_cursor): def test_sqlalchemy_execute_single_select(self, superset_engine): _, conn = superset_engine rows = conn.execute( - text( - """ + text(""" SELECT col_list[1] col_list_1, NUMBER(col_map.A) FROM %s WHERE key_partition=:pk - """ - % TESTCASE04_TABLE - ), + """ % TESTCASE04_TABLE), {"pk": "row_2"}, ).fetchall() assert len(rows) == 8 @@ -343,17 +307,14 @@ def test_sqlalchemy_execute_single_select(self, superset_engine): def test_sqlalchemy_execute_nested_select(self, superset_engine): _, conn = superset_engine rows = conn.execute( - text( - """ + text(""" SELECT "col_list_1", SUM("A"), COUNT("A") FROM ( SELECT col_list[1] col_list_1, NUMBER(col_map.A) FROM %s WHERE key_partition=:pk ) AS virtual_table GROUP BY "col_list_1" ORDER BY "col_list_1" DESC - """ - % TESTCASE04_TABLE - ), + """ % TESTCASE04_TABLE), {"pk": "row_1"}, ).fetchall() assert len(rows) == 3 @@ -361,8 +322,7 @@ def test_sqlalchemy_execute_nested_select(self, superset_engine): def test_sqlalchemy_execute_flat_data(self, superset_engine): _, conn = superset_engine rows = conn.execute( - text( - """ + text(""" SELECT "col_str", MAX("col_date"), MIN("col_datetime"), SUM("col_int"), MAX("col_float"), COUNT("key_sort"), COUNT("col_bool") @@ -374,9 +334,7 @@ def test_sqlalchemy_execute_flat_data(self, superset_engine): ) AS virtual_table GROUP BY "col_str" ORDER BY "col_str" DESC - """ - % TESTCASE04_TABLE - ), + """ % TESTCASE04_TABLE), {"pk": "row_2"}, ).fetchall() assert len(rows) == 3 @@ -389,17 +347,14 @@ def test_sqlalchemy_execute_flat_data(self, superset_engine): def test_sqlalchemy_execute_alias_select(self, superset_engine): _, conn = superset_engine rows = conn.execute( - text( - """ + text(""" SELECT "LST", SUM("MAP_A"), COUNT("MAP_A") FROM ( SELECT col_list[1] LST, NUMBER(col_map.A) MAP_A FROM %s WHERE key_partition=:pk ) AS virtual_table GROUP BY "LST" ORDER BY "LST" DESC - """ - % TESTCASE04_TABLE - ), + """ % TESTCASE04_TABLE), {"pk": "row_1"}, ).fetchall() assert len(rows) == 3 @@ -417,14 +372,11 @@ def test_cached_querydb_step1(self, superset_engine): def test_cached_querydb_step2(self, cursor): # Insert more raw data - sql = ( - """ + sql = """ INSERT INTO %s VALUE { 'key_partition': ?, 'key_sort': ?, 'col_list': ?, 'col_map': ? } - """ - % TESTCASE04_TABLE - ) + """ % TESTCASE04_TABLE params_1 = [ "row_1", 7, @@ -463,17 +415,14 @@ def test_purge_querydb_table(self, superset_engine): def query_final_cached_querydb(self, superset_engine): _, conn = superset_engine rows = conn.execute( - text( - """ + text(""" SELECT "LST", SUM("MAP_A"), COUNT("MAP_A") FROM ( SELECT col_list[1] LST, NUMBER(col_map.A) MAP_A FROM %s WHERE key_partition=:pk ) AS virtual_table GROUP BY "LST" ORDER BY "LST" DESC - """ - % TESTCASE04_TABLE - ), + """ % TESTCASE04_TABLE), {"pk": "row_1"}, ).fetchall() assert len(rows) == 4