Merge pull request #1836 from s7tya/support-runtime-related-tables-migration

Support missing tables migration

Author: Kobzol

database/src/bin/postgres-to-sqlite.rs

@@ -358,6 +358,87 @@ impl Table for RustcCompilation {
     }
 }
 
+struct RuntimePstat;
+
+impl Table for RuntimePstat {
+    fn name(&self) -> &'static str {
+        "runtime_pstat"
+    }
+
+    fn postgres_select_statement(&self, since_weeks_ago: Option<u32>) -> String {
+        let s = "select series, aid, cid, value from ".to_string() + self.name();
+        with_filter_clause_maybe(s, ARTIFACT_JOIN_AND_WHERE, since_weeks_ago)
+    }
+
+    fn sqlite_insert_statement(&self) -> &'static str {
+        "insert into runtime_pstat (series, aid, cid, value) VALUES (?, ?, ?, ?)"
+    }
+
+    fn sqlite_execute_insert(&self, statement: &mut rusqlite::Statement, row: tokio_postgres::Row) {
+        statement
+            .execute(params![
+                row.get::<_, i32>(0),
+                row.get::<_, i32>(1),
+                row.get::<_, i32>(2),
+                row.get::<_, f64>(3),
+            ])
+            .unwrap();
+    }
+}
+
+struct RuntimePstatSeries;
+
+impl Table for RuntimePstatSeries {
+    fn name(&self) -> &'static str {
+        "runtime_pstat_series"
+    }
+
+    fn postgres_select_statement(&self, _since_weeks_ago: Option<u32>) -> String {
+        "select id, benchmark, metric from ".to_string() + self.name()
+    }
+
+    fn sqlite_insert_statement(&self) -> &'static str {
+        "insert into runtime_pstat_series (id, benchmark, metric) VALUES (?, ?, ?)"
+    }
+
+    fn sqlite_execute_insert(&self, statement: &mut rusqlite::Statement, row: tokio_postgres::Row) {
+        statement
+            .execute(params![
+                row.get::<_, i32>(0),
+                row.get::<_, &str>(1),
+                row.get::<_, &str>(2),
+            ])
+            .unwrap();
+    }
+}
+
+struct ArtifactSize;
+
+impl Table for ArtifactSize {
+    fn name(&self) -> &'static str {
+        "artifact_size"
+    }
+
+    fn postgres_select_statement(&self, since_weeks_ago: Option<u32>) -> String {
+        let s = "select aid, component, size from ".to_string() + self.name();
+        with_filter_clause_maybe(s, ARTIFACT_JOIN_AND_WHERE, since_weeks_ago)
+    }
+
+    fn sqlite_insert_statement(&self) -> &'static str {
+        "insert into artifact_size (aid, component, size) VALUES (?, ?, ?)"
+    }
+
+    fn sqlite_execute_insert(&self, statement: &mut rusqlite::Statement, row: tokio_postgres::Row) {
+        statement
+            .execute(params![
+                row.get::<_, i32>(0),
+                row.get::<_, &str>(1),
+                row.get::<_, i32>(2),
+            ])
+            .unwrap();
+    }
+}
+
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     env_logger::init();
@@ -375,6 +456,9 @@ async fn main() -> anyhow::Result<()> {
         &PullRequestBuild,
         &RawSelfProfile,
         &RustcCompilation,
+        &RuntimePstatSeries,
+        &RuntimePstat,
+        &ArtifactSize,
     ];
 
     let table_names: Vec<_> = tables.iter().map(|table| table.name()).collect();

database/src/bin/sqlite-to-postgres.rs

@@ -492,6 +492,119 @@ impl Table for RustcCompilation {
     }
 }
 
+struct RuntimePstat;
+
+#[derive(Serialize)]
+struct RuntimePstatRow {
+    series: i32,
+    aid: i32,
+    cid: i32,
+    value: f64,
+}
+
+impl Table for RuntimePstat {
+    fn name() -> &'static str {
+        "runtime_pstat"
+    }
+
+    fn sqlite_attributes() -> &'static str {
+        "series, aid, cid, value"
+    }
+
+    fn postgres_attributes() -> &'static str {
+        "series, aid, cid, value"
+    }
+
+    fn postgres_generated_id_attribute() -> Option<&'static str> {
+        None
+    }
+
+    fn write_postgres_csv_row<W: Write>(writer: &mut csv::Writer<W>, row: &rusqlite::Row) {
+        writer
+            .serialize(PstatRow {
+                series: row.get(0).unwrap(),
+                aid: row.get(1).unwrap(),
+                cid: row.get(2).unwrap(),
+                value: row.get(3).unwrap(),
+            })
+            .unwrap();
+    }
+}
+
+struct RuntimePstatSeries;
+
+#[derive(Serialize)]
+struct RuntimePstatSeriesRow<'a> {
+    id: i32,
+    benchmark: &'a str,
+    metric: &'a str,
+}
+
+impl Table for RuntimePstatSeries {
+    fn name() -> &'static str {
+        "runtime_pstat_series"
+    }
+
+    fn sqlite_attributes() -> &'static str {
+        "id, benchmark, metric"
+    }
+
+    fn postgres_attributes() -> &'static str {
+        "id, benchmark, metric"
+    }
+
+    fn postgres_generated_id_attribute() -> Option<&'static str> {
+        Some("id")
+    }
+
+    fn write_postgres_csv_row<W: Write>(writer: &mut csv::Writer<W>, row: &rusqlite::Row) {
+        writer
+            .serialize(RuntimePstatSeriesRow {
+                id: row.get(0).unwrap(),
+                benchmark: row.get_ref(1).unwrap().as_str().unwrap(),
+                metric: row.get_ref(2).unwrap().as_str().unwrap(),
+            })
+            .unwrap();
+    }
+}
+
+struct ArtifactSize;
+
+#[derive(Serialize)]
+struct ArtifactSizeRow<'a> {
+    aid: i32,
+    component: &'a str,
+    size: i32,
+}
+
+impl Table for ArtifactSize {
+    fn name() -> &'static str {
+        "artifact_size"
+    }
+
+    fn sqlite_attributes() -> &'static str {
+        "aid, component, size"
+    }
+
+    fn postgres_attributes() -> &'static str {
+        "aid, component, size"
+    }
+
+    fn postgres_generated_id_attribute() -> Option<&'static str> {
+        None
+    }
+
+    fn write_postgres_csv_row<W: Write>(writer: &mut csv::Writer<W>, row: &rusqlite::Row) {
+        writer
+            .serialize(ArtifactSizeRow {
+                aid: row.get(0).unwrap(),
+                component: row.get_ref(1).unwrap().as_str().unwrap(),
+                size: row.get(2).unwrap(),
+            })
+            .unwrap();
+    }
+}
+
 // `Nullable<T>` helps to work around the fact that the `csv` crate (and the CSV
 // format in general) doesn't distinguish between nulls and empty strings, while
 // the Postgres CSV format does.
@@ -620,6 +733,9 @@ async fn main() -> anyhow::Result<()> {
     copy::<PullRequestBuild>(&sqlite_tx, &postgres_tx).await;
     copy::<RawSelfProfile>(&sqlite_tx, &postgres_tx).await;
     copy::<RustcCompilation>(&sqlite_tx, &postgres_tx).await;
+    copy::<RuntimePstatSeries>(&sqlite_tx, &postgres_tx).await;
+    copy::<RuntimePstat>(&sqlite_tx, &postgres_tx).await;
+    copy::<ArtifactSize>(&sqlite_tx, &postgres_tx).await;
     enable_table_triggers(&postgres_tx, &tables).await;
 
     // This is overly paranoid, but don't commit the Postgres transaction until