From 30a47a7412eb442d28750354652393f02dee0e65 Mon Sep 17 00:00:00 2001
From: Daven Quinn <code@davenquinn.com>
Date: Wed, 17 Dec 2025 01:25:36 -0600
Subject: [PATCH 1/9] Update autocomplete script for PostgreSQL

---
 .idea/misc.xml                                |   1 -
 cli/macrostrat/cli/commands/base.py           |   2 +-
 .../cli/commands/process_scripts/tesselate.py |  26 ++-
 .../commands/rebuild_scripts/autocomplete.py  |  10 ++
 .../rebuild_scripts/sql/autocomplete.sql      | 170 ++++++++++++++++++
 .../api_v3_lexicon/evaluation/main.sql        |  52 +++---
 cli/macrostrat/cli/v1_entrypoint.py           |   5 +-
 7 files changed, 222 insertions(+), 44 deletions(-)
 create mode 100644 cli/macrostrat/cli/commands/rebuild_scripts/sql/autocomplete.sql

diff --git a/.idea/misc.xml b/.idea/misc.xml
index ff78eebfd..127a10a35 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,4 +1,3 @@
-<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="Black">
     <option name="enabledOnReformat" value="true" />
diff --git a/cli/macrostrat/cli/commands/base.py b/cli/macrostrat/cli/commands/base.py
index cac67804b..4f6bf05b3 100644
--- a/cli/macrostrat/cli/commands/base.py
+++ b/cli/macrostrat/cli/commands/base.py
@@ -2,7 +2,7 @@
 
 from psycopg2.extras import NamedTupleCursor
 
-from ..database import mariaConnection, pgConnection
+from ..database._legacy import pgConnection
 
 
 class Base(object):
diff --git a/cli/macrostrat/cli/commands/process_scripts/tesselate.py b/cli/macrostrat/cli/commands/process_scripts/tesselate.py
index 8e4326081..a151f3ef3 100644
--- a/cli/macrostrat/cli/commands/process_scripts/tesselate.py
+++ b/cli/macrostrat/cli/commands/process_scripts/tesselate.py
@@ -9,14 +9,12 @@
 import numpy as np
 import pyproj
 import shapely.ops as ops
-from psycopg2.extensions import AsIs
-from psycopg2.extras import NamedTupleCursor
 from scipy.spatial import Voronoi
 from shapely.geometry import MultiPoint, Point, Polygon, mapping, shape
-from shapely.ops import cascaded_union
 from shapely.wkt import loads
 
-from .. import schlep
+# TODO: don't need this any longer
+# from .. import schlep
 from ..base import Base
 
 
@@ -660,16 +658,16 @@ def run(self, args):
         self.mariadb["connection"].close()
 
         # Update postgres
-        schlep_instance = schlep(
-            {
-                "pg": self.pg["raw_connection"],
-                "mariadb": self.mariadb["raw_connection"],
-            },
-            [None, ""],
-        )
-
-        schlep_instance.move_table("col_areas")
-        schlep_instance.move_table("cols")
+        # schlep_instance = schlep(
+        #     {
+        #         "pg": self.pg["raw_connection"],
+        #         "mariadb": self.mariadb["raw_connection"],
+        #     },
+        #     [None, ""],
+        # )
+        #
+        # schlep_instance.move_table("col_areas")
+        # schlep_instance.move_table("cols")
 
         urllib.request.urlopen(
             "http://127.0.0.1:5000/api/v2/columns/refresh-cache?cacheRefreshKey=%s"
diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/autocomplete.py b/cli/macrostrat/cli/commands/rebuild_scripts/autocomplete.py
index 5d9042a30..ad31b75ce 100644
--- a/cli/macrostrat/cli/commands/rebuild_scripts/autocomplete.py
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/autocomplete.py
@@ -1,4 +1,9 @@
+from pathlib import Path
+
 from ..base import Base
+from ...database import get_db
+
+here = Path(__file__).parent
 
 
 class Autocomplete(Base):
@@ -6,6 +11,11 @@ def __init__(self, *args):
         Base.__init__(self, {}, *args)
 
     def run(self):
+        db = get_db()
+        db.run_sql(here / "sql" / "autocomplete.sql")
+        # TODO: synchonize macrostrat_api.autocomplete view
+
+    def run_legacy(self):
         self.mariadb["cursor"].execute(
             """
             DROP TABLE IF EXISTS autocomplete_new;
diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/sql/autocomplete.sql b/cli/macrostrat/cli/commands/rebuild_scripts/sql/autocomplete.sql
new file mode 100644
index 000000000..36fa67875
--- /dev/null
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/sql/autocomplete.sql
@@ -0,0 +1,170 @@
+set SEARCH_PATH to macrostrat, public;
+
+-- Two views that we could look into recreating later
+DROP VIEW IF EXISTS macrostrat.grouped_autocomplete CASCADE;
+DROP VIEW IF EXISTS macrostrat_api.autocomplete CASCADE;
+
+DROP TABLE IF EXISTS macrostrat.autocomplete_new;
+DROP TABLE IF EXISTS macrostrat.autocomplete_old;
+
+/* Create table separately to enforce column types */
+CREATE TABLE macrostrat.autocomplete_new (
+  id       integer   default 0        not null,
+  name     varchar(255) default NULL::character varying,
+  type     varchar(20)  default ''::character varying not null, -- should change this
+  category varchar(10)  default ''::character varying not null -- should change this
+);
+
+-- create index autocomplete_new_category_idx1
+--   on macrostrat.autocomplete (category);
+--
+-- create index autocomplete_new_id_idx1
+--   on macrostrat.autocomplete (id);
+--
+-- create index autocomplete_new_name_idx1
+--   on macrostrat.autocomplete (name);
+--
+-- create index autocomplete_new_type_idx1
+--   on macrostrat.autocomplete (type);
+
+
+INSERT INTO macrostrat.autocomplete_new
+SELECT * FROM (
+  SELECT id, econ AS name, 'econs' AS type, 'econ' AS category
+  FROM econs
+  UNION
+  SELECT 0 AS id, econ_type::text AS name, 'econ_types' AS type, 'econ' AS category
+  FROM econs
+  WHERE econ != econ_type::text
+  GROUP BY econ_type
+  UNION
+  SELECT 0 AS id, econ_class::text AS name, 'econ_classes' AS type, 'econ' AS category
+  FROM econs
+  GROUP BY econ_class
+  UNION
+  SELECT id, environ AS name, 'environments' AS type, 'environ' AS category
+  FROM environs
+  WHERE environ != environ_class::text
+  UNION
+  SELECT 0 AS id, environ_type::text AS name, 'environment_types' AS type, 'environ' AS category
+  FROM environs
+  GROUP BY environ_type
+  UNION
+  SELECT 0 AS id, environ_class::text AS name, 'environment_classes' AS type, 'environ' AS category
+  FROM environs
+  GROUP BY environ_class
+  UNION
+  SELECT id,
+        CONCAT(lith_att, ' (', att_type, ')') AS name,
+        'lithology_attributes'                AS type,
+        'lith_att'                            AS category
+  FROM lith_atts
+  UNION
+  SELECT id, project::text AS name, 'projects' AS type, 'project' AS category
+  FROM projects
+  UNION
+  SELECT DISTINCT strat_names_meta.concept_id AS id,
+                 name,
+                 'strat_name_concepts'       AS type,
+                 'strat_name'                AS category
+  FROM strat_names_meta
+        JOIN strat_names ON strat_names_meta.concept_id = strat_names.concept_id
+  UNION
+  (SELECT id,
+         CONCAT(strat_name, ' ', rank) AS name,
+         'strat_name_orphans'          AS type,
+         'strat_name'                  AS category
+  FROM strat_names
+  WHERE concept_id = 0)
+  UNION
+  SELECT id, col_name AS name, 'columns' AS type, 'column' AS category
+  FROM cols
+  UNION
+  SELECT id, col_group_long AS name, 'groups' AS type, 'group' AS category
+  FROM col_groups
+  UNION
+  SELECT id, lith AS name, 'lithologies' AS type, 'lithology' AS category
+  FROM liths
+  WHERE lith != lith_type::text
+   AND lith != lith_class::text
+  UNION
+  SELECT 0 AS id, lith_type::text AS name, 'lithology_types' AS type, 'lithology' AS category
+  FROM liths
+  WHERE lith_type::text != lith_class::text
+  GROUP BY lith_type
+  UNION
+  SELECT 0 AS id, lith_class::text AS name, 'lithology_classes' AS type, 'lithology' AS category
+  FROM liths
+  GROUP BY lith_class
+  UNION
+  SELECT id, interval_name AS name, 'intervals' AS type, 'interval' AS category
+  FROM intervals
+  UNION
+  SELECT id, mineral AS name, 'minerals' AS type, 'mineral' AS category
+  FROM minerals
+  UNION
+  SELECT id, structure AS name, 'structures' AS type, 'structure' AS category
+  FROM structures
+) i;
+
+
+
+UPDATE macrostrat.autocomplete_new a
+SET name = sub.name
+FROM (
+  SELECT concept_id, CONCAT(name, COALESCE(CONCAT(' (', interval_name, ')'), '')) AS name
+  FROM strat_names_meta
+         LEFT JOIN intervals ON intervals.id = strat_names_meta.interval_id
+) sub
+WHERE a.id IN (
+  SELECT id FROM (
+    SELECT id
+    FROM autocomplete_new
+    WHERE name IN (
+      SELECT name
+      FROM (
+        SELECT name, type, count(*)
+        FROM autocomplete_new
+        WHERE type = 'strat_name_concepts'
+        GROUP BY name, type
+        HAVING count(*) > 1
+        ORDER BY count(*) desc
+      ) a
+    )
+  ) b
+) AND type = 'strat_name_concepts'
+AND a.id = sub.concept_id;
+
+UPDATE autocomplete_new AS a
+SET name = sub.name
+FROM (
+  SELECT DISTINCT strat_names.id, CONCAT(strat_name, ' (', FO_period, ')') AS name
+  FROM strat_names
+  JOIN unit_strat_names ON strat_names.id = unit_strat_names.strat_name_id
+  JOIN lookup_unit_intervals ON lookup_unit_intervals.unit_id = unit_strat_names.unit_id
+) sub
+WHERE a.id = sub.id
+  AND a.id IN (
+    SELECT id FROM (
+      SELECT id
+      FROM autocomplete_new
+      WHERE name IN (
+        SELECT name
+        FROM (
+          SELECT name, type, count(*)
+          FROM autocomplete_new
+          WHERE type = 'strat_name_orphans'
+          GROUP BY name, type
+          HAVING count(*) > 1
+          ORDER BY count(*) desc
+        ) a
+      )
+    ) b
+  ) AND type = 'strat_name_orphans';
+
+ALTER TABLE macrostrat.autocomplete
+  RENAME TO autocomplete_old;
+
+ALTER TABLE macrostrat.autocomplete_new
+  RENAME TO autocomplete;
+
diff --git a/cli/macrostrat/cli/database/migrations/api_v3_lexicon/evaluation/main.sql b/cli/macrostrat/cli/database/migrations/api_v3_lexicon/evaluation/main.sql
index 91d7914f1..5253f756a 100644
--- a/cli/macrostrat/cli/database/migrations/api_v3_lexicon/evaluation/main.sql
+++ b/cli/macrostrat/cli/database/migrations/api_v3_lexicon/evaluation/main.sql
@@ -1,34 +1,34 @@
 CREATE OR REPLACE VIEW macrostrat_api.autocomplete as
- SELECT autocomplete.id,
-    autocomplete.name,
-    autocomplete.type,
-    autocomplete.category
-   FROM macrostrat.autocomplete
+SELECT autocomplete.id,
+       autocomplete.name,
+       autocomplete.type,
+       autocomplete.category
+FROM macrostrat.autocomplete
 UNION ALL
- SELECT sources.source_id AS id,
-    sources.name,
-    'sources'::character varying AS type,
-    'maps'::character varying AS category
-   FROM maps.sources
+SELECT sources.source_id AS id,
+       sources.name,
+       'sources'::character varying AS type,
+       'maps'::character varying AS category
+FROM maps.sources
 UNION ALL
- SELECT cols.id,
-    cols.col_name AS name,
-    'col'::character varying AS type,
-    'columns'::character varying AS category
-   FROM macrostrat.cols
+SELECT cols.id,
+       cols.col_name AS name,
+       'col'::character varying AS type,
+       'columns'::character varying AS category
+FROM macrostrat.cols
 UNION ALL
- SELECT projects.id,
-    projects.project::text AS name,
-    'project'::character varying AS type,
-    'projects'::character varying AS category
-   FROM macrostrat.projects
+SELECT projects.id,
+       projects.project::text AS name,
+       'project'::character varying AS type,
+       'projects'::character varying AS category
+FROM macrostrat.projects
 UNION ALL
-  SELECT strat_names.id,
-    strat_names.strat_name::text AS name,
-    'strat_name'::character varying AS type,
-    'strat_names'::character varying AS category
-   FROM macrostrat.strat_names
-   where concept_id is null;
+SELECT strat_names.id,
+       strat_names.strat_name::text AS name,
+       'strat_name'::character varying AS type,
+       'strat_names'::character varying AS category
+FROM macrostrat.strat_names
+where concept_id is null;
 
 /**
   TODO: this is not needed but we keep it around for reference
diff --git a/cli/macrostrat/cli/v1_entrypoint.py b/cli/macrostrat/cli/v1_entrypoint.py
index 1be8f627e..dc9d849c7 100644
--- a/cli/macrostrat/cli/v1_entrypoint.py
+++ b/cli/macrostrat/cli/v1_entrypoint.py
@@ -27,6 +27,7 @@
 
 import click
 
+
 # CLI with unprocessed arguments
 
 
@@ -37,7 +38,7 @@ def v1_cli(args):
     # import all available commands
     from . import __version__ as VERSION
     from . import commands
-    from .database import mariaConnection, pgConnection
+    from .database._legacy import pgConnection
 
     # No parameters
     if len(args) == 0:
@@ -60,7 +61,7 @@ def v1_cli(args):
     # Get the class associated with the provided table name
     script = getattr(commands, cmd)
 
-    script = script({"pg": pgConnection, "mariadb": mariaConnection}, *args)
+    script = script({"pg": pgConnection, "mariadb": None}, *args)
 
     if len(args) == 1 or args[1] == "--help" or args[1] == "-h":
         # Print script help

From 863c144a290ddda7f28a332faa0e44cc092dcd02 Mon Sep 17 00:00:00 2001
From: Daven Quinn <code@davenquinn.com>
Date: Wed, 17 Dec 2025 02:16:32 -0600
Subject: [PATCH 2/9] Start working on lookup_strat_names

---
 .../rebuild_scripts/lookup_strat_names.py     | 468 +++++++++---------
 .../sql/lookup-strat-names.sql                |  97 ++++
 2 files changed, 329 insertions(+), 236 deletions(-)
 create mode 100644 cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names.sql

diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py b/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
index 701557924..cecbea73f 100644
--- a/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
@@ -1,4 +1,11 @@
+from pathlib import Path
+
+from psycopg2.sql import Identifier
+
 from ..base import Base
+from ...database import get_db
+
+here = Path(__file__).parent
 
 
 class LookupStratNames(Base):
@@ -6,6 +13,9 @@ def __init__(self, *args):
         Base.__init__(self, {}, *args)
 
     def run(self):
+        db = get_db()
+        db.run_sql(here / "sql" / "lookup-strat-names.sql")
+
         lookup_rank_children = {
             "sgp": ["SGp", "Gp", "SubGp", "Fm", "Mbr", "Bed"],
             "gp": ["Gp", "SubGp", "Fm", "Mbr", "Bed"],
@@ -15,114 +25,103 @@ def run(self):
             "bed": ["Bed"],
         }
 
-        # Copy structure to new table
-        self.mariadb["cursor"].execute(
-            """
-            DROP TABLE IF EXISTS lookup_strat_names_new;
-        """
-        )
-        self.mariadb["cursor"].close()
-        self.mariadb["cursor"] = self.mariadb["connection"].cursor()
-
-        self.mariadb["cursor"].execute(
-            """
-            DROP TABLE IF EXISTS lookup_strat_names_old;
-        """
-        )
-        self.mariadb["cursor"].close()
-        self.mariadb["cursor"] = self.mariadb["connection"].cursor()
-
-        self.mariadb["cursor"].execute(
-            """
-            CREATE TABLE lookup_strat_names_new LIKE lookup_strat_names;
-        """
-        )
-        self.mariadb["cursor"].close()
-        self.mariadb["cursor"] = self.mariadb["connection"].cursor()
-
         # Get all the strat names
-        self.mariadb["cursor"].execute(
+        res = db.run_query(
             """
             SELECT *
             FROM strat_names
             WHERE rank != ''
-            ORDER BY strat_name ASC
-        """
+            ORDER BY strat_name
+            """
         )
 
-        update_connection = self.mariadb["raw_connection"]()
-        update_cursor = update_connection.cursor()
-
-        for strat_name in self.mariadb["cursor"]:
+        for strat_name in res:
             rank_id = strat_name["rank"] + "_id"
             rank_name = strat_name["rank"] + "_name"
 
-            update_cursor.execute(
+            db.run_sql(
                 """
-              INSERT INTO lookup_strat_names_new (ref_id, concept_id, strat_name_id, strat_name, rank, """
-                + rank_id
-                + """, """
-                + rank_name
-                + """)
-              VALUES (%s, %s, %s, %s, %s, %s, %s)
-            """,
-                [
-                    strat_name["ref_id"],
-                    strat_name["concept_id"],
-                    strat_name["id"],
-                    strat_name["strat_name"],
-                    strat_name["rank"],
-                    strat_name["id"],
-                    strat_name["strat_name"],
-                ],
+                INSERT INTO macrostrat.lookup_strat_names_new (
+                    ref_id,
+                    concept_id,
+                    strat_name_id,
+                    strat_name,
+                    rank,
+                    {rank_id_col},
+                    {rank_name_col}
+                )
+                VALUES (:ref_id, :concept_id, :strat_name_id, :strat_name, :rank, :rank_id, :rank_name)
+                """,
+                dict(
+                    ref_id=strat_name["ref_id"],
+                    concept_id=strat_name["concept_id"],
+                    strat_name_id=strat_name["id"],
+                    strat_name=strat_name["strat_name"],
+                    rank=strat_name["rank"],
+                    rank_id=strat_name["id"],
+                    rank_name=strat_name["strat_name"],
+                    rank_id_col=Identifier(rank_id),
+                    rank_name_col=Identifier(rank_name),
+                ),
             )
-            update_connection.commit()
+            db.session.commit()
 
             has_parent = True
             name_id = strat_name["id"]
 
             while has_parent:
                 # Get the parent of this unit
-                update_cursor.execute(
-                    """
-                    SELECT this_name, strat_name, strat_names.id id, rank
-                    FROM strat_tree
-                    JOIN strat_names ON this_name = strat_names.id
-                    WHERE that_name = %s and rel = 'parent' and rank != ''
-                """,
-                    [name_id],
-                )
-                parent = update_cursor.fetchone()
 
-                update_cursor.close()
-                update_cursor = update_connection.cursor()
+                # Note: in PostgreSQL, the column `this_name` has been renamed to `parent`,
+                # and `that_name` has been renamed to `child`.
+                # Another note: there are only 3 entries in strat_tree where rel != 'parent', on 2025-12-17
+                parent = db.run_query(
+                    """
+                    SELECT
+                        parent, -- this_name has been renamed to parent
+                        strat_name,
+                        strat_names.id,
+                        rank
+                    FROM macrostrat.strat_tree
+                    JOIN macrostrat.strat_names
+                      ON parent = strat_names.id
+                    WHERE child = :name
+                      AND rel = 'parent' and rank != ''
+                    """,
+                    dict(name=name_id),
+                ).fetchone()
 
                 if parent is None:
+                    # Sketchy null check, we should improve this...
                     name_id = 0
                 else:
                     name_id = parent["id"]
+
+                if name_id > 0 and parent is not None:
                     parent_rank_id = parent["rank"] + "_id"
                     parent_rank_name = parent["rank"] + "_name"
-
-                if name_id > 0:
-                    update_cursor.execute(
+                    db.run_sql(
                         """
-                      UPDATE lookup_strat_names_new
-                      SET """
-                        + parent_rank_id
-                        + """ = %s, """
-                        + parent_rank_name
-                        + """ = %s
-                      WHERE strat_name_id = %s
-                    """,
-                        [parent["id"], parent["strat_name"], strat_name["id"]],
+                        UPDATE macrostrat.lookup_strat_names_new
+                        SET {parent_rank_id_col} = :parent_id, {parent_rank_name_col} = :parent_name
+                        WHERE strat_name_id = :strat_name_id
+                        """,
+                        dict(
+                            parent_rank_id_col=Identifier(parent_rank_id),
+                            parent_rank_name=Identifier(parent_rank_name),
+                            parent_id=parent["id"],
+                            parent_name=parent["strat_name"],
+                            strat_name_id=strat_name["id"],
+                        ),
                     )
-                    update_connection.commit()
+
                 else:
                     has_parent = False
 
+                _rank = strat_name["rank"].lower()
+
                 sql = """
-                UPDATE lookup_strat_names_new SET t_units = (
+                UPDATE macrostrat.lookup_strat_names_new SET t_units = (
                   SELECT COUNT(*)
                   FROM unit_strat_names
                   LEFT JOIN units_sections ON unit_strat_names.unit_id = units_sections.unit_id
@@ -130,40 +129,37 @@ def run(self):
                   WHERE unit_strat_names.strat_name_id IN (
                     SELECT strat_name_id
                     FROM lookup_strat_names
-                    WHERE %s_id = %s AND rank IN """ % (
-                    strat_name["rank"].lower(),
-                    strat_name["id"],
-                )
+                    WHERE {rank_col} = :strat_name_id
+                      AND rank = ANY(:strat_name_ranks)
+                      AND cols.status_code = 'active'
+                ) WHERE strat_name_id = :strat_name_id
+                """,
 
-                placeholders = ["%s"] * len(
-                    lookup_rank_children[strat_name["rank"].lower()]
+                params = dict(
+                    rank_col=Identifier(_rank + "_id"),
+                    strat_name_id=strat_name["id"],
+                    strat_name_ranks=lookup_rank_children[_rank],
                 )
-                sql += (
-                    " ("
-                    + ",".join(placeholders)
-                    + ")) AND cols.status_code = 'active') WHERE strat_name_id = %s"
-                )
-                params = [x for x in lookup_rank_children[strat_name["rank"].lower()]]
-                params.append(strat_name["id"])
-                update_cursor.execute(sql, params)
-                update_connection.commit()
 
-        update_cursor.close()
-        update_connection.close()
+                db.run_sql(sql, params)
+                db.session.commit()
+
+
+        db.session.commit()
 
         # Populate `early_age` and `late_age`
         self.mariadb["cursor"].execute(
             """
-          UPDATE lookup_strat_names_new lsn
-          LEFT JOIN (
-            SELECT strat_name_id, max(b_age) AS early_age, min(t_age) AS late_age
-            FROM lookup_strat_names_new
-            LEFT JOIN unit_strat_names USING (strat_name_id)
-            LEFT JOIN lookup_unit_intervals USING (unit_id)
-            GROUP BY strat_name_id
-          ) AS sub USING (strat_name_id)
-          SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
-        """
+            UPDATE lookup_strat_names_new lsn
+                LEFT JOIN (
+                SELECT strat_name_id, max(b_age) AS early_age, min(t_age) AS late_age
+                FROM lookup_strat_names_new
+                LEFT JOIN unit_strat_names USING (strat_name_id)
+                LEFT JOIN lookup_unit_intervals USING (unit_id)
+                GROUP BY strat_name_id
+                ) AS sub USING (strat_name_id)
+            SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
+            """
         )
         self.mariadb["connection"].commit()
 
@@ -171,27 +167,27 @@ def run(self):
         self.mariadb["cursor"].execute(
             """
             UPDATE lookup_strat_names_new SET rank_name =
-            CASE
-            	WHEN SUBSTRING_INDEX(strat_name, ' ', -1) IN ('Suite', 'Volcanics', 'Complex', 'Melange', 'Series', 'Supersuite', 'Tongue', 'Lens', 'Lentil', 'Drift', 'Metamorphics', 'Sequence', 'Supersequence', 'Intrusives', 'Measures', 'Division', 'Subsuite')
-                	THEN strat_name
-                WHEN LOWER(SUBSTRING_INDEX(strat_name, ' ', -1)) IN (SELECT lith FROM liths) AND rank = 'fm'
-                	THEN strat_name
-                 WHEN SUBSTRING_INDEX(strat_name, ' ', -1) = 'Beds' AND rank = 'Bed'
-                    THEN strat_name
-            	WHEN rank = 'SGp' THEN
-                	CONCAT(strat_name, ' Supergroup')
-            	WHEN rank = 'Gp' THEN
-                	CONCAT(strat_name, ' Group')
-              WHEN rank = 'SubGp' THEN
-                  CONCAT(strat_name, ' Subgroup')
-                WHEN rank = 'Fm' THEN
-                	CONCAT(strat_name, ' Formation')
-                WHEN rank = 'Mbr' THEN
-                	CONCAT(strat_name, ' Member')
-                WHEN rank = 'Bed' THEN
-                	CONCAT(strat_name, ' Bed')
-            END
-        """
+                                                  CASE
+                                                      WHEN SUBSTRING_INDEX(strat_name, ' ', -1) IN ('Suite', 'Volcanics', 'Complex', 'Melange', 'Series', 'Supersuite', 'Tongue', 'Lens', 'Lentil', 'Drift', 'Metamorphics', 'Sequence', 'Supersequence', 'Intrusives', 'Measures', 'Division', 'Subsuite')
+                                                          THEN strat_name
+                                                      WHEN LOWER(SUBSTRING_INDEX(strat_name, ' ', -1)) IN (SELECT lith FROM liths) AND rank = 'fm'
+                                                          THEN strat_name
+                                                      WHEN SUBSTRING_INDEX(strat_name, ' ', -1) = 'Beds' AND rank = 'Bed'
+                                                          THEN strat_name
+                                                      WHEN rank = 'SGp' THEN
+                                                          CONCAT(strat_name, ' Supergroup')
+                                                      WHEN rank = 'Gp' THEN
+                                                          CONCAT(strat_name, ' Group')
+                                                      WHEN rank = 'SubGp' THEN
+                                                          CONCAT(strat_name, ' Subgroup')
+                                                      WHEN rank = 'Fm' THEN
+                                                          CONCAT(strat_name, ' Formation')
+                                                      WHEN rank = 'Mbr' THEN
+                                                          CONCAT(strat_name, ' Member')
+                                                      WHEN rank = 'Bed' THEN
+                                                          CONCAT(strat_name, ' Bed')
+                                                      END
+            """
         )
         self.mariadb["connection"].commit()
 
@@ -201,7 +197,7 @@ def run(self):
             SELECT count(*) sn, (SELECT count(*) from lookup_strat_names_new) lsn
             FROM strat_names
             WHERE rank != ''
-        """
+            """
         )
         row = self.mariadb["cursor"].fetchone()
         if row["sn"] != row["lsn"]:
@@ -217,26 +213,26 @@ def run(self):
         # Populate the fields `parent` and `tree`
         self.mariadb["cursor"].execute(
             """
-          UPDATE lookup_strat_names_new
-          SET parent = CASE
-            WHEN bed_id > 0 AND strat_name_id != bed_id THEN bed_id
-            WHEN mbr_id > 0 AND strat_name_id != mbr_id THEN mbr_id
-            WHEN fm_id > 0 AND strat_name_id != fm_id THEN fm_id
-            WHEN subgp_id > 0 AND strat_name_id != subgp_id THEN subgp_id
-            WHEN gp_id > 0 AND strat_name_id != gp_id THEN gp_id
-            WHEN sgp_id > 0 AND strat_name_id != sgp_id THEN sgp_id
-            ELSE strat_name_id
-          END,
-            tree = CASE
-            WHEN sgp_id > 0 THEN sgp_id
-            WHEN gp_id > 0 THEN gp_id
-            WHEN subgp_id > 0 THEN subgp_id
-            WHEN fm_id > 0 THEN fm_id
-            WHEN mbr_id > 0 THEN mbr_id
-            WHEN bed_id > 0 THEN bed_id
-            ELSE tree = 0
-          END
-        """
+            UPDATE lookup_strat_names_new
+            SET parent = CASE
+                             WHEN bed_id > 0 AND strat_name_id != bed_id THEN bed_id
+                             WHEN mbr_id > 0 AND strat_name_id != mbr_id THEN mbr_id
+                             WHEN fm_id > 0 AND strat_name_id != fm_id THEN fm_id
+                             WHEN subgp_id > 0 AND strat_name_id != subgp_id THEN subgp_id
+                             WHEN gp_id > 0 AND strat_name_id != gp_id THEN gp_id
+                             WHEN sgp_id > 0 AND strat_name_id != sgp_id THEN sgp_id
+                             ELSE strat_name_id
+                END,
+                tree = CASE
+                           WHEN sgp_id > 0 THEN sgp_id
+                           WHEN gp_id > 0 THEN gp_id
+                           WHEN subgp_id > 0 THEN subgp_id
+                           WHEN fm_id > 0 THEN fm_id
+                           WHEN mbr_id > 0 THEN mbr_id
+                           WHEN bed_id > 0 THEN bed_id
+                           ELSE tree = 0
+                    END
+            """
         )
         self.mariadb["connection"].commit()
 
@@ -244,17 +240,17 @@ def run(self):
         self.mariadb["cursor"].execute(
             """
             UPDATE lookup_strat_names_new lsn
-             LEFT JOIN (
-               SELECT concept_id, max(b_age) AS early_age, min(t_age) AS late_age
-               FROM lookup_strat_names_new
-               LEFT JOIN unit_strat_names USING (strat_name_id)
-               LEFT JOIN lookup_unit_intervals USING (unit_id)
-               WHERE concept_id != 0
-               GROUP BY strat_name_id
-             ) AS sub USING (concept_id)
-             SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
+                LEFT JOIN (
+                SELECT concept_id, max(b_age) AS early_age, min(t_age) AS late_age
+                FROM lookup_strat_names_new
+                LEFT JOIN unit_strat_names USING (strat_name_id)
+                LEFT JOIN lookup_unit_intervals USING (unit_id)
+                WHERE concept_id != 0
+                GROUP BY strat_name_id
+                ) AS sub USING (concept_id)
+            SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
              WHERE lsn.early_age IS NULL AND lsn.late_age IS NULL
-        """
+            """
         )
         self.mariadb["connection"].commit()
 
@@ -262,15 +258,15 @@ def run(self):
         self.mariadb["cursor"].execute(
             """
             UPDATE lookup_strat_names_new lsn
-            LEFT JOIN (
+                LEFT JOIN (
                 SELECT concept_id, b.age_bottom, t.age_top
                 FROM strat_names_meta
                 JOIN intervals b on b.id = b_int
                 JOIN intervals t ON t.id = t_int
-            ) AS sub USING (concept_id)
+                ) AS sub USING (concept_id)
             SET lsn.early_age = sub.age_bottom, lsn.late_age = sub.age_top
             WHERE lsn.early_age IS NULL AND lsn.late_age IS NULL
-        """
+            """
         )
         self.mariadb["connection"].commit()
 
@@ -278,16 +274,16 @@ def run(self):
         self.mariadb["cursor"].execute(
             """
             UPDATE lookup_strat_names_new lsn
-             LEFT JOIN (
-               SELECT parent, max(b_age) AS early_age, min(t_age) AS late_age
-               FROM lookup_strat_names_new
-               LEFT JOIN unit_strat_names USING (strat_name_id)
-               LEFT JOIN lookup_unit_intervals USING (unit_id)
-               GROUP BY parent
-             ) AS sub USING (parent)
-             SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
+                LEFT JOIN (
+                SELECT parent, max(b_age) AS early_age, min(t_age) AS late_age
+                FROM lookup_strat_names_new
+                LEFT JOIN unit_strat_names USING (strat_name_id)
+                LEFT JOIN lookup_unit_intervals USING (unit_id)
+                GROUP BY parent
+                ) AS sub USING (parent)
+            SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
              WHERE lsn.early_age IS NULL AND lsn.late_age IS NULL
-        """
+            """
         )
         self.mariadb["connection"].commit()
 
@@ -295,49 +291,49 @@ def run(self):
         self.mariadb["cursor"].execute(
             """
             UPDATE lookup_strat_names_new lsn
-             LEFT JOIN (
-               SELECT tree, max(b_age) AS early_age, min(t_age) AS late_age
-               FROM lookup_strat_names
-               LEFT JOIN unit_strat_names USING (strat_name_id)
-               LEFT JOIN lookup_unit_intervals USING (unit_id)
-               GROUP BY tree
-             ) AS sub USING (tree)
-             SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
+                LEFT JOIN (
+                SELECT tree, max(b_age) AS early_age, min(t_age) AS late_age
+                FROM lookup_strat_names
+                LEFT JOIN unit_strat_names USING (strat_name_id)
+                LEFT JOIN lookup_unit_intervals USING (unit_id)
+                GROUP BY tree
+                ) AS sub USING (tree)
+            SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
              WHERE lsn.early_age IS NULL AND lsn.late_age IS NULL
-        """
+            """
         )
         self.mariadb["connection"].commit()
 
         # Populate the fields `b_period` and `t_period`
         self.mariadb["cursor"].execute(
             """
-          UPDATE lookup_strat_names_new
-          SET b_period = (
-            SELECT interval_name
-            FROM macrostrat.intervals
-            JOIN timescales_intervals ON intervals.id = timescales_intervals.interval_id
-            JOIN timescales ON timescales.id = timescales_intervals.timescale_id
-            WHERE age_bottom >= early_age AND age_top <= early_age
-            AND timescales.id = 20
-            LIMIT 1
-          );
-        """
+            UPDATE lookup_strat_names_new
+            SET b_period = (
+                SELECT interval_name
+                FROM macrostrat.intervals
+                         JOIN timescales_intervals ON intervals.id = timescales_intervals.interval_id
+                         JOIN timescales ON timescales.id = timescales_intervals.timescale_id
+                WHERE age_bottom >= early_age AND age_top <= early_age
+                  AND timescales.id = 20
+                LIMIT 1
+            );
+            """
         )
         self.mariadb["connection"].commit()
 
         self.mariadb["cursor"].execute(
             """
-          UPDATE lookup_strat_names_new
-          SET t_period = (
-            SELECT interval_name
-            FROM intervals
-            JOIN timescales_intervals ON intervals.id = timescales_intervals.interval_id
-            JOIN timescales ON timescales.id = timescales_intervals.timescale_id
-            WHERE age_bottom >= late_age AND age_top <= late_age
-            AND timescales.id = 20
-            LIMIT 1
-          );
-        """
+            UPDATE lookup_strat_names_new
+            SET t_period = (
+                SELECT interval_name
+                FROM intervals
+                         JOIN timescales_intervals ON intervals.id = timescales_intervals.interval_id
+                         JOIN timescales ON timescales.id = timescales_intervals.timescale_id
+                WHERE age_bottom >= late_age AND age_top <= late_age
+                  AND timescales.id = 20
+                LIMIT 1
+            );
+            """
         )
         self.mariadb["connection"].commit()
 
@@ -345,23 +341,23 @@ def run(self):
         self.mariadb["cursor"].execute(
             """
             UPDATE lookup_strat_names_new
-            JOIN strat_names_meta USING (concept_id)
-            JOIN intervals t on t.id = t_int
-            JOIN intervals b on b.id = b_int
+                JOIN strat_names_meta USING (concept_id)
+                JOIN intervals t on t.id = t_int
+                JOIN intervals b on b.id = b_int
             SET c_interval = (
                 SELECT interval_name
                 FROM intervals
-                JOIN timescales_intervals ON intervals.id = interval_id
-                JOIN timescales ON timescale_id = timescales.id
+                         JOIN timescales_intervals ON intervals.id = interval_id
+                         JOIN timescales ON timescale_id = timescales.id
                 WHERE timescale = 'international'
-                    AND b.age_bottom > age_top
-                    AND b.age_bottom <= age_bottom
-                    AND t.age_top < age_bottom
-                    AND t.age_top >= age_top
+                  AND b.age_bottom > age_top
+                  AND b.age_bottom <= age_bottom
+                  AND t.age_top < age_bottom
+                  AND t.age_top >= age_top
                 ORDER BY age_bottom - age_top
                 LIMIT 1
             ),
-            b_period = (
+                b_period = (
                 SELECT interval_name
                 FROM intervals
                 JOIN timescales_intervals ON intervals.id = interval_id
@@ -388,7 +384,7 @@ def run(self):
                 LIMIT 1
             )
             WHERE c_interval IS NULL and t_int > 0 and b_int > 0;
-        """
+            """
         )
         self.mariadb["connection"].commit()
 
@@ -399,7 +395,7 @@ def run(self):
         self.mariadb["cursor"].execute(
             """
             SELECT lith FROM liths
-        """
+            """
         )
         lith_results = self.mariadb["cursor"].fetchall()
         lithologies = [lith["lith"] for lith in lith_results]
@@ -423,7 +419,7 @@ def run(self):
         self.mariadb["cursor"].execute(
             """
             SELECT strat_name_id, strat_name FROM lookup_strat_names_new
-        """
+            """
         )
         for strat_name in self.mariadb["cursor"].fetchall():
             split_name = strat_name["strat_name"].split(" ")
@@ -434,8 +430,8 @@ def run(self):
             print(strat_name["strat_name_id"], name_no_lith)
             update_cursor.execute(
                 """
-              UPDATE lookup_strat_names_new SET name_no_lith = %(name_no_lith)s WHERE strat_name_id = %(strat_name_id)s
-            """,
+                UPDATE lookup_strat_names_new SET name_no_lith = %(name_no_lith)s WHERE strat_name_id = %(strat_name_id)s
+                """,
                 {
                     "name_no_lith": name_no_lith,
                     "strat_name_id": strat_name["strat_name_id"],
@@ -450,19 +446,19 @@ def run(self):
         # Make sure all names have an early and late_age
         self.mariadb["cursor"].execute(
             """
-          UPDATE lookup_strat_names_new
-          SET early_age = (
-            SELECT age_bottom
-            FROM macrostrat.intervals
-            WHERE interval_name = b_period
-            LIMIT 1
-          ), late_age = (
-            SELECT age_top
-            FROM macrostrat.intervals
-            WHERE interval_name = t_period
-            LIMIT 1
-          ) WHERE early_age IS NULL AND late_age IS NULL;
-        """
+            UPDATE lookup_strat_names_new
+            SET early_age = (
+                SELECT age_bottom
+                FROM macrostrat.intervals
+                WHERE interval_name = b_period
+                LIMIT 1
+            ), late_age = (
+                SELECT age_top
+                FROM macrostrat.intervals
+                WHERE interval_name = t_period
+                LIMIT 1
+            ) WHERE early_age IS NULL AND late_age IS NULL;
+            """
         )
         self.mariadb["connection"].commit()
 
@@ -472,17 +468,17 @@ def run(self):
             UPDATE lookup_strat_names_new
             SET c_interval = (
                 SELECT interval_name from intervals
-            	JOIN timescales_intervals ON intervals.id = interval_id
-            	JOIN timescales on timescale_id = timescales.id
-            	WHERE timescale = 'international'
-            		AND early_age > age_top
-            		AND early_age <= age_bottom
-            		AND late_age < age_bottom
-            		AND late_age >= age_top
-            		ORDER BY age_bottom - age_top
-                    LIMIT 1
+                                              JOIN timescales_intervals ON intervals.id = interval_id
+                                              JOIN timescales on timescale_id = timescales.id
+                WHERE timescale = 'international'
+                  AND early_age > age_top
+                  AND early_age <= age_bottom
+                  AND late_age < age_bottom
+                  AND late_age >= age_top
+                ORDER BY age_bottom - age_top
+                LIMIT 1
             )
-        """
+            """
         )
         self.mariadb["connection"].commit()
 
diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names.sql b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names.sql
new file mode 100644
index 000000000..e5ddbccea
--- /dev/null
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names.sql
@@ -0,0 +1,97 @@
+set SEARCH_PATH to macrostrat, public;
+
+DROP TABLE IF EXISTS macrostrat.lookup_strat_names_new;
+DROP TABLE IF EXISTS macrostrat.lookup_strat_names_old;
+
+CREATE TABLE macrostrat.lookup_strat_names (
+  strat_name_id integer NOT NULL PRIMARY KEY,
+  strat_name    varchar(100) NOT NULL,
+  rank          macrostrat.lookup_strat_names_rank,
+  concept_id    integer      NOT NULL,
+  rank_name     varchar(100) NOT NULL,
+  bed_id        integer      NOT NULL,
+  bed_name      varchar(100)  DEFAULT NULL::character varying,
+  mbr_id        integer      NOT NULL,
+  mbr_name      varchar(100)  DEFAULT NULL::character varying,
+  fm_id         integer      NOT NULL,
+  fm_name       varchar(100)  DEFAULT NULL::character varying,
+  subgp_id      integer      NOT NULL,
+  subgp_name    varchar(100)  DEFAULT NULL::character varying,
+  gp_id         integer      NOT NULL,
+  gp_name       varchar(100)  DEFAULT NULL::character varying,
+  sgp_id        integer      NOT NULL,
+  sgp_name      varchar(100)  DEFAULT NULL::character varying,
+  early_age     numeric(8, 4) DEFAULT NULL::numeric,
+  late_age      numeric(8, 4) DEFAULT NULL::numeric,
+  gsc_lexicon   char(15)      DEFAULT NULL::bpchar,
+  parent        integer      NOT NULL,
+  tree          integer      NOT NULL,
+  t_units       integer      NOT NULL,
+  b_period      varchar(100)  DEFAULT NULL::character varying,
+  t_period      varchar(100)  DEFAULT NULL::character varying,
+  name_no_lith  varchar(100)  DEFAULT NULL::character varying,
+  ref_id        integer      NOT NULL,
+  c_interval    varchar(100)  DEFAULT NULL::character varying
+);
+
+/** Indexes; may be auto-generated?
+CREATE INDEX idx_lookup_strat_names_bed_id
+  ON lookup_strat_names (bed_id);
+
+CREATE INDEX idx_lookup_strat_names_concept_id
+  ON lookup_strat_names (concept_id);
+
+CREATE INDEX idx_lookup_strat_names_fm_id
+  ON lookup_strat_names (fm_id);
+
+CREATE INDEX idx_lookup_strat_names_gp_id
+  ON lookup_strat_names (gp_id);
+
+CREATE INDEX idx_lookup_strat_names_mbr_id
+  ON lookup_strat_names (mbr_id);
+
+CREATE INDEX idx_lookup_strat_names_parent
+  ON lookup_strat_names (parent);
+
+CREATE INDEX idx_lookup_strat_names_rank
+  ON lookup_strat_names (rank);
+
+CREATE INDEX idx_lookup_strat_names_ref_id
+  ON lookup_strat_names (ref_id);
+
+CREATE INDEX idx_lookup_strat_names_sgp_id
+  ON lookup_strat_names (sgp_id);
+
+CREATE INDEX idx_lookup_strat_names_strat_name
+  ON lookup_strat_names (strat_name);
+
+CREATE INDEX idx_lookup_strat_names_subgp_id
+  ON lookup_strat_names (subgp_id);
+
+CREATE INDEX idx_lookup_strat_names_tree
+  ON lookup_strat_names (tree);
+
+CREATE INDEX lookup_strat_names_new_bed_id_idx
+  ON lookup_strat_names (bed_id);
+
+CREATE INDEX lookup_strat_names_new_concept_id_idx
+  ON lookup_strat_names (concept_id);
+
+CREATE INDEX lookup_strat_names_new_fm_id_idx
+  ON lookup_strat_names (fm_id);
+
+CREATE INDEX lookup_strat_names_new_gp_id_idx
+  ON lookup_strat_names (gp_id);
+
+CREATE INDEX lookup_strat_names_new_mbr_id_idx
+  ON lookup_strat_names (mbr_id);
+
+CREATE INDEX lookup_strat_names_new_sgp_id_idx
+  ON lookup_strat_names (sgp_id);
+
+CREATE INDEX lookup_strat_names_new_strat_name_id_idx
+  ON lookup_strat_names (strat_name_id);
+
+CREATE INDEX lookup_strat_names_new_strat_name_idx
+  ON lookup_strat_names (strat_name);
+*/

From 6deba42927a352f35fd524f201497e1d0bb8bfd7 Mon Sep 17 00:00:00 2001
From: Daven Quinn <code@davenquinn.com>
Date: Wed, 17 Dec 2025 03:03:24 -0600
Subject: [PATCH 3/9] Updated lookup_strat_names script, not quite finished

---
 .../commands/rebuild_scripts/autocomplete.py  | 170 +-------
 .../rebuild_scripts/lookup_strat_names.py     | 363 ++++--------------
 ...at-names.sql => lookup-strat-names-01.sql} |   0
 .../sql/lookup-strat-names-02.sql             | 143 +++++++
 .../sql/lookup-strat-names-03.sql             |  38 ++
 5 files changed, 252 insertions(+), 462 deletions(-)
 rename cli/macrostrat/cli/commands/rebuild_scripts/sql/{lookup-strat-names.sql => lookup-strat-names-01.sql} (100%)
 create mode 100644 cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-02.sql
 create mode 100644 cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-03.sql

diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/autocomplete.py b/cli/macrostrat/cli/commands/rebuild_scripts/autocomplete.py
index ad31b75ce..4d024c38a 100644
--- a/cli/macrostrat/cli/commands/rebuild_scripts/autocomplete.py
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/autocomplete.py
@@ -5,6 +5,8 @@
 
 here = Path(__file__).parent
 
+# NOTE: this was successfully migrated from MariaDB to PostgreSQL on 2025-12-16
+
 
 class Autocomplete(Base):
     def __init__(self, *args):
@@ -14,171 +16,3 @@ def run(self):
         db = get_db()
         db.run_sql(here / "sql" / "autocomplete.sql")
         # TODO: synchonize macrostrat_api.autocomplete view
-
-    def run_legacy(self):
-        self.mariadb["cursor"].execute(
-            """
-            DROP TABLE IF EXISTS autocomplete_new;
-        """
-        )
-        self.mariadb["connection"].commit()
-        self.mariadb["cursor"].execute(
-            """
-            DROP TABLE IF EXISTS autocomplete_old;
-        """
-        )
-        self.mariadb["connection"].commit()
-
-        # Build the new table
-        self.mariadb["cursor"].execute(
-            """
-            CREATE TABLE autocomplete_new AS
-              SELECT * FROM (
-                select id, econ as name, 'econs' as type, 'econ' as category from econs
-                union
-                select 0 AS id, econ_type AS name, 'econ_types' AS type, 'econ' as category
-                FROM econs
-                WHERE econ != econ_type
-                GROUP BY econ_type
-                union
-                SELECT 0 AS id, econ_class AS name, 'econ_classes' AS type, 'econ' as category FROM econs GROUP BY econ_class
-                union
-                select id, environ as name, 'environments' as type, 'environ' as category
-                FROM environs
-                WHERE environ != environ_class
-                union
-                select 0 AS id, environ_type AS name, 'environment_types' AS type, 'environ' as category
-                FROM environs
-                GROUP BY environ_type
-                union
-                select 0 AS id, environ_class AS name, 'environment_classes' AS type, 'environ' as category
-                FROM environs
-                GROUP BY environ_class
-                union
-                select id, concat(lith_att, ' (', att_type, ')') as name, 'lithology_attributes' as type, 'lith_att' as category from lith_atts
-                union
-                select id, project as name, 'projects' as type, 'project' as category from projects
-                union
-                SELECT DISTINCT strat_names_meta.concept_id AS id, name, 'strat_name_concepts' AS type, 'strat_name' as category
-                FROM strat_names_meta
-                JOIN strat_names ON strat_names_meta.concept_id = strat_names.concept_id
-                union
-                (select id, CONCAT(strat_name, ' ', rank) AS name, 'strat_name_orphans' as type, 'strat_name' as category from strat_names WHERE concept_id = 0)
-                union
-                select id, col_name as name, 'columns' as type, 'column' as category from cols
-                union
-                select id, col_group_long as name, 'groups' as type, 'group' as category from col_groups
-                union
-                SELECT id, lith AS name, 'lithologies' AS type, 'lithology' as category
-                FROM liths
-                WHERE lith != lith_type AND lith != lith_class
-                union
-                SELECT 0 AS id, lith_type AS name,  'lithology_types' AS type, 'lithology' AS category
-                FROM liths
-                WHERE lith_type != lith_class
-                GROUP BY lith_type
-                union
-                SELECT 0 AS id, lith_class AS name, 'lithology_classes' AS type, 'lithology' as category
-                FROM liths
-                GROUP BY lith_class
-                union
-                select id, interval_name as name, 'intervals' as type, 'interval' as category from intervals
-                union
-                SELECT id, mineral AS name, 'minerals' AS type, 'mineral' as category from minerals
-                union
-                SELECT id, structure as name, 'structures' as type, 'structure' as category from structures
-              ) i;
-        """
-        )
-        self.mariadb["cursor"].close()
-        self.mariadb["cursor"] = self.mariadb["connection"].cursor()
-
-        self.mariadb["cursor"].execute(
-            """
-          UPDATE autocomplete_new AS a
-            INNER JOIN (
-              SELECT concept_id, CONCAT(name, COALESCE(CONCAT(' (', interval_name, ')'), '')) AS name
-              FROM strat_names_meta
-              LEFT JOIN intervals ON intervals.id = strat_names_meta.interval_id
-            ) sub ON a.id = sub.concept_id
-          SET a.name = sub.name
-          WHERE a.id IN (
-            SELECT id FROM (
-              SELECT id
-              FROM autocomplete_new
-              WHERE name IN (
-                SELECT name
-                FROM (
-                  SELECT name, type, count(*)
-                  FROM autocomplete_new
-                  WHERE type = 'strat_name_concepts'
-                  GROUP BY name, type
-                  HAVING count(*) > 1
-                  ORDER BY count(*) desc
-                ) a
-              )
-            ) b
-          ) AND type = 'strat_name_concepts';
-        """
-        )
-        self.mariadb["cursor"].close()
-        self.mariadb["cursor"] = self.mariadb["connection"].cursor()
-
-        self.mariadb["cursor"].execute(
-            """
-          UPDATE autocomplete_new AS a
-            INNER JOIN (
-              SELECT DISTINCT strat_names.id, CONCAT(strat_name, ' (', FO_period, ')') AS name
-              FROM strat_names
-              JOIN unit_strat_names ON strat_names.id = unit_strat_names.strat_name_id
-              JOIN lookup_unit_intervals ON lookup_unit_intervals.unit_id = unit_strat_names.unit_id
-            ) sub ON a.id = sub.id
-          SET a.name = sub.name
-          WHERE a.id IN (
-            SELECT id FROM (
-              SELECT id
-              FROM autocomplete_new
-              WHERE name IN (
-                SELECT name
-                FROM (
-                  SELECT name, type, count(*)
-                  FROM autocomplete_new
-                  WHERE type = 'strat_name_orphans'
-                  GROUP BY name, type
-                  HAVING count(*) > 1
-                  ORDER BY count(*) desc
-                ) a
-              )
-            ) b
-          ) AND type = 'strat_name_orphans';
-        """
-        )
-        self.mariadb["cursor"].close()
-        self.mariadb["cursor"] = self.mariadb["connection"].cursor()
-
-        self.mariadb["cursor"].execute(
-            """
-            ALTER TABLE autocomplete rename to autocomplete_old;
-        """
-        )
-        self.mariadb["cursor"].close()
-        self.mariadb["cursor"] = self.mariadb["connection"].cursor()
-
-        self.mariadb["cursor"].execute(
-            """
-            ALTER TABLE autocomplete_new rename to autocomplete;
-        """
-        )
-        self.mariadb["cursor"].close()
-        self.mariadb["cursor"] = self.mariadb["connection"].cursor()
-
-        self.mariadb["cursor"].execute(
-            """
-            DROP TABLE IF EXISTS autocomplete_old;
-        """
-        )
-        self.mariadb["cursor"].close()
-        self.mariadb["cursor"] = self.mariadb["connection"].cursor()
-
-        self.mariadb["cursor"].close()
-        self.mariadb["connection"].close()
diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py b/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
index cecbea73f..e62d6c96f 100644
--- a/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
@@ -2,6 +2,7 @@
 
 from psycopg2.sql import Identifier
 
+from macrostrat.core.exc import MacrostratError
 from ..base import Base
 from ...database import get_db
 
@@ -25,6 +26,8 @@ def run(self):
             "bed": ["Bed"],
         }
 
+        db.run_sql("SET SEARCH_PATH TO macrostrat, public;")
+
         # Get all the strat names
         res = db.run_query(
             """
@@ -130,10 +133,12 @@ def run(self):
                     SELECT strat_name_id
                     FROM lookup_strat_names
                     WHERE {rank_col} = :strat_name_id
-                      AND rank = ANY(:strat_name_ranks)
-                      AND cols.status_code = 'active'
-                ) WHERE strat_name_id = :strat_name_id
-                """,
+                    AND rank = ANY (:strat_name_ranks)
+                  )
+                  AND cols.status_code = 'active'
+                )
+                WHERE strat_name_id = :strat_name_id
+                """
 
                 params = dict(
                     rank_col=Identifier(_rank + "_id"),
@@ -144,260 +149,82 @@ def run(self):
                 db.run_sql(sql, params)
                 db.session.commit()
 
-
         db.session.commit()
 
         # Populate `early_age` and `late_age`
-        self.mariadb["cursor"].execute(
+        db.run_sql(
             """
-            UPDATE lookup_strat_names_new lsn
-                LEFT JOIN (
+            UPDATE macrostrat.lookup_strat_names_new lsn
+            SET
+                early_age = sub.early_age,
+                late_age = sub.late_age
+            FROM (
                 SELECT strat_name_id, max(b_age) AS early_age, min(t_age) AS late_age
                 FROM lookup_strat_names_new
                 LEFT JOIN unit_strat_names USING (strat_name_id)
                 LEFT JOIN lookup_unit_intervals USING (unit_id)
                 GROUP BY strat_name_id
-                ) AS sub USING (strat_name_id)
-            SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
+                ) AS sub
+            WHERE lsn.strat_name_id = sub.strat_name_id
             """
         )
-        self.mariadb["connection"].commit()
+        db.session.commit()
 
+        # Note: replaced mariadb substring_index with split_part for PostgreSQL
         # Populate rank_name
-        self.mariadb["cursor"].execute(
+        # We have some python code to handle this now
+        db.run_sql(
             """
-            UPDATE lookup_strat_names_new SET rank_name =
-                                                  CASE
-                                                      WHEN SUBSTRING_INDEX(strat_name, ' ', -1) IN ('Suite', 'Volcanics', 'Complex', 'Melange', 'Series', 'Supersuite', 'Tongue', 'Lens', 'Lentil', 'Drift', 'Metamorphics', 'Sequence', 'Supersequence', 'Intrusives', 'Measures', 'Division', 'Subsuite')
-                                                          THEN strat_name
-                                                      WHEN LOWER(SUBSTRING_INDEX(strat_name, ' ', -1)) IN (SELECT lith FROM liths) AND rank = 'fm'
-                                                          THEN strat_name
-                                                      WHEN SUBSTRING_INDEX(strat_name, ' ', -1) = 'Beds' AND rank = 'Bed'
-                                                          THEN strat_name
-                                                      WHEN rank = 'SGp' THEN
-                                                          CONCAT(strat_name, ' Supergroup')
-                                                      WHEN rank = 'Gp' THEN
-                                                          CONCAT(strat_name, ' Group')
-                                                      WHEN rank = 'SubGp' THEN
-                                                          CONCAT(strat_name, ' Subgroup')
-                                                      WHEN rank = 'Fm' THEN
-                                                          CONCAT(strat_name, ' Formation')
-                                                      WHEN rank = 'Mbr' THEN
-                                                          CONCAT(strat_name, ' Member')
-                                                      WHEN rank = 'Bed' THEN
-                                                          CONCAT(strat_name, ' Bed')
-                                                      END
+            UPDATE lookup_strat_names_new
+            SET rank_name = CASE
+            WHEN split_part(strat_name, ' ', -1) IN (
+                'Suite', 'Volcanics', 'Complex', 'Melange', 'Series', 'Supersuite',
+                'Tongue', 'Lens', 'Lentil', 'Drift', 'Metamorphics', 'Sequence',
+                'Supersequence', 'Intrusives', 'Measures', 'Division', 'Subsuite'
+            )
+              THEN strat_name
+            WHEN lower(split_part(strat_name, ' ', -1)) IN (SELECT lith FROM liths) AND rank = 'fm'
+              THEN strat_name
+            WHEN lower(split_part(strat_name, ' ', -1) = 'Beds' AND rank = 'Bed'
+              THEN strat_name
+            WHEN rank = 'SGp' THEN
+              CONCAT(strat_name, ' Supergroup')
+            WHEN rank = 'Gp' THEN
+              CONCAT(strat_name, ' Group')
+            WHEN rank = 'SubGp' THEN
+              CONCAT(strat_name, ' Subgroup')
+            WHEN rank = 'Fm' THEN
+              CONCAT(strat_name, ' Formation')
+            WHEN rank = 'Mbr' THEN
+              CONCAT(strat_name, ' Member')
+            WHEN rank = 'Bed' THEN
+              CONCAT(strat_name, ' Bed')
+            END;
             """
         )
-        self.mariadb["connection"].commit()
 
         # Validate results
-        self.mariadb["cursor"].execute(
+        res = db.run_query(
             """
             SELECT count(*) sn, (SELECT count(*) from lookup_strat_names_new) lsn
             FROM strat_names
             WHERE rank != ''
             """
-        )
-        row = self.mariadb["cursor"].fetchone()
-        if row["sn"] != row["lsn"]:
-            print(
-                "   ERROR: inconsistent strat_name count in lookup table. Found %s rows in lookup_strat_names_new"
-                % (row["lsn"],)
+        ).fetchone()
+        n_rows = res["lsn"]
+        if res["sn"] != n_rows:
+            raise MacrostratError(
+                "Inconsistent strat_name count in lookup table.",
+                details=f"Found {n_rows} rows in lookup_strat_names_new",
             )
-            sys.exit(1)
-
-        self.mariadb["cursor"].close()
-        self.mariadb["cursor"] = self.mariadb["connection"].cursor()
-
-        # Populate the fields `parent` and `tree`
-        self.mariadb["cursor"].execute(
-            """
-            UPDATE lookup_strat_names_new
-            SET parent = CASE
-                             WHEN bed_id > 0 AND strat_name_id != bed_id THEN bed_id
-                             WHEN mbr_id > 0 AND strat_name_id != mbr_id THEN mbr_id
-                             WHEN fm_id > 0 AND strat_name_id != fm_id THEN fm_id
-                             WHEN subgp_id > 0 AND strat_name_id != subgp_id THEN subgp_id
-                             WHEN gp_id > 0 AND strat_name_id != gp_id THEN gp_id
-                             WHEN sgp_id > 0 AND strat_name_id != sgp_id THEN sgp_id
-                             ELSE strat_name_id
-                END,
-                tree = CASE
-                           WHEN sgp_id > 0 THEN sgp_id
-                           WHEN gp_id > 0 THEN gp_id
-                           WHEN subgp_id > 0 THEN subgp_id
-                           WHEN fm_id > 0 THEN fm_id
-                           WHEN mbr_id > 0 THEN mbr_id
-                           WHEN bed_id > 0 THEN bed_id
-                           ELSE tree = 0
-                    END
-            """
-        )
-        self.mariadb["connection"].commit()
-
-        # Group by concept_id and fill in NULL ages
-        self.mariadb["cursor"].execute(
-            """
-            UPDATE lookup_strat_names_new lsn
-                LEFT JOIN (
-                SELECT concept_id, max(b_age) AS early_age, min(t_age) AS late_age
-                FROM lookup_strat_names_new
-                LEFT JOIN unit_strat_names USING (strat_name_id)
-                LEFT JOIN lookup_unit_intervals USING (unit_id)
-                WHERE concept_id != 0
-                GROUP BY strat_name_id
-                ) AS sub USING (concept_id)
-            SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
-             WHERE lsn.early_age IS NULL AND lsn.late_age IS NULL
-            """
-        )
-        self.mariadb["connection"].commit()
-
-        # Group by concept_id, but using strat names meta
-        self.mariadb["cursor"].execute(
-            """
-            UPDATE lookup_strat_names_new lsn
-                LEFT JOIN (
-                SELECT concept_id, b.age_bottom, t.age_top
-                FROM strat_names_meta
-                JOIN intervals b on b.id = b_int
-                JOIN intervals t ON t.id = t_int
-                ) AS sub USING (concept_id)
-            SET lsn.early_age = sub.age_bottom, lsn.late_age = sub.age_top
-            WHERE lsn.early_age IS NULL AND lsn.late_age IS NULL
-            """
-        )
-        self.mariadb["connection"].commit()
-
-        # Group by parent and fill in NULL ages
-        self.mariadb["cursor"].execute(
-            """
-            UPDATE lookup_strat_names_new lsn
-                LEFT JOIN (
-                SELECT parent, max(b_age) AS early_age, min(t_age) AS late_age
-                FROM lookup_strat_names_new
-                LEFT JOIN unit_strat_names USING (strat_name_id)
-                LEFT JOIN lookup_unit_intervals USING (unit_id)
-                GROUP BY parent
-                ) AS sub USING (parent)
-            SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
-             WHERE lsn.early_age IS NULL AND lsn.late_age IS NULL
-            """
-        )
-        self.mariadb["connection"].commit()
 
-        # Group by tree and fill in NULL ages
-        self.mariadb["cursor"].execute(
-            """
-            UPDATE lookup_strat_names_new lsn
-                LEFT JOIN (
-                SELECT tree, max(b_age) AS early_age, min(t_age) AS late_age
-                FROM lookup_strat_names
-                LEFT JOIN unit_strat_names USING (strat_name_id)
-                LEFT JOIN lookup_unit_intervals USING (unit_id)
-                GROUP BY tree
-                ) AS sub USING (tree)
-            SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
-             WHERE lsn.early_age IS NULL AND lsn.late_age IS NULL
-            """
-        )
-        self.mariadb["connection"].commit()
-
-        # Populate the fields `b_period` and `t_period`
-        self.mariadb["cursor"].execute(
-            """
-            UPDATE lookup_strat_names_new
-            SET b_period = (
-                SELECT interval_name
-                FROM macrostrat.intervals
-                         JOIN timescales_intervals ON intervals.id = timescales_intervals.interval_id
-                         JOIN timescales ON timescales.id = timescales_intervals.timescale_id
-                WHERE age_bottom >= early_age AND age_top <= early_age
-                  AND timescales.id = 20
-                LIMIT 1
-            );
-            """
-        )
-        self.mariadb["connection"].commit()
-
-        self.mariadb["cursor"].execute(
-            """
-            UPDATE lookup_strat_names_new
-            SET t_period = (
-                SELECT interval_name
-                FROM intervals
-                         JOIN timescales_intervals ON intervals.id = timescales_intervals.interval_id
-                         JOIN timescales ON timescales.id = timescales_intervals.timescale_id
-                WHERE age_bottom >= late_age AND age_top <= late_age
-                  AND timescales.id = 20
-                LIMIT 1
-            );
-            """
-        )
-        self.mariadb["connection"].commit()
-
-        # Update containing interval for names not explicitly matched to units but have a concept_id
-        self.mariadb["cursor"].execute(
-            """
-            UPDATE lookup_strat_names_new
-                JOIN strat_names_meta USING (concept_id)
-                JOIN intervals t on t.id = t_int
-                JOIN intervals b on b.id = b_int
-            SET c_interval = (
-                SELECT interval_name
-                FROM intervals
-                         JOIN timescales_intervals ON intervals.id = interval_id
-                         JOIN timescales ON timescale_id = timescales.id
-                WHERE timescale = 'international'
-                  AND b.age_bottom > age_top
-                  AND b.age_bottom <= age_bottom
-                  AND t.age_top < age_bottom
-                  AND t.age_top >= age_top
-                ORDER BY age_bottom - age_top
-                LIMIT 1
-            ),
-                b_period = (
-                SELECT interval_name
-                FROM intervals
-                JOIN timescales_intervals ON intervals.id = interval_id
-                JOIN timescales ON timescale_id = timescales.id
-                WHERE timescale = 'international periods'
-                    AND b.age_bottom > age_top
-                    AND b.age_bottom <= age_bottom
-                    AND b.age_top < age_bottom
-                    AND b.age_top >= age_top
-                ORDER BY age_bottom - age_top
-                LIMIT 1
-            ),
-            t_period = (
-                SELECT interval_name
-                FROM intervals
-                JOIN timescales_intervals ON intervals.id = interval_id
-                JOIN timescales ON timescale_id = timescales.id
-                WHERE timescale = 'international periods'
-                    AND t.age_bottom > age_top
-                    AND t.age_bottom <= age_bottom
-                    AND t.age_top < age_bottom
-                    AND t.age_top >= age_top
-                ORDER BY age_bottom - age_top
-                LIMIT 1
-            )
-            WHERE c_interval IS NULL and t_int > 0 and b_int > 0;
-            """
-        )
-        self.mariadb["connection"].commit()
+        db.run_sql(here / "sql" / "lookup-strat-names-02.sql")
 
         # alter table lookup_strat_names add column name_no_lith varchar(100);
         ### Remove lithological terms from strat names ###
 
         # Get a list of lithologies
-        self.mariadb["cursor"].execute(
-            """
-            SELECT lith FROM liths
-            """
-        )
-        lith_results = self.mariadb["cursor"].fetchall()
+        lith_results = db.run_query("SELECT lith FROM macrostrat.liths").fetchall()
         lithologies = [lith["lith"] for lith in lith_results]
         plural_lithologies = [lith["lith"] + "s" for lith in lith_results]
         other_terms = [
@@ -413,82 +240,30 @@ def run(self):
 
         lithologies = lithologies + plural_lithologies + other_terms
 
-        update_connection = self.mariadb["raw_connection"]()
-        update_cursor = update_connection.cursor()
         # Fetch all strat names
-        self.mariadb["cursor"].execute(
-            """
-            SELECT strat_name_id, strat_name FROM lookup_strat_names_new
-            """
+        res = db.run_query(
+            "SELECT strat_name_id, strat_name FROM lookup_strat_names_new"
         )
-        for strat_name in self.mariadb["cursor"].fetchall():
+        for strat_name in res.fetchall():
             split_name = strat_name["strat_name"].split(" ")
 
             name_no_lith = " ".join(
                 [name for name in split_name if name.lower() not in lithologies]
             )
             print(strat_name["strat_name_id"], name_no_lith)
-            update_cursor.execute(
+            db.run_query(
                 """
-                UPDATE lookup_strat_names_new SET name_no_lith = %(name_no_lith)s WHERE strat_name_id = %(strat_name_id)s
+                UPDATE macrostrat.lookup_strat_names_new
+                SET name_no_lith = :name_no_lith
+                WHERE strat_name_id = :strat_name_id
                 """,
-                {
-                    "name_no_lith": name_no_lith,
-                    "strat_name_id": strat_name["strat_name_id"],
-                },
-            )
-            update_connection.commit()
-
-        update_connection.commit()
-        update_connection.close()
-        # self.mariadb['connection'].commit()
-
-        # Make sure all names have an early and late_age
-        self.mariadb["cursor"].execute(
-            """
-            UPDATE lookup_strat_names_new
-            SET early_age = (
-                SELECT age_bottom
-                FROM macrostrat.intervals
-                WHERE interval_name = b_period
-                LIMIT 1
-            ), late_age = (
-                SELECT age_top
-                FROM macrostrat.intervals
-                WHERE interval_name = t_period
-                LIMIT 1
-            ) WHERE early_age IS NULL AND late_age IS NULL;
-            """
-        )
-        self.mariadb["connection"].commit()
-
-        # Populate containing interval
-        self.mariadb["cursor"].execute(
-            """
-            UPDATE lookup_strat_names_new
-            SET c_interval = (
-                SELECT interval_name from intervals
-                                              JOIN timescales_intervals ON intervals.id = interval_id
-                                              JOIN timescales on timescale_id = timescales.id
-                WHERE timescale = 'international'
-                  AND early_age > age_top
-                  AND early_age <= age_bottom
-                  AND late_age < age_bottom
-                  AND late_age >= age_top
-                ORDER BY age_bottom - age_top
-                LIMIT 1
+                dict(
+                    name_no_lith=name_no_lith,
+                    strat_name_id=strat_name["strat_name_id"],
+                ),
             )
-            """
-        )
-        self.mariadb["connection"].commit()
+            db.session.commit()
 
-        # Out with the old, in with the new
-        self.mariadb["cursor"].execute("TRUNCATE lookup_strat_names")
-        self.mariadb["cursor"].execute(
-            "INSERT INTO lookup_strat_names SELECT * FROM lookup_strat_names_new"
-        )
-        self.mariadb["cursor"].close()
+        db.session.commit()
 
-        self.mariadb["cursor"] = self.mariadb["connection"].cursor()
-        self.mariadb["cursor"].execute("DROP TABLE lookup_strat_names_new")
-        self.mariadb["cursor"].close()
+        db.run_sql(here / "sql" / "lookup-strat-names-03.sql")
diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names.sql b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-01.sql
similarity index 100%
rename from cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names.sql
rename to cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-01.sql
diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-02.sql b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-02.sql
new file mode 100644
index 000000000..d8df47062
--- /dev/null
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-02.sql
@@ -0,0 +1,143 @@
+/** NOTE: this SQL still runs in MariaDB, not PostgreSQL, and needs to be updated */
+
+-- Populate the fields `parent` and `tree`
+UPDATE lookup_strat_names_new
+SET parent = CASE
+                 WHEN bed_id > 0 AND strat_name_id != bed_id THEN bed_id
+                 WHEN mbr_id > 0 AND strat_name_id != mbr_id THEN mbr_id
+                 WHEN fm_id > 0 AND strat_name_id != fm_id THEN fm_id
+                 WHEN subgp_id > 0 AND strat_name_id != subgp_id THEN subgp_id
+                 WHEN gp_id > 0 AND strat_name_id != gp_id THEN gp_id
+                 WHEN sgp_id > 0 AND strat_name_id != sgp_id THEN sgp_id
+                 ELSE strat_name_id
+    END,
+    tree = CASE
+               WHEN sgp_id > 0 THEN sgp_id
+               WHEN gp_id > 0 THEN gp_id
+               WHEN subgp_id > 0 THEN subgp_id
+               WHEN fm_id > 0 THEN fm_id
+               WHEN mbr_id > 0 THEN mbr_id
+               WHEN bed_id > 0 THEN bed_id
+               ELSE tree = 0
+        END;
+
+-- Group by concept_id and fill in NULL ages
+
+UPDATE lookup_strat_names_new lsn
+    LEFT JOIN (
+    SELECT concept_id, max(b_age) AS early_age, min(t_age) AS late_age
+    FROM lookup_strat_names_new
+    LEFT JOIN unit_strat_names USING (strat_name_id)
+    LEFT JOIN lookup_unit_intervals USING (unit_id)
+    WHERE concept_id != 0
+    GROUP BY strat_name_id
+) AS sub USING (concept_id)
+SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
+ WHERE lsn.early_age IS NULL AND lsn.late_age IS NULL;
+
+-- Group by concept_id, but using strat names meta
+
+UPDATE lookup_strat_names_new lsn
+    LEFT JOIN (
+    SELECT concept_id, b.age_bottom, t.age_top
+    FROM strat_names_meta
+    JOIN intervals b on b.id = b_int
+    JOIN intervals t ON t.id = t_int
+    ) AS sub USING (concept_id)
+SET lsn.early_age = sub.age_bottom, lsn.late_age = sub.age_top
+WHERE lsn.early_age IS NULL AND lsn.late_age IS NULL;
+
+-- Group by parent and fill in NULL ages
+UPDATE lookup_strat_names_new lsn
+    LEFT JOIN (
+    SELECT parent, max(b_age) AS early_age, min(t_age) AS late_age
+    FROM lookup_strat_names_new
+    LEFT JOIN unit_strat_names USING (strat_name_id)
+    LEFT JOIN lookup_unit_intervals USING (unit_id)
+    GROUP BY parent
+    ) AS sub USING (parent)
+SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
+ WHERE lsn.early_age IS NULL AND lsn.late_age IS NULL;
+
+-- Group by tree and fill in NULL ages
+UPDATE lookup_strat_names_new lsn
+    LEFT JOIN (
+    SELECT tree, max(b_age) AS early_age, min(t_age) AS late_age
+    FROM lookup_strat_names
+    LEFT JOIN unit_strat_names USING (strat_name_id)
+    LEFT JOIN lookup_unit_intervals USING (unit_id)
+    GROUP BY tree
+    ) AS sub USING (tree)
+SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
+ WHERE lsn.early_age IS NULL AND lsn.late_age IS NULL;
+
+-- Populate the fields `b_period` and `t_period`
+
+UPDATE lookup_strat_names_new
+SET b_period = (
+    SELECT interval_name
+    FROM macrostrat.intervals
+             JOIN timescales_intervals ON intervals.id = timescales_intervals.interval_id
+             JOIN timescales ON timescales.id = timescales_intervals.timescale_id
+    WHERE age_bottom >= early_age AND age_top <= early_age
+      AND timescales.id = 20
+    LIMIT 1
+);
+
+
+UPDATE lookup_strat_names_new
+SET t_period = (
+    SELECT interval_name
+    FROM intervals
+             JOIN timescales_intervals ON intervals.id = timescales_intervals.interval_id
+             JOIN timescales ON timescales.id = timescales_intervals.timescale_id
+    WHERE age_bottom >= late_age AND age_top <= late_age
+      AND timescales.id = 20
+    LIMIT 1
+);
+
+-- Update containing interval for names not explicitly matched to units but have a concept_id
+UPDATE lookup_strat_names_new
+    JOIN strat_names_meta USING (concept_id)
+    JOIN intervals t on t.id = t_int
+    JOIN intervals b on b.id = b_int
+SET c_interval = (
+    SELECT interval_name
+    FROM intervals
+             JOIN timescales_intervals ON intervals.id = interval_id
+             JOIN timescales ON timescale_id = timescales.id
+    WHERE timescale = 'international'
+      AND b.age_bottom > age_top
+      AND b.age_bottom <= age_bottom
+      AND t.age_top < age_bottom
+      AND t.age_top >= age_top
+    ORDER BY age_bottom - age_top
+    LIMIT 1
+),
+    b_period = (
+    SELECT interval_name
+    FROM intervals
+    JOIN timescales_intervals ON intervals.id = interval_id
+    JOIN timescales ON timescale_id = timescales.id
+    WHERE timescale = 'international periods'
+        AND b.age_bottom > age_top
+        AND b.age_bottom <= age_bottom
+        AND b.age_top < age_bottom
+        AND b.age_top >= age_top
+    ORDER BY age_bottom - age_top
+    LIMIT 1
+),
+t_period = (
+    SELECT interval_name
+    FROM intervals
+    JOIN timescales_intervals ON intervals.id = interval_id
+    JOIN timescales ON timescale_id = timescales.id
+    WHERE timescale = 'international periods'
+        AND t.age_bottom > age_top
+        AND t.age_bottom <= age_bottom
+        AND t.age_top < age_bottom
+        AND t.age_top >= age_top
+    ORDER BY age_bottom - age_top
+    LIMIT 1
+)
+WHERE c_interval IS NULL and t_int > 0 and b_int > 0;
diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-03.sql b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-03.sql
new file mode 100644
index 000000000..1172eb2a2
--- /dev/null
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-03.sql
@@ -0,0 +1,38 @@
+-- Make sure all names have an early and late_age
+
+SET SEARCH_PATH to macrostrat, public;
+
+UPDATE lookup_strat_names_new
+SET early_age = (
+    SELECT age_bottom
+    FROM macrostrat.intervals
+    WHERE interval_name = b_period
+    LIMIT 1
+), late_age = (
+    SELECT age_top
+    FROM macrostrat.intervals
+    WHERE interval_name = t_period
+    LIMIT 1
+) WHERE early_age IS NULL AND late_age IS NULL;
+
+-- Populate containing interval
+
+UPDATE macrostrat.lookup_strat_names_new
+SET c_interval = (
+    SELECT interval_name from intervals
+                                  JOIN timescales_intervals ON intervals.id = interval_id
+                                  JOIN timescales on timescale_id = timescales.id
+    WHERE timescale = 'international'
+      AND early_age > age_top
+      AND early_age <= age_bottom
+      AND late_age < age_bottom
+      AND late_age >= age_top
+    ORDER BY age_bottom - age_top
+    LIMIT 1
+);
+
+
+-- Out with the old, in with the new
+TRUNCATE lookup_strat_names;
+INSERT INTO lookup_strat_names SELECT * FROM lookup_strat_names_new;
+DROP TABLE lookup_strat_names_new;

From a59691062485aa3bc8c348d9d8cb4cffaf123d3d Mon Sep 17 00:00:00 2001
From: Daven Quinn <code@davenquinn.com>
Date: Wed, 17 Dec 2025 03:51:36 -0600
Subject: [PATCH 4/9] Update lookup-strat-names script

---
 .../sql/lookup-strat-names-02.sql             | 109 +++++++++++-------
 .../sql/lookup-strat-names-03.sql             |  26 ++---
 2 files changed, 78 insertions(+), 57 deletions(-)

diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-02.sql b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-02.sql
index d8df47062..f7682a496 100644
--- a/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-02.sql
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-02.sql
@@ -2,74 +2,95 @@
 
 -- Populate the fields `parent` and `tree`
 UPDATE lookup_strat_names_new
-SET parent = CASE
-                 WHEN bed_id > 0 AND strat_name_id != bed_id THEN bed_id
-                 WHEN mbr_id > 0 AND strat_name_id != mbr_id THEN mbr_id
-                 WHEN fm_id > 0 AND strat_name_id != fm_id THEN fm_id
-                 WHEN subgp_id > 0 AND strat_name_id != subgp_id THEN subgp_id
-                 WHEN gp_id > 0 AND strat_name_id != gp_id THEN gp_id
-                 WHEN sgp_id > 0 AND strat_name_id != sgp_id THEN sgp_id
-                 ELSE strat_name_id
-    END,
-    tree = CASE
-               WHEN sgp_id > 0 THEN sgp_id
-               WHEN gp_id > 0 THEN gp_id
-               WHEN subgp_id > 0 THEN subgp_id
-               WHEN fm_id > 0 THEN fm_id
-               WHEN mbr_id > 0 THEN mbr_id
-               WHEN bed_id > 0 THEN bed_id
-               ELSE tree = 0
-        END;
+SET
+  parent = CASE
+    WHEN bed_id > 0 AND strat_name_id != bed_id THEN bed_id
+    WHEN mbr_id > 0 AND strat_name_id != mbr_id THEN mbr_id
+    WHEN fm_id > 0 AND strat_name_id != fm_id THEN fm_id
+    WHEN subgp_id > 0 AND strat_name_id != subgp_id THEN subgp_id
+    WHEN gp_id > 0 AND strat_name_id != gp_id THEN gp_id
+    WHEN sgp_id > 0 AND strat_name_id != sgp_id THEN sgp_id
+    ELSE strat_name_id
+  END,
+  tree = CASE
+    WHEN sgp_id > 0 THEN sgp_id
+    WHEN gp_id > 0 THEN gp_id
+    WHEN subgp_id > 0 THEN subgp_id
+    WHEN fm_id > 0 THEN fm_id
+    WHEN mbr_id > 0 THEN mbr_id
+    WHEN bed_id > 0 THEN bed_id
+    ELSE tree = 0
+  END;
 
 -- Group by concept_id and fill in NULL ages
 
 UPDATE lookup_strat_names_new lsn
-    LEFT JOIN (
-    SELECT concept_id, max(b_age) AS early_age, min(t_age) AS late_age
-    FROM lookup_strat_names_new
-    LEFT JOIN unit_strat_names USING (strat_name_id)
-    LEFT JOIN lookup_unit_intervals USING (unit_id)
-    WHERE concept_id != 0
-    GROUP BY strat_name_id
-) AS sub USING (concept_id)
-SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
- WHERE lsn.early_age IS NULL AND lsn.late_age IS NULL;
+SET
+  early_age = sub.early_age,
+  late_age = sub.late_age
+FROM (
+  SELECT
+    concept_id,
+    max(b_age) AS early_age,
+    min(t_age) AS late_age
+  FROM lookup_strat_names_new
+  LEFT JOIN unit_strat_names USING (strat_name_id)
+  LEFT JOIN lookup_unit_intervals USING (unit_id)
+  WHERE concept_id != 0
+  GROUP BY strat_name_id
+) AS sub
+ WHERE lsn.concept_id = sub.concept_id
+   AND lsn.early_age IS NULL
+   AND lsn.late_age IS NULL;
 
 -- Group by concept_id, but using strat names meta
 
 UPDATE lookup_strat_names_new lsn
-    LEFT JOIN (
-    SELECT concept_id, b.age_bottom, t.age_top
-    FROM strat_names_meta
-    JOIN intervals b on b.id = b_int
-    JOIN intervals t ON t.id = t_int
-    ) AS sub USING (concept_id)
-SET lsn.early_age = sub.age_bottom, lsn.late_age = sub.age_top
-WHERE lsn.early_age IS NULL AND lsn.late_age IS NULL;
+SET
+  early_age = sub.age_bottom,
+  late_age = sub.age_top
+FROM (
+  SELECT concept_id, b.age_bottom, t.age_top
+  FROM strat_names_meta
+  JOIN intervals b on b.id = b_int
+  JOIN intervals t ON t.id = t_int
+) AS sub
+WHERE lsn.concept_id = sub.concept_id
+  AND lsn.early_age IS NULL
+  AND lsn.late_age IS NULL;
 
 -- Group by parent and fill in NULL ages
 UPDATE lookup_strat_names_new lsn
-    LEFT JOIN (
+SET
+  early_age = sub.early_age
+  late_age = sub.late_age
+FROM (
     SELECT parent, max(b_age) AS early_age, min(t_age) AS late_age
     FROM lookup_strat_names_new
     LEFT JOIN unit_strat_names USING (strat_name_id)
     LEFT JOIN lookup_unit_intervals USING (unit_id)
     GROUP BY parent
-    ) AS sub USING (parent)
-SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
- WHERE lsn.early_age IS NULL AND lsn.late_age IS NULL;
+) AS sub
+WHERE lsn.parent = sub.parent
+  AND lsn.early_age IS NULL
+  AND lsn.late_age IS NULL;
 
 -- Group by tree and fill in NULL ages
 UPDATE lookup_strat_names_new lsn
-    LEFT JOIN (
+SET
+  early_age = sub.early_age,
+  late_age = sub.late_age
+FROM (
     SELECT tree, max(b_age) AS early_age, min(t_age) AS late_age
     FROM lookup_strat_names
     LEFT JOIN unit_strat_names USING (strat_name_id)
     LEFT JOIN lookup_unit_intervals USING (unit_id)
     GROUP BY tree
-    ) AS sub USING (tree)
-SET lsn.early_age = sub.early_age, lsn.late_age = sub.late_age
- WHERE lsn.early_age IS NULL AND lsn.late_age IS NULL;
+    )
+AS sub
+WHERE lsn.tree = sub.tree
+  AND lsn.early_age IS NULL
+  AND lsn.late_age IS NULL;
 
 -- Populate the fields `b_period` and `t_period`
 
diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-03.sql b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-03.sql
index 1172eb2a2..f75fb717c 100644
--- a/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-03.sql
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-03.sql
@@ -19,20 +19,20 @@ SET early_age = (
 
 UPDATE macrostrat.lookup_strat_names_new
 SET c_interval = (
-    SELECT interval_name from intervals
-                                  JOIN timescales_intervals ON intervals.id = interval_id
-                                  JOIN timescales on timescale_id = timescales.id
-    WHERE timescale = 'international'
-      AND early_age > age_top
-      AND early_age <= age_bottom
-      AND late_age < age_bottom
-      AND late_age >= age_top
-    ORDER BY age_bottom - age_top
-    LIMIT 1
+  SELECT interval_name from intervals
+    JOIN timescales_intervals ON intervals.id = interval_id
+    JOIN timescales on timescale_id = timescales.id
+  WHERE timescale = 'international'
+    AND early_age > age_top
+    AND early_age <= age_bottom
+    AND late_age < age_bottom
+    AND late_age >= age_top
+  ORDER BY age_bottom - age_top
+  LIMIT 1
 );
 
 
 -- Out with the old, in with the new
-TRUNCATE lookup_strat_names;
-INSERT INTO lookup_strat_names SELECT * FROM lookup_strat_names_new;
-DROP TABLE lookup_strat_names_new;
+TRUNCATE macrostrat.lookup_strat_names;
+INSERT INTO macrostrat.lookup_strat_names SELECT * FROM macrostrat.lookup_strat_names_new;
+DROP TABLE macrostrat.lookup_strat_names_new;

From 39b3a388171525d0f1561b658e09d6101e7f385d Mon Sep 17 00:00:00 2001
From: Daven Quinn <code@davenquinn.com>
Date: Wed, 17 Dec 2025 04:27:23 -0600
Subject: [PATCH 5/9] Partially working lookup-strat-names script

---
 .../rebuild_scripts/lookup_strat_names.py     | 55 +++++------
 .../sql/lookup-strat-names-01.sql             | 97 ++-----------------
 .../sql/lookup-strat-names-03.sql             |  7 +-
 3 files changed, 36 insertions(+), 123 deletions(-)

diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py b/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
index e62d6c96f..dd86cedad 100644
--- a/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
@@ -15,7 +15,7 @@ def __init__(self, *args):
 
     def run(self):
         db = get_db()
-        db.run_sql(here / "sql" / "lookup-strat-names.sql")
+        db.run_sql(here / "sql" / "lookup-strat-names-01.sql")
 
         lookup_rank_children = {
             "sgp": ["SGp", "Gp", "SubGp", "Fm", "Mbr", "Bed"],
@@ -38,9 +38,22 @@ def run(self):
             """
         )
 
-        for strat_name in res:
-            rank_id = strat_name["rank"] + "_id"
-            rank_name = strat_name["rank"] + "_name"
+        for strat_name in res.mappings():
+            rank_id = strat_name["rank"].lower() + "_id"
+            rank_name = strat_name["rank"].lower() + "_name"
+            print(f"Processing {strat_name['strat_name']} ({strat_name['rank']})")
+
+            params = dict(
+                ref_id=strat_name["ref_id"],
+                concept_id=strat_name["concept_id"],
+                strat_name_id=strat_name["id"],
+                strat_name=strat_name["strat_name"],
+                rank=strat_name["rank"],
+                rank_id_col=Identifier(rank_id),
+                rank_name_col=Identifier(rank_name),
+            )
+
+            print(params)
 
             db.run_sql(
                 """
@@ -53,19 +66,9 @@ def run(self):
                     {rank_id_col},
                     {rank_name_col}
                 )
-                VALUES (:ref_id, :concept_id, :strat_name_id, :strat_name, :rank, :rank_id, :rank_name)
+                VALUES (:ref_id, :concept_id, :strat_name_id, :strat_name, :rank, :strat_name_id, :strat_name)
                 """,
-                dict(
-                    ref_id=strat_name["ref_id"],
-                    concept_id=strat_name["concept_id"],
-                    strat_name_id=strat_name["id"],
-                    strat_name=strat_name["strat_name"],
-                    rank=strat_name["rank"],
-                    rank_id=strat_name["id"],
-                    rank_name=strat_name["strat_name"],
-                    rank_id_col=Identifier(rank_id),
-                    rank_name_col=Identifier(rank_name),
-                ),
+                params,
             )
             db.session.commit()
 
@@ -94,15 +97,9 @@ def run(self):
                     dict(name=name_id),
                 ).fetchone()
 
-                if parent is None:
-                    # Sketchy null check, we should improve this...
-                    name_id = 0
-                else:
-                    name_id = parent["id"]
-
-                if name_id > 0 and parent is not None:
-                    parent_rank_id = parent["rank"] + "_id"
-                    parent_rank_name = parent["rank"] + "_name"
+                if parent is not None and parent.id > 0:
+                    parent_rank_id = parent.rank.lower() + "_id"
+                    parent_rank_name = parent.rank.lower() + "_name"
                     db.run_sql(
                         """
                         UPDATE macrostrat.lookup_strat_names_new
@@ -111,9 +108,9 @@ def run(self):
                         """,
                         dict(
                             parent_rank_id_col=Identifier(parent_rank_id),
-                            parent_rank_name=Identifier(parent_rank_name),
-                            parent_id=parent["id"],
-                            parent_name=parent["strat_name"],
+                            parent_rank_name_col=Identifier(parent_rank_name),
+                            parent_id=parent.id,
+                            parent_name=parent.strat_name,
                             strat_name_id=strat_name["id"],
                         ),
                     )
@@ -133,7 +130,7 @@ def run(self):
                     SELECT strat_name_id
                     FROM lookup_strat_names
                     WHERE {rank_col} = :strat_name_id
-                    AND rank = ANY (:strat_name_ranks)
+                    AND rank::text = ANY(:strat_name_ranks)
                   )
                   AND cols.status_code = 'active'
                 )
diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-01.sql b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-01.sql
index e5ddbccea..f9671cc53 100644
--- a/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-01.sql
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-01.sql
@@ -3,95 +3,10 @@ set SEARCH_PATH to macrostrat, public;
 DROP TABLE IF EXISTS macrostrat.lookup_strat_names_new;
 DROP TABLE IF EXISTS macrostrat.lookup_strat_names_old;
 
-CREATE TABLE macrostrat.lookup_strat_names (
-  strat_name_id integer NOT NULL PRIMARY KEY,
-  strat_name    varchar(100) NOT NULL,
-  rank          macrostrat.lookup_strat_names_rank,
-  concept_id    integer      NOT NULL,
-  rank_name     varchar(100) NOT NULL,
-  bed_id        integer      NOT NULL,
-  bed_name      varchar(100)  DEFAULT NULL::character varying,
-  mbr_id        integer      NOT NULL,
-  mbr_name      varchar(100)  DEFAULT NULL::character varying,
-  fm_id         integer      NOT NULL,
-  fm_name       varchar(100)  DEFAULT NULL::character varying,
-  subgp_id      integer      NOT NULL,
-  subgp_name    varchar(100)  DEFAULT NULL::character varying,
-  gp_id         integer      NOT NULL,
-  gp_name       varchar(100)  DEFAULT NULL::character varying,
-  sgp_id        integer      NOT NULL,
-  sgp_name      varchar(100)  DEFAULT NULL::character varying,
-  early_age     numeric(8, 4) DEFAULT NULL::numeric,
-  late_age      numeric(8, 4) DEFAULT NULL::numeric,
-  gsc_lexicon   char(15)      DEFAULT NULL::bpchar,
-  parent        integer      NOT NULL,
-  tree          integer      NOT NULL,
-  t_units       integer      NOT NULL,
-  b_period      varchar(100)  DEFAULT NULL::character varying,
-  t_period      varchar(100)  DEFAULT NULL::character varying,
-  name_no_lith  varchar(100)  DEFAULT NULL::character varying,
-  ref_id        integer      NOT NULL,
-  c_interval    varchar(100)  DEFAULT NULL::character varying
-);
+-- Create new empty table mimicking structure of existing lookup_strat_names table
+-- Do not carry over not-null constraints etc.
+CREATE TABLE macrostrat.lookup_strat_names_new
+AS SELECT *
+FROM macrostrat.lookup_strat_names
+WHERE false;
 
-/** Indexes; may be auto-generated?
-CREATE INDEX idx_lookup_strat_names_bed_id
-  ON lookup_strat_names (bed_id);
-
-CREATE INDEX idx_lookup_strat_names_concept_id
-  ON lookup_strat_names (concept_id);
-
-CREATE INDEX idx_lookup_strat_names_fm_id
-  ON lookup_strat_names (fm_id);
-
-CREATE INDEX idx_lookup_strat_names_gp_id
-  ON lookup_strat_names (gp_id);
-
-CREATE INDEX idx_lookup_strat_names_mbr_id
-  ON lookup_strat_names (mbr_id);
-
-CREATE INDEX idx_lookup_strat_names_parent
-  ON lookup_strat_names (parent);
-
-CREATE INDEX idx_lookup_strat_names_rank
-  ON lookup_strat_names (rank);
-
-CREATE INDEX idx_lookup_strat_names_ref_id
-  ON lookup_strat_names (ref_id);
-
-CREATE INDEX idx_lookup_strat_names_sgp_id
-  ON lookup_strat_names (sgp_id);
-
-CREATE INDEX idx_lookup_strat_names_strat_name
-  ON lookup_strat_names (strat_name);
-
-CREATE INDEX idx_lookup_strat_names_subgp_id
-  ON lookup_strat_names (subgp_id);
-
-CREATE INDEX idx_lookup_strat_names_tree
-  ON lookup_strat_names (tree);
-
-CREATE INDEX lookup_strat_names_new_bed_id_idx
-  ON lookup_strat_names (bed_id);
-
-CREATE INDEX lookup_strat_names_new_concept_id_idx
-  ON lookup_strat_names (concept_id);
-
-CREATE INDEX lookup_strat_names_new_fm_id_idx
-  ON lookup_strat_names (fm_id);
-
-CREATE INDEX lookup_strat_names_new_gp_id_idx
-  ON lookup_strat_names (gp_id);
-
-CREATE INDEX lookup_strat_names_new_mbr_id_idx
-  ON lookup_strat_names (mbr_id);
-
-CREATE INDEX lookup_strat_names_new_sgp_id_idx
-  ON lookup_strat_names (sgp_id);
-
-CREATE INDEX lookup_strat_names_new_strat_name_id_idx
-  ON lookup_strat_names (strat_name_id);
-
-CREATE INDEX lookup_strat_names_new_strat_name_idx
-  ON lookup_strat_names (strat_name);
-*/
diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-03.sql b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-03.sql
index f75fb717c..3fa369b99 100644
--- a/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-03.sql
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-03.sql
@@ -32,7 +32,8 @@ SET c_interval = (
 );
 
 
+-- TODO: verify that all rows have been populated correctly before running the final swa
 -- Out with the old, in with the new
-TRUNCATE macrostrat.lookup_strat_names;
-INSERT INTO macrostrat.lookup_strat_names SELECT * FROM macrostrat.lookup_strat_names_new;
-DROP TABLE macrostrat.lookup_strat_names_new;
+--TRUNCATE macrostrat.lookup_strat_names;
+-- INSERT INTO macrostrat.lookup_strat_names SELECT * FROM macrostrat.lookup_strat_names_new;
+-- DROP TABLE macrostrat.lookup_strat_names_new;

From cf5d25caf03ca0f5c01805a486ae6d3c3f2ae564 Mon Sep 17 00:00:00 2001
From: davenquinn <1537910+davenquinn@users.noreply.github.com>
Date: Wed, 17 Dec 2025 10:33:22 +0000
Subject: [PATCH 6/9] Format code and sort imports

---
 cli/macrostrat/cli/commands/rebuild_scripts/autocomplete.py    | 2 +-
 .../cli/commands/rebuild_scripts/lookup_strat_names.py         | 3 ++-
 cli/macrostrat/cli/v1_entrypoint.py                            | 1 -
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/autocomplete.py b/cli/macrostrat/cli/commands/rebuild_scripts/autocomplete.py
index 4d024c38a..85d4efedc 100644
--- a/cli/macrostrat/cli/commands/rebuild_scripts/autocomplete.py
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/autocomplete.py
@@ -1,7 +1,7 @@
 from pathlib import Path
 
-from ..base import Base
 from ...database import get_db
+from ..base import Base
 
 here = Path(__file__).parent
 
diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py b/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
index dd86cedad..1f848d104 100644
--- a/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
@@ -3,8 +3,9 @@
 from psycopg2.sql import Identifier
 
 from macrostrat.core.exc import MacrostratError
-from ..base import Base
+
 from ...database import get_db
+from ..base import Base
 
 here = Path(__file__).parent
 
diff --git a/cli/macrostrat/cli/v1_entrypoint.py b/cli/macrostrat/cli/v1_entrypoint.py
index dc9d849c7..0afd626d3 100644
--- a/cli/macrostrat/cli/v1_entrypoint.py
+++ b/cli/macrostrat/cli/v1_entrypoint.py
@@ -27,7 +27,6 @@
 
 import click
 
-
 # CLI with unprocessed arguments
 
 

From e7232ed07230a4f8f7d52c84755fd97395354aa3 Mon Sep 17 00:00:00 2001
From: Daven Quinn <code@davenquinn.com>
Date: Wed, 17 Dec 2025 10:10:21 -0600
Subject: [PATCH 7/9] Reverted control flow error

---
 .../cli/commands/rebuild_scripts/lookup_strat_names.py   | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py b/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
index dd86cedad..1062e6733 100644
--- a/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
@@ -97,9 +97,15 @@ def run(self):
                     dict(name=name_id),
                 ).fetchone()
 
-                if parent is not None and parent.id > 0:
+                name_id = 0
+                parent_rank_id = None
+                parent_rank_name = None
+                if parent is not None:
+                    name_id = parent.id
                     parent_rank_id = parent.rank.lower() + "_id"
                     parent_rank_name = parent.rank.lower() + "_name"
+
+                if name_id > 0:
                     db.run_sql(
                         """
                         UPDATE macrostrat.lookup_strat_names_new
@@ -114,7 +120,6 @@ def run(self):
                             strat_name_id=strat_name["id"],
                         ),
                     )
-
                 else:
                     has_parent = False
 

From 83fecc350838abdb06534088e8705993ce49100d Mon Sep 17 00:00:00 2001
From: Daven Quinn <code@davenquinn.com>
Date: Wed, 17 Dec 2025 13:37:52 -0600
Subject: [PATCH 8/9] Small control flow improvements

---
 .../rebuild_scripts/lookup_strat_names.py     | 41 ++++++++++---------
 .../sql/lookup-strat-names-02.sql             |  2 +-
 2 files changed, 23 insertions(+), 20 deletions(-)

diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py b/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
index bfec638ac..c08b0c530 100644
--- a/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
@@ -3,9 +3,8 @@
 from psycopg2.sql import Identifier
 
 from macrostrat.core.exc import MacrostratError
-
-from ...database import get_db
 from ..base import Base
+from ...database import get_db
 
 here = Path(__file__).parent
 
@@ -16,7 +15,13 @@ def __init__(self, *args):
 
     def run(self):
         db = get_db()
-        db.run_sql(here / "sql" / "lookup-strat-names-01.sql")
+        db.run_sql("SET SEARCH_PATH TO macrostrat, public;")
+
+        # self.part_1()
+        self.part_2()
+
+    def part_1(self):
+        db = get_db()
 
         lookup_rank_children = {
             "sgp": ["SGp", "Gp", "SubGp", "Fm", "Mbr", "Bed"],
@@ -154,6 +159,9 @@ def run(self):
 
         db.session.commit()
 
+    def part_2(self):
+        db = get_db()
+
         # Populate `early_age` and `late_age`
         db.run_sql(
             """
@@ -178,17 +186,12 @@ def run(self):
         # We have some python code to handle this now
         db.run_sql(
             """
-            UPDATE lookup_strat_names_new
-            SET rank_name = CASE
-            WHEN split_part(strat_name, ' ', -1) IN (
-                'Suite', 'Volcanics', 'Complex', 'Melange', 'Series', 'Supersuite',
-                'Tongue', 'Lens', 'Lentil', 'Drift', 'Metamorphics', 'Sequence',
-                'Supersequence', 'Intrusives', 'Measures', 'Division', 'Subsuite'
-            )
+            UPDATE lookup_strat_names_new SET rank_name = CASE
+            WHEN split_part(strat_name, ' ', -1) IN ('Suite', 'Volcanics', 'Complex', 'Melange', 'Series', 'Supersuite', 'Tongue', 'Lens', 'Lentil', 'Drift', 'Metamorphics', 'Sequence', 'Supersequence', 'Intrusives', 'Measures', 'Division', 'Subsuite')
               THEN strat_name
-            WHEN lower(split_part(strat_name, ' ', -1)) IN (SELECT lith FROM liths) AND rank = 'fm'
+            WHEN lower(split_part(strat_name, ' ', -1)) IN (SELECT lith FROM liths) AND rank = 'Fm'
               THEN strat_name
-            WHEN lower(split_part(strat_name, ' ', -1) = 'Beds' AND rank = 'Bed'
+            WHEN lower(split_part(strat_name, ' ', -1)) = 'beds' AND rank = 'Bed'
               THEN strat_name
             WHEN rank = 'SGp' THEN
               CONCAT(strat_name, ' Supergroup')
@@ -214,8 +217,8 @@ def run(self):
             WHERE rank != ''
             """
         ).fetchone()
-        n_rows = res["lsn"]
-        if res["sn"] != n_rows:
+        n_rows = res.lsn
+        if res.sn != n_rows:
             raise MacrostratError(
                 "Inconsistent strat_name count in lookup table.",
                 details=f"Found {n_rows} rows in lookup_strat_names_new",
@@ -228,8 +231,8 @@ def run(self):
 
         # Get a list of lithologies
         lith_results = db.run_query("SELECT lith FROM macrostrat.liths").fetchall()
-        lithologies = [lith["lith"] for lith in lith_results]
-        plural_lithologies = [lith["lith"] + "s" for lith in lith_results]
+        lithologies = [lith.lith for lith in lith_results]
+        plural_lithologies = [lith + "s" for lith in lithologies]
         other_terms = [
             "beds",
             "volcanics",
@@ -248,12 +251,12 @@ def run(self):
             "SELECT strat_name_id, strat_name FROM lookup_strat_names_new"
         )
         for strat_name in res.fetchall():
-            split_name = strat_name["strat_name"].split(" ")
+            split_name = strat_name.strat_name.split(" ")
 
             name_no_lith = " ".join(
                 [name for name in split_name if name.lower() not in lithologies]
             )
-            print(strat_name["strat_name_id"], name_no_lith)
+            print(strat_name.strat_name_id, name_no_lith)
             db.run_query(
                 """
                 UPDATE macrostrat.lookup_strat_names_new
@@ -262,7 +265,7 @@ def run(self):
                 """,
                 dict(
                     name_no_lith=name_no_lith,
-                    strat_name_id=strat_name["strat_name_id"],
+                    strat_name_id=strat_name.strat_name_id,
                 ),
             )
             db.session.commit()
diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-02.sql b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-02.sql
index f7682a496..57c38b684 100644
--- a/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-02.sql
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/sql/lookup-strat-names-02.sql
@@ -8,7 +8,7 @@ SET
     WHEN mbr_id > 0 AND strat_name_id != mbr_id THEN mbr_id
     WHEN fm_id > 0 AND strat_name_id != fm_id THEN fm_id
     WHEN subgp_id > 0 AND strat_name_id != subgp_id THEN subgp_id
-    WHEN gp_id > 0 AND strat_name_id != gp_id THEN gp_id
+    WHEN sgp_id > 0 AND strat_name_id != gp_id THEN gp_id
     WHEN sgp_id > 0 AND strat_name_id != sgp_id THEN sgp_id
     ELSE strat_name_id
   END,

From 1756b84f6364ecbc6e4308546bbf66935e2f0099 Mon Sep 17 00:00:00 2001
From: davenquinn <1537910+davenquinn@users.noreply.github.com>
Date: Thu, 18 Dec 2025 07:23:11 +0000
Subject: [PATCH 9/9] Format code and sort imports

---
 .../cli/commands/rebuild_scripts/lookup_strat_names.py         | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py b/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
index c08b0c530..d82b228a8 100644
--- a/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
+++ b/cli/macrostrat/cli/commands/rebuild_scripts/lookup_strat_names.py
@@ -3,8 +3,9 @@
 from psycopg2.sql import Identifier
 
 from macrostrat.core.exc import MacrostratError
-from ..base import Base
+
 from ...database import get_db
+from ..base import Base
 
 here = Path(__file__).parent