[nexus] Experiment with using closer-to-raw-SQL pagination

common/src/api/external/mod.rs

@@ -1066,6 +1066,7 @@ pub struct IdentityMetadataUpdateParams {
     Debug,
     Deserialize,
     Eq,
+    Hash,
     Ord,
     PartialEq,
     PartialOrd,
@@ -1320,14 +1321,20 @@ pub enum FailureDomain {
 #[derive(Clone, Debug, Deserialize, Serialize, JsonSchema, PartialEq)]
 #[serde(tag = "type", content = "value", rename_all = "snake_case")]
 pub enum AffinityGroupMember {
-    /// An instance belonging to this group, identified by UUID.
-    Instance(InstanceUuid),
+    /// An instance belonging to this group
+    Instance { id: InstanceUuid, name: Name, run_state: InstanceState },
 }
 
-impl SimpleIdentity for AffinityGroupMember {
+impl SimpleIdentityOrName for AffinityGroupMember {
     fn id(&self) -> Uuid {
         match self {
-            AffinityGroupMember::Instance(id) => *id.as_untyped_uuid(),
+            AffinityGroupMember::Instance { id, .. } => *id.as_untyped_uuid(),
+        }
+    }
+
+    fn name(&self) -> &Name {
+        match self {
+            AffinityGroupMember::Instance { name, .. } => name,
         }
     }
 }
@@ -1339,14 +1346,22 @@ impl SimpleIdentity for AffinityGroupMember {
 #[derive(Clone, Debug, Deserialize, Serialize, JsonSchema, PartialEq)]
 #[serde(tag = "type", content = "value", rename_all = "snake_case")]
 pub enum AntiAffinityGroupMember {
-    /// An instance belonging to this group, identified by UUID.
-    Instance(InstanceUuid),
+    /// An instance belonging to this group
+    Instance { id: InstanceUuid, name: Name, run_state: InstanceState },
 }
 
-impl SimpleIdentity for AntiAffinityGroupMember {
+impl SimpleIdentityOrName for AntiAffinityGroupMember {
     fn id(&self) -> Uuid {
         match self {
-            AntiAffinityGroupMember::Instance(id) => *id.as_untyped_uuid(),
+            AntiAffinityGroupMember::Instance { id, .. } => {
+                *id.as_untyped_uuid()
+            }
+        }
+    }
+
+    fn name(&self) -> &Name {
+        match self {
+            AntiAffinityGroupMember::Instance { name, .. } => name,
         }
     }
 }

nexus/db-model/src/affinity.rs

@@ -228,11 +228,17 @@ impl AffinityGroupInstanceMembership {
     pub fn new(group_id: AffinityGroupUuid, instance_id: InstanceUuid) -> Self {
         Self { group_id: group_id.into(), instance_id: instance_id.into() }
     }
-}
 
-impl From<AffinityGroupInstanceMembership> for external::AffinityGroupMember {
-    fn from(member: AffinityGroupInstanceMembership) -> Self {
-        Self::Instance(member.instance_id.into())
+    pub fn to_external(
+        self,
+        member_name: external::Name,
+        run_state: external::InstanceState,
+    ) -> external::AffinityGroupMember {
+        external::AffinityGroupMember::Instance {
+            id: self.instance_id.into(),
+            name: member_name,
+            run_state,
+        }
     }
 }
 
@@ -250,12 +256,16 @@ impl AntiAffinityGroupInstanceMembership {
     ) -> Self {
         Self { group_id: group_id.into(), instance_id: instance_id.into() }
     }
-}
 
-impl From<AntiAffinityGroupInstanceMembership>
-    for external::AntiAffinityGroupMember
-{
-    fn from(member: AntiAffinityGroupInstanceMembership) -> Self {
-        Self::Instance(member.instance_id.into())
+    pub fn to_external(
+        self,
+        member_name: external::Name,
+        run_state: external::InstanceState,
+    ) -> external::AntiAffinityGroupMember {
+        external::AntiAffinityGroupMember::Instance {
+            id: self.instance_id.into(),
+            name: member_name,
+            run_state,
+        }
     }
 }

nexus/db-model/src/instance.rs

@@ -10,10 +10,7 @@ use crate::collection::DatastoreAttachTargetConfig;
 use crate::schema::{disk, external_ip, instance};
 use chrono::{DateTime, TimeDelta, Utc};
 use db_macros::Resource;
-use diesel::expression::{ValidGrouping, is_aggregate};
-use diesel::pg;
 use diesel::prelude::*;
-use diesel::sql_types::{Bool, Nullable};
 use nexus_types::external_api::params;
 use omicron_uuid_kinds::{GenericUuid, InstanceUuid};
 use serde::Deserialize;
@@ -392,66 +389,6 @@ impl InstanceAutoRestart {
 
         Reincarnatability::WillReincarnate
     }
-
-    /// Filters a database query to include only instances whose auto-restart
-    /// configs permit them to reincarnate.
-    ///
-    /// Yes, this should probably be in `nexus-db-queries`, but it seemed nice
-    /// for it to be defined on the same struct as the in-memory logic
-    /// (`can_reincarnate`).
-    pub fn filter_reincarnatable()
-    -> impl diesel::query_builder::QueryFragment<pg::Pg>
-    + diesel::query_builder::QueryId
-    // All elements in this expression appear on the `instance` table, so
-    // it's a valid `filter` for that table, and the expression evaluates
-    // to a bool (or NULL), making it a valid WHERE clause.
-    + AppearsOnTable<instance::table, SqlType = Nullable<Bool>>
-    // I think this trait tells diesel that the query fragment has no
-    // GROUP BY clause, so that it knows it can be used as a WHERE clause
-    + ValidGrouping<(), IsAggregate = is_aggregate::No> {
-        use instance::dsl;
-
-        let now = diesel::dsl::now.into_sql::<pg::sql_types::Timestamptz>();
-
-        // The instance's auto-restart policy must allow the control plane
-        // to restart it automatically.
-        //
-        // N.B. that this may become more complex in the future if we grow
-        // additional auto-restart policies that require additional logic
-        // (such as restart limits...)
-        (dsl::auto_restart_policy
-            .eq(InstanceAutoRestartPolicy::BestEffort)
-            // If the auto-restart policy is null, then it should
-            // default to "best effort".
-            .or(dsl::auto_restart_policy.is_null()))
-        // An instance whose last reincarnation was within the cooldown
-        // interval from now must remain in _bardo_ --- the liminal
-        // state between death and rebirth --- before its next
-        // reincarnation.
-        .and(
-            // If the instance has never previously been reincarnated, then
-            // it's allowed to reincarnate.
-            dsl::time_last_auto_restarted
-                .is_null()
-                // Or, if it has an overridden cooldown period, has that elapsed?
-                .or(dsl::auto_restart_cooldown.is_not_null().and(
-                    dsl::time_last_auto_restarted
-                        .le(now.nullable() - dsl::auto_restart_cooldown),
-                ))
-                // Or, finally, if it does not have an overridden cooldown
-                // period, has the default cooldown period elapsed?
-                .or(dsl::auto_restart_cooldown.is_null().and(
-                    dsl::time_last_auto_restarted
-                        .le((now - Self::DEFAULT_COOLDOWN).nullable()),
-                )),
-        )
-        // Deleted instances may not be reincarnated.
-        .and(dsl::time_deleted.is_null())
-        // If the instance is currently in the process of being updated,
-        // let's not mess with it for now and try to restart it on another
-        // pass.
-        .and(dsl::updater_id.is_null())
-    }
 }
 
 /// It's just a type with the same representation as a `TimeDelta` that

nexus/db-queries/src/db/column_walker.rs

@@ -28,6 +28,10 @@ impl<T> ColumnWalker<T> {
 
 macro_rules! impl_column_walker {
     ( $len:literal $($column:ident)+ ) => (
+        /// Returns all columns with the "(prefix)." string prepended.
+        ///
+        /// For example, with the columns "id, name" and the prefix "foo:
+        /// The output string would be: "foo.id, foo.name"
         #[allow(dead_code)]
         impl<$($column: Column),+> ColumnWalker<($($column,)+)> {
             pub fn with_prefix(prefix: &'static str) -> TrustedStr {
@@ -42,6 +46,46 @@ macro_rules! impl_column_walker {
             }
         }
 
+        /// Identical to [Self::with_prefix], but also aliases each column.
+        ///
+        /// The aliased name is "(prefix)_(column name)".
+        ///
+        /// For example, with the columns "id, name" and the prefix "foo:
+        /// The output string would be: "foo.id as foo_id, foo.name as foo_name"
+        #[allow(dead_code)]
+        impl<$($column: Column),+> ColumnWalker<($($column,)+)> {
+            pub fn with_prefix_and_alias(prefix: &'static str) -> TrustedStr {
+                // This string is derived from:
+                // - The "table" type, with associated columns, which
+                // are not controlled by an arbitrary user, and
+                // - The "prefix" type, which is a "&'static str" (AKA,
+                // hopefully known at compile-time, and not leaked).
+                TrustedStr::i_take_responsibility_for_validating_this_string(
+                    [
+                        $(
+                            format!(
+                                "{prefix}.{column} as {prefix}_{column}",
+                                prefix = prefix, column = $column::NAME
+                            ),
+                        )+
+                    ].join(", ")
+                )
+            }
+        }
+
+        /// Returns all columns without any suffix.
+        #[allow(dead_code)]
+        impl<$($column: Column),+> ColumnWalker<($($column,)+)> {
+            pub fn as_str() -> TrustedStr {
+                // This string is derived from:
+                // - The "table" type, with associated columns, which
+                // are not controlled by an arbitrary user, and
+                TrustedStr::i_take_responsibility_for_validating_this_string(
+                    [$($column::NAME,)+].join(", ")
+                )
+            }
+        }
+
         impl<$($column: Column),+> IntoIterator for ColumnWalker<($($column,)+)> {
             type Item = &'static str;
             type IntoIter = std::array::IntoIter<Self::Item, $len>;