Update to SQLAlchemy 2.0 (#961)

* Updated legacy usage of SQLAlchemy

* Bump sqlalchemy version and update dependencies

Pipfile

@@ -23,7 +23,7 @@ prometheus_client = "*"
 pyjwt = {version = ">=2.4.0", extras = ["crypto"]}
 pyyaml = "*"
 sortedcontainers = "*"
-sqlalchemy = "~=1.4"
+sqlalchemy = ">=2.0.0"
 trueskill = "*"
 twilio = ">=7.0.0"
 uvloop = {version = "*", markers = "sys_platform != 'win32'"}

server/game_service.py

@@ -91,14 +91,14 @@ async def update_data(self):
         time we need, but which can in principle change over time.
         """
         async with self._db.acquire() as conn:
-            rows = await conn.execute(select([
+            rows = await conn.execute(select(
                 game_featuredMods.c.id,
                 game_featuredMods.c.gamemod,
                 game_featuredMods.c.name,
                 game_featuredMods.c.description,
                 game_featuredMods.c.publish,
                 game_featuredMods.c.order
-            ]).select_from(game_featuredMods))
+            ).select_from(game_featuredMods))
 
             for row in rows:
                 self.featured_mods[row.gamemod] = FeaturedMod(

server/gameconnection.py

@@ -338,7 +338,7 @@ async def handle_operation_complete(
         secondary, delta = secondary, str(delta)
         async with self._db.acquire() as conn:
             result = await conn.execute(
-                select([coop_map.c.id]).where(
+                select(coop_map.c.id).where(
                     coop_map.c.filename == self.game.map_file_path
                 )
             )

server/games/game_results.py

@@ -213,11 +213,11 @@ async def from_db(cls, database, game_id):
         results = cls(game_id)
         async with database.acquire() as conn:
             result = await conn.execute(
-                select([
+                select(
                     game_player_stats.c.place,
                     game_player_stats.c.score,
                     game_player_stats.c.result
-                ]).where(game_player_stats.c.gameId == game_id)
+                ).where(game_player_stats.c.gameId == game_id)
             )
 
             for row in result:

server/ladder_service/ladder_service.py

@@ -123,15 +123,15 @@ async def update_data(self) -> None:
 
     async def fetch_map_pools(self, conn) -> dict[int, tuple[str, list[Map]]]:
         result = await conn.execute(
-            select([
+            select(
                 map_pool.c.id,
                 map_pool.c.name,
                 map_pool_map_version.c.weight,
                 map_pool_map_version.c.map_params,
                 map_version.c.id.label("map_id"),
                 map_version.c.filename,
                 t_map.c.display_name
-            ]).select_from(
+            ).select_from(
                 map_pool.outerjoin(map_pool_map_version)
                 .outerjoin(map_version)
                 .outerjoin(t_map)
@@ -176,7 +176,7 @@ async def fetch_map_pools(self, conn) -> dict[int, tuple[str, list[Map]]]:
 
     async def fetch_matchmaker_queues(self, conn):
         result = await conn.execute(
-            select([
+            select(
                 matchmaker_queue.c.id,
                 matchmaker_queue.c.technical_name,
                 matchmaker_queue.c.team_size,
@@ -186,7 +186,7 @@ async def fetch_matchmaker_queues(self, conn):
                 matchmaker_queue_map_pool.c.max_rating,
                 game_featuredMods.c.gamemod,
                 leaderboard.c.technical_name.label("rating_type")
-            ])
+            )
             .select_from(
                 matchmaker_queue
                 .join(matchmaker_queue_map_pool)
@@ -227,10 +227,10 @@ async def fetch_matchmaker_queues(self, conn):
     async def fetch_rating_peak(self, rating_type):
         async with self._db.acquire() as conn:
             result = await conn.execute(
-                select([
+                select(
                     leaderboard_rating_journal.c.rating_mean_before,
                     leaderboard_rating_journal.c.rating_deviation_before
-                ])
+                )
                 .select_from(leaderboard_rating_journal.join(leaderboard))
                 .where(leaderboard.c.technical_name == rating_type)
                 .order_by(leaderboard_rating_journal.c.id.desc())
@@ -678,9 +678,9 @@ async def get_game_history(
         async with self._db.acquire() as conn:
             result = []
             for player in players:
-                query = select([
+                query = select(
                     game_stats.c.mapId,
-                ]).select_from(
+                ).select_from(
                     game_player_stats
                     .join(game_stats)
                     .join(matchmaker_queue_game)

server/lobbyconnection.py

@@ -215,7 +215,7 @@ async def command_create_account(self, message):
     async def command_coop_list(self, message):
         """Request for coop map list"""
         async with self._db.acquire() as conn:
-            result = await conn.stream(select([coop_map]))
+            result = await conn.stream(select(coop_map))
 
             campaigns = [
                 "FA Campaign",
@@ -377,13 +377,13 @@ async def command_admin(self, message):
     async def check_user_login(self, conn, username, password):
         # TODO: Hash passwords server-side so the hashing actually *does* something.
         result = await conn.execute(
-            select([
+            select(
                 t_login.c.id,
                 t_login.c.login,
                 t_login.c.password,
                 lobby_ban.c.reason,
                 lobby_ban.c.expires_at
-            ]).select_from(t_login.outerjoin(lobby_ban))
+            ).select_from(t_login.outerjoin(lobby_ban))
             .where(t_login.c.login == username)
             .order_by(lobby_ban.c.expires_at.desc())
         )
@@ -500,7 +500,7 @@ async def command_auth(self, message):
 
         async with self._db.acquire() as conn:
             result = await conn.execute(
-                select([t_login.c.login])
+                select(t_login.c.login)
                 .where(t_login.c.id == player_id)
             )
             row = result.fetchone()
@@ -643,20 +643,19 @@ async def on_player_login(
         foes = []
         async with self._db.acquire() as conn:
             result = await conn.execute(
-                select([
+                select(
                     friends_and_foes.c.subject_id,
                     friends_and_foes.c.status
-                ]).where(
+                ).where(
                     friends_and_foes.c.user_id == self.player.id
                 )
             )
 
             for row in result:
-                target_id, status = row["subject_id"], row["status"]
-                if status == "FRIEND":
-                    friends.append(target_id)
+                if row.status == "FRIEND":
+                    friends.append(row.subject_id)
                 else:
-                    foes.append(target_id)
+                    foes.append(row.subject_id)
 
         self.player.friends = set(friends)
         self.player.foes = set(foes)
@@ -739,10 +738,10 @@ async def command_avatar(self, message):
         if action == "list_avatar":
             async with self._db.acquire() as conn:
                 result = await conn.execute(
-                    select([
+                    select(
                         avatars_list.c.url,
                         avatars_list.c.tooltip
-                    ]).select_from(
+                    ).select_from(
                         avatars.outerjoin(
                             avatars_list
                         )
@@ -765,9 +764,10 @@ async def command_avatar(self, message):
             async with self._db.acquire() as conn:
                 if avatar_url is not None:
                     result = await conn.execute(
-                        select([
-                            avatars_list.c.id, avatars_list.c.tooltip
-                        ]).select_from(
+                        select(
+                            avatars_list.c.id,
+                            avatars_list.c.tooltip
+                        ).select_from(
                             avatars.join(avatars_list)
                         ).where(
                             and_(
@@ -1261,7 +1261,7 @@ async def abort_connection_if_banned(self):
         async with self._db.acquire() as conn:
             now = datetime.utcnow()
             result = await conn.execute(
-                select([lobby_ban.c.reason, lobby_ban.c.expires_at])
+                select(lobby_ban.c.reason, lobby_ban.c.expires_at)
                 .where(lobby_ban.c.idUser == self.player.id)
                 .order_by(lobby_ban.c.expires_at.desc())
             )

server/player_service.py

@@ -78,17 +78,17 @@ def pop_dirty_players(self) -> set[Player]:
     async def fetch_player_data(self, player):
         async with self._db.acquire() as conn:
             result = await conn.execute(
-                select([user_group.c.technical_name])
+                select(user_group.c.technical_name)
                 .select_from(user_group_assignment.join(user_group))
                 .where(user_group_assignment.c.user_id == player.id)
             )
             player.user_groups = {row.technical_name for row in result}
 
-            sql = select([
+            sql = select(
                 avatars_list.c.url,
                 avatars_list.c.tooltip,
                 clan.c.tag
-            ], use_labels=True).select_from(
+            ).select_from(
                 login
                 .outerjoin(clan_membership)
                 .outerjoin(clan)
@@ -124,12 +124,12 @@ async def fetch_player_data(self, player):
             await self._fetch_player_ratings(player, conn)
 
     async def _fetch_player_ratings(self, player, conn):
-        sql = select([
+        sql = select(
             leaderboard_rating.c.mean,
             leaderboard_rating.c.deviation,
             leaderboard_rating.c.total_games,
             leaderboard.c.technical_name,
-        ]).select_from(
+        ).select_from(
             leaderboard.join(leaderboard_rating)
         ).where(
             leaderboard_rating.c.login_id == player.id
@@ -160,12 +160,12 @@ async def _fetch_player_legacy_rating(self, player, rating_types, conn):
             return
 
         sql = select(
-            [
-                global_rating.c.mean, global_rating.c.deviation,
-                global_rating.c.numGames,
-                ladder1v1_rating.c.mean, ladder1v1_rating.c.deviation,
-                ladder1v1_rating.c.numGames,
-            ], use_labels=True
+            global_rating.c.mean,
+            global_rating.c.deviation,
+            global_rating.c.numGames,
+            ladder1v1_rating.c.mean,
+            ladder1v1_rating.c.deviation,
+            ladder1v1_rating.c.numGames,
         ).select_from(
             login.outerjoin(ladder1v1_rating).outerjoin(global_rating)
         ).where(
@@ -181,26 +181,26 @@ async def _fetch_player_legacy_rating(self, player, rating_types, conn):
         row = row._mapping
 
         table_map = {
-            RatingType.GLOBAL: "global_rating_{}",
-            RatingType.LADDER_1V1: "ladder1v1_rating_{}",
+            RatingType.GLOBAL: global_rating,
+            RatingType.LADDER_1V1: ladder1v1_rating,
         }
         for rating_type in rating_types:
             if rating_type not in table_map:
                 raise ValueError(f"Unknown rating type {rating_type}.")
 
             table = table_map[rating_type]
-            if row[table.format("mean")] is None:
+            if row[table.c.mean] is None:
                 self._logger.info(
                     "Found no %s ratings for Player with id %i",
                     rating_type, player.id
                 )
                 continue
 
             player.ratings[rating_type] = (
-                row[table.format("mean")],
-                row[table.format("deviation")]
+                row[table.c.mean],
+                row[table.c.deviation]
             )
-            player.game_count[rating_type] = row[table.format("numGames")]
+            player.game_count[rating_type] = row[table.c.numGames]
 
     def remove_player(self, player: Player):
         if player.id in self._players:
@@ -210,7 +210,7 @@ def remove_player(self, player: Player):
     async def has_permission_role(self, player: Player, role_name: str) -> bool:
         async with self._db.acquire() as conn:
             result = await conn.execute(
-                select([group_permission.c.id])
+                select(group_permission.c.id)
                 .select_from(
                     user_group_assignment
                     .join(group_permission_assignment, onclause=(

server/rating_service/rating_service.py

@@ -67,11 +67,11 @@ async def initialize(self) -> None:
     async def update_data(self):
         async with self._db.acquire() as conn:
             initializer = leaderboard.alias()
-            sql = select([
+            sql = select(
                 leaderboard.c.id,
                 leaderboard.c.technical_name,
                 initializer.c.technical_name.label("initializer")
-            ]).select_from(
+            ).select_from(
                 leaderboard.outerjoin(
                     initializer,
                     leaderboard.c.initializer_id == initializer.c.id
@@ -284,12 +284,12 @@ async def _create_initial_ratings(
     async def _get_all_player_ratings(
         self, conn, player_ids: list[PlayerID]
     ) -> dict[PlayerID, PlayerRatings]:
-        sql = select([
+        sql = select(
             leaderboard_rating.c.login_id,
             leaderboard.c.technical_name,
             leaderboard_rating.c.mean,
             leaderboard_rating.c.deviation
-        ]).join(leaderboard).where(
+        ).join(leaderboard).where(
             leaderboard_rating.c.login_id.in_(player_ids)
         )
         result = await conn.execute(sql)
@@ -391,7 +391,7 @@ async def _persist_rating_changes(
             rating_deviation_before=bindparam("rating_deviation_before"),
             rating_mean_after=bindparam("rating_mean_after"),
             rating_deviation_after=bindparam("rating_deviation_after"),
-            game_player_stats_id=select([game_player_stats.c.id]).where(
+            game_player_stats_id=select(game_player_stats.c.id).where(
                 and_(
                     game_player_stats.c.playerId == bindparam("player_id"),
                     game_player_stats.c.gameId == game_id,

tests/integration_tests/test_coop.py

@@ -86,7 +86,7 @@ async def test_single_player_game_recorded(lobby_server, database):
 
     async with database.acquire() as conn:
         result = await conn.execute(
-            select([coop_leaderboard]).where(
+            select(coop_leaderboard).where(
                 coop_leaderboard.c.gameuid == game_id
             )
         )

tests/integration_tests/test_game.py

@@ -677,7 +677,7 @@ async def test_ladder_game_draw_bug(lobby_server, database):
 
     async with database.acquire() as conn:
         result = await conn.execute(
-            select([game_player_stats]).where(
+            select(game_player_stats).where(
                 game_player_stats.c.gameId == game_id
             )
         )

tests/integration_tests/test_matchmaker.py

@@ -142,23 +142,23 @@ async def test_game_matchmaking_start(lobby_server, database):
     await read_until_launched(guest, game_id)
 
     async with database.acquire() as conn:
-        result = await conn.execute(select([
+        result = await conn.execute(select(
             game_player_stats.c.faction,
             game_player_stats.c.color,
             game_player_stats.c.team,
             game_player_stats.c.place,
-        ]).where(game_player_stats.c.gameId == game_id))
+        ).where(game_player_stats.c.gameId == game_id))
         rows = result.fetchall()
         assert len(rows) == 2
         for row in rows:
-            assert row["faction"] == 1
-            assert row["color"] in (1, 2)
-            assert row["team"] is not None
-            assert row["place"] is not None
+            assert row.faction == 1
+            assert row.color in (1, 2)
+            assert row.team is not None
+            assert row.place is not None
 
-        result = await conn.execute(select([
+        result = await conn.execute(select(
             matchmaker_queue.c.technical_name,
-        ]).select_from(
+        ).select_from(
             matchmaker_queue_game.outerjoin(matchmaker_queue)
         ).where(matchmaker_queue_game.c.game_stats_id == game_id))
         row = result.fetchone()

tests/integration_tests/test_server.py

@@ -523,7 +523,7 @@ async def test_ice_servers_empty(lobby_server):
 
 async def get_player_selected_avatars(conn, player_id):
     return await conn.execute(
-        select([avatars.c.id, avatars_list.c.url])
+        select(avatars.c.id, avatars_list.c.url)
         .select_from(avatars_list.join(avatars))
         .where(
             and_(