ephraimbuddy commented on code in PR #32883:
URL: https://github.com/apache/airflow/pull/32883#discussion_r1299772232


##########
airflow/utils/sqlalchemy.py:
##########
@@ -436,7 +436,7 @@ def lock_rows(query: Query, session: Session) -> 
Generator[None, None, None]:
 
     :meta private:
     """
-    locked_rows = with_row_locks(query, session).all()
+    locked_rows = with_row_locks(query, session)

Review Comment:
   Is the removal necessary?



##########
airflow/models/variable.py:
##########
@@ -200,8 +200,7 @@ def update(
 
         if Variable.get_variable_from_secrets(key=key) is None:
             raise KeyError(f"Variable {key} does not exist")
-
-        obj = session.query(Variable).filter(Variable.key == key).first()
+        obj = session.scalar(select(Variable).where(Variable.key == key))

Review Comment:
   Should we use `limit(1)` since it was picking the first item?



##########
airflow/www/security.py:
##########
@@ -243,11 +243,9 @@ def __init__(self, appbuilder) -> None:
 
     def _get_root_dag_id(self, dag_id: str) -> str:
         if "." in dag_id:
-            dm = (
-                self.appbuilder.get_session.query(DagModel.dag_id, 
DagModel.root_dag_id)
-                .filter(DagModel.dag_id == dag_id)
-                .first()
-            )
+            dm = self.appbuilder.get_session.execute(
+                select(DagModel.dag_id, 
DagModel.root_dag_id).where(DagModel.dag_id == dag_id)
+            ).one()

Review Comment:
   Since `first` was used originally, we should use `limit(1)` because using 
`one()` will throw error



##########
airflow/www/security.py:
##########
@@ -358,16 +356,15 @@ def get_accessible_dag_ids(
             if (permissions.ACTION_CAN_EDIT in user_actions and 
self.can_edit_all_dags(user)) or (
                 permissions.ACTION_CAN_READ in user_actions and 
self.can_read_all_dags(user)
             ):
-                return {dag.dag_id for dag in session.query(DagModel.dag_id)}
-            user_query = (
-                session.query(User)
+                return {dag.dag_id for dag in 
session.execute(select(DagModel.dag_id))}
+            user_query = session.scalar(
+                select(User)
                 .options(
                     joinedload(User.roles)
                     .subqueryload(Role.permissions)
                     .options(joinedload(Permission.action), 
joinedload(Permission.resource))
                 )
-                .filter(User.id == user.id)
-                .first()
+                .where(User.id == user.id)

Review Comment:
   ```suggestion
                   .where(User.id == user.id).limit(1)
   ```



##########
airflow/auth/managers/fab/models/__init__.py:
##########
@@ -210,12 +211,13 @@ def perms(self):
             if current_app:
                 sm = current_app.appbuilder.sm
                 self._perms: set[tuple[str, str]] = set(
-                    sm.get_session.query(sm.action_model.name, 
sm.resource_model.name)
-                    .join(sm.permission_model.action)
-                    .join(sm.permission_model.resource)
-                    .join(sm.permission_model.role)
-                    .filter(sm.role_model.user.contains(self))
-                    .all()
+                    sm.get_session.execute(
+                        select(sm.action_model.name, sm.resource_model.name)
+                        .join(sm.permission_model.action)
+                        .join(sm.permission_model.resource)
+                        .join(sm.permission_model.role)
+                        .where(sm.role_model.user.contains(self))
+                    )

Review Comment:
   Seems we are missing `all()` but if that doesn't have an effect then fine



##########
airflow/operators/subdag.py:
##########
@@ -112,7 +113,7 @@ def _validate_pool(self, session):
             conflicts = [t for t in self.subdag.tasks if t.pool == self.pool]
             if conflicts:
                 # only query for pool conflicts if one may exist
-                pool = session.query(Pool).filter(Pool.slots == 
1).filter(Pool.pool == self.pool).first()
+                pool = session.scalar(select(Pool).where(Pool.slots == 1, 
Pool.pool == self.pool))

Review Comment:
   Also here, should we apply a limit to get the first item



##########
airflow/www/security.py:
##########
@@ -524,10 +524,8 @@ def _merge_perm(self, action_name: str, resource_name: 
str) -> None:
         resource = self.get_resource(resource_name)
         perm = None
         if action and resource:
-            perm = (
-                self.appbuilder.get_session.query(self.permission_model)
-                .filter_by(action=action, resource=resource)
-                .first()
+            perm = self.appbuilder.get_session.scalar(
+                select(self.permission_model).filter_by(action=action, 
resource=resource)

Review Comment:
   apply `limit(1)`



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]

Reply via email to