diff --git a/.env.example b/.env.example
new file mode 100644
index 00000000..4d116a9f
--- /dev/null
+++ b/.env.example
@@ -0,0 +1,25 @@
+POSTGRES_USER=username
+POSTGRES_PASSWORD=password
+POSTGRES_DB=postgis
+
+PGUSER=username
+PGPASSWORD=password
+PGDATABASE=postgis
+PGHOST=localhost
+PGPORT=5439
+
+DOCKER_BUILDKIT=1
+BUILDKIT_INLINE_CACHE=1
+
+# Host-script defaults.
+PGSTAC_BUILD_POLICY=always
+PGSTAC_FAST=0
+PGSTAC_WATCH=0
+PGSTAC_STRICT=1
+
+# Migration helper defaults.
+# PGSTAC_VERSION=0.9.11
+# PGSTAC_FROM_VERSION=0.9.10
+# PGSTAC_TO_VERSION=0.9.11
+# PGSTAC_OVERWRITE=0
+# PGSTAC_DEBUG=0
\ No newline at end of file
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index b1b1e35d..f2090777 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -5,11 +5,50 @@ updates:
     schedule:
       interval: "weekly"
       day: "monday"
+    open-pull-requests-limit: 5
     groups:
-      minor-and-patch:
+      actions-all:
         applies-to: version-updates
         patterns:
           - "*"
-        update-types:
-          - "minor"
-          - "patch"
+
+  - package-ecosystem: "docker"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    open-pull-requests-limit: 5
+    groups:
+      docker-base-images:
+        applies-to: version-updates
+        patterns:
+          - "*"
+
+  - package-ecosystem: "pip"
+    directory: "/src/pypgstac"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    open-pull-requests-limit: 5
+    groups:
+      python-dev-tooling:
+        applies-to: version-updates
+        patterns:
+          - "ruff"
+          - "ty"
+          - "pre-commit"
+          - "types-*"
+      python-runtime:
+        applies-to: version-updates
+        patterns:
+          - "cachetools"
+          - "fire"
+          - "hydraters"
+          - "orjson"
+          - "plpygis"
+          - "pydantic"
+          - "python-dateutil"
+          - "smart-open"
+          - "tenacity"
+          - "version-parser"
+          - "psycopg*"
diff --git a/.github/instructions/scripts.instructions.md b/.github/instructions/scripts.instructions.md
index 1382f83d..6cec1b70 100644
--- a/.github/instructions/scripts.instructions.md
+++ b/.github/instructions/scripts.instructions.md
@@ -7,5 +7,6 @@ applyTo: "scripts/**"
 See CLAUDE.md "Development Workflow" for usage. All scripts require the Docker compose environment.
 
 - `runinpypgstac` is the foundation — most scripts delegate to it
+- `scripts/container-scripts/` contains the in-container script payload copied into the pypgstac image; keep host wrappers in `scripts/`
 - `stageversion` modifies version files AND generates migrations — see CLAUDE.md "Migration Process"
 - DO NOT run `stageversion` without understanding its side effects
diff --git a/.github/workflows/continuous-integration.yml b/.github/workflows/continuous-integration.yml
index 4ac4f3b7..d30090cf 100644
--- a/.github/workflows/continuous-integration.yml
+++ b/.github/workflows/continuous-integration.yml
@@ -5,6 +5,9 @@ on:
     branches:
       - main
   pull_request:
+  workflow_dispatch:
+  schedule:
+    - cron: '23 4 * * 0'
 
 env:
   REGISTRY: ghcr.io
@@ -18,14 +21,14 @@ jobs:
     permissions:
       pull-requests: read
     outputs:
-      pgdocker: ${{ steps.check.outputs.pgtag }}
+      pgtagprefix: ${{ steps.check.outputs.pgtagprefix }}
       buildpgdocker: ${{ steps.check.outputs.buildpg }}
       pyrustdocker: ${{ steps.check.outputs.pytag }}
       buildpyrustdocker: ${{ steps.check.outputs.buildpy }}
 
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - uses: dorny/paths-filter@4512585405083f25c027a35db413c2b3b9006d50 # v2
+      - uses: dorny/paths-filter@6852f92c20ea7fd3b0c25de3b5112db3a98da050 # v3
         id: filter
         with:
           filters: |
@@ -37,12 +40,22 @@ jobs:
         run: |
           buildpg=false;
           ref=$(echo ${GITHUB_HEAD_REF:-${GITHUB_REF#refs/heads/}} | tr / _);
-          [[ "${{ steps.filter.outputs.pgstac }}" == "true" ]] && buildpg=true || ref=main;
-          echo "pgtag=${{ env.REGISTRY }}/${GITHUB_REPOSITORY_OWNER}/pgstac-postgres:$ref" >>$GITHUB_OUTPUT;
+          pgref=$ref;
+          [[ "${{ steps.filter.outputs.pgstac }}" == "true" ]] && buildpg=true || pgref=main;
+          if [[ "${{ github.event_name }}" == "schedule" || "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            buildpg=true;
+            pgref=main;
+          fi
+          echo "pgtagprefix=${{ env.REGISTRY }}/${GITHUB_REPOSITORY_OWNER}/pgstac-postgres:$pgref" >>$GITHUB_OUTPUT;
           echo "buildpg=$buildpg" >>$GITHUB_OUTPUT;
           buildpy=false;
-          [[ "${{ steps.filter.outputs.pypgstac }}" == "true" ]] && buildpy=true || ref=main;
-          echo "pytag=${{ env.REGISTRY }}/${GITHUB_REPOSITORY_OWNER}/pgstac-pyrust:$ref" >>$GITHUB_OUTPUT;
+          pyref=$ref;
+          [[ "${{ steps.filter.outputs.pypgstac }}" == "true" ]] && buildpy=true || pyref=main;
+          if [[ "${{ github.event_name }}" == "schedule" || "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            buildpy=true;
+            pyref=main;
+          fi
+          echo "pytag=${{ env.REGISTRY }}/${GITHUB_REPOSITORY_OWNER}/pgstac-pyrust:$pyref" >>$GITHUB_OUTPUT;
           echo "buildpy=$buildpy" >>$GITHUB_OUTPUT;
 
   # This builds a base postgres image that has everything installed to be able to run pgstac. This image does not have pgstac itself installed.
@@ -50,6 +63,9 @@ jobs:
     name: Build and push base postgres image
     runs-on: ubuntu-latest
     needs: [changes]
+    strategy:
+      matrix:
+        pg_major: [16, 17, 18]
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
       - uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
@@ -60,14 +76,16 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
       - name: Build and Push Base Postgres
-        if: ${{ needs.changes.outputs.buildpgdocker == 'true' }}
-        uses: docker/build-push-action@0a97817b6ade9f46837855d676c4cca3a2471fc9 # v4
+        if: ${{ needs.changes.outputs.buildpgdocker == 'true' || github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' }}
+        uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6
         with:
           platforms: linux/amd64,linux/arm64
           context: .
           target: pgstacbase
           file: docker/pgstac/Dockerfile
-          tags: ${{ needs.changes.outputs.pgdocker }}
+          build-args: |
+            PG_MAJOR=${{ matrix.pg_major }}
+          tags: ${{ needs.changes.outputs.pgtagprefix }}-pg${{ matrix.pg_major }}
           push: true
           cache-from: type=gha
           cache-to: type=gha, mode=max
@@ -86,8 +104,8 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
       - name: Build and Push Base pyrust
-        if: ${{ needs.changes.outputs.buildpyrustdocker == 'true' }}
-        uses: docker/build-push-action@0a97817b6ade9f46837855d676c4cca3a2471fc9 # v4
+        if: ${{ needs.changes.outputs.buildpyrustdocker == 'true' || github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' }}
+        uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6
         with:
           platforms: linux/amd64,linux/arm64
           context: .
@@ -104,6 +122,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
+        pg_major: [16, 17, 18]
         flags:
           - ""
           - "--resolution lowest-direct"
@@ -115,11 +134,12 @@ jobs:
         PGHOST: postgres
         PGDATABASE: postgres
         PGUSER: postgres
+        UV_CACHE_DIR: /tmp/.uv-cache
     services:
       postgres:
         env:
           POSTGRES_PASSWORD: postgres
-        image: ${{ needs.changes.outputs.pgdocker }}
+        image: ${{ needs.changes.outputs.pgtagprefix }}-pg${{ matrix.pg_major }}
         options: >-
           --health-cmd pg_isready
           --health-interval 10s
@@ -127,18 +147,25 @@ jobs:
           --health-retries 5
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - name: Ensure PostgreSQL 17 client tools
+      - name: Ensure PostgreSQL client tools
         run: |
           apt-get update
-          apt-get install -y --no-install-recommends postgresql-client-17
+          pg_client_pkg="postgresql-client-${{ matrix.pg_major }}"
+          if apt-cache show "$pg_client_pkg" >/dev/null 2>&1; then
+            apt-get install -y --no-install-recommends "$pg_client_pkg"
+          else
+            apt-get install -y --no-install-recommends postgresql-client
+          fi
       - uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
       - name: Install pypgstac
         working-directory: /__w/pgstac/pgstac/src/pypgstac
-        run: uv pip install ${{ matrix.flags }} .[dev,test,psycopg]
-        env:
-          UV_SYSTEM_PYTHON: 1
-      - name: Run tests
-        working-directory: /__w/pgstac/pgstac/docker/pypgstac/bin
         run: |
-          export PATH=/opt/docker/pypgstac/bin:$PATH
-          ./test
+          export UV_CACHE_DIR=/tmp/.uv-cache
+          export XDG_CACHE_HOME=/tmp/.cache
+          mkdir -p "$UV_CACHE_DIR" "$XDG_CACHE_HOME"
+          uv --cache-dir "$UV_CACHE_DIR" venv /tmp/ci-venv
+          uv --cache-dir "$UV_CACHE_DIR" pip install --python /tmp/ci-venv/bin/python ${{ matrix.flags }} .[dev,test,psycopg]
+          echo "/tmp/ci-venv/bin" >> "$GITHUB_PATH"
+      - name: Run tests
+        working-directory: /__w/pgstac/pgstac
+        run: scripts/container-scripts/test
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 73c4b902..6ba18921 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -42,11 +42,11 @@ jobs:
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
-        uses: docker/metadata-action@030e881283bb7a6894de51c315a6bfe6a94e05cf # 98669ae865ea3cffbcbaa878cf57c20bbf1c6c38
+        uses: docker/metadata-action@c299e40c65443455700f0fdfc63efafe5b349051 # v5
         with:
           images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}-postgres
       - name: Build and Push Base Postgres
-        uses: docker/build-push-action@0a97817b6ade9f46837855d676c4cca3a2471fc9 # v4
+        uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6
         with:
           platforms: linux/amd64,linux/arm64
           context: .
@@ -79,11 +79,11 @@ jobs:
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
-        uses: docker/metadata-action@030e881283bb7a6894de51c315a6bfe6a94e05cf # 98669ae865ea3cffbcbaa878cf57c20bbf1c6c38
+        uses: docker/metadata-action@c299e40c65443455700f0fdfc63efafe5b349051 # v5
         with:
           images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
       - name: Build and Push Base Postgres
-        uses: docker/build-push-action@0a97817b6ade9f46837855d676c4cca3a2471fc9 # v4
+        uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6
         with:
           platforms: linux/amd64,linux/arm64
           context: .
@@ -115,11 +115,11 @@ jobs:
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
-        uses: docker/metadata-action@030e881283bb7a6894de51c315a6bfe6a94e05cf # 98669ae865ea3cffbcbaa878cf57c20bbf1c6c38
+        uses: docker/metadata-action@c299e40c65443455700f0fdfc63efafe5b349051 # v5
         with:
           images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}-pyrust
       - name: Build and Push Base Postgres
-        uses: docker/build-push-action@0a97817b6ade9f46837855d676c4cca3a2471fc9 # v4
+        uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6
         with:
           platforms: linux/amd64,linux/arm64
           context: .
@@ -151,11 +151,11 @@ jobs:
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
-        uses: docker/metadata-action@030e881283bb7a6894de51c315a6bfe6a94e05cf # 98669ae865ea3cffbcbaa878cf57c20bbf1c6c38
+        uses: docker/metadata-action@c299e40c65443455700f0fdfc63efafe5b349051 # v5
         with:
           images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}-pypgstac
       - name: Build and Push Base Postgres
-        uses: docker/build-push-action@0a97817b6ade9f46837855d676c4cca3a2471fc9 # v4
+        uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6
         with:
           platforms: linux/amd64,linux/arm64
           context: .
@@ -167,6 +167,40 @@ jobs:
           cache-from: type=gha
           cache-to: type=gha, mode=max
 
+  buildpypgstacruntime:
+    name: Build and push pypgstac runtime image
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: docker/setup-qemu-action@c7c53464625b32c7a7e944ae62b3e17d2b600130 # v3
+        with:
+          image: tonistiigi/binfmt:qemu-v7.0.0-28
+      - uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
+      - name: Log in to the Container registry
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@c299e40c65443455700f0fdfc63efafe5b349051 # v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}-pypgstac-runtime
+      - name: Build and Push pypgstac runtime
+        uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6
+        with:
+          platforms: linux/amd64,linux/arm64
+          context: .
+          target: pypgstac-runtime
+          file: docker/pypgstac/Dockerfile
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          push: true
+          cache-from: type=gha
+          cache-to: type=gha, mode=max
+
   releasetopypi:
     name: Release
     runs-on: ubuntu-latest
diff --git a/.gitignore b/.gitignore
index 32565592..c57bfb98 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,4 +12,7 @@ src/pypgstac/python/pypgstac/*.so
 .vscode
 .ipynb_checkpoints
 .venv
-.pytest_cache
\ No newline at end of file
+.pytest_cache
+.plans/
+.env
+src/pgstacrust/target/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 89ad3173..d6c1df84 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -2,7 +2,7 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
+    rev: v5.0.0
     hooks:
     -   id: trailing-whitespace
     -   id: check-yaml
@@ -17,17 +17,6 @@ repos:
     -   id: check-executables-have-shebangs
     -   id: check-symlinks
 
-
--   repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 'v0.8.2'
-    hooks:
-    -   id: ruff
-        files: src/pypgstac\/.*\.py$
-        args: [--fix, --exit-non-zero-on-fix]
-    -   id: ruff-format
-        files: src/pypgstac\/.*\.py$
-
-
 -   repo: local
     hooks:
     -   id: dockerbuild
@@ -55,7 +44,7 @@ repos:
         pass_filenames: false
         verbose: true
         fail_fast: true
-        always_run: true
+        files: ^(src/pypgstac/(src/pypgstac|tests)/.*\.py|src/pypgstac/pyproject\.toml)$
     -   id: pypgstac
         name: pypgstac
         entry: scripts/test
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6c440b79..953a4d2d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,8 +6,82 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
 
+## [Unreleased]
+
+### Added
+- `scripts/makemigration` host wrapper for the in-container `makemigration` helper.
+- `.env.example` documenting all supported environment variables for local development.
+- All host-facing scripts (`test`, `format`, `migrate`, `server`, `stageversion`,
+  `runinpypgstac`, `console`) now accept `--help` / `-h` and honor environment-variable
+  counterparts for common flags (`PGSTAC_BUILD_POLICY`, `PGSTAC_FAST`, `PGSTAC_WATCH`,
+  `PGSTAC_STRICT`).
+- `scripts/pgstacenv` gains `ensure_env_file` (auto-creates `.env` from `.env.example`
+  on first run) and `first_available_pgport` (avoids port collisions on shared machines).
+- `scripts/test` expanded from a 3-line wrapper to a full-featured test runner supporting
+  `--fast`, `--watch`, `--build-policy`, `--no-strict`, and stale-image detection.
+- PostgreSQL 16, 17, and 18-beta added to the CI and Docker build matrix. (Closes #334)
+- Weekly scheduled CI run (`cron: '23 4 * * 0'`) to catch upstream base-image CVEs without
+  requiring a code change. (Closes #202)
+- `workflow_dispatch` trigger for manual CI runs.
+- `pg_tle` v1.5.2 built and pre-loaded in the `pgstacbase` image; database init runs
+  `CREATE EXTENSION IF NOT EXISTS pg_tle`.
+- `pypgstac-runtime` Docker target: slim Python 3.13-trixie image without the Rust/build
+  toolchain, for production deployments where the Rust build environment is not needed.
+- Dependabot coverage expanded to Docker base images and pip packages (two new
+  ecosystems with grouped update policies).
+
+### Changed
+- In-container helper scripts moved from `docker/pypgstac/bin/` to
+  `scripts/container-scripts/`; container `PATH` updated accordingly.
+- `docker/pgstac/Dockerfile` and `docker/pypgstac/Dockerfile` base images updated from
+  `bullseye` to `trixie`. (Closes #231)
+- All Docker `RUN` layers now use BuildKit cache mounts for apt, uv, and git caches,
+  significantly reducing incremental rebuild times.
+- `docker-compose.yml`: adds `env_file: .env`, explicit `PGHOST`/`PGPORT` defaults,
+  a pgstac healthcheck, and a `service_healthy` dependency on pypgstac.
+- `runinpypgstac` gains `--build-policy {always,missing,never}` replacing the bare
+  `--build` flag; `PGSTAC_BUILD_POLICY` env var provides a persistent default.
+- Dev tooling: `flake8`, `black`, and `mypy` removed in favour of `ruff==0.15.11` and
+  `ty==0.0.31`. `pre-commit` pinned to `3.5.0`. `pre-commit-hooks` updated to v5.0.0.
+- `pypgstac` package floor raised to Python 3.11; metadata now advertises 3.11-3.14.
+- `pypgstac` settings now use `pydantic-settings` (`BaseSettings` from
+  `pydantic_settings`) and require `pydantic>=2,<3`.
+- `cachetools` upper bound removed (`cachetools>=5.3.0`) since `pypgstac` only uses
+  `cachetools.func.lru_cache`; no known incompatible API changes affect this usage.
+- `pypgstac` developer tooling config now consistently targets Ruff + ty:
+  removes stale mypy config, pins Ruff to `0.15.11` to match pre-commit,
+  and adds minimal `[tool.ty]` project settings.
+- Formatting/type-check pipeline now uses `scripts/test --formatting` as the
+  single pre-commit entry point (removing duplicate direct Ruff pre-commit hooks)
+  and aligns Ruff line-length handling with the formatter (`E501` ignored;
+  explicit `line-length = 88`).
+- GitHub Actions updated: `dorny/paths-filter` v2→v3, `docker/build-push-action`
+  v4→v6, `astral-sh/setup-uv` v8.0.0→v8.1.0; all SHA pins refreshed.
+- Dependabot groups reworked: `actions-all` (replaces `minor-and-patch`), new
+  `docker-base-images`, `python-dev-tooling`, and `python-runtime` groups.
+- `docker-compose.yml` removes explicit `container_name` entries to avoid conflicts
+  between concurrent local instances.
+
+### Removed
+- PL/Rust support: `pgstacbase-plrust` and `pgstac-plrust` Docker targets removed; the
+  pgstac image no longer builds or ships PL/Rust or the Rust toolchain. (Closes #339)
+- `flake8`, `black`, and `mypy` removed from dev dependencies.
+
+### Fixed
+- `load.py`: Use timezone-aware `MIN_DATETIME_UTC` / `MAX_DATETIME_UTC` sentinel
+  constants (instead of naive `datetime.min` / `datetime.max`) to avoid
+  `TypeError: can't compare offset-naive and offset-aware datetimes`.
+- CI `lowest-direct` dependency install: avoid uv cache permission failures by using
+  a writable temp cache path in the test job install step.
+- `pypgstac` dependency floor for `orjson` raised to `>=3.11.0` to avoid selecting
+  the broken `3.9.0` sdist under `--resolution lowest-direct`.
+- `pydantic` minimum raised to `>=2.10` so `--resolution lowest-direct` on Python 3.13
+  does not resolve to `pydantic-core==2.0.1`, which fails to build.
+
+
 ## [v0.9.11]
 
+
 ### Fixed
 - Fix timestamp regex in partition constraint parsing to handle fractional seconds (microseconds), preventing incorrect `(-infinity, infinity)` constraint bounds.
 - Add explicit ANALYZE before `st_estimatedextent()` in `update_partition_stats` for deterministic spatial extent calculation.
@@ -616,6 +690,7 @@ _TODO_
 
 - Fixed issue with pypgstac loads which caused some writes to fail ([#18](https://github.com/stac-utils/pgstac/pull/18))
 
+[Unreleased]: https://github.com/stac-utils/pgstac/compare/v0.9.11...HEAD
 [v0.9.11]: https://github.com/stac-utils/pgstac/compare/v0.9.10...v0.9.11
 [v0.9.10]: https://github.com/stac-utils/pgstac/compare/v0.9.9...v0.9.10
 [v0.9.9]: https://github.com/stac-utils/pgstac/compare/v0.9.8...v0.9.9
diff --git a/CLAUDE.md b/CLAUDE.md
index f4b6274b..4849c58a 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -17,7 +17,8 @@ src/pgstac/migrations/   ← Base + incremental migration files
 src/pgstac/tests/        ← PGTap and basic SQL tests
 src/pypgstac/src/pypgstac/ ← Python package source
 src/pypgstac/tests/        ← pytest tests
-docker/pypgstac/bin/     ← Build/test/utility scripts (pgstac_restore, test, etc.)
+scripts/                 ← Host-facing entrypoint scripts
+scripts/container-scripts/ ← Scripts copied into the pypgstac container image
 ```
 
 ### Documentation Files
@@ -64,7 +65,7 @@ PgSTAC functions reference PostGIS functions (e.g. `st_makeenvelope`, `st_geomfr
 
 - **Do NOT schema-qualify PostGIS function calls** in PgSTAC SQL
 - **Avoid cross-function dependencies in SQL functions used by GENERATED columns** — pg_dump orders functions alphabetically, so `func_a` calling `func_b` may be created before `func_b` exists. Inline the logic instead.
-- Use `pgstac_restore` (in `docker/pypgstac/bin/`) to restore dumps — it installs a temporary event trigger that sets the correct `search_path` before each DDL command
+- Use `pgstac_restore` (via `scripts/container-scripts/pgstac_restore` in the image) to restore dumps — it installs a temporary event trigger that sets the correct `search_path` before each DDL command
 - Test with `scripts/test --pgdump`
 
 ## Development Workflow
@@ -84,7 +85,7 @@ scripts/test --pypgstac         # pytest only
 scripts/test --pgtap            # PGTap SQL tests
 scripts/test --basicsql         # SQL output comparison tests
 scripts/test --migrations       # Full migration chain test
-scripts/test --formatting       # ruff + mypy
+scripts/test --formatting       # ruff + ty
 scripts/test --pgdump           # pg_dump/pg_restore round-trip test
 ```
 
@@ -114,7 +115,7 @@ This runs inside Docker and:
 
 ### How makemigration Works
 
-`makemigration` (in `docker/pypgstac/bin/makemigration`) generates incremental migrations by diffing schemas:
+`makemigration` (copied from `scripts/container-scripts/makemigration` into the image) generates incremental migrations by diffing schemas:
 
 1. Creates two temp databases: `migra_from`, `migra_to`
 2. Loads old base migration into `migra_from`
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 327d6305..1aac96df 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,10 +1,10 @@
 # Development - Contributing
 
-PgSTAC uses a dockerized development environment. However,
-it still needs a local install of pypgstac to allow an editable
-install inside the docker container. This is installed automatically
-if you have set up a virtual environment for the project. Otherwise
-you'll need to install a local copy yourself by running `scripts/install`.
+PgSTAC uses a dockerized development environment.
+
+Local-only planning notes now live under `.plans/` and are intentionally gitignored.
+If you keep local execution settings, start from `.env.example` and write overrides to
+`.env`.
 
 To build the docker images and set up the test database, use:
 
@@ -22,11 +22,34 @@ To run tests, use:
 scripts/test
 ```
 
+To set up pre-commit using the project uv workflow:
+
+```bash
+uv tool install pre-commit==3.5.0
+pre-commit install
+```
+
+Useful options:
+
+```bash
+scripts/test --fast
+scripts/test --pypgstac
+scripts/test --build-policy always
+```
+
+`scripts/test` defaults to `PGSTAC_BUILD_POLICY=always` so the container image reflects
+your current checkout. If you intentionally want to reuse an existing image, set
+`PGSTAC_BUILD_POLICY=missing` or pass `--build-policy missing`.
+
 To rebuild docker images:
 ```bash
 scripts/update
 ```
 
+Container-only helper scripts now live in `scripts/container-scripts/` and are copied
+into the `pypgstac` image during build. Top-level `scripts/` remain the host-facing
+entrypoint surface.
+
 To drop into a console, use
 ```bash
 scripts/console
@@ -47,6 +70,12 @@ To stage code and configurations and create template migrations for a version re
 scripts/stageversion [version]
 ```
 
+To generate only the incremental migration, use:
+
+```bash
+scripts/makemigration --from 0.9.10 --to 0.9.11
+```
+
 Examples:
 ```
 scripts/stageversion 0.2.8
@@ -71,7 +100,7 @@ PyPgSTAC tests are pytest tests, and they are located in `/src/pypgstac/tests`
 
 All tests can be found in tests/pgtap.sql and are run using `scripts/test`.
 
-Individual tests can be run with any combination of the following flags `--formatting --basicsql --pgtap --migrations --pypgstac`. If pre-commit is installed, tests will be run on commit based on which files have changed.
+Individual tests can be run with any combination of the following flags `--formatting --basicsql --pgtap --migrations --pypgstac`. The `--formatting` suite runs Ruff lint/format checks and Ty type checks. If pre-commit is installed, tests will be run on commit based on which files have changed.
 
 
 ### To make a PR
@@ -108,4 +137,4 @@ Rehydration is the process of adding the stripped attributes back to the STAC it
 
 PgSTAC, a versatile tool, is designed to seamlessly integrate with PyPgSTAC or alternative backends. This flexibility allows for direct calls for both rehydration and dehydration, giving developers and technical users a sense of control over the process.
 
-Hydration and dehydration are de-facto settings that users can not opt out of. In the future, we may provide a configuration for use cases where the size benefits do not justify the added complexity.
\ No newline at end of file
+Hydration and dehydration are de-facto settings that users can not opt out of. In the future, we may provide a configuration for use cases where the size benefits do not justify the added complexity.
diff --git a/docker-compose.yml b/docker-compose.yml
index 47ad9327..d7fe59eb 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,7 +1,8 @@
 services:
   pgstac:
-    container_name: pgstac
     image: pgstac
+    env_file:
+      - .env
     build:
       context: .
       network: host
@@ -9,20 +10,29 @@ services:
       target: pgstac
     platform: linux/amd64
     environment:
-      - POSTGRES_USER=username
-      - POSTGRES_PASSWORD=password
-      - POSTGRES_DB=postgis
-      - PGUSER=username
-      - PGPASSWORD=password
-      - PGDATABASE=postgis
+      - POSTGRES_USER=${POSTGRES_USER:-username}
+      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-password}
+      - POSTGRES_DB=${POSTGRES_DB:-postgis}
+      - PGHOST=/var/run/postgresql
+      - PGPORT=5432
+      - PGUSER=${PGUSER:-username}
+      - PGPASSWORD=${PGPASSWORD:-password}
+      - PGDATABASE=${PGDATABASE:-postgis}
     ports:
-      - "5439:5432"
+      - "${PGPORT:-5439}:5432"
     volumes:
       - pgstac-pgdata:/var/lib/postgresql/data
     command: postgres
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -h /var/run/postgresql -p 5432 -U ${PGUSER:-username} -d ${PGDATABASE:-postgis}"]
+      interval: 5s
+      timeout: 5s
+      retries: 12
+      start_period: 5s
   pypgstac:
-    container_name: pypgstac
     image: pypgstac
+    env_file:
+      - .env
     build:
       context: .
       network: host
@@ -31,10 +41,12 @@ services:
     platform: linux/amd64
     environment:
       - PGHOST=pgstac
-      - PGUSER=username
-      - PGPASSWORD=password
-      - PGDATABASE=postgis
+      - PGPORT=5432
+      - PGUSER=${PGUSER:-username}
+      - PGPASSWORD=${PGPASSWORD:-password}
+      - PGDATABASE=${PGDATABASE:-postgis}
     depends_on:
-      - pgstac
+      pgstac:
+        condition: service_healthy
 volumes:
   pgstac-pgdata:
diff --git a/docker/pgstac/Dockerfile b/docker/pgstac/Dockerfile
index 14114be1..671ac025 100644
--- a/docker/pgstac/Dockerfile
+++ b/docker/pgstac/Dockerfile
@@ -1,76 +1,51 @@
+# syntax=docker/dockerfile:1.7
 ARG PG_MAJOR=17
 ARG POSTGIS_MAJOR=3
+ARG PG_TLE_VERSION=1.5.2
+ARG DEBIAN_SUITE=trixie
 
 # Base postgres image that pgstac can be installed onto
-FROM postgres:${PG_MAJOR}-bullseye AS pgstacbase
+FROM postgres:${PG_MAJOR}-${DEBIAN_SUITE} AS pgstacbase
 ARG POSTGIS_MAJOR
 ARG PG_MAJOR
-RUN  \
+ARG PG_TLE_VERSION
+RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
+    --mount=type=cache,target=/var/lib/apt/lists,sharing=locked \
+    --mount=type=cache,target=/root/.cache/git,sharing=locked \
     apt-get update \
-    && apt-get upgrade -y \
     && apt-get install -y --no-install-recommends \
         postgresql-$PG_MAJOR-postgis-$POSTGIS_MAJOR \
         postgresql-$PG_MAJOR-postgis-$POSTGIS_MAJOR-scripts \
         postgresql-$PG_MAJOR-pgtap \
         postgresql-$PG_MAJOR-plpgsql-check \
         postgresql-$PG_MAJOR-partman \
-    && apt-get remove -y apt-transport-https \
-    && apt-get clean && apt-get -y autoremove \
-    && rm -rf /var/lib/apt/lists/*
-COPY docker/pgstac/dbinit/docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
-
-# Base postgres image with plrust installed that can be used for future development using plrust
-FROM pgstacbase AS pgstacbase-plrust
-ENV PLRUSTVERSION=1.2.7
-ENV RUSTVERSION=1.72.0
-ENV PLRUSTDOWNLOADURL=https://github.com/tcdi/plrust/releases/download/
-ENV PLRUSTFILE=plrust-trusted-${PLRUSTVERSION}_${RUSTVERSION}-debian-pg${PG_MAJOR}-amd64.deb
-ENV PLRUSTURL=${PLRUSTDOWNLOADURL}v${PLRUSTVERSION}/${PLRUSTFILE}
-ADD $PLRUSTURL .
-ENV PATH=/home/postgres/.cargo/bin:$PATH
-RUN  \
-    apt-get update \
-    && apt-get upgrade -y \
-    && apt-get install -y --no-install-recommends \
         postgresql-server-dev-$PG_MAJOR \
         build-essential \
         ca-certificates \
-        clang \
-        clang-11 \
-        gcc \
+        curl \
+        git \
+        flex \
+        bison \
+        libkrb5-dev \
+    && GIT_TERMINAL_PROMPT=0 git clone --branch v${PG_TLE_VERSION} --depth 1 https://github.com/aws/pg_tle.git /tmp/pg_tle \
+    && make -C /tmp/pg_tle \
+    && make -C /tmp/pg_tle install \
+    && rm -rf /tmp/pg_tle \
+    && sed -i "s/^#shared_preload_libraries = .*/shared_preload_libraries = 'pg_tle'/" /usr/share/postgresql/$PG_MAJOR/postgresql.conf.sample \
+    && sed -i "s/^#shared_preload_libraries = .*/shared_preload_libraries = 'pg_tle'/" /usr/share/postgresql/postgresql.conf.sample \
+    && apt-get purge -y --auto-remove \
+        postgresql-server-dev-$PG_MAJOR \
+        build-essential \
+        curl \
         git \
-        gnupg \
-        libssl-dev \
-        llvm-11 \
-        lsb-release \
-        make \
-        pkg-config \
-        wget \
-    && apt-get remove -y apt-transport-https \
+        flex \
+        bison \
+        libkrb5-dev \
     && apt-get clean && apt-get -y autoremove \
     && rm -rf /var/lib/apt/lists/*
-USER postgres
-RUN \
-    wget -qO- https://sh.rustup.rs | sh -s -- -y --profile minimal --default-toolchain=${RUSTVERSION} \
-    && $HOME/.cargo/bin/rustup toolchain install ${RUSTVERSION} \
-    && $HOME/.cargo/bin/rustup default ${RUSTVERSION} \
-    && $HOME/.cargo/bin/rustup component add rustc-dev
-WORKDIR /docker-entrypoint-preinitdb.d
-COPY docker/pgstac/dbinit/pgstac-rust-preinit.sh preloadplrust.sh
-WORKDIR /docker-entrypoint-initdb.d
-COPY docker/pgstac/dbinit/pgstac-rust.sh 991_plrust.sh
-
-USER root
-RUN apt-get install -y /${PLRUSTFILE}
 
 # The pgstacbase image with latest version of pgstac installed
 FROM pgstacbase AS pgstac
 WORKDIR /docker-entrypoint-initdb.d
 COPY docker/pgstac/dbinit/pgstac.sh 990_pgstac.sh
 COPY src/pgstac/pgstac.sql 999_pgstac.sql
-
-# The pgstacbase-plrust image with the latest version of pgstac installed
-FROM pgstacbase-plrust AS pgstac-plrust
-WORKDIR /docker-entrypoint-initdb.d
-COPY docker/pgstac/dbinit/pgstac.sh 990_pgstac.sh
-COPY src/pgstac/pgstac.sql 999_pgstac.sql
diff --git a/docker/pgstac/dbinit/docker-entrypoint.sh b/docker/pgstac/dbinit/docker-entrypoint.sh
deleted file mode 100755
index b6c55481..00000000
--- a/docker/pgstac/dbinit/docker-entrypoint.sh
+++ /dev/null
@@ -1,354 +0,0 @@
-#!/usr/bin/env bash
-set -Eeo pipefail
-# TODO swap to -Eeuo pipefail above (after handling all potentially-unset variables)
-
-# usage: file_env VAR [DEFAULT]
-#    ie: file_env 'XYZ_DB_PASSWORD' 'example'
-# (will allow for "$XYZ_DB_PASSWORD_FILE" to fill in the value of
-#  "$XYZ_DB_PASSWORD" from a file, especially for Docker's secrets feature)
-file_env() {
-	local var="$1"
-	local fileVar="${var}_FILE"
-	local def="${2:-}"
-	if [ "${!var:-}" ] && [ "${!fileVar:-}" ]; then
-		printf >&2 'error: both %s and %s are set (but are exclusive)\n' "$var" "$fileVar"
-		exit 1
-	fi
-	local val="$def"
-	if [ "${!var:-}" ]; then
-		val="${!var}"
-	elif [ "${!fileVar:-}" ]; then
-		val="$(< "${!fileVar}")"
-	fi
-	export "$var"="$val"
-	unset "$fileVar"
-}
-
-# check to see if this file is being run or sourced from another script
-_is_sourced() {
-	# https://unix.stackexchange.com/a/215279
-	[ "${#FUNCNAME[@]}" -ge 2 ] \
-		&& [ "${FUNCNAME[0]}" = '_is_sourced' ] \
-		&& [ "${FUNCNAME[1]}" = 'source' ]
-}
-
-# used to create initial postgres directories and if run as root, ensure ownership to the "postgres" user
-docker_create_db_directories() {
-	local user; user="$(id -u)"
-
-	mkdir -p "$PGDATA"
-	# ignore failure since there are cases where we can't chmod (and PostgreSQL might fail later anyhow - it's picky about permissions of this directory)
-	chmod 00700 "$PGDATA" || :
-
-	# ignore failure since it will be fine when using the image provided directory; see also https://github.com/docker-library/postgres/pull/289
-	mkdir -p /var/run/postgresql || :
-	chmod 03775 /var/run/postgresql || :
-
-	# Create the transaction log directory before initdb is run so the directory is owned by the correct user
-	if [ -n "${POSTGRES_INITDB_WALDIR:-}" ]; then
-		mkdir -p "$POSTGRES_INITDB_WALDIR"
-		if [ "$user" = '0' ]; then
-			find "$POSTGRES_INITDB_WALDIR" \! -user postgres -exec chown postgres '{}' +
-		fi
-		chmod 700 "$POSTGRES_INITDB_WALDIR"
-	fi
-
-	# allow the container to be started with `--user`
-	if [ "$user" = '0' ]; then
-		find "$PGDATA" \! -user postgres -exec chown postgres '{}' +
-		find /var/run/postgresql \! -user postgres -exec chown postgres '{}' +
-	fi
-}
-
-# initialize empty PGDATA directory with new database via 'initdb'
-# arguments to `initdb` can be passed via POSTGRES_INITDB_ARGS or as arguments to this function
-# `initdb` automatically creates the "postgres", "template0", and "template1" dbnames
-# this is also where the database user is created, specified by `POSTGRES_USER` env
-docker_init_database_dir() {
-	# "initdb" is particular about the current user existing in "/etc/passwd", so we use "nss_wrapper" to fake that if necessary
-	# see https://github.com/docker-library/postgres/pull/253, https://github.com/docker-library/postgres/issues/359, https://cwrap.org/nss_wrapper.html
-	local uid; uid="$(id -u)"
-	if ! getent passwd "$uid" &> /dev/null; then
-		# see if we can find a suitable "libnss_wrapper.so" (https://salsa.debian.org/sssd-team/nss-wrapper/-/commit/b9925a653a54e24d09d9b498a2d913729f7abb15)
-		local wrapper
-		for wrapper in {/usr,}/lib{/*,}/libnss_wrapper.so; do
-			if [ -s "$wrapper" ]; then
-				NSS_WRAPPER_PASSWD="$(mktemp)"
-				NSS_WRAPPER_GROUP="$(mktemp)"
-				export LD_PRELOAD="$wrapper" NSS_WRAPPER_PASSWD NSS_WRAPPER_GROUP
-				local gid; gid="$(id -g)"
-				printf 'postgres:x:%s:%s:PostgreSQL:%s:/bin/false\n' "$uid" "$gid" "$PGDATA" > "$NSS_WRAPPER_PASSWD"
-				printf 'postgres:x:%s:\n' "$gid" > "$NSS_WRAPPER_GROUP"
-				break
-			fi
-		done
-	fi
-
-	if [ -n "${POSTGRES_INITDB_WALDIR:-}" ]; then
-		set -- --waldir "$POSTGRES_INITDB_WALDIR" "$@"
-	fi
-
-	# --pwfile refuses to handle a properly-empty file (hence the "\n"): https://github.com/docker-library/postgres/issues/1025
-	eval 'initdb --username="$POSTGRES_USER" --pwfile=<(printf "%s\n" "$POSTGRES_PASSWORD") '"$POSTGRES_INITDB_ARGS"' "$@"'
-
-	# unset/cleanup "nss_wrapper" bits
-	if [[ "${LD_PRELOAD:-}" == */libnss_wrapper.so ]]; then
-		rm -f "$NSS_WRAPPER_PASSWD" "$NSS_WRAPPER_GROUP"
-		unset LD_PRELOAD NSS_WRAPPER_PASSWD NSS_WRAPPER_GROUP
-	fi
-}
-
-# print large warning if POSTGRES_PASSWORD is long
-# error if both POSTGRES_PASSWORD is empty and POSTGRES_HOST_AUTH_METHOD is not 'trust'
-# print large warning if POSTGRES_HOST_AUTH_METHOD is set to 'trust'
-# assumes database is not set up, ie: [ -z "$DATABASE_ALREADY_EXISTS" ]
-docker_verify_minimum_env() {
-	# check password first so we can output the warning before postgres
-	# messes it up
-	if [ "${#POSTGRES_PASSWORD}" -ge 100 ]; then
-		cat >&2 <<-'EOWARN'
-
-			WARNING: The supplied POSTGRES_PASSWORD is 100+ characters.
-
-			  This will not work if used via PGPASSWORD with "psql".
-
-			  https://www.postgresql.org/message-id/flat/E1Rqxp2-0004Qt-PL%40wrigleys.postgresql.org (BUG #6412)
-			  https://github.com/docker-library/postgres/issues/507
-
-		EOWARN
-	fi
-	if [ -z "$POSTGRES_PASSWORD" ] && [ 'trust' != "$POSTGRES_HOST_AUTH_METHOD" ]; then
-		# The - option suppresses leading tabs but *not* spaces. :)
-		cat >&2 <<-'EOE'
-			Error: Database is uninitialized and superuser password is not specified.
-			       You must specify POSTGRES_PASSWORD to a non-empty value for the
-			       superuser. For example, "-e POSTGRES_PASSWORD=password" on "docker run".
-
-			       You may also use "POSTGRES_HOST_AUTH_METHOD=trust" to allow all
-			       connections without a password. This is *not* recommended.
-
-			       See PostgreSQL documentation about "trust":
-			       https://www.postgresql.org/docs/current/auth-trust.html
-		EOE
-		exit 1
-	fi
-	if [ 'trust' = "$POSTGRES_HOST_AUTH_METHOD" ]; then
-		cat >&2 <<-'EOWARN'
-			********************************************************************************
-			WARNING: POSTGRES_HOST_AUTH_METHOD has been set to "trust". This will allow
-			         anyone with access to the Postgres port to access your database without
-			         a password, even if POSTGRES_PASSWORD is set. See PostgreSQL
-			         documentation about "trust":
-			         https://www.postgresql.org/docs/current/auth-trust.html
-			         In Docker's default configuration, this is effectively any other
-			         container on the same system.
-
-			         It is not recommended to use POSTGRES_HOST_AUTH_METHOD=trust. Replace
-			         it with "-e POSTGRES_PASSWORD=password" instead to set a password in
-			         "docker run".
-			********************************************************************************
-		EOWARN
-	fi
-}
-
-# usage: docker_process_init_files [file [file [...]]]
-#    ie: docker_process_init_files /always-initdb.d/*
-# process initializer files, based on file extensions and permissions
-docker_process_init_files() {
-	# psql here for backwards compatibility "${psql[@]}"
-	psql=( docker_process_sql )
-
-	printf '\n'
-	local f
-	for f; do
-		case "$f" in
-			*.sh)
-				# https://github.com/docker-library/postgres/issues/450#issuecomment-393167936
-				# https://github.com/docker-library/postgres/pull/452
-				if [ -x "$f" ]; then
-					printf '%s: running %s\n' "$0" "$f"
-					"$f"
-				else
-					printf '%s: sourcing %s\n' "$0" "$f"
-					. "$f"
-				fi
-				;;
-			*.sql)     printf '%s: running %s\n' "$0" "$f"; docker_process_sql -f "$f"; printf '\n' ;;
-			*.sql.gz)  printf '%s: running %s\n' "$0" "$f"; gunzip -c "$f" | docker_process_sql; printf '\n' ;;
-			*.sql.xz)  printf '%s: running %s\n' "$0" "$f"; xzcat "$f" | docker_process_sql; printf '\n' ;;
-			*.sql.zst) printf '%s: running %s\n' "$0" "$f"; zstd -dc "$f" | docker_process_sql; printf '\n' ;;
-			*)         printf '%s: ignoring %s\n' "$0" "$f" ;;
-		esac
-		printf '\n'
-	done
-}
-
-# Execute sql script, passed via stdin (or -f flag of pqsl)
-# usage: docker_process_sql [psql-cli-args]
-#    ie: docker_process_sql --dbname=mydb <<<'INSERT ...'
-#    ie: docker_process_sql -f my-file.sql
-#    ie: docker_process_sql <my-file.sql
-docker_process_sql() {
-	local query_runner=( psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --no-password --no-psqlrc )
-	if [ -n "$POSTGRES_DB" ]; then
-		query_runner+=( --dbname "$POSTGRES_DB" )
-	fi
-
-	PGHOST= PGHOSTADDR= "${query_runner[@]}" "$@"
-}
-
-# create initial database
-# uses environment variables for input: POSTGRES_DB
-docker_setup_db() {
-	local dbAlreadyExists
-	dbAlreadyExists="$(
-		POSTGRES_DB= docker_process_sql --dbname postgres --set db="$POSTGRES_DB" --tuples-only <<-'EOSQL'
-			SELECT 1 FROM pg_database WHERE datname = :'db' ;
-		EOSQL
-	)"
-	if [ -z "$dbAlreadyExists" ]; then
-		POSTGRES_DB= docker_process_sql --dbname postgres --set db="$POSTGRES_DB" <<-'EOSQL'
-			CREATE DATABASE :"db" ;
-		EOSQL
-		printf '\n'
-	fi
-}
-
-# Loads various settings that are used elsewhere in the script
-# This should be called before any other functions
-docker_setup_env() {
-	file_env 'POSTGRES_PASSWORD'
-
-	file_env 'POSTGRES_USER' 'postgres'
-	file_env 'POSTGRES_DB' "$POSTGRES_USER"
-	file_env 'POSTGRES_INITDB_ARGS'
-	: "${POSTGRES_HOST_AUTH_METHOD:=}"
-
-	declare -g DATABASE_ALREADY_EXISTS
-	# look specifically for PG_VERSION, as it is expected in the DB dir
-	if [ -s "$PGDATA/PG_VERSION" ]; then
-		DATABASE_ALREADY_EXISTS='true'
-	fi
-}
-
-# append POSTGRES_HOST_AUTH_METHOD to pg_hba.conf for "host" connections
-# all arguments will be passed along as arguments to `postgres` for getting the value of 'password_encryption'
-pg_setup_hba_conf() {
-	# default authentication method is md5 on versions before 14
-	# https://www.postgresql.org/about/news/postgresql-14-released-2318/
-	if [ "$1" = 'postgres' ]; then
-		shift
-	fi
-	local auth
-	# check the default/configured encryption and use that as the auth method
-	auth="$(postgres -C password_encryption "$@")"
-	: "${POSTGRES_HOST_AUTH_METHOD:=$auth}"
-	{
-		printf '\n'
-		if [ 'trust' = "$POSTGRES_HOST_AUTH_METHOD" ]; then
-			printf '# warning trust is enabled for all connections\n'
-			printf '# see https://www.postgresql.org/docs/12/auth-trust.html\n'
-		fi
-		printf 'host all all all %s\n' "$POSTGRES_HOST_AUTH_METHOD"
-	} >> "$PGDATA/pg_hba.conf"
-}
-
-# start socket-only postgresql server for setting up or running scripts
-# all arguments will be passed along as arguments to `postgres` (via pg_ctl)
-docker_temp_server_start() {
-	if [ "$1" = 'postgres' ]; then
-		shift
-	fi
-
-	# internal start of server in order to allow setup using psql client
-	# does not listen on external TCP/IP and waits until start finishes
-	set -- "$@" -c listen_addresses='' -p "${PGPORT:-5432}"
-
-	PGUSER="${PGUSER:-$POSTGRES_USER}" \
-	pg_ctl -D "$PGDATA" \
-		-o "$(printf '%q ' "$@")" \
-		-w start
-}
-
-# stop postgresql server after done setting up user and running scripts
-docker_temp_server_stop() {
-	PGUSER="${PGUSER:-postgres}" \
-	pg_ctl -D "$PGDATA" -m fast -w stop
-}
-
-# check arguments for an option that would cause postgres to stop
-# return true if there is one
-_pg_want_help() {
-	local arg
-	for arg; do
-		case "$arg" in
-			# postgres --help | grep 'then exit'
-			# leaving out -C on purpose since it always fails and is unhelpful:
-			# postgres: could not access the server configuration file "/var/lib/postgresql/data/postgresql.conf": No such file or directory
-			-'?'|--help|--describe-config|-V|--version)
-				return 0
-				;;
-		esac
-	done
-	return 1
-}
-
-_main() {
-	# if first arg looks like a flag, assume we want to run postgres server
-	if [ "${1:0:1}" = '-' ]; then
-		set -- postgres "$@"
-	fi
-
-	if [ "$1" = 'postgres' ] && ! _pg_want_help "$@"; then
-		docker_setup_env
-		# setup data directories and permissions (when run as root)
-		docker_create_db_directories
-		if [ "$(id -u)" = '0' ]; then
-			# then restart script as postgres user
-			exec gosu postgres "$BASH_SOURCE" "$@"
-		fi
-
-		# only run initialization on an empty data directory
-		if [ -z "$DATABASE_ALREADY_EXISTS" ]; then
-			docker_verify_minimum_env
-
-			# check dir permissions to reduce likelihood of half-initialized database
-			ls /docker-entrypoint-initdb.d/ > /dev/null
-
-			docker_init_database_dir
-			pg_setup_hba_conf "$@"
-
-			# PGPASSWORD is required for psql when authentication is required for 'local' connections via pg_hba.conf and is otherwise harmless
-			# e.g. when '--auth=md5' or '--auth-local=md5' is used in POSTGRES_INITDB_ARGS
-			export PGPASSWORD="${PGPASSWORD:-$POSTGRES_PASSWORD}"
-			docker_temp_server_start "$@"
-
-			docker_setup_db
-            docker_process_init_files /docker-entrypoint-preinitdb.d/*
-            docker_temp_server_stop
-            docker_temp_server_start "$@"
-			docker_process_init_files /docker-entrypoint-initdb.d/*
-
-			docker_temp_server_stop
-			unset PGPASSWORD
-
-			cat <<-'EOM'
-
-				PostgreSQL init process complete; ready for start up.
-
-			EOM
-		else
-			cat <<-'EOM'
-
-				PostgreSQL Database directory appears to contain a database; Skipping initialization
-
-			EOM
-		fi
-	fi
-
-	exec "$@"
-}
-
-if ! _is_sourced; then
-	_main "$@"
-fi
diff --git a/docker/pgstac/dbinit/pgstac-rust-preinit.sh b/docker/pgstac/dbinit/pgstac-rust-preinit.sh
deleted file mode 100755
index 91b734c2..00000000
--- a/docker/pgstac/dbinit/pgstac-rust-preinit.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-psql -X -q -v ON_ERROR_STOP=1 <<EOSQL
-ALTER SYSTEM SET shared_preload_libraries=plrust;
-EOSQL
diff --git a/docker/pgstac/dbinit/pgstac-rust.sh b/docker/pgstac/dbinit/pgstac-rust.sh
deleted file mode 100755
index a9e39da4..00000000
--- a/docker/pgstac/dbinit/pgstac-rust.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-psql -X -q -v ON_ERROR_STOP=1 <<EOSQL
-ALTER SYSTEM SET plrust.work_dir='/tmp';
-CREATE EXTENSION plrust;
-EOSQL
diff --git a/docker/pgstac/dbinit/pgstac.sh b/docker/pgstac/dbinit/pgstac.sh
index 70fb1606..f4e97986 100755
--- a/docker/pgstac/dbinit/pgstac.sh
+++ b/docker/pgstac/dbinit/pgstac.sh
@@ -5,6 +5,7 @@ MAINTENANCE_WORK_MEM=$(( $SYSMEM/8 ))
 WORK_MEM=$(( $SHARED_BUFFERS/50 ))
 
 psql -X -q -v ON_ERROR_STOP=1 <<EOSQL
+CREATE EXTENSION IF NOT EXISTS pg_tle;
 ALTER SYSTEM SET search_path TO pgstac, public;
 ALTER SYSTEM SET client_min_messages TO WARNING;
 ALTER SYSTEM SET shared_buffers='${SHARED_BUFFERS}kB';
@@ -13,4 +14,4 @@ ALTER SYSTEM SET maintenance_work_mem='${MAINTENANCE_WORK_MEM}kB';
 ALTER SYSTEM SET work_mem='${WORK_MEM}kB';
 ALTER SYSTEM SET effective_io_concurrency=200;
 ALTER SYSTEM SET random_page_cost=1.1;
-EOSQL
\ No newline at end of file
+EOSQL
diff --git a/docker/pypgstac/Dockerfile b/docker/pypgstac/Dockerfile
index f2bbf512..aee9873b 100644
--- a/docker/pypgstac/Dockerfile
+++ b/docker/pypgstac/Dockerfile
@@ -1,41 +1,80 @@
-FROM rust:1-slim-bullseye AS pyrustbase
+# syntax=docker/dockerfile:1.7
+FROM rust:1-slim-trixie AS pyrustbase
 ENV PYTHONWRITEBYTECODE=1
 ENV PYTHONBUFFERED=1
 ENV PIP_ROOT_USER_ACTION=ignore
+ENV UV_BREAK_SYSTEM_PACKAGES=1
 ENV PYTHONPATH="/opt/src/pypgstac:$PYTHONPATH"
-ENV PATH="/opt/docker/pypgstac/bin:$PATH"
+ENV PATH="/opt/pgstac/container-scripts:$PATH"
+ENV UV_CACHE_DIR=/root/.cache/uv
 ARG PG_MAJOR=17
-RUN \
+RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
+    --mount=type=cache,target=/var/lib/apt/lists,sharing=locked \
+    --mount=type=cache,target=/root/.cache/uv,sharing=locked \
     apt-get update \
-    && apt-get upgrade -y \
-    && apt-get install -y --no-install-recommends ca-certificates curl gnupg lsb-release \
-    && curl -fsSL https://www.postgresql.org/media/keys/ACCC4CF8.asc \
-       | gpg --dearmor -o /usr/share/keyrings/pgdg.gpg \
-    && echo "deb [signed-by=/usr/share/keyrings/pgdg.gpg] http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" \
-       > /etc/apt/sources.list.d/pgdg.list \
-    && apt-get update \
     && apt-get install -y --no-install-recommends \
+        adduser \
+        ca-certificates \
+        curl \
         postgresql-client-${PG_MAJOR} \
         python3 python-is-python3 python3-pip python3-venv \
-        build-essential clang clang-11 gcc git libssl-dev llvm-11 make pkg-config \
-    && python3 -m pip install --upgrade pip uv wheel setuptools \
-    && apt-get remove -y apt-transport-https \
+        build-essential clang gcc git libssl-dev llvm make pkg-config \
+    && curl -LsSf https://astral.sh/uv/install.sh | UV_INSTALL_DIR=/usr/local/bin sh \
     && apt-get clean && apt-get -y autoremove \
     && rm -rf /var/lib/apt/lists/*
 
 FROM pyrustbase AS pypgstac
 COPY ./src/pypgstac/pyproject.toml /tmp/pyproject.toml
 WORKDIR /tmp
-RUN \
-    uv pip compile --all-extras /tmp/pyproject.toml >/tmp/requirements.txt \
+RUN --mount=type=cache,target=/root/.cache/uv,sharing=locked \
+    uv pip compile /tmp/pyproject.toml \
+    --extra dev \
+    --extra test \
+    --extra psycopg \
+    --extra migrations \
+    >/tmp/requirements.txt \
     && uv pip install --system -r /tmp/requirements.txt
-COPY docker/pypgstac/bin /opt/docker/pypgstac/bin
+COPY scripts/container-scripts /opt/pgstac/container-scripts
 COPY src/pypgstac /opt/src/pypgstac
 COPY src/pgstac /opt/src/pgstac
 WORKDIR /opt/src/pypgstac
-RUN uv pip install --system -e . && rm -rf /usr/local/cargo/registry
+RUN --mount=type=cache,target=/root/.cache/uv,sharing=locked \
+    uv pip install --system -e . \
+    && rm -rf /usr/local/cargo/registry
 
 RUN addgroup --gid 1000 user && \
     adduser --uid 1000 --gid 1000 --disabled-password --gecos "" --home /home/user user && \
     chown -R user:user /opt/src/pypgstac /opt/src/pgstac
 USER user
+
+# Optional runtime-optimized image: no build toolchain, only pypgstac package + runtime deps.
+FROM python:3.13-slim-trixie AS pypgstac-runtime
+ENV PYTHONWRITEBYTECODE=1
+ENV PYTHONBUFFERED=1
+ENV UV_BREAK_SYSTEM_PACKAGES=1
+ENV PATH="/opt/pgstac/container-scripts:$PATH"
+ENV UV_CACHE_DIR=/root/.cache/uv
+ARG PG_MAJOR=17
+RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
+    --mount=type=cache,target=/var/lib/apt/lists,sharing=locked \
+    --mount=type=cache,target=/root/.cache/uv,sharing=locked \
+    apt-get update \
+    && apt-get install -y --no-install-recommends \
+        ca-certificates \
+        curl \
+        postgresql-client-${PG_MAJOR} \
+    && curl -LsSf https://astral.sh/uv/install.sh | UV_INSTALL_DIR=/usr/local/bin sh \
+    && apt-get clean && rm -rf /var/lib/apt/lists/*
+COPY ./src/pypgstac/pyproject.toml /tmp/pyproject.toml
+RUN --mount=type=cache,target=/root/.cache/uv,sharing=locked \
+    uv pip compile /tmp/pyproject.toml \
+    --extra psycopg \
+    --extra migrations \
+    >/tmp/requirements.txt \
+    && uv pip install --system -r /tmp/requirements.txt
+COPY scripts/container-scripts /opt/pgstac/container-scripts
+COPY src/pypgstac /opt/src/pypgstac
+COPY src/pgstac /opt/src/pgstac
+WORKDIR /opt/src/pypgstac
+RUN --mount=type=cache,target=/root/.cache/uv,sharing=locked \
+    uv pip install --system .
diff --git a/docker/pypgstac/bin/tmpdb b/docker/pypgstac/bin/tmpdb
deleted file mode 100755
index b4788406..00000000
--- a/docker/pypgstac/bin/tmpdb
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/bin/bash
-set -e
-
-if [[ "${CI}" ]]; then
-    set -x
-fi
-
-if [ ! $PGSTACDOCKER == 1 ]; then
-    echo "This script should only be run within pgstac docker"; exit 1;
-fi
-
-function tmppg(){
-
-# Make temp directories for pgdata and logs
-WORKSPACE=$(mktemp -d)
-
-# Find an unused port
-
-# Run tests using postgres user and trust authentication
-
-export PGDATA=$WORKSPACE/pgdata
-export PGLOG=$WORKSPACE/pglog
-
-export PGDATABASE=postgres
-export PGUSER=postgres
-
-# Leverage scripts from docker-entrypoint.sh
-source /usr/local/bin/docker-entrypoint.sh
-
-gosu postgres initdb --username $PGUSER --auth=trust -D $PGDATA
-
-# Start postgres with minimal logging settings
-gosu postgres pg_ctl -l "$PGLOG" -w -o "-F -c fsync=off -c full_page_writes=off -c synchronous_commit=off -c archive_mode=off" start
-trap "gosu postgres pg_ctl stop && rm -fr $WORKSPACE " 0 2 3 15
-
-# Get location of script directory
-SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-
-cd /opt/src/pgstac
-# Create template database with pgstac installed
-psql -X -q -v ON_ERROR_STOP=1 <<EOSQL
-CREATE DATABASE pgstac_test_db_template;
-ALTER DATABASE pgstac_test_db_template SET CLIENT_MIN_MESSAGES TO WARNING;
-ALTER DATABASE pgstac_test_db_template SET SEARCH_PATH to pgstac, public;
-\connect pgstac_test_db_template;
-\i pgstac.sql
-EOSQL
-}
-export -f setuptestdb
-
-function tmpdb(){
-    TMPFILE=$(mktemp -t tmpdb_XXXXX)
-    trap "rm $TMPFILE" 0 2 3 15
-    TMPDB=$(basename $TMPFILE)
diff --git a/scripts/console b/scripts/console
index 60068e4b..7defafa4 100755
--- a/scripts/console
+++ b/scripts/console
@@ -1,6 +1,7 @@
 #!/bin/bash
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 cd $SCRIPT_DIR/..
+source "$SCRIPT_DIR/pgstacenv"
 set -e
 
 if [[ "${CI}" ]]; then
@@ -9,7 +10,7 @@ fi
 
 function usage() {
     echo -n \
-        "Usage: $(basename "$0") [--db]
+        "Usage: $(basename "$0") [--db] [--help]
 Start a console in the dev container
 
 --db: Instead, start a psql console in the database container.
@@ -21,14 +22,19 @@ while [[ "$#" > 0 ]]; do case $1 in
         DB_CONSOLE=1
         shift
         ;;
+    -h|--help)
+        usage
+        exit 0
+        ;;
     *)
-        usage "Unknown parameter passed: $1"
-        shift
-        shift
+        echo "Unknown parameter passed: $1" >&2
+        usage
+        exit 1
         ;;
     esac; done
 
 if [ "${BASH_SOURCE[0]}" = "${0}" ]; then
+    ensure_env_file
 
     docker compose up -d
 
@@ -39,6 +45,6 @@ if [ "${BASH_SOURCE[0]}" = "${0}" ]; then
         exit 0
     fi
 
-    docker compose exec pgstac /bin/bash
+    docker compose exec pypgstac /bin/bash
 
 fi
diff --git a/docker/pypgstac/bin/format b/scripts/container-scripts/format
similarity index 60%
rename from docker/pypgstac/bin/format
rename to scripts/container-scripts/format
index 15053b66..6c22233e 100755
--- a/docker/pypgstac/bin/format
+++ b/scripts/container-scripts/format
@@ -5,20 +5,20 @@ if [[ "${CI}" ]]; then
     set -x
 fi
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-cd $SCRIPT_DIR/../../../src
+cd ${PGSTAC_REPO_DIR:-/opt/src}
 
 function usage() {
     echo -n \
         "Usage: $(basename "$0")
 Format code.
 
-This scripts is meant to be run inside the dev container.
+This script is meant to be run inside the dev container.
 
 "
 }
 
 if [ "${BASH_SOURCE[0]}" = "${0}" ]; then
     echo "Formatting pypgstac..."
-    ruff --fix pypgstac/pypgstac
-    ruff --fix pypgstac/tests
+    ruff check --fix pypgstac/src/pypgstac pypgstac/tests
+    ruff format pypgstac/src/pypgstac pypgstac/tests
 fi
diff --git a/docker/pypgstac/bin/initpgstac b/scripts/container-scripts/initpgstac
similarity index 79%
rename from docker/pypgstac/bin/initpgstac
rename to scripts/container-scripts/initpgstac
index b205b7cf..880b350d 100755
--- a/docker/pypgstac/bin/initpgstac
+++ b/scripts/container-scripts/initpgstac
@@ -1,11 +1,11 @@
 #!/bin/bash
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-cd $SCRIPT_DIR/../../../src/pgstac
+cd ${PGSTAC_PGSTAC_DIR:-/opt/src/pgstac}
 
 psql -X -q -v ON_ERROR_STOP=1 <<EOSQL
 ALTER DATABASE $POSTGRES_DB SET CLIENT_MIN_MESSAGES TO WARNING;
 ALTER DATABASE $POSTGRES_DB SET SEARCH_PATH to pgstac, public;
 \connect $POSTGRES_DB;
-CREATE EXTENSION IF NOT EXISTS plrust;
+CREATE EXTENSION IF NOT EXISTS pg_tle;
 \i pgstac.sql
 EOSQL
diff --git a/docker/pypgstac/bin/loadsampledata b/scripts/container-scripts/loadsampledata
similarity index 87%
rename from docker/pypgstac/bin/loadsampledata
rename to scripts/container-scripts/loadsampledata
index 88e85f61..a349dd7a 100755
--- a/docker/pypgstac/bin/loadsampledata
+++ b/scripts/container-scripts/loadsampledata
@@ -1,7 +1,7 @@
 #!/bin/bash
 set -e
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-cd $SCRIPT_DIR/../../../src/pgstac
+cd ${PGSTAC_PGSTAC_DIR:-/opt/src/pgstac}
 psql -f pgstac.sql
 psql -v ON_ERROR_STOP=1 <<-EOSQL
     \copy collections (content) FROM 'tests/testdata/collections.ndjson'
diff --git a/docker/pypgstac/bin/makemigration b/scripts/container-scripts/makemigration
similarity index 76%
rename from docker/pypgstac/bin/makemigration
rename to scripts/container-scripts/makemigration
index e2a6f7a3..bb24831e 100755
--- a/docker/pypgstac/bin/makemigration
+++ b/scripts/container-scripts/makemigration
@@ -1,6 +1,6 @@
 #!/bin/bash
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-SRCDIR=$SCRIPT_DIR/../../../src
+SRCDIR=${PGSTAC_REPO_DIR:-/opt/src}
 cd $SRCDIR
 
 SHORT=f:,t:,o,d,h
@@ -29,8 +29,23 @@ do
       shift 1
       ;;
     -h | --help)
-      "Help"
-      exit 2
+      cat <<EOF
+Usage: $(basename "$0") -f VERSION -t VERSION [options]
+
+Options:
+  -f, --from VERSION    Source base version.
+  -t, --to VERSION      Target base version.
+  -o, --overwrite       Replace an existing migration file.
+  -d, --debug           Print the generated migra SQL before wrapping it.
+  -h, --help            Show this help text.
+
+Environment:
+  PGSTAC_FROM_VERSION   Default source version.
+  PGSTAC_TO_VERSION     Default target version.
+  PGSTAC_OVERWRITE      Set to 1 to imply --overwrite.
+  PGSTAC_DEBUG          Set to 1 to imply --debug.
+EOF
+      exit 0
       ;;
     --)
       shift;
@@ -44,6 +59,16 @@ done
 
 # make sure that from and to exist
 
+FROM=${FROM:-${PGSTAC_FROM_VERSION:-}}
+TO=${TO:-${PGSTAC_TO_VERSION:-}}
+[[ "${PGSTAC_OVERWRITE:-0}" == "1" ]] && OVERWRITE=1
+[[ "${PGSTAC_DEBUG:-0}" == "1" ]] && DEBUG=1
+
+if [[ -z "$FROM" || -z "$TO" ]]; then
+  echo "Both --from and --to are required." >&2
+  exit 1
+fi
+
 
 
 BASEDIR=$SRCDIR
@@ -72,13 +97,8 @@ fi
 MIGRATIONSQL=$MIGRATIONSDIR/pgstac.$FROM-$TO.sql
 if [[ -f "$MIGRATIONSQL" ]]; then
   if [[ "$OVERWRITE" != 1 ]]; then
-    echo "$MIGRATIONSQL Already exists."
-    select yn in "Yes" "No"; do
-      case $yn in
-        Yes ) break;;
-        No ) exit 1;;
-      esac
-    done
+    echo "ERROR: $MIGRATIONSQL already exists. Use --overwrite to replace." >&2
+    exit 1
   else
     echo "Removing existing $MIGRATIONSQL"
     rm $MIGRATIONSQL
diff --git a/docker/pypgstac/bin/pgstac_restore b/scripts/container-scripts/pgstac_restore
similarity index 100%
rename from docker/pypgstac/bin/pgstac_restore
rename to scripts/container-scripts/pgstac_restore
diff --git a/docker/pypgstac/bin/resetpgstac b/scripts/container-scripts/resetpgstac
similarity index 90%
rename from docker/pypgstac/bin/resetpgstac
rename to scripts/container-scripts/resetpgstac
index 097c3d5b..6c428cee 100755
--- a/docker/pypgstac/bin/resetpgstac
+++ b/scripts/container-scripts/resetpgstac
@@ -1,6 +1,6 @@
 #!/bin/bash
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-cd $SCRIPT_DIR/../../../src/pgstac
+cd ${PGSTAC_PGSTAC_DIR:-/opt/src/pgstac}
 set -e
 psql -v ON_ERROR_STOP=1 <<-EOSQL
     DROP SCHEMA IF EXISTS pgstac CASCADE;
diff --git a/docker/pypgstac/bin/stageversion b/scripts/container-scripts/stageversion
similarity index 74%
rename from docker/pypgstac/bin/stageversion
rename to scripts/container-scripts/stageversion
index e99a6121..fcac770c 100755
--- a/docker/pypgstac/bin/stageversion
+++ b/scripts/container-scripts/stageversion
@@ -1,19 +1,41 @@
 #!/bin/bash
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-SRCDIR=$SCRIPT_DIR/../../../src
+SRCDIR=${PGSTAC_REPO_DIR:-/opt/src}
 cd $SRCDIR
 BASEDIR=$SRCDIR
 SQLDIR=$BASEDIR/pgstac/sql
 PYPGSTACDIR=$BASEDIR/pypgstac
 MIGRATIONSDIR=$BASEDIR/pgstac/migrations
 
+function usage() {
+        cat <<EOF
+Usage: $(basename "$0") [version]
+
+Create a new base migration, update pypgstac version metadata, and generate the
+incremental migration via makemigration.
+
+Environment:
+    PGSTAC_VERSION   Default version when no positional version is provided.
+EOF
+}
+
+if [[ "$1" == "-h" || "$1" == "--help" ]]; then
+        usage
+        exit 0
+fi
+
 
 # Remove any existing unreleased migrations
 find $MIGRATIONSDIR -name "*unreleased*" -exec rm {} \;
 
 # Get Version
-if [[ ! -z "$1" ]]; then
+if [[ -n "$1" ]]; then
     VERSION=$1
+elif [[ -n "${PGSTAC_VERSION:-}" ]]; then
+    VERSION=$PGSTAC_VERSION
+fi
+
+if [[ -n "$VERSION" ]]; then
     if echo "$VERSION" | grep -E "^[0-9]+[.][0-9]+[.][0-9]+$"; then
         echo "STAGING VERSION: $VERSION"
     else
diff --git a/docker/pypgstac/bin/test b/scripts/container-scripts/test
similarity index 86%
rename from docker/pypgstac/bin/test
rename to scripts/container-scripts/test
index 3d2c5b56..3a86694d 100755
--- a/docker/pypgstac/bin/test
+++ b/scripts/container-scripts/test
@@ -1,25 +1,45 @@
 #!/bin/bash
 set -e
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+REPO_DIR=${PGSTAC_REPO_DIR:-/opt/src}
 export PATH="$SCRIPT_DIR:$PATH"
-export SRCDIR=$SCRIPT_DIR/../../../src
+if [[ -d "$REPO_DIR/pgstac" && -d "$REPO_DIR/pypgstac" ]]; then
+    export SRCDIR="$REPO_DIR"
+elif [[ -d "$REPO_DIR/src/pgstac" && -d "$REPO_DIR/src/pypgstac" ]]; then
+    export SRCDIR="$REPO_DIR/src"
+elif [[ -d "$SCRIPT_DIR/../../src/pgstac" && -d "$SCRIPT_DIR/../../src/pypgstac" ]]; then
+    export SRCDIR="$(cd "$SCRIPT_DIR/../../src" && pwd)"
+else
+    echo "Unable to find pgstac/pypgstac sources under '$REPO_DIR'." >&2
+    echo "Set PGSTAC_REPO_DIR to either a directory containing pgstac/ and pypgstac/ or a repository root containing src/pgstac and src/pypgstac." >&2
+    exit 1
+fi
 export PGSTACDIR=$SRCDIR/pgstac
 
-echo $SCRIPT_DIR
-echo $SRCDIR
-echo $PGSTACDIR
-
 if [[ "${CI}" ]]; then
     set -x
 fi
 
 function usage() {
-    echo -n \
-        "Usage: $(basename "$0")
-Run PgSTAC tests.
-This scripts is meant to be run inside the dev container.
+        cat <<EOF
+Usage: $(basename "$0") [options]
 
-"
+Run PgSTAC tests.
+This script is meant to be run inside the dev container.
+
+Options:
+    --formatting          Run ruff + ty checks.
+    --pgtap               Run PGTap SQL tests.
+    --basicsql            Run basic SQL output tests.
+    --basicsql-createout  Recreate missing .sql.out fixtures.
+    --pypgstac            Run Python tests.
+    --migrations          Run migration-path validation.
+    --pgdump              Run pg_dump / pg_restore validation.
+    --nomigrations        Run everything except migration and pg_dump tests.
+    --v                   Raise client_min_messages to notice.
+    --vv                  Raise client_min_messages to debug1.
+    --help                Show this help text.
+EOF
 }
 
 function setuptestdb(){
@@ -43,14 +63,21 @@ END
 EOSQL
 }
 
+function refresh_collation_versions(){
+    # Newer container libc versions can make template collation metadata stale.
+    psql -X -q -d postgres -c "ALTER DATABASE template1 REFRESH COLLATION VERSION;" >/dev/null 2>&1 || true
+    psql -X -q -d postgres -c "ALTER DATABASE postgis REFRESH COLLATION VERSION;" >/dev/null 2>&1 || true
+}
+
 function test_formatting(){
     cd $SRCDIR/pypgstac
 
     echo "Running ruff"
     ruff check src/pypgstac tests
+    ruff format --check src/pypgstac tests
 
-    echo "Running mypy"
-    mypy src/pypgstac
+    echo "Running ty"
+    ty check
 
     echo "Checking if there are any staged migrations."
     find $SRCDIR/pgstac/migrations | grep 'staged' && { echo "There are staged migrations in pypgstac/migrations. Please check migrations and remove staged suffix."; exit 1; }
@@ -378,7 +405,7 @@ then
 fi
 
 [ $FORMATTING -eq 1 ] && test_formatting
-[ $SETUPDB -eq 1 ] && setuptestdb
+[ $SETUPDB -eq 1 ] && refresh_collation_versions && setuptestdb
 [ $PGTAP -eq 1 ] && test_pgtap
 [ $BASICSQL -eq 1 ] && test_basicsql
 [ $PYPGSTAC -eq 1 ] && test_pypgstac
diff --git a/scripts/format b/scripts/format
index 0a47433a..84d8565f 100755
--- a/scripts/format
+++ b/scripts/format
@@ -1,4 +1,37 @@
 #!/bin/bash
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 cd $SCRIPT_DIR/..
-$SCRIPT_DIR/runinpypgstac format "$@"
+
+function usage() {
+	cat <<EOF
+Usage: $(basename "$0") [options]
+
+Run formatting checks inside the pypgstac development container.
+
+Options:
+  --build-policy POLICY   One of: always, missing, never. Default: always.
+  -h, --help              Show this help text.
+EOF
+}
+
+BUILD_POLICY="${PGSTAC_BUILD_POLICY:-always}"
+
+while [[ $# -gt 0 ]]; do
+	case "$1" in
+		--build-policy)
+			BUILD_POLICY="$2"
+			shift 2
+			;;
+		-h|--help)
+			usage
+			exit 0
+			;;
+		*)
+			echo "Unknown option: $1" >&2
+			usage
+			exit 1
+			;;
+	esac
+done
+
+$SCRIPT_DIR/runinpypgstac --build-policy "$BUILD_POLICY" --cpfiles format
diff --git a/scripts/makemigration b/scripts/makemigration
new file mode 100755
index 00000000..64572a5c
--- /dev/null
+++ b/scripts/makemigration
@@ -0,0 +1,64 @@
+#!/bin/bash
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+cd $SCRIPT_DIR/..
+
+function usage() {
+    cat <<EOF
+Usage: $(basename "$0") [options]
+
+Run the in-container makemigration helper.
+
+Options:
+  -f, --from VERSION      Source base version.
+  -t, --to VERSION        Target base version.
+  -o, --overwrite         Replace an existing migration file.
+  -d, --debug             Print the generated migra SQL before wrapping it.
+  --build-policy POLICY   One of: always, missing, never. Default: always.
+  -h, --help              Show this help text.
+
+Environment:
+  PGSTAC_FROM_VERSION     Default source version.
+  PGSTAC_TO_VERSION       Default target version.
+  PGSTAC_OVERWRITE        Set to 1 to imply --overwrite.
+  PGSTAC_DEBUG            Set to 1 to imply --debug.
+  PGSTAC_BUILD_POLICY     Default build policy.
+EOF
+}
+
+BUILD_POLICY="${PGSTAC_BUILD_POLICY:-always}"
+POSITIONAL=()
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --build-policy)
+            BUILD_POLICY="$2"
+            shift 2
+            ;;
+        -h|--help)
+            usage
+            exit 0
+            ;;
+        *)
+            POSITIONAL+=("$1")
+            shift
+            ;;
+    esac
+done
+
+if [[ -n "${PGSTAC_FROM_VERSION:-}" ]]; then
+    POSITIONAL=(-f "$PGSTAC_FROM_VERSION" "${POSITIONAL[@]}")
+fi
+
+if [[ -n "${PGSTAC_TO_VERSION:-}" ]]; then
+    POSITIONAL=(-t "$PGSTAC_TO_VERSION" "${POSITIONAL[@]}")
+fi
+
+if [[ "${PGSTAC_OVERWRITE:-0}" == "1" ]]; then
+    POSITIONAL=(--overwrite "${POSITIONAL[@]}")
+fi
+
+if [[ "${PGSTAC_DEBUG:-0}" == "1" ]]; then
+    POSITIONAL=(--debug "${POSITIONAL[@]}")
+fi
+
+$SCRIPT_DIR/runinpypgstac --build-policy "$BUILD_POLICY" --cpfiles makemigration "${POSITIONAL[@]}"
diff --git a/scripts/migrate b/scripts/migrate
index 445a5179..dd97f82a 100755
--- a/scripts/migrate
+++ b/scripts/migrate
@@ -1,4 +1,37 @@
 #!/bin/bash
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 cd $SCRIPT_DIR/..
-$SCRIPT_DIR/runinpypgstac pypgstac migrate "$@"
+
+function usage() {
+	cat <<EOF
+Usage: $(basename "$0") [options] [pypgstac migrate args...]
+
+Run pypgstac migrations inside the development container.
+
+Options:
+  --build-policy POLICY   One of: always, missing, never. Default: always.
+  -h, --help              Show this help text.
+EOF
+}
+
+BUILD_POLICY="${PGSTAC_BUILD_POLICY:-always}"
+POSITIONAL=()
+
+while [[ $# -gt 0 ]]; do
+	case "$1" in
+		--build-policy)
+			BUILD_POLICY="$2"
+			shift 2
+			;;
+		-h|--help)
+			usage
+			exit 0
+			;;
+		*)
+			POSITIONAL+=("$1")
+			shift
+			;;
+	esac
+done
+
+$SCRIPT_DIR/runinpypgstac --build-policy "$BUILD_POLICY" pypgstac migrate "${POSITIONAL[@]}"
diff --git a/scripts/pgstacenv b/scripts/pgstacenv
index 264c3725..1aadfec2 100644
--- a/scripts/pgstacenv
+++ b/scripts/pgstacenv
@@ -9,3 +9,28 @@ set -e
 if [[ "${CI}" ]]; then
     set -x
 fi
+
+function first_available_pgport() {
+    local port
+
+    for port in 5439 5440 5441 5442 5443 5444 5445; do
+        if ! ss -ltn "( sport = :$port )" 2>/dev/null | tail -n +2 | grep -q .; then
+            echo "$port"
+            return 0
+        fi
+    done
+
+    echo 5439
+}
+
+function ensure_env_file() {
+    if [[ ! -f .env && -f .env.example ]]; then
+        cp .env.example .env
+        local selected_port
+        selected_port=$(first_available_pgport)
+        if [[ "$selected_port" != "5439" ]]; then
+            sed -i "s/^PGPORT=.*/PGPORT=${selected_port}/" .env
+        fi
+        echo "Created .env from .env.example"
+    fi
+}
diff --git a/scripts/runinpypgstac b/scripts/runinpypgstac
index bbd0517e..8e978725 100755
--- a/scripts/runinpypgstac
+++ b/scripts/runinpypgstac
@@ -1,56 +1,141 @@
 #!/bin/bash
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 cd $SCRIPT_DIR/..
+source "$SCRIPT_DIR/pgstacenv"
 set -e
 
 if [[ "${CI}" ]]; then
     set -x
 fi
+
 function usage() {
-    echo -n \
-        "Usage: $(basename "$0") <--build> <--no-cache> <script>
-        script options: format, test, makemigration, stageversion
-        "
-exit 1
+    cat <<EOF
+Usage: $(basename "$0") [options] <command> [command args...]
+
+Run a command inside the pypgstac development container.
+
+Options:
+  --build                 Equivalent to --build-policy always.
+  --build-policy POLICY   One of: always, missing, never.
+  --no-cache              Rebuild images without Docker layer cache.
+  --cpfiles               Copy /opt/src back to the host after the command runs.
+  -h, --help              Show this help text.
+
+Examples:
+  $(basename "$0") --build test --pypgstac
+  $(basename "$0") --build-policy missing format
+  $(basename "$0") --build-policy always --cpfiles stageversion 0.9.11
+EOF
 }
 
-[ "$#" -eq 0 ] && usage
+function ensure_images_exist() {
+    docker image inspect pgstac >/dev/null 2>&1 && docker image inspect pypgstac >/dev/null 2>&1
+}
+
+function wait_for_pgstac() {
+    local attempts=60
+    local status=""
+    local container_id=""
+
+    while [[ $attempts -gt 0 ]]; do
+        container_id=$(docker compose ps -q pgstac 2>/dev/null || true)
+        status=$(docker inspect --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}' "$container_id" 2>/dev/null || true)
+
+        if [[ "$status" == "healthy" || "$status" == "running" ]]; then
+            return 0
+        fi
+
+        attempts=$((attempts - 1))
+        sleep 1
+    done
+
+    echo "Timed out waiting for pgstac to become ready." >&2
+    return 1
+}
+
+[ "$#" -eq 0 ] && usage && exit 1
 
-ARGS=($@)
 CONTAINER_ARGS=()
-for ARG in "${ARGS[@]}"
-do
-    if [[ $ARG == "--no-cache" ]]; then
-        BUILD=1
-        NOCACHE="--no-cache"
-    elif [[ $ARG == "--build" ]]; then
-        BUILD=1
-    elif [[ $ARG == "--cpfiles" ]]; then
-        CPFILES=1
-    else
-        CONTAINER_ARGS+=($ARG)
-    fi
+BUILD_POLICY="${PGSTAC_BUILD_POLICY:-always}"
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --build)
+            BUILD_POLICY="always"
+            shift
+            ;;
+        --build-policy)
+            BUILD_POLICY="$2"
+            shift 2
+            ;;
+        --no-cache)
+            NOCACHE="--no-cache"
+            shift
+            ;;
+        --cpfiles)
+            CPFILES=1
+            shift
+            ;;
+        -h|--help)
+            usage
+            exit 0
+            ;;
+        --)
+            shift
+            break
+            ;;
+        *)
+            break
+            ;;
+    esac
 done
-if [[ $BUILD == 1 ]]; then
+
+CONTAINER_ARGS=("$@")
+
+if [[ ${#CONTAINER_ARGS[@]} -eq 0 ]]; then
+    usage
+    exit 1
+fi
+
+case "$BUILD_POLICY" in
+    always|missing|never)
+        ;;
+    *)
+        echo "Invalid build policy: $BUILD_POLICY" >&2
+        usage
+        exit 1
+        ;;
+esac
+
+if [[ -n "$NOCACHE" && "$BUILD_POLICY" == "never" ]]; then
+    echo "--no-cache cannot be used with --build-policy never." >&2
+    exit 1
+fi
+
+if [[ "$BUILD_POLICY" == "always" || ( "$BUILD_POLICY" == "missing" && ! ensure_images_exist ) ]]; then
     echo "Building docker images..."
-    docker compose down -v --remove-orphans
-    docker compose build $NOCACHE
-    docker compose up -d pgstac
-    sleep 4
+    ensure_env_file
+    docker compose build ${NOCACHE}
 fi
+
+ensure_env_file
 PGSTAC_RUNNING=$(docker compose ps pgstac --status running -q)
 echo "PGSTAC_RUNNING=$PGSTAC_RUNNING"
+
+if [[ -z "$PGSTAC_RUNNING" ]]; then
+    docker compose up -d pgstac
+    wait_for_pgstac
+fi
+
 if [[ $CPFILES == 1 ]]; then
-    echo "Checking if pypgstacworker is running"
-    docker ps | grep pypgstacworker && echo "Killing pypgstacworker" && docker kill pypgstacworker || echo "pypgstac worker not running"
     echo "Running pypgstac worker"
-    docker compose run -d --rm --name pypgstacworker pypgstac /bin/bash
+    WORKER_ID=$(docker compose run -d --rm pypgstac tail -f /dev/null)
     echo "Executing ${CONTAINER_ARGS[@]} in pypgstac worker"
-    docker compose exec pypgstac "${CONTAINER_ARGS[@]}"
+    docker exec "$WORKER_ID" "${CONTAINER_ARGS[@]}"
     echo "copying datafiles to host"
-    docker cp pypgstacworker:/opt/src $SCRIPT_DIR/..
+    docker cp "$WORKER_ID":/opt/src $SCRIPT_DIR/..
     echo "killing pypgstac worker"
-    docker kill pypgstacworker
+    docker kill "$WORKER_ID" >/dev/null
 else
     echo "Running ${CONTAINER_ARGS[@]} in pypgstacworker"
     docker compose run -T --rm pypgstac "${CONTAINER_ARGS[@]}"
diff --git a/scripts/server b/scripts/server
index da92e4f1..ec498654 100755
--- a/scripts/server
+++ b/scripts/server
@@ -1,6 +1,7 @@
 #!/bin/bash
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 cd $SCRIPT_DIR/..
+source "$SCRIPT_DIR/pgstacenv"
 set -e
 
 if [[ "${CI}" ]]; then
@@ -8,13 +9,17 @@ if [[ "${CI}" ]]; then
 fi
 
 function usage() {
-    echo $1
+    if [[ -n "$1" ]]; then
+        echo "$1" >&2
+        echo >&2
+    fi
 
     echo -n \
-        "Usage: $(basename "$0") [--detach]
+        "Usage: $(basename "$0") [--detach] [--no-cache] [--help]
 Runs the development database.
 
 --detach: Run in detached mode.
+--no-cache: Rebuild container images from scratch before startup.
 "
 }
 
@@ -25,15 +30,22 @@ while [[ "$#" > 0 ]]; do case $1 in
         DETACH_ARG="--detach"
         shift
         ;;
-    --help)
+    --no-cache)
+        NO_CACHE="--no-cache"
+        shift
+        ;;
+    -h|--help)
         usage
         exit 0
-        shift
         ;;
-    *) break ;;
+    *)
+        usage "Unknown option: $1"
+        exit 1
+        ;;
     esac; done
 
 if [ "${BASH_SOURCE[0]}" = "${0}" ]; then
-    docker compose build
+    ensure_env_file
+    docker compose build ${NO_CACHE}
     docker compose up ${DETACH_ARG} $@
 fi
diff --git a/scripts/setup b/scripts/setup
index c87aca3a..258868b6 100755
--- a/scripts/setup
+++ b/scripts/setup
@@ -9,11 +9,25 @@ fi
 
 function usage() {
     echo -n \
-        "Usage: $(basename "$0")
+        "Usage: $(basename "$0") [--help]
 Sets up this project for development.
 "
 }
 
+while [[ "$#" -gt 0 ]]; do
+    case "$1" in
+        -h|--help)
+            usage
+            exit 0
+            ;;
+        *)
+            echo "Unknown option: $1" >&2
+            usage
+            exit 1
+            ;;
+    esac
+done
+
 if [ "${BASH_SOURCE[0]}" = "${0}" ]; then
 
     # Build docker containers
diff --git a/scripts/stageversion b/scripts/stageversion
index cf5ee8e8..6d0efd58 100755
--- a/scripts/stageversion
+++ b/scripts/stageversion
@@ -1,4 +1,55 @@
 #!/bin/bash
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 cd $SCRIPT_DIR/..
-$SCRIPT_DIR/runinpypgstac --build --cpfiles stageversion "$@"
+
+function usage() {
+	cat <<EOF
+Usage: $(basename "$0") [options] [version]
+
+Run the in-container stageversion script and copy generated files back to the host.
+
+Options:
+  --build-policy POLICY   One of: always, missing, never. Default: always.
+  --no-cache              Rebuild without Docker layer cache.
+  -h, --help              Show this help text.
+
+Environment:
+  PGSTAC_VERSION          Default version if no positional version is provided.
+  PGSTAC_BUILD_POLICY     Default build policy.
+EOF
+}
+
+BUILD_POLICY="${PGSTAC_BUILD_POLICY:-always}"
+POSITIONAL=()
+
+while [[ $# -gt 0 ]]; do
+	case "$1" in
+		--build-policy)
+			BUILD_POLICY="$2"
+			shift 2
+			;;
+		--no-cache)
+			NO_CACHE="--no-cache"
+			shift
+			;;
+		-h|--help)
+			usage
+			exit 0
+			;;
+		*)
+			POSITIONAL+=("$1")
+			shift
+			;;
+	esac
+done
+
+if [[ ${#POSITIONAL[@]} -eq 0 && -n "${PGSTAC_VERSION:-}" ]]; then
+	POSITIONAL=("$PGSTAC_VERSION")
+fi
+
+RUN_ARGS=(--build-policy "$BUILD_POLICY")
+[[ -n "$NO_CACHE" ]] && RUN_ARGS+=("$NO_CACHE")
+RUN_ARGS+=(--cpfiles stageversion)
+RUN_ARGS+=("${POSITIONAL[@]}")
+
+$SCRIPT_DIR/runinpypgstac "${RUN_ARGS[@]}"
diff --git a/scripts/test b/scripts/test
index 2104d0bc..2ddcef0a 100755
--- a/scripts/test
+++ b/scripts/test
@@ -1,3 +1,109 @@
 #!/bin/bash
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-$SCRIPT_DIR/runinpypgstac --build test "$@"
+
+function usage() {
+	cat <<EOF
+Usage: $(basename "$0") [options] [test suite flags]
+
+Host wrapper for the in-container PgSTAC test runner.
+
+Options:
+  --fast                  Run formatting plus non-migration test suites.
+  --watch                 Re-run tests when files change.
+  --build-policy POLICY   One of: always, missing, never.
+  --no-strict             Allow stale-image shortcuts and watch fallback.
+  -h, --help              Show this help text.
+
+Examples:
+  $(basename "$0")
+  $(basename "$0") --fast
+  $(basename "$0") --pypgstac --build-policy always
+EOF
+}
+
+FAST="${PGSTAC_FAST:-0}"
+WATCH="${PGSTAC_WATCH:-0}"
+STRICT="${PGSTAC_STRICT:-1}"
+BUILD_POLICY="${PGSTAC_BUILD_POLICY:-always}"
+POSITIONAL=()
+
+while [[ $# -gt 0 ]]; do
+	case "$1" in
+		--fast)
+			FAST=1
+			shift
+			;;
+		--watch)
+			WATCH=1
+			shift
+			;;
+		--build-policy)
+			BUILD_POLICY="$2"
+			shift 2
+			;;
+		--no-strict)
+			STRICT=0
+			shift
+			;;
+		-h|--help)
+			usage
+			exit 0
+			;;
+		*)
+			POSITIONAL+=("$1")
+			shift
+			;;
+	esac
+done
+
+if [[ ${#POSITIONAL[@]} -eq 0 && $FAST -eq 1 ]]; then
+	POSITIONAL=(--formatting --nomigrations)
+fi
+
+function has_rebuild_sensitive_changes() {
+	local changed
+
+	changed=$(git -C "$SCRIPT_DIR/.." status --short -- scripts docker src 2>/dev/null || true)
+	[[ -n "$changed" ]]
+}
+
+if [[ "$BUILD_POLICY" != "always" && $STRICT -eq 1 ]]; then
+	if [[ $WATCH -eq 1 ]]; then
+		echo "Watch mode requires --build-policy always unless --no-strict is set." >&2
+		exit 1
+	fi
+
+	if has_rebuild_sensitive_changes; then
+		echo "Refusing to run tests with build-policy '$BUILD_POLICY' while scripts/docker/src changes are present." >&2
+		echo "Use --build-policy always or --no-strict if you intentionally want to reuse an existing image." >&2
+		exit 1
+	fi
+fi
+
+RUN_ARGS=(--build-policy "$BUILD_POLICY" test)
+RUN_ARGS+=("${POSITIONAL[@]}")
+
+function run_once() {
+	"$SCRIPT_DIR/runinpypgstac" "${RUN_ARGS[@]}"
+}
+
+if [[ $WATCH -eq 1 ]]; then
+	if ! command -v inotifywait >/dev/null 2>&1; then
+		if [[ $STRICT -eq 1 ]]; then
+			echo "Watch mode requires inotifywait (from inotify-tools)." >&2
+			exit 1
+		fi
+
+		echo "Watch mode requested but inotifywait is unavailable; running tests once because --no-strict was set." >&2
+		run_once
+		exit $?
+	fi
+
+	while true; do
+		run_once || true
+		echo "Waiting for file changes..."
+		inotifywait -qq -r -e close_write,create,delete,move "$SCRIPT_DIR/.."/scripts "$SCRIPT_DIR/.."/docker "$SCRIPT_DIR/.."/src "$SCRIPT_DIR/.."/.github "$SCRIPT_DIR/.."/CONTRIBUTING.md "$SCRIPT_DIR/.."/CLAUDE.md
+	done
+fi
+
+run_once
diff --git a/scripts/update b/scripts/update
index c4d8f89b..07860299 100755
--- a/scripts/update
+++ b/scripts/update
@@ -1,6 +1,7 @@
 #!/bin/bash
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 cd $SCRIPT_DIR/..
+source "$SCRIPT_DIR/pgstacenv"
 set -e
 
 if [[ "${CI}" ]]; then
@@ -20,14 +21,15 @@ Builds the docker containers for this project.
 NO_CACHE="";
 while [[ "$#" > 0 ]]; do case $1 in
     --no-cache) NO_CACHE="--no-cache"; shift;;
-    --help) usage; exit 0; shift;;
-  *) usage "Unknown parameter passed: $1"; shift; shift;;
+        -h|--help) usage; exit 0;;
+    *) echo "Unknown parameter passed: $1" >&2; usage; exit 1;;
 esac; done
 
 if [ "${BASH_SOURCE[0]}" = "${0}" ]; then
 
     echo "==Building images..."
 
+    ensure_env_file
     docker compose build ${NO_CACHE}
 
 fi
diff --git a/src/pgstac/migrations/pgstac.0.9.11-unreleased.sql b/src/pgstac/migrations/pgstac.0.9.11-unreleased.sql
new file mode 100644
index 00000000..cddaf7eb
--- /dev/null
+++ b/src/pgstac/migrations/pgstac.0.9.11-unreleased.sql
@@ -0,0 +1,324 @@
+SET client_min_messages TO WARNING;
+SET SEARCH_PATH to pgstac, public;
+RESET ROLE;
+DO $$
+DECLARE
+BEGIN
+  IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname='postgis') THEN
+    CREATE EXTENSION IF NOT EXISTS postgis;
+  END IF;
+  IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname='btree_gist') THEN
+    CREATE EXTENSION IF NOT EXISTS btree_gist;
+  END IF;
+  IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname='unaccent') THEN
+    CREATE EXTENSION IF NOT EXISTS unaccent;
+  END IF;
+END;
+$$ LANGUAGE PLPGSQL;
+
+DO $$
+  BEGIN
+    CREATE ROLE pgstac_admin;
+  EXCEPTION WHEN duplicate_object THEN
+    RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
+  END
+$$;
+
+DO $$
+  BEGIN
+    CREATE ROLE pgstac_read;
+  EXCEPTION WHEN duplicate_object THEN
+    RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
+  END
+$$;
+
+DO $$
+  BEGIN
+    CREATE ROLE pgstac_ingest;
+  EXCEPTION WHEN duplicate_object THEN
+    RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
+  END
+$$;
+
+
+GRANT pgstac_admin TO current_user;
+
+-- Function to make sure pgstac_admin is the owner of items
+CREATE OR REPLACE FUNCTION pgstac_admin_owns() RETURNS VOID AS $$
+DECLARE
+  f RECORD;
+BEGIN
+  FOR f IN (
+    SELECT
+      concat(
+        oid::regproc::text,
+        '(',
+        coalesce(pg_get_function_identity_arguments(oid),''),
+        ')'
+      ) AS name,
+      CASE prokind WHEN 'f' THEN 'FUNCTION' WHEN 'p' THEN 'PROCEDURE' WHEN 'a' THEN 'AGGREGATE' END as typ
+    FROM pg_proc
+    WHERE
+      pronamespace=to_regnamespace('pgstac')
+      AND proowner != to_regrole('pgstac_admin')
+      AND proname NOT LIKE 'pg_stat%'
+  )
+  LOOP
+    BEGIN
+      EXECUTE format('ALTER %s %s OWNER TO pgstac_admin;', f.typ, f.name);
+    EXCEPTION WHEN others THEN
+      RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
+    END;
+  END LOOP;
+  FOR f IN (
+    SELECT
+      oid::regclass::text as name,
+      CASE relkind
+        WHEN 'i' THEN 'INDEX'
+        WHEN 'I' THEN 'INDEX'
+        WHEN 'p' THEN 'TABLE'
+        WHEN 'r' THEN 'TABLE'
+        WHEN 'v' THEN 'VIEW'
+        WHEN 'S' THEN 'SEQUENCE'
+        ELSE NULL
+      END as typ
+    FROM pg_class
+    WHERE relnamespace=to_regnamespace('pgstac') and relowner != to_regrole('pgstac_admin') AND relkind IN ('r','p','v','S') AND relname NOT LIKE 'pg_stat'
+  )
+  LOOP
+    BEGIN
+      EXECUTE format('ALTER %s %s OWNER TO pgstac_admin;', f.typ, f.name);
+    EXCEPTION WHEN others THEN
+      RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
+    END;
+  END LOOP;
+  RETURN;
+END;
+$$ LANGUAGE PLPGSQL;
+SELECT pgstac_admin_owns();
+
+CREATE SCHEMA IF NOT EXISTS pgstac AUTHORIZATION pgstac_admin;
+
+GRANT ALL ON ALL FUNCTIONS IN SCHEMA pgstac to pgstac_admin;
+GRANT ALL ON ALL TABLES IN SCHEMA pgstac to pgstac_admin;
+GRANT ALL ON ALL SEQUENCES IN SCHEMA pgstac to pgstac_admin;
+
+ALTER ROLE pgstac_admin SET SEARCH_PATH TO pgstac, public;
+ALTER ROLE pgstac_read SET SEARCH_PATH TO pgstac, public;
+ALTER ROLE pgstac_ingest SET SEARCH_PATH TO pgstac, public;
+
+GRANT USAGE ON SCHEMA pgstac to pgstac_read;
+ALTER DEFAULT PRIVILEGES IN SCHEMA pgstac GRANT SELECT ON TABLES TO pgstac_read;
+ALTER DEFAULT PRIVILEGES IN SCHEMA pgstac GRANT USAGE ON TYPES TO pgstac_read;
+ALTER DEFAULT PRIVILEGES IN SCHEMA pgstac GRANT ALL ON SEQUENCES TO pgstac_read;
+
+GRANT pgstac_read TO pgstac_ingest;
+GRANT ALL ON SCHEMA pgstac TO pgstac_ingest;
+ALTER DEFAULT PRIVILEGES IN SCHEMA pgstac GRANT ALL ON TABLES TO pgstac_ingest;
+ALTER DEFAULT PRIVILEGES IN SCHEMA pgstac GRANT ALL ON FUNCTIONS TO pgstac_ingest;
+
+SET ROLE pgstac_admin;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_admin IN SCHEMA pgstac GRANT SELECT ON TABLES TO pgstac_read;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_admin IN SCHEMA pgstac GRANT USAGE ON TYPES TO pgstac_read;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_admin IN SCHEMA pgstac GRANT ALL ON SEQUENCES TO pgstac_read;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_admin IN SCHEMA pgstac GRANT ALL ON TABLES TO pgstac_ingest;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_admin IN SCHEMA pgstac GRANT ALL ON FUNCTIONS TO pgstac_ingest;
+RESET ROLE;
+
+SET ROLE pgstac_ingest;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_ingest IN SCHEMA pgstac GRANT SELECT ON TABLES TO pgstac_read;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_ingest IN SCHEMA pgstac GRANT USAGE ON TYPES TO pgstac_read;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_ingest IN SCHEMA pgstac GRANT ALL ON SEQUENCES TO pgstac_read;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_ingest IN SCHEMA pgstac GRANT ALL ON TABLES TO pgstac_ingest;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_ingest IN SCHEMA pgstac GRANT ALL ON FUNCTIONS TO pgstac_ingest;
+RESET ROLE;
+
+SET SEARCH_PATH TO pgstac, public;
+SET ROLE pgstac_admin;
+
+DO $$
+  BEGIN
+    DROP FUNCTION IF EXISTS analyze_items;
+  EXCEPTION WHEN others THEN
+    RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
+  END
+$$;
+DO $$
+  BEGIN
+    DROP FUNCTION IF EXISTS validate_constraints;
+  EXCEPTION WHEN others THEN
+    RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
+  END
+$$;
+
+-- Install these idempotently as migrations do not put them before trying to modify the collections table
+
+
+CREATE OR REPLACE FUNCTION collection_geom(content jsonb)
+RETURNS geometry AS $$
+    WITH box AS (SELECT content->'extent'->'spatial'->'bbox'->0 as box)
+    SELECT
+        st_makeenvelope(
+            (box->>0)::float,
+            (box->>1)::float,
+            (box->>2)::float,
+            (box->>3)::float,
+            4326
+        )
+    FROM box;
+$$ LANGUAGE SQL IMMUTABLE STRICT;
+
+CREATE OR REPLACE FUNCTION collection_datetime(content jsonb)
+RETURNS timestamptz AS $$
+    SELECT
+        CASE
+            WHEN
+                (content->'extent'->'temporal'->'interval'->0->>0) IS NULL
+            THEN '-infinity'::timestamptz
+            ELSE
+                (content->'extent'->'temporal'->'interval'->0->>0)::timestamptz
+        END
+    ;
+$$ LANGUAGE SQL IMMUTABLE STRICT;
+
+CREATE OR REPLACE FUNCTION collection_enddatetime(content jsonb)
+RETURNS timestamptz AS $$
+    SELECT
+        CASE
+            WHEN
+                (content->'extent'->'temporal'->'interval'->0->>1) IS NULL
+            THEN 'infinity'::timestamptz
+            ELSE
+                (content->'extent'->'temporal'->'interval'->0->>1)::timestamptz
+        END
+    ;
+$$ LANGUAGE SQL IMMUTABLE STRICT;
+-- BEGIN migra calculated SQL
+-- END migra calculated SQL
+DO $$
+  BEGIN
+    INSERT INTO queryables (name, definition, property_wrapper, property_index_type) VALUES
+    ('id', '{"title": "Item ID","description": "Item identifier","$ref": "https://schemas.stacspec.org/v1.0.0/item-spec/json-schema/item.json#/definitions/core/allOf/2/properties/id"}', null, null);
+  EXCEPTION WHEN unique_violation THEN
+    RAISE NOTICE '%', SQLERRM USING ERRCODE = SQLSTATE;
+  END
+$$;
+
+DO $$
+  BEGIN
+    INSERT INTO queryables (name, definition, property_wrapper, property_index_type) VALUES
+    ('geometry', '{"title": "Item Geometry","description": "Item Geometry","$ref": "https://geojson.org/schema/Feature.json"}', null, null);
+  EXCEPTION WHEN unique_violation THEN
+    RAISE NOTICE '%', SQLERRM USING ERRCODE = SQLSTATE;
+  END
+$$;
+
+DO $$
+  BEGIN
+    INSERT INTO queryables (name, definition, property_wrapper, property_index_type) VALUES
+    ('datetime','{"description": "Datetime","type": "string","title": "Acquired","format": "date-time","pattern": "(\\+00:00|Z)$"}', null, null);
+  EXCEPTION WHEN unique_violation THEN
+    RAISE NOTICE '%', SQLERRM USING ERRCODE = SQLSTATE;
+  END
+$$;
+
+DELETE FROM queryables a USING queryables b
+  WHERE a.name = b.name AND a.collection_ids IS NOT DISTINCT FROM b.collection_ids AND a.id > b.id;
+
+
+INSERT INTO pgstac_settings (name, value) VALUES
+  ('context', 'off'),
+  ('context_estimated_count', '100000'),
+  ('context_estimated_cost', '100000'),
+  ('context_stats_ttl', '1 day'),
+  ('default_filter_lang', 'cql2-json'),
+  ('additional_properties', 'true'),
+  ('use_queue', 'false'),
+  ('queue_timeout', '10 minutes'),
+  ('update_collection_extent', 'false'),
+  ('format_cache', 'false'),
+  ('readonly', 'false')
+ON CONFLICT DO NOTHING
+;
+
+
+INSERT INTO cql2_ops (op, template, types) VALUES
+    ('eq', '%s = %s', NULL),
+    ('neq', '%s != %s', NULL),
+    ('ne', '%s != %s', NULL),
+    ('!=', '%s != %s', NULL),
+    ('<>', '%s != %s', NULL),
+    ('lt', '%s < %s', NULL),
+    ('lte', '%s <= %s', NULL),
+    ('gt', '%s > %s', NULL),
+    ('gte', '%s >= %s', NULL),
+    ('le', '%s <= %s', NULL),
+    ('ge', '%s >= %s', NULL),
+    ('=', '%s = %s', NULL),
+    ('<', '%s < %s', NULL),
+    ('<=', '%s <= %s', NULL),
+    ('>', '%s > %s', NULL),
+    ('>=', '%s >= %s', NULL),
+    ('like', '%s LIKE %s', NULL),
+    ('ilike', '%s ILIKE %s', NULL),
+    ('+', '%s + %s', NULL),
+    ('-', '%s - %s', NULL),
+    ('*', '%s * %s', NULL),
+    ('/', '%s / %s', NULL),
+    ('not', 'NOT (%s)', NULL),
+    ('between', '%s BETWEEN %s AND %s', NULL),
+    ('isnull', '%s IS NULL', NULL),
+    ('upper', 'upper(%s)', NULL),
+    ('lower', 'lower(%s)', NULL),
+    ('casei', 'upper(%s)', NULL),
+    ('accenti', 'unaccent(%s)', NULL)
+ON CONFLICT (op) DO UPDATE
+    SET
+        template = EXCLUDED.template
+;
+
+
+ALTER FUNCTION to_text COST 5000;
+ALTER FUNCTION to_float COST 5000;
+ALTER FUNCTION to_int COST 5000;
+ALTER FUNCTION to_tstz COST 5000;
+ALTER FUNCTION to_text_array COST 5000;
+
+ALTER FUNCTION update_partition_stats SECURITY DEFINER;
+ALTER FUNCTION partition_after_triggerfunc SECURITY DEFINER;
+ALTER FUNCTION drop_table_constraints SECURITY DEFINER;
+ALTER FUNCTION create_table_constraints SECURITY DEFINER;
+ALTER FUNCTION check_partition SECURITY DEFINER;
+ALTER FUNCTION repartition SECURITY DEFINER;
+ALTER FUNCTION where_stats SECURITY DEFINER;
+ALTER FUNCTION search_query SECURITY DEFINER;
+ALTER FUNCTION format_item SECURITY DEFINER;
+ALTER FUNCTION maintain_index SECURITY DEFINER;
+
+GRANT USAGE ON SCHEMA pgstac to pgstac_read;
+GRANT ALL ON SCHEMA pgstac to pgstac_ingest;
+GRANT ALL ON SCHEMA pgstac to pgstac_admin;
+
+-- pgstac_read role limited to using function apis
+GRANT EXECUTE ON FUNCTION search TO pgstac_read;
+GRANT EXECUTE ON FUNCTION search_query TO pgstac_read;
+GRANT EXECUTE ON FUNCTION item_by_id TO pgstac_read;
+GRANT EXECUTE ON FUNCTION get_item TO pgstac_read;
+GRANT SELECT ON ALL TABLES IN SCHEMA pgstac TO pgstac_read;
+
+
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA pgstac to pgstac_ingest;
+GRANT ALL ON ALL TABLES IN SCHEMA pgstac to pgstac_ingest;
+GRANT USAGE ON ALL SEQUENCES IN SCHEMA pgstac to pgstac_ingest;
+
+REVOKE ALL PRIVILEGES ON PROCEDURE run_queued_queries FROM public;
+GRANT ALL ON PROCEDURE run_queued_queries TO pgstac_admin;
+
+REVOKE ALL PRIVILEGES ON FUNCTION run_queued_queries_intransaction FROM public;
+GRANT ALL ON FUNCTION run_queued_queries_intransaction TO pgstac_admin;
+
+RESET ROLE;
+
+SET ROLE pgstac_ingest;
+SELECT update_partition_stats_q(partition) FROM partitions_view;
+SELECT set_version('unreleased');
diff --git a/src/pgstac/migrations/pgstac.unreleased.sql b/src/pgstac/migrations/pgstac.unreleased.sql
new file mode 100644
index 00000000..4c836762
--- /dev/null
+++ b/src/pgstac/migrations/pgstac.unreleased.sql
@@ -0,0 +1,4659 @@
+RESET ROLE;
+DO $$
+DECLARE
+BEGIN
+  IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname='postgis') THEN
+    CREATE EXTENSION IF NOT EXISTS postgis;
+  END IF;
+  IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname='btree_gist') THEN
+    CREATE EXTENSION IF NOT EXISTS btree_gist;
+  END IF;
+  IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname='unaccent') THEN
+    CREATE EXTENSION IF NOT EXISTS unaccent;
+  END IF;
+END;
+$$ LANGUAGE PLPGSQL;
+
+DO $$
+  BEGIN
+    CREATE ROLE pgstac_admin;
+  EXCEPTION WHEN duplicate_object THEN
+    RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
+  END
+$$;
+
+DO $$
+  BEGIN
+    CREATE ROLE pgstac_read;
+  EXCEPTION WHEN duplicate_object THEN
+    RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
+  END
+$$;
+
+DO $$
+  BEGIN
+    CREATE ROLE pgstac_ingest;
+  EXCEPTION WHEN duplicate_object THEN
+    RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
+  END
+$$;
+
+
+GRANT pgstac_admin TO current_user;
+
+-- Function to make sure pgstac_admin is the owner of items
+CREATE OR REPLACE FUNCTION pgstac_admin_owns() RETURNS VOID AS $$
+DECLARE
+  f RECORD;
+BEGIN
+  FOR f IN (
+    SELECT
+      concat(
+        oid::regproc::text,
+        '(',
+        coalesce(pg_get_function_identity_arguments(oid),''),
+        ')'
+      ) AS name,
+      CASE prokind WHEN 'f' THEN 'FUNCTION' WHEN 'p' THEN 'PROCEDURE' WHEN 'a' THEN 'AGGREGATE' END as typ
+    FROM pg_proc
+    WHERE
+      pronamespace=to_regnamespace('pgstac')
+      AND proowner != to_regrole('pgstac_admin')
+      AND proname NOT LIKE 'pg_stat%'
+  )
+  LOOP
+    BEGIN
+      EXECUTE format('ALTER %s %s OWNER TO pgstac_admin;', f.typ, f.name);
+    EXCEPTION WHEN others THEN
+      RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
+    END;
+  END LOOP;
+  FOR f IN (
+    SELECT
+      oid::regclass::text as name,
+      CASE relkind
+        WHEN 'i' THEN 'INDEX'
+        WHEN 'I' THEN 'INDEX'
+        WHEN 'p' THEN 'TABLE'
+        WHEN 'r' THEN 'TABLE'
+        WHEN 'v' THEN 'VIEW'
+        WHEN 'S' THEN 'SEQUENCE'
+        ELSE NULL
+      END as typ
+    FROM pg_class
+    WHERE relnamespace=to_regnamespace('pgstac') and relowner != to_regrole('pgstac_admin') AND relkind IN ('r','p','v','S') AND relname NOT LIKE 'pg_stat'
+  )
+  LOOP
+    BEGIN
+      EXECUTE format('ALTER %s %s OWNER TO pgstac_admin;', f.typ, f.name);
+    EXCEPTION WHEN others THEN
+      RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
+    END;
+  END LOOP;
+  RETURN;
+END;
+$$ LANGUAGE PLPGSQL;
+SELECT pgstac_admin_owns();
+
+CREATE SCHEMA IF NOT EXISTS pgstac AUTHORIZATION pgstac_admin;
+
+GRANT ALL ON ALL FUNCTIONS IN SCHEMA pgstac to pgstac_admin;
+GRANT ALL ON ALL TABLES IN SCHEMA pgstac to pgstac_admin;
+GRANT ALL ON ALL SEQUENCES IN SCHEMA pgstac to pgstac_admin;
+
+ALTER ROLE pgstac_admin SET SEARCH_PATH TO pgstac, public;
+ALTER ROLE pgstac_read SET SEARCH_PATH TO pgstac, public;
+ALTER ROLE pgstac_ingest SET SEARCH_PATH TO pgstac, public;
+
+GRANT USAGE ON SCHEMA pgstac to pgstac_read;
+ALTER DEFAULT PRIVILEGES IN SCHEMA pgstac GRANT SELECT ON TABLES TO pgstac_read;
+ALTER DEFAULT PRIVILEGES IN SCHEMA pgstac GRANT USAGE ON TYPES TO pgstac_read;
+ALTER DEFAULT PRIVILEGES IN SCHEMA pgstac GRANT ALL ON SEQUENCES TO pgstac_read;
+
+GRANT pgstac_read TO pgstac_ingest;
+GRANT ALL ON SCHEMA pgstac TO pgstac_ingest;
+ALTER DEFAULT PRIVILEGES IN SCHEMA pgstac GRANT ALL ON TABLES TO pgstac_ingest;
+ALTER DEFAULT PRIVILEGES IN SCHEMA pgstac GRANT ALL ON FUNCTIONS TO pgstac_ingest;
+
+SET ROLE pgstac_admin;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_admin IN SCHEMA pgstac GRANT SELECT ON TABLES TO pgstac_read;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_admin IN SCHEMA pgstac GRANT USAGE ON TYPES TO pgstac_read;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_admin IN SCHEMA pgstac GRANT ALL ON SEQUENCES TO pgstac_read;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_admin IN SCHEMA pgstac GRANT ALL ON TABLES TO pgstac_ingest;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_admin IN SCHEMA pgstac GRANT ALL ON FUNCTIONS TO pgstac_ingest;
+RESET ROLE;
+
+SET ROLE pgstac_ingest;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_ingest IN SCHEMA pgstac GRANT SELECT ON TABLES TO pgstac_read;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_ingest IN SCHEMA pgstac GRANT USAGE ON TYPES TO pgstac_read;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_ingest IN SCHEMA pgstac GRANT ALL ON SEQUENCES TO pgstac_read;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_ingest IN SCHEMA pgstac GRANT ALL ON TABLES TO pgstac_ingest;
+ALTER DEFAULT PRIVILEGES FOR ROLE pgstac_ingest IN SCHEMA pgstac GRANT ALL ON FUNCTIONS TO pgstac_ingest;
+RESET ROLE;
+
+SET SEARCH_PATH TO pgstac, public;
+SET ROLE pgstac_admin;
+
+DO $$
+  BEGIN
+    DROP FUNCTION IF EXISTS analyze_items;
+  EXCEPTION WHEN others THEN
+    RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
+  END
+$$;
+DO $$
+  BEGIN
+    DROP FUNCTION IF EXISTS validate_constraints;
+  EXCEPTION WHEN others THEN
+    RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
+  END
+$$;
+
+-- Install these idempotently as migrations do not put them before trying to modify the collections table
+
+
+CREATE OR REPLACE FUNCTION collection_geom(content jsonb)
+RETURNS geometry AS $$
+    WITH box AS (SELECT content->'extent'->'spatial'->'bbox'->0 as box)
+    SELECT
+        st_makeenvelope(
+            (box->>0)::float,
+            (box->>1)::float,
+            (box->>2)::float,
+            (box->>3)::float,
+            4326
+        )
+    FROM box;
+$$ LANGUAGE SQL IMMUTABLE STRICT;
+
+CREATE OR REPLACE FUNCTION collection_datetime(content jsonb)
+RETURNS timestamptz AS $$
+    SELECT
+        CASE
+            WHEN
+                (content->'extent'->'temporal'->'interval'->0->>0) IS NULL
+            THEN '-infinity'::timestamptz
+            ELSE
+                (content->'extent'->'temporal'->'interval'->0->>0)::timestamptz
+        END
+    ;
+$$ LANGUAGE SQL IMMUTABLE STRICT;
+
+CREATE OR REPLACE FUNCTION collection_enddatetime(content jsonb)
+RETURNS timestamptz AS $$
+    SELECT
+        CASE
+            WHEN
+                (content->'extent'->'temporal'->'interval'->0->>1) IS NULL
+            THEN 'infinity'::timestamptz
+            ELSE
+                (content->'extent'->'temporal'->'interval'->0->>1)::timestamptz
+        END
+    ;
+$$ LANGUAGE SQL IMMUTABLE STRICT;
+
+CREATE TABLE IF NOT EXISTS migrations (
+  version text PRIMARY KEY,
+  datetime timestamptz DEFAULT clock_timestamp() NOT NULL
+);
+
+CREATE OR REPLACE FUNCTION get_version() RETURNS text AS $$
+  SELECT version FROM pgstac.migrations ORDER BY datetime DESC, version DESC LIMIT 1;
+$$ LANGUAGE SQL;
+
+CREATE OR REPLACE FUNCTION set_version(text) RETURNS text AS $$
+  INSERT INTO pgstac.migrations (version) VALUES ($1)
+  ON CONFLICT DO NOTHING
+  RETURNING version;
+$$ LANGUAGE SQL;
+
+
+CREATE TABLE IF NOT EXISTS pgstac_settings (
+  name text PRIMARY KEY,
+  value text NOT NULL
+);
+
+CREATE OR REPLACE FUNCTION table_empty(text) RETURNS boolean AS $$
+DECLARE
+    retval boolean;
+BEGIN
+    EXECUTE format($q$
+        SELECT NOT EXISTS (SELECT 1 FROM %I LIMIT 1)
+        $q$,
+        $1
+    ) INTO retval;
+    RETURN retval;
+END;
+$$ LANGUAGE PLPGSQL;
+
+
+CREATE OR REPLACE FUNCTION get_setting(IN _setting text, IN conf jsonb DEFAULT NULL) RETURNS text AS $$
+SELECT COALESCE(
+  nullif(conf->>_setting, ''),
+  nullif(current_setting(concat('pgstac.',_setting), TRUE),''),
+  nullif((SELECT value FROM pgstac.pgstac_settings WHERE name=_setting),'')
+);
+$$ LANGUAGE SQL;
+
+CREATE OR REPLACE FUNCTION get_setting_bool(IN _setting text, IN conf jsonb DEFAULT NULL) RETURNS boolean AS $$
+SELECT COALESCE(
+  nullif(conf->>_setting, ''),
+  nullif(current_setting(concat('pgstac.',_setting), TRUE),''),
+  nullif((SELECT value FROM pgstac.pgstac_settings WHERE name=_setting),''),
+  'FALSE'
+)::boolean;
+$$ LANGUAGE SQL;
+
+CREATE OR REPLACE FUNCTION base_url(conf jsonb DEFAULT NULL) RETURNS text AS $$
+  SELECT COALESCE(pgstac.get_setting('base_url', conf), '.');
+$$ LANGUAGE SQL;
+
+CREATE OR REPLACE FUNCTION additional_properties() RETURNS boolean AS $$
+    SELECT pgstac.get_setting_bool('additional_properties');
+$$ LANGUAGE SQL;
+
+CREATE OR REPLACE FUNCTION readonly(conf jsonb DEFAULT NULL) RETURNS boolean AS $$
+    SELECT pgstac.get_setting_bool('readonly', conf);
+$$ LANGUAGE SQL;
+
+CREATE OR REPLACE FUNCTION context(conf jsonb DEFAULT NULL) RETURNS text AS $$
+  SELECT pgstac.get_setting('context', conf);
+$$ LANGUAGE SQL;
+
+CREATE OR REPLACE FUNCTION context_estimated_count(conf jsonb DEFAULT NULL) RETURNS int AS $$
+  SELECT pgstac.get_setting('context_estimated_count', conf)::int;
+$$ LANGUAGE SQL;
+
+DROP FUNCTION IF EXISTS context_estimated_cost();
+CREATE OR REPLACE FUNCTION context_estimated_cost(conf jsonb DEFAULT NULL) RETURNS float AS $$
+  SELECT pgstac.get_setting('context_estimated_cost', conf)::float;
+$$ LANGUAGE SQL;
+
+DROP FUNCTION IF EXISTS context_stats_ttl();
+CREATE OR REPLACE FUNCTION context_stats_ttl(conf jsonb DEFAULT NULL) RETURNS interval AS $$
+  SELECT pgstac.get_setting('context_stats_ttl', conf)::interval;
+$$ LANGUAGE SQL;
+
+CREATE OR REPLACE FUNCTION t2s(text) RETURNS text AS $$
+    SELECT extract(epoch FROM $1::interval)::text || ' s';
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT;
+
+CREATE OR REPLACE FUNCTION age_ms(a timestamptz, b timestamptz DEFAULT clock_timestamp()) RETURNS float AS $$
+    SELECT abs(extract(epoch from age(a,b)) * 1000);
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+
+CREATE OR REPLACE FUNCTION queue_timeout() RETURNS interval AS $$
+    SELECT t2s(coalesce(
+            get_setting('queue_timeout'),
+            '1h'
+        ))::interval;
+$$ LANGUAGE SQL;
+
+CREATE OR REPLACE FUNCTION notice(VARIADIC text[]) RETURNS boolean AS $$
+DECLARE
+debug boolean := current_setting('pgstac.debug', true);
+BEGIN
+    IF debug THEN
+        RAISE NOTICE 'NOTICE FROM FUNC: %  >>>>> %', concat_ws(' | ', $1), clock_timestamp();
+        RETURN TRUE;
+    END IF;
+    RETURN FALSE;
+END;
+$$ LANGUAGE PLPGSQL;
+
+CREATE OR REPLACE FUNCTION empty_arr(ANYARRAY) RETURNS BOOLEAN AS $$
+SELECT CASE
+  WHEN $1 IS NULL THEN TRUE
+  WHEN cardinality($1)<1 THEN TRUE
+ELSE FALSE
+END;
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION array_intersection(_a ANYARRAY, _b ANYARRAY) RETURNS ANYARRAY AS $$
+  SELECT ARRAY ( SELECT unnest(_a) INTERSECT SELECT UNNEST(_b) );
+$$ LANGUAGE SQL IMMUTABLE;
+
+
+CREATE OR REPLACE FUNCTION array_map_ident(_a text[])
+  RETURNS text[] AS $$
+  SELECT array_agg(quote_ident(v)) FROM unnest(_a) v;
+$$ LANGUAGE sql IMMUTABLE PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION array_map_literal(_a text[])
+  RETURNS text[] AS $$
+  SELECT array_agg(quote_literal(v)) FROM unnest(_a) v;
+$$ LANGUAGE sql IMMUTABLE PARALLEL SAFE;
+
+
+CREATE OR REPLACE FUNCTION array_reverse(anyarray) RETURNS anyarray AS $$
+SELECT ARRAY(
+    SELECT $1[i]
+    FROM generate_subscripts($1,1) AS s(i)
+    ORDER BY i DESC
+);
+$$ LANGUAGE SQL STRICT IMMUTABLE;
+
+DROP TABLE IF EXISTS query_queue;
+CREATE TABLE query_queue (
+    query text PRIMARY KEY,
+    added timestamptz DEFAULT now()
+);
+
+DROP TABLE IF EXISTS query_queue_history;
+CREATE TABLE query_queue_history(
+    query text,
+    added timestamptz NOT NULL,
+    finished timestamptz NOT NULL DEFAULT now(),
+    error text
+);
+
+CREATE OR REPLACE PROCEDURE run_queued_queries() AS $$
+DECLARE
+    qitem query_queue%ROWTYPE;
+    timeout_ts timestamptz;
+    error text;
+    cnt int := 0;
+BEGIN
+    timeout_ts := statement_timestamp() + queue_timeout();
+    WHILE clock_timestamp() < timeout_ts LOOP
+        DELETE FROM query_queue WHERE query = (SELECT query FROM query_queue ORDER BY added DESC LIMIT 1 FOR UPDATE SKIP LOCKED) RETURNING * INTO qitem;
+        IF NOT FOUND THEN
+            EXIT;
+        END IF;
+        cnt := cnt + 1;
+        BEGIN
+            RAISE NOTICE 'RUNNING QUERY: %', qitem.query;
+            EXECUTE qitem.query;
+            EXCEPTION WHEN others THEN
+                error := format('%s | %s', SQLERRM, SQLSTATE);
+        END;
+        INSERT INTO query_queue_history (query, added, finished, error)
+            VALUES (qitem.query, qitem.added, clock_timestamp(), error);
+        COMMIT;
+    END LOOP;
+END;
+$$ LANGUAGE PLPGSQL;
+
+CREATE OR REPLACE FUNCTION run_queued_queries_intransaction() RETURNS int AS $$
+DECLARE
+    qitem query_queue%ROWTYPE;
+    timeout_ts timestamptz;
+    error text;
+    cnt int := 0;
+BEGIN
+    timeout_ts := statement_timestamp() + queue_timeout();
+    WHILE clock_timestamp() < timeout_ts LOOP
+        DELETE FROM query_queue WHERE query = (SELECT query FROM query_queue ORDER BY added DESC LIMIT 1 FOR UPDATE SKIP LOCKED) RETURNING * INTO qitem;
+        IF NOT FOUND THEN
+            RETURN cnt;
+        END IF;
+        cnt := cnt + 1;
+        BEGIN
+            qitem.query := regexp_replace(qitem.query, 'CONCURRENTLY', '');
+            RAISE NOTICE 'RUNNING QUERY: %', qitem.query;
+
+            EXECUTE qitem.query;
+            EXCEPTION WHEN others THEN
+                error := format('%s | %s', SQLERRM, SQLSTATE);
+                RAISE WARNING '%', error;
+        END;
+        INSERT INTO query_queue_history (query, added, finished, error)
+            VALUES (qitem.query, qitem.added, clock_timestamp(), error);
+    END LOOP;
+    RETURN cnt;
+END;
+$$ LANGUAGE PLPGSQL;
+
+
+CREATE OR REPLACE FUNCTION run_or_queue(query text) RETURNS VOID AS $$
+DECLARE
+    use_queue text := COALESCE(get_setting('use_queue'), 'FALSE')::boolean;
+BEGIN
+    IF get_setting_bool('debug') THEN
+        RAISE NOTICE '%', query;
+    END IF;
+    IF use_queue THEN
+        INSERT INTO query_queue (query) VALUES (query) ON CONFLICT DO NOTHING;
+    ELSE
+        EXECUTE query;
+    END IF;
+    RETURN;
+END;
+$$ LANGUAGE PLPGSQL;
+
+
+
+DROP FUNCTION IF EXISTS check_pgstac_settings;
+CREATE OR REPLACE FUNCTION check_pgstac_settings(_sysmem text DEFAULT NULL) RETURNS VOID AS $$
+DECLARE
+    settingval text;
+    sysmem bigint := pg_size_bytes(_sysmem);
+    effective_cache_size bigint := pg_size_bytes(current_setting('effective_cache_size', TRUE));
+    shared_buffers bigint := pg_size_bytes(current_setting('shared_buffers', TRUE));
+    work_mem bigint := pg_size_bytes(current_setting('work_mem', TRUE));
+    max_connections int := current_setting('max_connections', TRUE);
+    maintenance_work_mem bigint := pg_size_bytes(current_setting('maintenance_work_mem', TRUE));
+    seq_page_cost float := current_setting('seq_page_cost', TRUE);
+    random_page_cost float := current_setting('random_page_cost', TRUE);
+    temp_buffers bigint := pg_size_bytes(current_setting('temp_buffers', TRUE));
+    r record;
+BEGIN
+    IF _sysmem IS NULL THEN
+      RAISE NOTICE 'Call function with the size of your system memory `SELECT check_pgstac_settings(''4GB'')` to get pg system setting recommendations.';
+    ELSE
+        IF effective_cache_size < (sysmem * 0.5) THEN
+            RAISE WARNING 'effective_cache_size of % is set low for a system with %. Recomended value between % and %', pg_size_pretty(effective_cache_size), pg_size_pretty(sysmem), pg_size_pretty(sysmem * 0.5), pg_size_pretty(sysmem * 0.75);
+        ELSIF effective_cache_size > (sysmem * 0.75) THEN
+            RAISE WARNING 'effective_cache_size of % is set high for a system with %. Recomended value between % and %', pg_size_pretty(effective_cache_size), pg_size_pretty(sysmem), pg_size_pretty(sysmem * 0.5), pg_size_pretty(sysmem * 0.75);
+        ELSE
+            RAISE NOTICE 'effective_cache_size of % is set appropriately for a system with %', pg_size_pretty(effective_cache_size), pg_size_pretty(sysmem);
+        END IF;
+
+        IF shared_buffers < (sysmem * 0.2) THEN
+            RAISE WARNING 'shared_buffers of % is set low for a system with %. Recomended value between % and %', pg_size_pretty(shared_buffers), pg_size_pretty(sysmem), pg_size_pretty(sysmem * 0.2), pg_size_pretty(sysmem * 0.3);
+        ELSIF shared_buffers > (sysmem * 0.3) THEN
+            RAISE WARNING 'shared_buffers of % is set high for a system with %. Recomended value between % and %', pg_size_pretty(shared_buffers), pg_size_pretty(sysmem), pg_size_pretty(sysmem * 0.2), pg_size_pretty(sysmem * 0.3);
+        ELSE
+            RAISE NOTICE 'shared_buffers of % is set appropriately for a system with %', pg_size_pretty(shared_buffers), pg_size_pretty(sysmem);
+        END IF;
+        shared_buffers = sysmem * 0.3;
+        IF maintenance_work_mem < (sysmem * 0.2) THEN
+            RAISE WARNING 'maintenance_work_mem of % is set low for shared_buffers of %. Recomended value between % and %', pg_size_pretty(maintenance_work_mem), pg_size_pretty(shared_buffers), pg_size_pretty(shared_buffers * 0.2), pg_size_pretty(shared_buffers * 0.3);
+        ELSIF maintenance_work_mem > (shared_buffers * 0.3) THEN
+            RAISE WARNING 'maintenance_work_mem of % is set high for shared_buffers of %. Recomended value between % and %', pg_size_pretty(maintenance_work_mem), pg_size_pretty(shared_buffers), pg_size_pretty(shared_buffers * 0.2), pg_size_pretty(shared_buffers * 0.3);
+        ELSE
+            RAISE NOTICE 'maintenance_work_mem of % is set appropriately for shared_buffers of %', pg_size_pretty(shared_buffers), pg_size_pretty(shared_buffers);
+        END IF;
+
+        IF work_mem * max_connections > shared_buffers THEN
+            RAISE WARNING 'work_mem setting of % is set high for % max_connections please reduce work_mem to % or decrease max_connections to %', pg_size_pretty(work_mem), max_connections, pg_size_pretty(shared_buffers/max_connections), floor(shared_buffers/work_mem);
+        ELSIF work_mem * max_connections < (shared_buffers * 0.75) THEN
+            RAISE WARNING 'work_mem setting of % is set low for % max_connections you may consider raising work_mem to % or increasing max_connections to %', pg_size_pretty(work_mem), max_connections, pg_size_pretty(shared_buffers/max_connections), floor(shared_buffers/work_mem);
+        ELSE
+            RAISE NOTICE 'work_mem setting of % and max_connections of % are adequate for shared_buffers of %', pg_size_pretty(work_mem), max_connections, pg_size_pretty(shared_buffers);
+        END IF;
+
+        IF random_page_cost / seq_page_cost != 1.1 THEN
+            RAISE WARNING 'random_page_cost (%) /seq_page_cost (%) should be set to 1.1 for SSD. Change random_page_cost to %', random_page_cost, seq_page_cost, 1.1 * seq_page_cost;
+        ELSE
+            RAISE NOTICE 'random_page_cost and seq_page_cost set appropriately for SSD';
+        END IF;
+
+        IF temp_buffers < greatest(pg_size_bytes('128MB'),(maintenance_work_mem / 2)) THEN
+            RAISE WARNING 'pgstac makes heavy use of temp tables, consider raising temp_buffers from % to %', pg_size_pretty(temp_buffers), greatest('128MB', pg_size_pretty((shared_buffers / 16)));
+        END IF;
+    END IF;
+
+    RAISE NOTICE 'VALUES FOR PGSTAC VARIABLES';
+    RAISE NOTICE 'These can be set either as GUC system variables or by setting in the pgstac_settings table.';
+
+    FOR r IN SELECT name, get_setting(name) as setting, CASE WHEN current_setting(concat('pgstac.',name), TRUE) IS NOT NULL THEN concat('pgstac.',name, ' GUC') WHEN value IS NOT NULL THEN 'pgstac_settings table' ELSE 'Not Set' END as loc FROM pgstac_settings LOOP
+      RAISE NOTICE '% is set to % from the %', r.name, r.setting, r.loc;
+    END LOOP;
+
+    SELECT installed_version INTO settingval from pg_available_extensions WHERE name = 'pg_cron';
+    IF NOT FOUND OR settingval IS NULL THEN
+        RAISE NOTICE 'Consider intalling pg_cron which can be used to automate tasks';
+    ELSE
+        RAISE NOTICE 'pg_cron % is installed', settingval;
+    END IF;
+
+    SELECT installed_version INTO settingval from pg_available_extensions WHERE name = 'pgstattuple';
+    IF NOT FOUND OR settingval IS NULL THEN
+        RAISE NOTICE 'Consider installing the pgstattuple extension which can be used to help maintain tables and indexes.';
+    ELSE
+        RAISE NOTICE 'pgstattuple % is installed', settingval;
+    END IF;
+
+    SELECT installed_version INTO settingval from pg_available_extensions WHERE name = 'pg_stat_statements';
+    IF NOT FOUND OR settingval IS NULL THEN
+        RAISE NOTICE 'Consider installing the pg_stat_statements extension which is very helpful for tracking the types of queries on the system';
+    ELSE
+        RAISE NOTICE 'pg_stat_statements % is installed', settingval;
+        IF current_setting('pg_stat_statements.track_statements', TRUE) IS DISTINCT FROM 'all' THEN
+            RAISE WARNING 'SET pg_stat_statements.track_statements TO ''all''; --In order to track statements within functions.';
+        END IF;
+    END IF;
+
+END;
+$$ LANGUAGE PLPGSQL SET SEARCH_PATH TO pgstac, public SET CLIENT_MIN_MESSAGES TO NOTICE;
+CREATE OR REPLACE FUNCTION to_int(jsonb) RETURNS int AS $$
+    SELECT floor(($1->>0)::float)::int;
+$$ LANGUAGE SQL IMMUTABLE STRICT COST 5000 PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION to_float(jsonb) RETURNS float AS $$
+    SELECT ($1->>0)::float;
+$$ LANGUAGE SQL IMMUTABLE STRICT COST 5000 PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION to_tstz(jsonb) RETURNS timestamptz AS $$
+    SELECT ($1->>0)::timestamptz;
+$$ LANGUAGE SQL IMMUTABLE STRICT SET TIME ZONE 'UTC' COST 5000 PARALLEL SAFE;
+
+
+CREATE OR REPLACE FUNCTION to_text(jsonb) RETURNS text AS $$
+    SELECT CASE WHEN jsonb_typeof($1) IN ('array','object') THEN $1::text ELSE $1->>0 END;
+$$ LANGUAGE SQL IMMUTABLE STRICT COST 5000 PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION to_text_array(jsonb) RETURNS text[] AS $$
+    SELECT
+        CASE jsonb_typeof($1)
+            WHEN 'array' THEN ARRAY(SELECT jsonb_array_elements_text($1))
+            ELSE ARRAY[$1->>0]
+        END
+    ;
+$$ LANGUAGE SQL IMMUTABLE STRICT COST 5000 PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION bbox_geom(_bbox jsonb) RETURNS geometry AS $$
+SELECT CASE jsonb_array_length(_bbox)
+    WHEN 4 THEN
+        ST_SetSRID(ST_MakeEnvelope(
+            (_bbox->>0)::float,
+            (_bbox->>1)::float,
+            (_bbox->>2)::float,
+            (_bbox->>3)::float
+        ),4326)
+    WHEN 6 THEN
+    ST_SetSRID(ST_3DMakeBox(
+        ST_MakePoint(
+            (_bbox->>0)::float,
+            (_bbox->>1)::float,
+            (_bbox->>2)::float
+        ),
+        ST_MakePoint(
+            (_bbox->>3)::float,
+            (_bbox->>4)::float,
+            (_bbox->>5)::float
+        )
+    ),4326)
+    ELSE null END;
+;
+$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION geom_bbox(_geom geometry) RETURNS jsonb AS $$
+    SELECT jsonb_build_array(
+        st_xmin(_geom),
+        st_ymin(_geom),
+        st_xmax(_geom),
+        st_ymax(_geom)
+    );
+$$ LANGUAGE SQL IMMUTABLE STRICT;
+
+CREATE OR REPLACE FUNCTION flip_jsonb_array(j jsonb) RETURNS jsonb AS $$
+    SELECT jsonb_agg(value) FROM (SELECT value FROM jsonb_array_elements(j) WITH ORDINALITY ORDER BY ordinality DESC) as t;
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+
+CREATE OR REPLACE FUNCTION explode_dotpaths(j jsonb) RETURNS SETOF text[] AS $$
+    SELECT string_to_array(p, '.') as e FROM jsonb_array_elements_text(j) p;
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION explode_dotpaths_recurse(IN j jsonb) RETURNS SETOF text[] AS $$
+    WITH RECURSIVE t AS (
+        SELECT e FROM explode_dotpaths(j) e
+        UNION ALL
+        SELECT e[1:cardinality(e)-1]
+        FROM t
+        WHERE cardinality(e)>1
+    ) SELECT e FROM t;
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+
+CREATE OR REPLACE FUNCTION jsonb_set_nested(j jsonb, path text[], val jsonb) RETURNS jsonb AS $$
+DECLARE
+BEGIN
+    IF cardinality(path) > 1 THEN
+        FOR i IN 1..(cardinality(path)-1) LOOP
+            IF j #> path[:i] IS NULL THEN
+                j := jsonb_set_lax(j, path[:i], '{}', TRUE);
+            END IF;
+        END LOOP;
+    END IF;
+    RETURN jsonb_set_lax(j, path, val, true);
+
+END;
+$$ LANGUAGE PLPGSQL IMMUTABLE;
+
+
+
+CREATE OR REPLACE FUNCTION jsonb_include(j jsonb, f jsonb) RETURNS jsonb AS $$
+DECLARE
+    includes jsonb := f-> 'include';
+    outj jsonb := '{}'::jsonb;
+    path text[];
+BEGIN
+    IF
+        includes IS NULL
+        OR jsonb_array_length(includes) = 0
+    THEN
+        RETURN j;
+    ELSE
+        includes := includes || (
+            CASE WHEN j ? 'collection' THEN
+                '["id","collection"]'
+            ELSE
+                '["id"]'
+            END)::jsonb;
+        FOR path IN SELECT explode_dotpaths(includes) LOOP
+            outj := jsonb_set_nested(outj, path, j #> path);
+        END LOOP;
+    END IF;
+    RETURN outj;
+END;
+$$ LANGUAGE PLPGSQL IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION jsonb_exclude(j jsonb, f jsonb) RETURNS jsonb AS $$
+DECLARE
+    excludes jsonb := f-> 'exclude';
+    outj jsonb := j;
+    path text[];
+BEGIN
+    IF
+        excludes IS NULL
+        OR jsonb_array_length(excludes) = 0
+    THEN
+        RETURN j;
+    ELSE
+        FOR path IN SELECT explode_dotpaths(excludes) LOOP
+            outj := outj #- path;
+        END LOOP;
+    END IF;
+    RETURN outj;
+END;
+$$ LANGUAGE PLPGSQL IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION jsonb_fields(j jsonb, f jsonb DEFAULT '{"fields":[]}') RETURNS jsonb AS $$
+    SELECT jsonb_exclude(jsonb_include(j, f), f);
+$$ LANGUAGE SQL IMMUTABLE;
+
+
+CREATE OR REPLACE FUNCTION merge_jsonb(_a jsonb, _b jsonb) RETURNS jsonb AS $$
+    SELECT
+    CASE
+        WHEN _a = '"𒍟※"'::jsonb THEN NULL
+        WHEN _a IS NULL OR jsonb_typeof(_a) = 'null' THEN _b
+        WHEN jsonb_typeof(_a) = 'object' AND jsonb_typeof(_b) = 'object' THEN
+            (
+                SELECT
+                    jsonb_strip_nulls(
+                        jsonb_object_agg(
+                            key,
+                            merge_jsonb(a.value, b.value)
+                        )
+                    )
+                FROM
+                    jsonb_each(coalesce(_a,'{}'::jsonb)) as a
+                FULL JOIN
+                    jsonb_each(coalesce(_b,'{}'::jsonb)) as b
+                USING (key)
+            )
+        WHEN
+            jsonb_typeof(_a) = 'array'
+            AND jsonb_typeof(_b) = 'array'
+            AND jsonb_array_length(_a) = jsonb_array_length(_b)
+        THEN
+            (
+                SELECT jsonb_agg(m) FROM
+                    ( SELECT
+                        merge_jsonb(
+                            jsonb_array_elements(_a),
+                            jsonb_array_elements(_b)
+                        ) as m
+                    ) as l
+            )
+        ELSE _a
+    END
+    ;
+$$ LANGUAGE SQL IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION strip_jsonb(_a jsonb, _b jsonb) RETURNS jsonb AS $$
+    SELECT
+    CASE
+
+        WHEN (_a IS NULL OR jsonb_typeof(_a) = 'null') AND _b IS NOT NULL AND jsonb_typeof(_b) != 'null' THEN '"𒍟※"'::jsonb
+        WHEN _b IS NULL OR jsonb_typeof(_a) = 'null' THEN _a
+        WHEN _a = _b AND jsonb_typeof(_a) = 'object' THEN '{}'::jsonb
+        WHEN _a = _b THEN NULL
+        WHEN jsonb_typeof(_a) = 'object' AND jsonb_typeof(_b) = 'object' THEN
+            (
+                SELECT
+                    jsonb_strip_nulls(
+                        jsonb_object_agg(
+                            key,
+                            strip_jsonb(a.value, b.value)
+                        )
+                    )
+                FROM
+                    jsonb_each(_a) as a
+                FULL JOIN
+                    jsonb_each(_b) as b
+                USING (key)
+            )
+        WHEN
+            jsonb_typeof(_a) = 'array'
+            AND jsonb_typeof(_b) = 'array'
+            AND jsonb_array_length(_a) = jsonb_array_length(_b)
+        THEN
+            (
+                SELECT jsonb_agg(m) FROM
+                    ( SELECT
+                        strip_jsonb(
+                            jsonb_array_elements(_a),
+                            jsonb_array_elements(_b)
+                        ) as m
+                    ) as l
+            )
+        ELSE _a
+    END
+    ;
+$$ LANGUAGE SQL IMMUTABLE;
+
+
+CREATE OR REPLACE FUNCTION nullif_jsonbnullempty(j jsonb) RETURNS jsonb AS $$
+    SELECT nullif(nullif(nullif(j,'null'::jsonb),'{}'::jsonb),'[]'::jsonb);
+$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION jsonb_array_unique(j jsonb) RETURNS jsonb AS $$
+    SELECT nullif_jsonbnullempty(jsonb_agg(DISTINCT a)) v FROM jsonb_array_elements(j) a;
+$$ LANGUAGE SQL IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION jsonb_concat_ignorenull(a jsonb, b jsonb) RETURNS jsonb AS $$
+    SELECT coalesce(a,'[]'::jsonb) || coalesce(b,'[]'::jsonb);
+$$ LANGUAGE SQL IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION jsonb_least(a jsonb, b jsonb) RETURNS jsonb AS $$
+    SELECT nullif_jsonbnullempty(least(nullif_jsonbnullempty(a), nullif_jsonbnullempty(b)));
+$$ LANGUAGE SQL IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION jsonb_greatest(a jsonb, b jsonb) RETURNS jsonb AS $$
+    SELECT nullif_jsonbnullempty(greatest(a, b));
+$$ LANGUAGE SQL IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION first_notnull_sfunc(anyelement, anyelement) RETURNS anyelement AS $$
+    SELECT COALESCE($1,$2);
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+CREATE OR REPLACE AGGREGATE first_notnull(anyelement)(
+    SFUNC = first_notnull_sfunc,
+    STYPE = anyelement
+);
+
+CREATE OR REPLACE AGGREGATE jsonb_array_unique_merge(jsonb) (
+    STYPE = jsonb,
+    SFUNC = jsonb_concat_ignorenull,
+    FINALFUNC = jsonb_array_unique
+);
+
+CREATE OR REPLACE AGGREGATE jsonb_min(jsonb) (
+    STYPE = jsonb,
+    SFUNC = jsonb_least
+);
+
+CREATE OR REPLACE AGGREGATE jsonb_max(jsonb) (
+    STYPE = jsonb,
+    SFUNC = jsonb_greatest
+);
+/* looks for a geometry in a stac item first from geometry and falling back to bbox */
+CREATE OR REPLACE FUNCTION stac_geom(value jsonb) RETURNS geometry AS $$
+SELECT
+    CASE
+            WHEN value ? 'intersects' THEN
+                ST_GeomFromGeoJSON(value->>'intersects')
+            WHEN value ? 'geometry' THEN
+                ST_GeomFromGeoJSON(value->>'geometry')
+            WHEN value ? 'bbox' THEN
+                pgstac.bbox_geom(value->'bbox')
+            ELSE NULL
+        END as geometry
+;
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+
+
+CREATE OR REPLACE FUNCTION stac_daterange(
+    value jsonb
+) RETURNS tstzrange AS $$
+DECLARE
+    props jsonb := value;
+    dt timestamptz;
+    edt timestamptz;
+BEGIN
+    IF props ? 'properties' THEN
+        props := props->'properties';
+    END IF;
+    IF
+        props ? 'start_datetime'
+        AND props->>'start_datetime' IS NOT NULL
+        AND props ? 'end_datetime'
+        AND props->>'end_datetime' IS NOT NULL
+    THEN
+        dt := props->>'start_datetime';
+        edt := props->>'end_datetime';
+        IF dt > edt THEN
+            RAISE EXCEPTION 'start_datetime must be < end_datetime';
+        END IF;
+    ELSE
+        dt := props->>'datetime';
+        edt := props->>'datetime';
+    END IF;
+    IF dt is NULL OR edt IS NULL THEN
+        RAISE NOTICE 'DT: %, EDT: %', dt, edt;
+        RAISE EXCEPTION 'Either datetime (%) or both start_datetime (%) and end_datetime (%) must be set.', props->>'datetime',props->>'start_datetime',props->>'end_datetime';
+    END IF;
+    RETURN tstzrange(dt, edt, '[]');
+END;
+$$ LANGUAGE PLPGSQL IMMUTABLE PARALLEL SAFE SET TIMEZONE='UTC';
+
+CREATE OR REPLACE FUNCTION stac_datetime(value jsonb) RETURNS timestamptz AS $$
+    SELECT lower(stac_daterange(value));
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE SET TIMEZONE='UTC';
+
+CREATE OR REPLACE FUNCTION stac_end_datetime(value jsonb) RETURNS timestamptz AS $$
+    SELECT upper(stac_daterange(value));
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE SET TIMEZONE='UTC';
+
+CREATE TABLE IF NOT EXISTS stac_extensions(
+    url text PRIMARY KEY,
+    content jsonb
+);
+CREATE OR REPLACE FUNCTION collection_base_item(content jsonb) RETURNS jsonb AS $$
+    SELECT jsonb_build_object(
+        'type', 'Feature',
+        'stac_version', content->'stac_version',
+        'assets', content->'item_assets',
+        'collection', content->'id'
+    );
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+
+CREATE TABLE IF NOT EXISTS collections (
+    key bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    id text GENERATED ALWAYS AS (content->>'id') STORED UNIQUE NOT NULL,
+    content JSONB NOT NULL,
+    base_item jsonb GENERATED ALWAYS AS (pgstac.collection_base_item(content)) STORED,
+    geometry geometry GENERATED ALWAYS AS (pgstac.collection_geom(content)) STORED,
+    datetime timestamptz GENERATED ALWAYS AS (pgstac.collection_datetime(content)) STORED,
+    end_datetime timestamptz GENERATED ALWAYS AS (pgstac.collection_enddatetime(content)) STORED,
+    private jsonb,
+    partition_trunc text CHECK (partition_trunc IN ('year', 'month'))
+);
+
+CREATE OR REPLACE FUNCTION collection_base_item(cid text) RETURNS jsonb AS $$
+    SELECT pgstac.collection_base_item(content) FROM pgstac.collections WHERE id = cid LIMIT 1;
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+
+CREATE OR REPLACE FUNCTION create_collection(data jsonb) RETURNS VOID AS $$
+    INSERT INTO collections (content)
+    VALUES (data)
+    ;
+$$ LANGUAGE SQL SET SEARCH_PATH TO pgstac,public;
+
+CREATE OR REPLACE FUNCTION update_collection(data jsonb) RETURNS VOID AS $$
+DECLARE
+    out collections%ROWTYPE;
+BEGIN
+    UPDATE collections SET content=data WHERE id = data->>'id' RETURNING * INTO STRICT out;
+END;
+$$ LANGUAGE PLPGSQL SET SEARCH_PATH TO pgstac,public;
+
+CREATE OR REPLACE FUNCTION upsert_collection(data jsonb) RETURNS VOID AS $$
+    INSERT INTO collections (content)
+    VALUES (data)
+    ON CONFLICT (id) DO
+    UPDATE
+        SET content=EXCLUDED.content
+    ;
+$$ LANGUAGE SQL SET SEARCH_PATH TO pgstac,public;
+
+
+CREATE OR REPLACE FUNCTION delete_collection(_id text) RETURNS VOID AS $$
+DECLARE
+    out collections%ROWTYPE;
+BEGIN
+    DELETE FROM collections WHERE id = _id RETURNING * INTO STRICT out;
+END;
+$$ LANGUAGE PLPGSQL SET SEARCH_PATH TO pgstac,public;
+
+
+CREATE OR REPLACE FUNCTION get_collection(id text) RETURNS jsonb AS $$
+    SELECT content FROM collections
+    WHERE id=$1
+    ;
+$$ LANGUAGE SQL SET SEARCH_PATH TO pgstac,public;
+
+
+CREATE OR REPLACE FUNCTION all_collections() RETURNS jsonb AS $$
+    SELECT coalesce(jsonb_agg(content), '[]'::jsonb) FROM collections;
+$$ LANGUAGE SQL SET SEARCH_PATH TO pgstac,public;
+
+CREATE OR REPLACE FUNCTION collection_delete_trigger_func() RETURNS TRIGGER AS $$
+DECLARE
+    collection_base_partition text := concat('_items_', OLD.key);
+BEGIN
+    EXECUTE format($q$
+        DELETE FROM partition_stats WHERE partition IN (
+            SELECT partition FROM partition_sys_meta
+            WHERE collection=%L
+        );
+        DROP TABLE IF EXISTS %I CASCADE;
+        $q$,
+        OLD.id,
+        collection_base_partition
+    );
+    RETURN OLD;
+END;
+$$ LANGUAGE PLPGSQL;
+
+CREATE TRIGGER collection_delete_trigger BEFORE DELETE ON collections
+FOR EACH ROW EXECUTE FUNCTION collection_delete_trigger_func();
+CREATE OR REPLACE FUNCTION queryable_signature(n text, c text[]) RETURNS text AS $$
+    SELECT concat(n, c);
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+CREATE TABLE queryables (
+    id bigint GENERATED ALWAYS AS identity PRIMARY KEY,
+    name text NOT NULL,
+    collection_ids text[], -- used to determine what partitions to create indexes on
+    definition jsonb,
+    property_path text,
+    property_wrapper text,
+    property_index_type text
+);
+CREATE INDEX queryables_name_idx ON queryables (name);
+CREATE INDEX queryables_collection_idx ON queryables USING GIN (collection_ids);
+CREATE INDEX queryables_property_wrapper_idx ON queryables (property_wrapper);
+
+CREATE OR REPLACE FUNCTION pgstac.queryables_constraint_triggerfunc() RETURNS TRIGGER AS $$
+DECLARE
+    allcollections text[];
+BEGIN
+    RAISE NOTICE 'Making sure that name/collection is unique for queryables %', NEW;
+    IF NEW.collection_ids IS NOT NULL THEN
+        IF EXISTS (
+            SELECT 1
+                FROM unnest(NEW.collection_ids) c
+                LEFT JOIN
+                collections
+                ON (collections.id = c)
+                WHERE collections.id IS NULL
+        ) THEN
+            RAISE foreign_key_violation USING MESSAGE = format(
+                'One or more collections in %s do not exist.', NEW.collection_ids
+            );
+            RETURN NULL;
+        END IF;
+    END IF;
+    IF TG_OP = 'INSERT' THEN
+        IF EXISTS (
+            SELECT 1 FROM queryables q
+            WHERE
+                q.name = NEW.name
+                AND (
+                    q.collection_ids && NEW.collection_ids
+                    OR
+                    q.collection_ids IS NULL
+                    OR
+                    NEW.collection_ids IS NULL
+                )
+        ) THEN
+            RAISE unique_violation USING MESSAGE = format(
+                'There is already a queryable for %s for a collection in %s: %s',
+                NEW.name,
+                NEW.collection_ids,
+				(SELECT json_agg(row_to_json(q)) FROM queryables q WHERE
+                q.name = NEW.name
+                AND (
+                    q.collection_ids && NEW.collection_ids
+                    OR
+                    q.collection_ids IS NULL
+                    OR
+                    NEW.collection_ids IS NULL
+                ))
+            );
+            RETURN NULL;
+        END IF;
+    END IF;
+    IF TG_OP = 'UPDATE' THEN
+        IF EXISTS (
+            SELECT 1 FROM queryables q
+            WHERE
+                q.id != NEW.id
+                AND
+                q.name = NEW.name
+                AND (
+                    q.collection_ids && NEW.collection_ids
+                    OR
+                    q.collection_ids IS NULL
+                    OR
+                    NEW.collection_ids IS NULL
+                )
+        ) THEN
+            RAISE unique_violation
+            USING MESSAGE = format(
+                'There is already a queryable for %s for a collection in %s',
+                NEW.name,
+                NEW.collection_ids
+            );
+            RETURN NULL;
+        END IF;
+    END IF;
+
+    RETURN NEW;
+END;
+$$ LANGUAGE PLPGSQL;
+
+CREATE TRIGGER queryables_constraint_insert_trigger
+BEFORE INSERT ON queryables
+FOR EACH ROW EXECUTE PROCEDURE queryables_constraint_triggerfunc();
+
+CREATE TRIGGER queryables_constraint_update_trigger
+BEFORE UPDATE ON queryables
+FOR EACH ROW
+WHEN (NEW.name = OLD.name AND NEW.collection_ids IS DISTINCT FROM OLD.collection_ids)
+EXECUTE PROCEDURE queryables_constraint_triggerfunc();
+
+
+CREATE OR REPLACE FUNCTION array_to_path(arr text[]) RETURNS text AS $$
+    SELECT string_agg(
+        quote_literal(v),
+        '->'
+    ) FROM unnest(arr) v;
+$$ LANGUAGE SQL IMMUTABLE STRICT;
+
+
+
+
+CREATE OR REPLACE FUNCTION queryable(
+    IN dotpath text,
+    OUT path text,
+    OUT expression text,
+    OUT wrapper text,
+    OUT nulled_wrapper text
+) AS $$
+DECLARE
+    q RECORD;
+    path_elements text[];
+BEGIN
+    dotpath := replace(dotpath, 'properties.', '');
+    IF dotpath = 'start_datetime' THEN
+        dotpath := 'datetime';
+    END IF;
+    IF dotpath IN ('id', 'geometry', 'datetime', 'end_datetime', 'collection') THEN
+        path := dotpath;
+        expression := dotpath;
+        wrapper := NULL;
+        RETURN;
+    END IF;
+
+    SELECT * INTO q FROM queryables
+        WHERE
+            name=dotpath
+            OR name = 'properties.' || dotpath
+            OR name = replace(dotpath, 'properties.', '')
+    ;
+    IF q.property_wrapper IS NULL THEN
+        IF q.definition->>'type' = 'number' THEN
+            wrapper := 'to_float';
+            nulled_wrapper := wrapper;
+        ELSIF q.definition->>'format' = 'date-time' THEN
+            wrapper := 'to_tstz';
+            nulled_wrapper := wrapper;
+        ELSE
+            nulled_wrapper := NULL;
+            wrapper := 'to_text';
+        END IF;
+    ELSE
+        wrapper := q.property_wrapper;
+        nulled_wrapper := wrapper;
+    END IF;
+    IF q.property_path IS NOT NULL THEN
+        path := q.property_path;
+    ELSE
+        path_elements := string_to_array(dotpath, '.');
+        IF path_elements[1] IN ('links', 'assets', 'stac_version', 'stac_extensions') THEN
+            path := format('content->%s', array_to_path(path_elements));
+        ELSIF path_elements[1] = 'properties' THEN
+            path := format('content->%s', array_to_path(path_elements));
+        ELSE
+            path := format($F$content->'properties'->%s$F$, array_to_path(path_elements));
+        END IF;
+    END IF;
+    expression := format('%I(%s)', wrapper, path);
+    RETURN;
+END;
+$$ LANGUAGE PLPGSQL STABLE STRICT;
+
+CREATE OR REPLACE FUNCTION unnest_collection(collection_ids text[] DEFAULT NULL) RETURNS SETOF text AS $$
+    DECLARE
+    BEGIN
+        IF collection_ids IS NULL THEN
+            RETURN QUERY SELECT id FROM collections;
+        END IF;
+        RETURN QUERY SELECT unnest(collection_ids);
+    END;
+$$ LANGUAGE PLPGSQL STABLE;
+
+CREATE OR REPLACE FUNCTION normalize_indexdef(def text) RETURNS text AS $$
+DECLARE
+BEGIN
+    def := btrim(def, ' \n\t');
+	def := regexp_replace(def, '^CREATE (UNIQUE )?INDEX ([^ ]* )?ON (ONLY )?([^ ]* )?', '', 'i');
+    RETURN def;
+END;
+$$ LANGUAGE PLPGSQL IMMUTABLE STRICT PARALLEL SAFE;
+
+
+CREATE OR REPLACE FUNCTION indexdef(q queryables) RETURNS text AS $$
+    DECLARE
+        out text;
+    BEGIN
+        IF q.name = 'id' THEN
+            out := 'CREATE UNIQUE INDEX ON %I USING btree (id)';
+        ELSIF q.name = 'datetime' THEN
+            out := 'CREATE INDEX ON %I USING btree (datetime DESC, end_datetime)';
+        ELSIF q.name = 'geometry' THEN
+            out := 'CREATE INDEX ON %I USING gist (geometry)';
+        ELSE
+            out := format($q$CREATE INDEX ON %%I USING %s (%s(((content -> 'properties'::text) -> %L::text)))$q$,
+                lower(COALESCE(q.property_index_type, 'BTREE')),
+                lower(COALESCE(q.property_wrapper, 'to_text')),
+                q.name
+            );
+        END IF;
+        RETURN btrim(out, ' \n\t');
+    END;
+$$ LANGUAGE PLPGSQL IMMUTABLE;
+
+DROP VIEW IF EXISTS pgstac_indexes;
+CREATE VIEW pgstac_indexes AS
+SELECT
+    i.schemaname,
+    i.tablename,
+    i.indexname,
+    regexp_replace(btrim(replace(replace(indexdef, i.indexname, ''),'pgstac.',''),' \t\n'), '[ ]+', ' ', 'g') as idx,
+    COALESCE(
+        (regexp_match(indexdef, '\(([a-zA-Z]+)\)'))[1],
+        (regexp_match(indexdef,  '\(content -> ''properties''::text\) -> ''([a-zA-Z0-9\:\_-]+)''::text'))[1],
+        CASE WHEN indexdef ~* '\(datetime desc, end_datetime\)' THEN 'datetime' ELSE NULL END
+    ) AS field,
+    pg_table_size(i.indexname::text) as index_size,
+    pg_size_pretty(pg_table_size(i.indexname::text)) as index_size_pretty
+FROM
+    pg_indexes i
+WHERE i.schemaname='pgstac' and i.tablename ~ '_items_' AND indexdef !~* ' only ';
+
+DROP VIEW IF EXISTS pgstac_index_stats;
+CREATE VIEW pgstac_indexes_stats AS
+SELECT
+    i.schemaname,
+    i.tablename,
+    i.indexname,
+    indexdef,
+    COALESCE(
+        (regexp_match(indexdef, '\(([a-zA-Z]+)\)'))[1],
+        (regexp_match(indexdef,  '\(content -> ''properties''::text\) -> ''([a-zA-Z0-9\:\_]+)''::text'))[1],
+        CASE WHEN indexdef ~* '\(datetime desc, end_datetime\)' THEN 'datetime_end_datetime' ELSE NULL END
+    ) AS field,
+    pg_table_size(i.indexname::text) as index_size,
+    pg_size_pretty(pg_table_size(i.indexname::text)) as index_size_pretty,
+    n_distinct,
+    most_common_vals::text::text[],
+    most_common_freqs::text::text[],
+    histogram_bounds::text::text[],
+    correlation
+FROM
+    pg_indexes i
+    LEFT JOIN pg_stats s ON (s.tablename = i.indexname)
+WHERE i.schemaname='pgstac' and i.tablename ~ '_items_';
+
+CREATE OR REPLACE FUNCTION queryable_indexes(
+    IN treeroot text DEFAULT 'items',
+    IN changes boolean DEFAULT FALSE,
+    OUT collection text,
+    OUT partition text,
+    OUT field text,
+    OUT indexname text,
+    OUT existing_idx text,
+    OUT queryable_idx text
+) RETURNS SETOF RECORD AS $$
+WITH p AS (
+        SELECT
+            relid::text as partition,
+            replace(replace(
+                CASE
+                    WHEN parentrelid::regclass::text='items' THEN pg_get_expr(c.relpartbound, c.oid)
+                    ELSE pg_get_expr(parent.relpartbound, parent.oid)
+                END,
+                'FOR VALUES IN (''',''), ''')',
+                ''
+            ) AS collection
+        FROM pg_partition_tree(treeroot)
+        JOIN pg_class c ON (relid::regclass = c.oid)
+        JOIN pg_class parent ON (parentrelid::regclass = parent.oid AND isleaf)
+    ), i AS (
+        SELECT
+            partition,
+            indexname,
+            regexp_replace(btrim(replace(replace(indexdef, indexname, ''),'pgstac.',''),' \t\n'), '[ ]+', ' ', 'g') as iidx,
+            COALESCE(
+                (regexp_match(indexdef, '\(([a-zA-Z]+)\)'))[1],
+                (regexp_match(indexdef,  '\(content -> ''properties''::text\) -> ''([a-zA-Z0-9\:\_-]+)''::text'))[1],
+                CASE WHEN indexdef ~* '\(datetime desc, end_datetime\)' THEN 'datetime' ELSE NULL END
+            ) AS field
+        FROM
+            pg_indexes
+            JOIN p ON (tablename=partition)
+    ), q AS (
+        SELECT
+            name AS field,
+            collection,
+            partition,
+            format(indexdef(queryables), partition) as qidx
+        FROM queryables, unnest_collection(queryables.collection_ids) collection
+            JOIN p USING (collection)
+        WHERE property_index_type IS NOT NULL OR name IN ('datetime','geometry','id')
+    )
+    SELECT
+        collection,
+        partition,
+        field,
+        indexname,
+        iidx as existing_idx,
+        qidx as queryable_idx
+    FROM i FULL JOIN q USING (field, partition)
+    WHERE CASE WHEN changes THEN lower(iidx) IS DISTINCT FROM lower(qidx) ELSE TRUE END;
+;
+$$ LANGUAGE SQL;
+
+CREATE OR REPLACE FUNCTION maintain_index(
+    indexname text,
+    queryable_idx text,
+    dropindexes boolean DEFAULT FALSE,
+    rebuildindexes boolean DEFAULT FALSE,
+    idxconcurrently boolean DEFAULT FALSE
+) RETURNS VOID AS $$
+DECLARE
+BEGIN
+    IF indexname IS NOT NULL THEN
+        IF dropindexes OR queryable_idx IS NOT NULL THEN
+            EXECUTE format('DROP INDEX IF EXISTS %I;', indexname);
+        ELSIF rebuildindexes THEN
+            IF idxconcurrently THEN
+                EXECUTE format('REINDEX INDEX CONCURRENTLY %I;', indexname);
+            ELSE
+                EXECUTE format('REINDEX INDEX CONCURRENTLY %I;', indexname);
+            END IF;
+        END IF;
+    END IF;
+    IF queryable_idx IS NOT NULL THEN
+        IF idxconcurrently THEN
+            EXECUTE replace(queryable_idx, 'INDEX', 'INDEX CONCURRENTLY');
+        ELSE EXECUTE queryable_idx;
+        END IF;
+    END IF;
+END;
+$$ LANGUAGE PLPGSQL SECURITY DEFINER;
+
+
+
+set check_function_bodies to off;
+CREATE OR REPLACE FUNCTION maintain_partition_queries(
+    part text DEFAULT 'items',
+    dropindexes boolean DEFAULT FALSE,
+    rebuildindexes boolean DEFAULT FALSE,
+    idxconcurrently boolean DEFAULT FALSE
+) RETURNS SETOF text AS $$
+DECLARE
+   rec record;
+   q text;
+BEGIN
+    FOR rec IN (
+        SELECT * FROM queryable_indexes(part,true)
+    ) LOOP
+        q := format(
+            'SELECT maintain_index(
+                %L,%L,%L,%L,%L
+            );',
+            rec.indexname,
+            rec.queryable_idx,
+            dropindexes,
+            rebuildindexes,
+            idxconcurrently
+        );
+        RAISE NOTICE 'Q: %', q;
+        RETURN NEXT q;
+    END LOOP;
+    RETURN;
+END;
+$$ LANGUAGE PLPGSQL;
+
+CREATE OR REPLACE FUNCTION maintain_partitions(
+    part text DEFAULT 'items',
+    dropindexes boolean DEFAULT FALSE,
+    rebuildindexes boolean DEFAULT FALSE
+) RETURNS VOID AS $$
+    WITH t AS (
+        SELECT run_or_queue(q) FROM maintain_partition_queries(part, dropindexes, rebuildindexes) q
+    ) SELECT count(*) FROM t;
+$$ LANGUAGE SQL;
+
+
+CREATE OR REPLACE FUNCTION queryables_trigger_func() RETURNS TRIGGER AS $$
+DECLARE
+BEGIN
+    PERFORM maintain_partitions();
+    RETURN NULL;
+END;
+$$ LANGUAGE PLPGSQL;
+
+CREATE TRIGGER queryables_trigger AFTER INSERT OR UPDATE ON queryables
+FOR EACH STATEMENT EXECUTE PROCEDURE queryables_trigger_func();
+
+
+CREATE OR REPLACE FUNCTION get_queryables(_collection_ids text[] DEFAULT NULL) RETURNS jsonb AS $$
+DECLARE
+BEGIN
+    -- Build up queryables if the input contains valid collection ids or is empty
+    IF EXISTS (
+        SELECT 1 FROM collections
+        WHERE
+            _collection_ids IS NULL
+            OR cardinality(_collection_ids) = 0
+            OR id = ANY(_collection_ids)
+    )
+    THEN
+        RETURN (
+            WITH base AS (
+                SELECT
+                    unnest(collection_ids) as collection_id,
+                    name,
+                    coalesce(definition, '{"type":"string"}'::jsonb) as definition
+                FROM queryables
+                WHERE
+                    _collection_ids IS NULL OR
+                    _collection_ids = '{}'::text[] OR
+                    _collection_ids && collection_ids
+                UNION ALL
+                SELECT null, name, coalesce(definition, '{"type":"string"}'::jsonb) as definition
+                FROM queryables WHERE collection_ids IS NULL OR collection_ids = '{}'::text[]
+            ), g AS (
+                SELECT
+                    name,
+                    first_notnull(definition) as definition,
+                    jsonb_array_unique_merge(definition->'enum') as enum,
+                    jsonb_min(definition->'minimum') as minimum,
+                    jsonb_min(definition->'maxiumn') as maximum
+                FROM base
+                GROUP BY 1
+            )
+            SELECT
+                jsonb_build_object(
+                    '$schema', 'http://json-schema.org/draft-07/schema#',
+                    '$id', '',
+                    'type', 'object',
+                    'title', 'STAC Queryables.',
+                    'properties', jsonb_object_agg(
+                        name,
+                        definition
+                        ||
+                        jsonb_strip_nulls(jsonb_build_object(
+                            'enum', enum,
+                            'minimum', minimum,
+                            'maximum', maximum
+                        ))
+                    ),
+                    'additionalProperties', pgstac.additional_properties()
+                )
+                FROM g
+        );
+    ELSE
+        RETURN NULL;
+    END IF;
+END;
+$$ LANGUAGE PLPGSQL STABLE;
+
+CREATE OR REPLACE FUNCTION get_queryables(_collection text DEFAULT NULL) RETURNS jsonb AS $$
+    SELECT
+        CASE
+            WHEN _collection IS NULL THEN get_queryables(NULL::text[])
+            ELSE get_queryables(ARRAY[_collection])
+        END
+    ;
+$$ LANGUAGE SQL;
+
+CREATE OR REPLACE FUNCTION get_queryables() RETURNS jsonb AS $$
+    SELECT get_queryables(NULL::text[]);
+$$ LANGUAGE SQL;
+
+CREATE OR REPLACE FUNCTION schema_qualify_refs(url text, j jsonb) returns jsonb as $$
+    SELECT regexp_replace(j::text, '"\$ref": "#', concat('"$ref": "', url, '#'), 'g')::jsonb;
+$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;
+
+
+CREATE OR REPLACE VIEW stac_extension_queryables AS
+SELECT DISTINCT key as name, schema_qualify_refs(e.url, j.value) as definition FROM stac_extensions e, jsonb_each(e.content->'definitions'->'fields'->'properties') j;
+
+
+CREATE OR REPLACE FUNCTION missing_queryables(_collection text, _tablesample float DEFAULT 5, minrows float DEFAULT 10) RETURNS TABLE(collection text, name text, definition jsonb, property_wrapper text) AS $$
+DECLARE
+    q text;
+    _partition text;
+    explain_json json;
+    psize float;
+    estrows float;
+BEGIN
+    SELECT format('_items_%s', key) INTO _partition FROM collections WHERE id=_collection;
+
+    EXECUTE format('EXPLAIN (format json) SELECT 1 FROM %I;', _partition)
+    INTO explain_json;
+    psize := explain_json->0->'Plan'->'Plan Rows';
+    estrows := _tablesample * .01 * psize;
+    IF estrows < minrows THEN
+        _tablesample := least(100,greatest(_tablesample, (estrows / psize) / 100));
+        RAISE NOTICE '%', (psize / estrows) / 100;
+    END IF;
+    RAISE NOTICE 'Using tablesample % to find missing queryables from % % that has ~% rows estrows: %', _tablesample, _collection, _partition, psize, estrows;
+
+    q := format(
+        $q$
+            WITH q AS (
+                SELECT * FROM queryables
+                WHERE
+                    collection_ids IS NULL
+                    OR %L = ANY(collection_ids)
+            ), t AS (
+                SELECT
+                    content->'properties' AS properties
+                FROM
+                    %I
+                TABLESAMPLE SYSTEM(%L)
+            ), p AS (
+                SELECT DISTINCT ON (key)
+                    key,
+                    value,
+                    s.definition
+                FROM t
+                JOIN LATERAL jsonb_each(properties) ON TRUE
+                LEFT JOIN q ON (q.name=key)
+                LEFT JOIN stac_extension_queryables s ON (s.name=key)
+                WHERE q.definition IS NULL
+            )
+            SELECT
+                %L,
+                key,
+                COALESCE(definition, jsonb_build_object('type',jsonb_typeof(value))) as definition,
+                CASE
+                    WHEN definition->>'type' = 'integer' THEN 'to_int'
+                    WHEN COALESCE(definition->>'type', jsonb_typeof(value)) = 'number' THEN 'to_float'
+                    WHEN COALESCE(definition->>'type', jsonb_typeof(value)) = 'array' THEN 'to_text_array'
+                    ELSE 'to_text'
+                END
+            FROM p;
+        $q$,
+        _collection,
+        _partition,
+        _tablesample,
+        _collection
+    );
+    RETURN QUERY EXECUTE q;
+END;
+$$ LANGUAGE PLPGSQL;
+
+CREATE OR REPLACE FUNCTION missing_queryables(_tablesample float DEFAULT 5) RETURNS TABLE(collection_ids text[], name text, definition jsonb, property_wrapper text) AS $$
+    SELECT
+        array_agg(collection),
+        name,
+        definition,
+        property_wrapper
+    FROM
+        collections
+        JOIN LATERAL
+        missing_queryables(id, _tablesample) c
+        ON TRUE
+    GROUP BY
+        2,3,4
+    ORDER BY 2,1
+    ;
+$$ LANGUAGE SQL;
+CREATE OR REPLACE FUNCTION parse_dtrange(
+    _indate jsonb,
+    relative_base timestamptz DEFAULT date_trunc('hour', CURRENT_TIMESTAMP)
+) RETURNS tstzrange AS $$
+DECLARE
+    timestrs text[];
+    s timestamptz;
+    e timestamptz;
+BEGIN
+    timestrs :=
+    CASE
+        WHEN _indate ? 'timestamp' THEN
+            ARRAY[_indate->>'timestamp']
+        WHEN _indate ? 'interval' THEN
+            to_text_array(_indate->'interval')
+        WHEN jsonb_typeof(_indate) = 'array' THEN
+            to_text_array(_indate)
+        ELSE
+            regexp_split_to_array(
+                _indate->>0,
+                '/'
+            )
+    END;
+    RAISE NOTICE 'TIMESTRS %', timestrs;
+    IF cardinality(timestrs) = 1 THEN
+        IF timestrs[1] ILIKE 'P%' THEN
+            RETURN tstzrange(relative_base - upper(timestrs[1])::interval, relative_base, '[)');
+        END IF;
+        s := timestrs[1]::timestamptz;
+        RETURN tstzrange(s, s, '[]');
+    END IF;
+
+    IF cardinality(timestrs) != 2 THEN
+        RAISE EXCEPTION 'Timestamp cannot have more than 2 values';
+    END IF;
+
+    IF timestrs[1] = '..' OR timestrs[1] = '' THEN
+        s := '-infinity'::timestamptz;
+        e := timestrs[2]::timestamptz;
+        RETURN tstzrange(s,e,'[)');
+    END IF;
+
+    IF timestrs[2] = '..' OR timestrs[2] = '' THEN
+        s := timestrs[1]::timestamptz;
+        e := 'infinity'::timestamptz;
+        RETURN tstzrange(s,e,'[)');
+    END IF;
+
+    IF timestrs[1] ILIKE 'P%' AND timestrs[2] NOT ILIKE 'P%' THEN
+        e := timestrs[2]::timestamptz;
+        s := e - upper(timestrs[1])::interval;
+        RETURN tstzrange(s,e,'[)');
+    END IF;
+
+    IF timestrs[2] ILIKE 'P%' AND timestrs[1] NOT ILIKE 'P%' THEN
+        s := timestrs[1]::timestamptz;
+        e := s + upper(timestrs[2])::interval;
+        RETURN tstzrange(s,e,'[)');
+    END IF;
+
+    s := timestrs[1]::timestamptz;
+    e := timestrs[2]::timestamptz;
+
+    RETURN tstzrange(s,e,'[)');
+
+    RETURN NULL;
+
+END;
+$$ LANGUAGE PLPGSQL STABLE STRICT PARALLEL SAFE SET TIME ZONE 'UTC';
+
+CREATE OR REPLACE FUNCTION parse_dtrange(
+    _indate text,
+    relative_base timestamptz DEFAULT CURRENT_TIMESTAMP
+) RETURNS tstzrange AS $$
+    SELECT parse_dtrange(to_jsonb(_indate), relative_base);
+$$ LANGUAGE SQL STABLE STRICT PARALLEL SAFE;
+
+
+CREATE OR REPLACE FUNCTION temporal_op_query(op text, args jsonb) RETURNS text AS $$
+DECLARE
+    ll text := 'datetime';
+    lh text := 'end_datetime';
+    rrange tstzrange;
+    rl text;
+    rh text;
+    outq text;
+BEGIN
+    rrange := parse_dtrange(args->1);
+    RAISE NOTICE 'Constructing temporal query OP: %, ARGS: %, RRANGE: %', op, args, rrange;
+    op := lower(op);
+    rl := format('%L::timestamptz', lower(rrange));
+    rh := format('%L::timestamptz', upper(rrange));
+    outq := CASE op
+        WHEN 't_before'       THEN 'lh < rl'
+        WHEN 't_after'        THEN 'll > rh'
+        WHEN 't_meets'        THEN 'lh = rl'
+        WHEN 't_metby'        THEN 'll = rh'
+        WHEN 't_overlaps'     THEN 'll < rl AND rl < lh < rh'
+        WHEN 't_overlappedby' THEN 'rl < ll < rh AND lh > rh'
+        WHEN 't_starts'       THEN 'll = rl AND lh < rh'
+        WHEN 't_startedby'    THEN 'll = rl AND lh > rh'
+        WHEN 't_during'       THEN 'll > rl AND lh < rh'
+        WHEN 't_contains'     THEN 'll < rl AND lh > rh'
+        WHEN 't_finishes'     THEN 'll > rl AND lh = rh'
+        WHEN 't_finishedby'   THEN 'll < rl AND lh = rh'
+        WHEN 't_equals'       THEN 'll = rl AND lh = rh'
+        WHEN 't_disjoint'     THEN 'NOT (ll <= rh AND lh >= rl)'
+        WHEN 't_intersects'   THEN 'll <= rh AND lh >= rl'
+        WHEN 'anyinteracts'   THEN 'll <= rh AND lh >= rl'
+    END;
+    outq := regexp_replace(outq, '\mll\M', ll);
+    outq := regexp_replace(outq, '\mlh\M', lh);
+    outq := regexp_replace(outq, '\mrl\M', rl);
+    outq := regexp_replace(outq, '\mrh\M', rh);
+    outq := format('(%s)', outq);
+    RETURN outq;
+END;
+$$ LANGUAGE PLPGSQL STABLE STRICT;
+
+
+
+CREATE OR REPLACE FUNCTION spatial_op_query(op text, args jsonb) RETURNS text AS $$
+DECLARE
+    geom text;
+    j jsonb := args->1;
+BEGIN
+    op := lower(op);
+    RAISE NOTICE 'Constructing spatial query OP: %, ARGS: %', op, args;
+    IF op NOT IN ('s_equals','s_disjoint','s_touches','s_within','s_overlaps','s_crosses','s_intersects','intersects','s_contains') THEN
+        RAISE EXCEPTION 'Spatial Operator % Not Supported', op;
+    END IF;
+    op := regexp_replace(op, '^s_', 'st_');
+    IF op = 'intersects' THEN
+        op := 'st_intersects';
+    END IF;
+    -- Convert geometry to WKB string
+    IF j ? 'type' AND j ? 'coordinates' THEN
+        geom := st_geomfromgeojson(j)::text;
+    ELSIF jsonb_typeof(j) = 'array' THEN
+        geom := bbox_geom(j)::text;
+    END IF;
+
+    RETURN format('%s(geometry, %L::geometry)', op, geom);
+END;
+$$ LANGUAGE PLPGSQL;
+
+CREATE OR REPLACE FUNCTION query_to_cql2(q jsonb) RETURNS jsonb AS $$
+-- Translates anything passed in through the deprecated "query" into equivalent CQL2
+WITH t AS (
+    SELECT key as property, value as ops
+        FROM jsonb_each(q)
+), t2 AS (
+    SELECT property, (jsonb_each(ops)).*
+        FROM t WHERE jsonb_typeof(ops) = 'object'
+    UNION ALL
+    SELECT property, 'eq', ops
+        FROM t WHERE jsonb_typeof(ops) != 'object'
+)
+SELECT
+    jsonb_strip_nulls(jsonb_build_object(
+        'op', 'and',
+        'args', jsonb_agg(
+            jsonb_build_object(
+                'op', key,
+                'args', jsonb_build_array(
+                    jsonb_build_object('property',property),
+                    value
+                )
+            )
+        )
+    )
+) as qcql FROM t2
+;
+$$ LANGUAGE SQL IMMUTABLE STRICT;
+
+
+CREATE OR REPLACE FUNCTION cql1_to_cql2(j jsonb) RETURNS jsonb AS $$
+DECLARE
+    args jsonb;
+    ret jsonb;
+BEGIN
+    RAISE NOTICE 'CQL1_TO_CQL2: %', j;
+    IF j ? 'filter' THEN
+        RETURN cql1_to_cql2(j->'filter');
+    END IF;
+    IF j ? 'property' THEN
+        RETURN j;
+    END IF;
+    IF jsonb_typeof(j) = 'array' THEN
+        SELECT jsonb_agg(cql1_to_cql2(el)) INTO args FROM jsonb_array_elements(j) el;
+        RETURN args;
+    END IF;
+    IF jsonb_typeof(j) = 'number' THEN
+        RETURN j;
+    END IF;
+    IF jsonb_typeof(j) = 'string' THEN
+        RETURN j;
+    END IF;
+
+    IF jsonb_typeof(j) = 'object' THEN
+        SELECT jsonb_build_object(
+                'op', key,
+                'args', cql1_to_cql2(value)
+            ) INTO ret
+        FROM jsonb_each(j)
+        WHERE j IS NOT NULL;
+        RETURN ret;
+    END IF;
+    RETURN NULL;
+END;
+$$ LANGUAGE PLPGSQL IMMUTABLE STRICT;
+
+CREATE TABLE cql2_ops (
+    op text PRIMARY KEY,
+    template text,
+    types text[]
+);
+INSERT INTO cql2_ops (op, template, types) VALUES
+    ('eq', '%s = %s', NULL),
+    ('neq', '%s != %s', NULL),
+    ('ne', '%s != %s', NULL),
+    ('!=', '%s != %s', NULL),
+    ('<>', '%s != %s', NULL),
+    ('lt', '%s < %s', NULL),
+    ('lte', '%s <= %s', NULL),
+    ('gt', '%s > %s', NULL),
+    ('gte', '%s >= %s', NULL),
+    ('le', '%s <= %s', NULL),
+    ('ge', '%s >= %s', NULL),
+    ('=', '%s = %s', NULL),
+    ('<', '%s < %s', NULL),
+    ('<=', '%s <= %s', NULL),
+    ('>', '%s > %s', NULL),
+    ('>=', '%s >= %s', NULL),
+    ('like', '%s LIKE %s', NULL),
+    ('ilike', '%s ILIKE %s', NULL),
+    ('+', '%s + %s', NULL),
+    ('-', '%s - %s', NULL),
+    ('*', '%s * %s', NULL),
+    ('/', '%s / %s', NULL),
+    ('not', 'NOT (%s)', NULL),
+    ('between', '%s BETWEEN %s AND %s', NULL),
+    ('isnull', '%s IS NULL', NULL),
+    ('upper', 'upper(%s)', NULL),
+    ('lower', 'lower(%s)', NULL),
+    ('casei', 'upper(%s)', NULL),
+    ('accenti', 'unaccent(%s)', NULL)
+ON CONFLICT (op) DO UPDATE
+    SET
+        template = EXCLUDED.template
+;
+
+
+CREATE OR REPLACE FUNCTION cql2_query(j jsonb, wrapper text DEFAULT NULL) RETURNS text AS $$
+#variable_conflict use_variable
+DECLARE
+    args jsonb := j->'args';
+    arg jsonb;
+    op text := lower(j->>'op');
+    cql2op RECORD;
+    literal text;
+    _wrapper text;
+    leftarg text;
+    rightarg text;
+    prop text;
+    extra_props bool := pgstac.additional_properties();
+BEGIN
+    IF j IS NULL OR (op IS NOT NULL AND args IS NULL) THEN
+        RETURN NULL;
+    END IF;
+    RAISE NOTICE 'CQL2_QUERY: %', j;
+
+    -- check if all properties are represented in the queryables
+    IF NOT extra_props THEN
+        FOR prop IN
+            SELECT DISTINCT p->>0
+            FROM jsonb_path_query(j, 'strict $.**.property') p
+            WHERE p->>0 NOT IN ('id', 'datetime', 'geometry', 'end_datetime', 'collection')
+        LOOP
+            IF (queryable(prop)).nulled_wrapper IS NULL THEN
+                RAISE EXCEPTION 'Term % is not found in queryables.', prop;
+            END IF;
+        END LOOP;
+    END IF;
+
+    IF j ? 'filter' THEN
+        RETURN cql2_query(j->'filter');
+    END IF;
+
+    IF j ? 'upper' THEN
+        RETURN  cql2_query(jsonb_build_object('op', 'upper', 'args', j->'upper'));
+    END IF;
+
+    IF j ? 'lower' THEN
+        RETURN  cql2_query(jsonb_build_object('op', 'lower', 'args', j->'lower'));
+    END IF;
+
+    -- Temporal Query
+    IF op ilike 't_%' or op = 'anyinteracts' THEN
+        RETURN temporal_op_query(op, args);
+    END IF;
+
+    -- If property is a timestamp convert it to text to use with
+    -- general operators
+    IF j ? 'timestamp' THEN
+        RETURN format('%L::timestamptz', to_tstz(j->'timestamp'));
+    END IF;
+    IF j ? 'interval' THEN
+        RAISE EXCEPTION 'Please use temporal operators when using intervals.';
+        RETURN NONE;
+    END IF;
+
+    -- Spatial Query
+    IF op ilike 's_%' or op = 'intersects' THEN
+        RETURN spatial_op_query(op, args);
+    END IF;
+
+    IF op IN ('a_equals','a_contains','a_contained_by','a_overlaps') THEN
+        IF args->0 ? 'property' THEN
+            leftarg := format('to_text_array(%s)', (queryable(args->0->>'property')).path);
+        END IF;
+        IF args->1 ? 'property' THEN
+            rightarg := format('to_text_array(%s)', (queryable(args->1->>'property')).path);
+        END IF;
+        RETURN FORMAT(
+            '%s %s %s',
+            COALESCE(leftarg, quote_literal(to_text_array(args->0))),
+            CASE op
+                WHEN 'a_equals' THEN '='
+                WHEN 'a_contains' THEN '@>'
+                WHEN 'a_contained_by' THEN '<@'
+                WHEN 'a_overlaps' THEN '&&'
+            END,
+            COALESCE(rightarg, quote_literal(to_text_array(args->1)))
+        );
+    END IF;
+
+    IF op = 'in' THEN
+        RAISE NOTICE 'IN : % % %', args, jsonb_build_array(args->0), args->1;
+        args := jsonb_build_array(args->0) || (args->1);
+        RAISE NOTICE 'IN2 : %', args;
+    END IF;
+
+
+
+    IF op = 'between' THEN
+        args = jsonb_build_array(
+            args->0,
+            args->1,
+            args->2
+        );
+    END IF;
+
+    -- Make sure that args is an array and run cql2_query on
+    -- each element of the array
+    RAISE NOTICE 'ARGS PRE: %', args;
+    IF j ? 'args' THEN
+        IF jsonb_typeof(args) != 'array' THEN
+            args := jsonb_build_array(args);
+        END IF;
+
+        IF jsonb_path_exists(args, '$[*] ? (@.property == "id" || @.property == "datetime" || @.property == "end_datetime" || @.property == "collection")') THEN
+            wrapper := NULL;
+        ELSE
+            -- if any of the arguments are a property, try to get the property_wrapper
+            FOR arg IN SELECT jsonb_path_query(args, '$[*] ? (@.property != null)') LOOP
+                RAISE NOTICE 'Arg: %', arg;
+                wrapper := (queryable(arg->>'property')).nulled_wrapper;
+                RAISE NOTICE 'Property: %, Wrapper: %', arg, wrapper;
+                IF wrapper IS NOT NULL THEN
+                    EXIT;
+                END IF;
+            END LOOP;
+
+            -- if the property was not in queryables, see if any args were numbers
+            IF
+                wrapper IS NULL
+                AND jsonb_path_exists(args, '$[*] ? (@.type()=="number")')
+            THEN
+                wrapper := 'to_float';
+            END IF;
+            wrapper := coalesce(wrapper, 'to_text');
+        END IF;
+
+        SELECT jsonb_agg(cql2_query(a, wrapper))
+            INTO args
+        FROM jsonb_array_elements(args) a;
+    END IF;
+    RAISE NOTICE 'ARGS: %', args;
+
+    IF op IN ('and', 'or') THEN
+        RETURN
+            format(
+                '(%s)',
+                array_to_string(to_text_array(args), format(' %s ', upper(op)))
+            );
+    END IF;
+
+    IF op = 'in' THEN
+        RAISE NOTICE 'IN --  % %', args->0, to_text(args->0);
+        RETURN format(
+            '%s IN (%s)',
+            to_text(args->0),
+            array_to_string((to_text_array(args))[2:], ',')
+        );
+    END IF;
+
+    -- Look up template from cql2_ops
+    IF j ? 'op' THEN
+        SELECT * INTO cql2op FROM cql2_ops WHERE  cql2_ops.op ilike op;
+        IF FOUND THEN
+            -- If specific index set in queryables for a property cast other arguments to that type
+
+            RETURN format(
+                cql2op.template,
+                VARIADIC (to_text_array(args))
+            );
+        ELSE
+            RAISE EXCEPTION 'Operator % Not Supported.', op;
+        END IF;
+    END IF;
+
+
+    IF wrapper IS NOT NULL THEN
+        RAISE NOTICE 'Wrapping % with %', j, wrapper;
+        IF j ? 'property' THEN
+            RETURN format('%I(%s)', wrapper, (queryable(j->>'property')).path);
+        ELSE
+            RETURN format('%I(%L)', wrapper, j);
+        END IF;
+    ELSIF j ? 'property' THEN
+        RETURN quote_ident(j->>'property');
+    END IF;
+
+    RETURN quote_literal(to_text(j));
+END;
+$$ LANGUAGE PLPGSQL STABLE;
+
+
+CREATE OR REPLACE FUNCTION paging_dtrange(
+    j jsonb
+) RETURNS tstzrange AS $$
+DECLARE
+    op text;
+    filter jsonb := j->'filter';
+    dtrange tstzrange := tstzrange('-infinity'::timestamptz,'infinity'::timestamptz);
+    sdate timestamptz := '-infinity'::timestamptz;
+    edate timestamptz := 'infinity'::timestamptz;
+    jpitem jsonb;
+BEGIN
+
+    IF j ? 'datetime' THEN
+        dtrange := parse_dtrange(j->'datetime');
+        sdate := lower(dtrange);
+        edate := upper(dtrange);
+    END IF;
+    IF NOT (filter  @? '$.**.op ? (@ == "or" || @ == "not")') THEN
+        FOR jpitem IN SELECT j FROM jsonb_path_query(filter,'strict $.** ? (@.args[*].property == "datetime")'::jsonpath) j LOOP
+            op := lower(jpitem->>'op');
+            dtrange := parse_dtrange(jpitem->'args'->1);
+            IF op IN ('<=', 'lt', 'lte', '<', 'le', 't_before') THEN
+                sdate := greatest(sdate,'-infinity');
+                edate := least(edate, upper(dtrange));
+            ELSIF op IN ('>=', '>', 'gt', 'gte', 'ge', 't_after') THEN
+                edate := least(edate, 'infinity');
+                sdate := greatest(sdate, lower(dtrange));
+            ELSIF op IN ('=', 'eq') THEN
+                edate := least(edate, upper(dtrange));
+                sdate := greatest(sdate, lower(dtrange));
+            END IF;
+            RAISE NOTICE '2 OP: %, ARGS: %, DTRANGE: %, SDATE: %, EDATE: %', op, jpitem->'args'->1, dtrange, sdate, edate;
+        END LOOP;
+    END IF;
+    IF sdate > edate THEN
+        RETURN 'empty'::tstzrange;
+    END IF;
+    RETURN tstzrange(sdate,edate, '[]');
+END;
+$$ LANGUAGE PLPGSQL STABLE STRICT SET TIME ZONE 'UTC';
+
+CREATE OR REPLACE FUNCTION paging_collections(
+    IN j jsonb
+) RETURNS text[] AS $$
+DECLARE
+    filter jsonb := j->'filter';
+    jpitem jsonb;
+    op text;
+    args jsonb;
+    arg jsonb;
+    collections text[];
+BEGIN
+    IF j ? 'collections' THEN
+        collections := to_text_array(j->'collections');
+    END IF;
+    IF NOT (filter  @? '$.**.op ? (@ == "or" || @ == "not")') THEN
+        FOR jpitem IN SELECT j FROM jsonb_path_query(filter,'strict $.** ? (@.args[*].property == "collection")'::jsonpath) j LOOP
+            RAISE NOTICE 'JPITEM: %', jpitem;
+            op := jpitem->>'op';
+            args := jpitem->'args';
+            IF op IN ('=', 'eq', 'in') THEN
+                FOR arg IN SELECT a FROM jsonb_array_elements(args) a LOOP
+                    IF jsonb_typeof(arg) IN ('string', 'array') THEN
+                        RAISE NOTICE 'arg: %, collections: %', arg, collections;
+                        IF collections IS NULL OR collections = '{}'::text[] THEN
+                            collections := to_text_array(arg);
+                        ELSE
+                            collections := array_intersection(collections, to_text_array(arg));
+                        END IF;
+                    END IF;
+                END LOOP;
+            END IF;
+        END LOOP;
+    END IF;
+    IF collections = '{}'::text[] THEN
+        RETURN NULL;
+    END IF;
+    RETURN collections;
+END;
+$$ LANGUAGE PLPGSQL STABLE STRICT;
+CREATE TABLE items (
+    id text NOT NULL,
+    geometry geometry NOT NULL,
+    collection text NOT NULL,
+    datetime timestamptz NOT NULL,
+    end_datetime timestamptz NOT NULL,
+    content JSONB NOT NULL,
+    private jsonb
+)
+PARTITION BY LIST (collection)
+;
+
+CREATE INDEX "datetime_idx" ON items USING BTREE (datetime DESC, end_datetime ASC);
+CREATE INDEX "geometry_idx" ON items USING GIST (geometry);
+
+CREATE STATISTICS datetime_stats (dependencies) on datetime, end_datetime from items;
+
+ALTER TABLE items ADD CONSTRAINT items_collections_fk FOREIGN KEY (collection) REFERENCES collections(id) ON DELETE CASCADE DEFERRABLE;
+
+CREATE OR REPLACE FUNCTION partition_after_triggerfunc() RETURNS TRIGGER AS $$
+DECLARE
+    p text;
+    t timestamptz := clock_timestamp();
+BEGIN
+    RAISE NOTICE 'Updating partition stats %', t;
+    FOR p IN SELECT DISTINCT partition
+        FROM newdata n JOIN partition_sys_meta p
+        ON (n.collection=p.collection AND n.datetime <@ p.partition_dtrange)
+    LOOP
+        PERFORM run_or_queue(format('SELECT update_partition_stats(%L, %L);', p, true));
+    END LOOP;
+    IF TG_OP IN ('DELETE','UPDATE') THEN
+        DELETE FROM format_item_cache c USING newdata n WHERE c.collection = n.collection AND c.id = n.id;
+    END IF;
+    RAISE NOTICE 't: % %', t, clock_timestamp() - t;
+    RETURN NULL;
+END;
+$$ LANGUAGE PLPGSQL SECURITY DEFINER;
+
+CREATE TRIGGER items_after_insert_trigger
+AFTER INSERT ON items
+REFERENCING NEW TABLE AS newdata
+FOR EACH STATEMENT
+EXECUTE FUNCTION partition_after_triggerfunc();
+
+CREATE TRIGGER items_after_update_trigger
+AFTER DELETE ON items
+REFERENCING OLD TABLE AS newdata
+FOR EACH STATEMENT
+EXECUTE FUNCTION partition_after_triggerfunc();
+
+CREATE TRIGGER items_after_delete_trigger
+AFTER UPDATE ON items
+REFERENCING NEW TABLE AS newdata
+FOR EACH STATEMENT
+EXECUTE FUNCTION partition_after_triggerfunc();
+
+
+CREATE OR REPLACE FUNCTION content_slim(_item jsonb) RETURNS jsonb AS $$
+    SELECT strip_jsonb(_item - '{id,geometry,collection,type}'::text[], collection_base_item(_item->>'collection')) - '{id,geometry,collection,type}'::text[];
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION content_dehydrate(content jsonb) RETURNS items AS $$
+    SELECT
+            content->>'id' as id,
+            stac_geom(content) as geometry,
+            content->>'collection' as collection,
+            stac_datetime(content) as datetime,
+            stac_end_datetime(content) as end_datetime,
+            content_slim(content) as content,
+            null::jsonb as private
+    ;
+$$ LANGUAGE SQL STABLE;
+
+CREATE OR REPLACE FUNCTION include_field(f text, fields jsonb DEFAULT '{}'::jsonb) RETURNS boolean AS $$
+DECLARE
+    includes jsonb := fields->'include';
+    excludes jsonb := fields->'exclude';
+BEGIN
+    IF f IS NULL THEN
+        RETURN NULL;
+    END IF;
+
+
+    IF
+        jsonb_typeof(excludes) = 'array'
+        AND jsonb_array_length(excludes)>0
+        AND excludes ? f
+    THEN
+        RETURN FALSE;
+    END IF;
+
+    IF
+        (
+            jsonb_typeof(includes) = 'array'
+            AND jsonb_array_length(includes) > 0
+            AND includes ? f
+        ) OR
+        (
+            includes IS NULL
+            OR jsonb_typeof(includes) = 'null'
+            OR jsonb_array_length(includes) = 0
+        )
+    THEN
+        RETURN TRUE;
+    END IF;
+
+    RETURN FALSE;
+END;
+$$ LANGUAGE PLPGSQL IMMUTABLE;
+
+DROP FUNCTION IF EXISTS content_hydrate(jsonb, jsonb, jsonb);
+CREATE OR REPLACE FUNCTION content_hydrate(
+    _item jsonb,
+    _base_item jsonb,
+    fields jsonb DEFAULT '{}'::jsonb
+) RETURNS jsonb AS $$
+    SELECT merge_jsonb(
+            jsonb_fields(_item, fields),
+            jsonb_fields(_base_item, fields)
+    );
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+
+
+CREATE OR REPLACE FUNCTION content_hydrate(_item items, _collection collections, fields jsonb DEFAULT '{}'::jsonb) RETURNS jsonb AS $$
+DECLARE
+    geom jsonb;
+    bbox jsonb;
+    output jsonb;
+    content jsonb;
+    base_item jsonb := _collection.base_item;
+BEGIN
+    IF include_field('geometry', fields) THEN
+        geom := ST_ASGeoJson(_item.geometry, 20)::jsonb;
+    END IF;
+    output := content_hydrate(
+        jsonb_build_object(
+            'id', _item.id,
+            'geometry', geom,
+            'collection', _item.collection,
+            'type', 'Feature'
+        ) || _item.content,
+        _collection.base_item,
+        fields
+    );
+
+    RETURN output;
+END;
+$$ LANGUAGE PLPGSQL STABLE PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION content_nonhydrated(
+    _item items,
+    fields jsonb DEFAULT '{}'::jsonb
+) RETURNS jsonb AS $$
+DECLARE
+    geom jsonb;
+    bbox jsonb;
+    output jsonb;
+BEGIN
+    IF include_field('geometry', fields) THEN
+        geom := ST_ASGeoJson(_item.geometry, 20)::jsonb;
+    END IF;
+    output := jsonb_build_object(
+                'id', _item.id,
+                'geometry', geom,
+                'collection', _item.collection,
+                'type', 'Feature'
+            ) || _item.content;
+    RETURN output;
+END;
+$$ LANGUAGE PLPGSQL STABLE PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION content_hydrate(_item items, fields jsonb DEFAULT '{}'::jsonb) RETURNS jsonb AS $$
+    SELECT content_hydrate(
+        _item,
+        (SELECT c FROM collections c WHERE id=_item.collection LIMIT 1),
+        fields
+    );
+$$ LANGUAGE SQL STABLE;
+
+
+CREATE UNLOGGED TABLE items_staging (
+    content JSONB NOT NULL
+);
+CREATE UNLOGGED TABLE items_staging_ignore (
+    content JSONB NOT NULL
+);
+CREATE UNLOGGED TABLE items_staging_upsert (
+    content JSONB NOT NULL
+);
+
+CREATE OR REPLACE FUNCTION items_staging_triggerfunc() RETURNS TRIGGER AS $$
+DECLARE
+    p record;
+    _partitions text[];
+    part text;
+    ts timestamptz := clock_timestamp();
+    nrows int;
+BEGIN
+    RAISE NOTICE 'Creating Partitions. %', clock_timestamp() - ts;
+
+    FOR part IN WITH t AS (
+        SELECT
+            n.content->>'collection' as collection,
+            stac_daterange(n.content->'properties') as dtr,
+            partition_trunc
+        FROM newdata n JOIN collections ON (n.content->>'collection'=collections.id)
+    ), p AS (
+        SELECT
+            collection,
+            COALESCE(date_trunc(partition_trunc::text, lower(dtr)),'-infinity') as d,
+            tstzrange(min(lower(dtr)),max(lower(dtr)),'[]') as dtrange,
+            tstzrange(min(upper(dtr)),max(upper(dtr)),'[]') as edtrange
+        FROM t
+        GROUP BY 1,2
+    ) SELECT check_partition(collection, dtrange, edtrange) FROM p LOOP
+        RAISE NOTICE 'Partition %', part;
+    END LOOP;
+
+    RAISE NOTICE 'Creating temp table with data to be added. %', clock_timestamp() - ts;
+    DROP TABLE IF EXISTS tmpdata;
+    CREATE TEMP TABLE tmpdata ON COMMIT DROP AS
+    SELECT
+        (content_dehydrate(content)).*
+    FROM newdata;
+    GET DIAGNOSTICS nrows = ROW_COUNT;
+    RAISE NOTICE 'Added % rows to tmpdata. %', nrows, clock_timestamp() - ts;
+
+    RAISE NOTICE 'Doing the insert. %', clock_timestamp() - ts;
+    IF TG_TABLE_NAME = 'items_staging' THEN
+        INSERT INTO items
+        SELECT * FROM tmpdata;
+        GET DIAGNOSTICS nrows = ROW_COUNT;
+        RAISE NOTICE 'Inserted % rows to items. %', nrows, clock_timestamp() - ts;
+    ELSIF TG_TABLE_NAME = 'items_staging_ignore' THEN
+        INSERT INTO items
+        SELECT * FROM tmpdata
+        ON CONFLICT DO NOTHING;
+        GET DIAGNOSTICS nrows = ROW_COUNT;
+        RAISE NOTICE 'Inserted % rows to items. %', nrows, clock_timestamp() - ts;
+    ELSIF TG_TABLE_NAME = 'items_staging_upsert' THEN
+        DELETE FROM items i USING tmpdata s
+            WHERE
+                i.id = s.id
+                AND i.collection = s.collection
+                AND i IS DISTINCT FROM s
+        ;
+        GET DIAGNOSTICS nrows = ROW_COUNT;
+        RAISE NOTICE 'Deleted % rows from items. %', nrows, clock_timestamp() - ts;
+        INSERT INTO items AS t
+        SELECT * FROM tmpdata
+        ON CONFLICT DO NOTHING;
+        GET DIAGNOSTICS nrows = ROW_COUNT;
+        RAISE NOTICE 'Inserted % rows to items. %', nrows, clock_timestamp() - ts;
+    END IF;
+
+    RAISE NOTICE 'Deleting data from staging table. %', clock_timestamp() - ts;
+    DELETE FROM items_staging;
+    RAISE NOTICE 'Done. %', clock_timestamp() - ts;
+
+    RETURN NULL;
+
+END;
+$$ LANGUAGE PLPGSQL;
+
+
+CREATE TRIGGER items_staging_insert_trigger AFTER INSERT ON items_staging REFERENCING NEW TABLE AS newdata
+    FOR EACH STATEMENT EXECUTE PROCEDURE items_staging_triggerfunc();
+
+CREATE TRIGGER items_staging_insert_ignore_trigger AFTER INSERT ON items_staging_ignore REFERENCING NEW TABLE AS newdata
+    FOR EACH STATEMENT EXECUTE PROCEDURE items_staging_triggerfunc();
+
+CREATE TRIGGER items_staging_insert_upsert_trigger AFTER INSERT ON items_staging_upsert REFERENCING NEW TABLE AS newdata
+    FOR EACH STATEMENT EXECUTE PROCEDURE items_staging_triggerfunc();
+
+
+CREATE OR REPLACE FUNCTION item_by_id(_id text, _collection text DEFAULT NULL) RETURNS items AS
+$$
+DECLARE
+    i items%ROWTYPE;
+BEGIN
+    SELECT * INTO i FROM items WHERE id=_id AND (_collection IS NULL OR collection=_collection) LIMIT 1;
+    RETURN i;
+END;
+$$ LANGUAGE PLPGSQL STABLE SET SEARCH_PATH TO pgstac, public;
+
+CREATE OR REPLACE FUNCTION get_item(_id text, _collection text DEFAULT NULL) RETURNS jsonb AS $$
+    SELECT content_hydrate(items) FROM items WHERE id=_id AND (_collection IS NULL OR collection=_collection);
+$$ LANGUAGE SQL STABLE SET SEARCH_PATH TO pgstac, public;
+
+CREATE OR REPLACE FUNCTION delete_item(_id text, _collection text DEFAULT NULL) RETURNS VOID AS $$
+DECLARE
+out items%ROWTYPE;
+BEGIN
+    DELETE FROM items WHERE id = _id AND (_collection IS NULL OR collection=_collection) RETURNING * INTO STRICT out;
+END;
+$$ LANGUAGE PLPGSQL;
+
+--/*
+CREATE OR REPLACE FUNCTION create_item(data jsonb) RETURNS VOID AS $$
+    INSERT INTO items_staging (content) VALUES (data);
+$$ LANGUAGE SQL SET SEARCH_PATH TO pgstac,public;
+
+
+CREATE OR REPLACE FUNCTION update_item(content jsonb) RETURNS VOID AS $$
+DECLARE
+    old items %ROWTYPE;
+    out items%ROWTYPE;
+BEGIN
+    PERFORM delete_item(content->>'id', content->>'collection');
+    PERFORM create_item(content);
+END;
+$$ LANGUAGE PLPGSQL SET SEARCH_PATH TO pgstac,public;
+
+CREATE OR REPLACE FUNCTION upsert_item(data jsonb) RETURNS VOID AS $$
+    INSERT INTO items_staging_upsert (content) VALUES (data);
+$$ LANGUAGE SQL SET SEARCH_PATH TO pgstac,public;
+
+CREATE OR REPLACE FUNCTION create_items(data jsonb) RETURNS VOID AS $$
+    INSERT INTO items_staging (content)
+    SELECT * FROM jsonb_array_elements(data);
+$$ LANGUAGE SQL SET SEARCH_PATH TO pgstac,public;
+
+CREATE OR REPLACE FUNCTION upsert_items(data jsonb) RETURNS VOID AS $$
+    INSERT INTO items_staging_upsert (content)
+    SELECT * FROM jsonb_array_elements(data);
+$$ LANGUAGE SQL SET SEARCH_PATH TO pgstac,public;
+
+
+CREATE OR REPLACE FUNCTION collection_bbox(id text) RETURNS jsonb AS $$
+    SELECT (replace(replace(replace(st_extent(geometry)::text,'BOX(','[['),')',']]'),' ',','))::jsonb
+    FROM items WHERE collection=$1;
+    ;
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE SET SEARCH_PATH TO pgstac, public;
+
+CREATE OR REPLACE FUNCTION collection_temporal_extent(id text) RETURNS jsonb AS $$
+    SELECT to_jsonb(array[array[min(datetime), max(datetime)]])
+    FROM items WHERE collection=$1;
+;
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE SET SEARCH_PATH TO pgstac, public;
+
+CREATE OR REPLACE FUNCTION update_collection_extents() RETURNS VOID AS $$
+UPDATE collections
+    SET content = jsonb_set_lax(
+        content,
+        '{extent}'::text[],
+        collection_extent(id, FALSE),
+        true,
+        'use_json_null'
+    )
+;
+$$ LANGUAGE SQL;
+CREATE TABLE partition_stats (
+    partition text PRIMARY KEY,
+    dtrange tstzrange,
+    edtrange tstzrange,
+    spatial geometry,
+    last_updated timestamptz,
+    keys text[]
+) WITH (FILLFACTOR=90);
+
+CREATE INDEX partitions_range_idx ON partition_stats USING GIST(dtrange);
+
+
+CREATE OR REPLACE FUNCTION constraint_tstzrange(expr text) RETURNS tstzrange AS $$
+    WITH t AS (
+        SELECT regexp_matches(
+            expr,
+            E'\\(''\([0-9 :+-]*\)''\\).*\\(''\([0-9 :+-]*\)''\\)'
+        ) AS m
+    ) SELECT tstzrange(m[1]::timestamptz, m[2]::timestamptz) FROM t
+    ;
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT;
+
+CREATE OR REPLACE FUNCTION get_tstz_constraint(reloid oid, colname text) RETURNS tstzrange AS $$
+DECLARE
+    expr text := NULL;
+    m text[];
+    ts_lower timestamptz := NULL;
+    ts_upper timestamptz := NULL;
+    lower_inclusive text := '[';
+    upper_inclusive text := ']';
+    ts timestamptz;
+BEGIN
+    SELECT INTO expr
+        string_agg(def, ' AND ')
+    FROM pg_constraint JOIN LATERAL pg_get_constraintdef(oid) AS def ON TRUE
+    WHERE
+        conrelid = reloid
+        AND contype = 'c'
+        AND def LIKE '%' || colname || '%'
+    ;
+
+    IF expr IS NULL THEN
+        RETURN NULL;
+    END IF;
+
+    RAISE DEBUG 'Constraint expression for % on %: %', colname, reloid::regclass, expr;
+    -- collect all constraints for the specified column
+    FOR m IN SELECT regexp_matches(expr, '[ (]' || colname || $expr$\s*([<>=]{1,2})\s*'([0-9 :.+\-]+)'$expr$, 'g') LOOP
+        ts := m[2]::timestamptz;
+        IF m[1] IN ('>', '>=')
+        THEN
+            IF ts_lower IS NULL OR ts > ts_lower OR (ts = ts_lower AND m[1] = '>') THEN
+                ts_lower := ts;
+                lower_inclusive := CASE WHEN m[1] = '>' THEN '(' ELSE '[' END;
+            END IF;
+        ELSIF m[1] IN ('<', '<=')
+        THEN
+            IF ts_upper IS NULL OR ts < ts_upper OR (ts = ts_upper AND m[1] = '<') THEN
+                ts_upper := ts;
+                upper_inclusive := CASE WHEN m[1] = '<' THEN ')' ELSE ']' END;
+            END IF;
+        END IF;
+    END LOOP;
+    RAISE DEBUG 'Constraint % for %: % %', colname, reloid::regclass, ts_lower, ts_upper;
+    RETURN tstzrange(ts_lower, ts_upper, lower_inclusive || upper_inclusive);
+END;
+$$ LANGUAGE plpgsql STRICT STABLE;
+
+CREATE OR REPLACE FUNCTION get_partition_name(relid regclass) RETURNS text AS $$
+    SELECT (parse_ident(relid::text))[cardinality(parse_ident(relid::text))];
+$$ LANGUAGE SQL STABLE STRICT;
+
+CREATE OR REPLACE VIEW partition_sys_meta AS
+SELECT
+    partition,
+    replace(
+        replace(
+            CASE WHEN level = 1 THEN partition_expr ELSE parent_partition_expr END,
+            'FOR VALUES IN (''',
+            ''
+        ),
+        ''')',
+        ''
+    ) AS collection,
+    level,
+    c.reltuples,
+    c.relhastriggers,
+    partition_dtrange,
+    COALESCE(
+        get_tstz_constraint(c.oid, 'datetime'),
+        partition_dtrange,
+        inf_range
+    ) as constraint_dtrange,
+    COALESCE(
+        get_tstz_constraint(c.oid, 'end_datetime'),
+        inf_range
+    ) as constraint_edtrange
+FROM
+    pg_partition_tree('items')
+    JOIN pg_class c ON (relid::regclass = c.oid)
+    JOIN pg_class parent ON (parentrelid::regclass = parent.oid AND isleaf)
+    LEFT JOIN pg_constraint edt ON (conrelid=c.oid AND contype='c')
+    JOIN LATERAL get_partition_name(relid) AS partition ON TRUE
+    JOIN LATERAL pg_get_expr(c.relpartbound, c.oid) as partition_expr ON TRUE
+    JOIN LATERAL pg_get_expr(parent.relpartbound, parent.oid) as parent_partition_expr ON TRUE
+    JOIN LATERAL tstzrange('-infinity', 'infinity','[]') as inf_range ON TRUE
+    JOIN LATERAL COALESCE(constraint_tstzrange(pg_get_expr(c.relpartbound, c.oid)), inf_range) as partition_dtrange ON TRUE
+    JOIN LATERAL get_tstz_constraint(c.oid, 'datetime') as datetime_constraint ON TRUE
+    JOIN LATERAL get_tstz_constraint(c.oid, 'end_datetime') as end_datetime_constraint ON TRUE
+WHERE isleaf
+;
+
+CREATE OR REPLACE VIEW partitions_view AS
+SELECT
+    (parse_ident(relid::text))[cardinality(parse_ident(relid::text))] as partition,
+    replace(
+        replace(
+            CASE WHEN level = 1 THEN partition_expr ELSE parent_partition_expr END,
+            'FOR VALUES IN (''',
+            ''
+        ),
+        ''')',
+        ''
+    ) AS collection,
+    level,
+    c.reltuples,
+    c.relhastriggers,
+    partition_dtrange,
+    COALESCE(
+        get_tstz_constraint(c.oid, 'datetime'),
+        partition_dtrange,
+        inf_range
+    ) as constraint_dtrange,
+    COALESCE(
+        get_tstz_constraint(c.oid, 'end_datetime'),
+        inf_range
+    ) as constraint_edtrange,
+    dtrange,
+    edtrange,
+    spatial,
+    last_updated
+FROM
+    pg_partition_tree('items')
+    JOIN pg_class c ON (relid::regclass = c.oid)
+    JOIN pg_class parent ON (parentrelid::regclass = parent.oid AND isleaf)
+    LEFT JOIN pg_constraint edt ON (conrelid=c.oid AND contype='c')
+    JOIN LATERAL get_partition_name(relid) AS partition ON TRUE
+    JOIN LATERAL pg_get_expr(c.relpartbound, c.oid) as partition_expr ON TRUE
+    JOIN LATERAL pg_get_expr(parent.relpartbound, parent.oid) as parent_partition_expr ON TRUE
+    JOIN LATERAL tstzrange('-infinity', 'infinity','[]') as inf_range ON TRUE
+    JOIN LATERAL COALESCE(constraint_tstzrange(pg_get_expr(c.relpartbound, c.oid)), inf_range) as partition_dtrange ON TRUE
+    JOIN LATERAL get_tstz_constraint(c.oid, 'datetime') as datetime_constraint ON TRUE
+    JOIN LATERAL get_tstz_constraint(c.oid, 'end_datetime') as end_datetime_constraint ON TRUE
+    LEFT JOIN pgstac.partition_stats USING (partition)
+WHERE isleaf
+;
+
+CREATE MATERIALIZED VIEW partitions AS
+SELECT * FROM partitions_view;
+CREATE UNIQUE INDEX ON partitions (partition);
+
+CREATE MATERIALIZED VIEW partition_steps AS
+SELECT
+    partition as name,
+    date_trunc('month',lower(partition_dtrange)) as sdate,
+    date_trunc('month', upper(partition_dtrange)) + '1 month'::interval as edate
+    FROM partitions_view WHERE partition_dtrange IS NOT NULL AND partition_dtrange != 'empty'::tstzrange
+    ORDER BY dtrange ASC
+;
+
+
+CREATE OR REPLACE FUNCTION update_partition_stats_q(_partition text, istrigger boolean default false) RETURNS VOID AS $$
+DECLARE
+BEGIN
+    PERFORM run_or_queue(
+        format('SELECT update_partition_stats(%L, %L);', _partition, istrigger)
+    );
+END;
+$$ LANGUAGE PLPGSQL;
+
+CREATE OR REPLACE FUNCTION update_partition_stats(_partition text, istrigger boolean default false) RETURNS VOID AS $$
+DECLARE
+    dtrange tstzrange;
+    edtrange tstzrange;
+    cdtrange tstzrange;
+    cedtrange tstzrange;
+    extent geometry;
+    collection text;
+BEGIN
+    RAISE NOTICE 'Updating stats for %.', _partition;
+    EXECUTE format(
+        $q$
+            SELECT
+                tstzrange(min(datetime), max(datetime),'[]'),
+                tstzrange(min(end_datetime), max(end_datetime), '[]')
+            FROM %I
+        $q$,
+        _partition
+    ) INTO dtrange, edtrange;
+    EXECUTE format('ANALYZE %I;', _partition);
+    extent := st_estimatedextent('pgstac', _partition, 'geometry');
+    RAISE DEBUG 'Estimated Extent: %', extent;
+    INSERT INTO partition_stats (partition, dtrange, edtrange, spatial, last_updated)
+        SELECT _partition, dtrange, edtrange, extent, now()
+        ON CONFLICT (partition) DO
+            UPDATE SET
+                dtrange=EXCLUDED.dtrange,
+                edtrange=EXCLUDED.edtrange,
+                spatial=EXCLUDED.spatial,
+                last_updated=EXCLUDED.last_updated
+    ;
+
+    SELECT
+        constraint_dtrange, constraint_edtrange, pv.collection
+        INTO cdtrange, cedtrange, collection
+    FROM partitions_view pv WHERE partition = _partition;
+
+    RAISE NOTICE 'Checking if we need to modify constraints...';
+    RAISE NOTICE 'cdtrange: % dtrange: % cedtrange: % edtrange: %',cdtrange, dtrange, cedtrange, edtrange;
+    IF
+        (cdtrange IS DISTINCT FROM dtrange OR edtrange IS DISTINCT FROM cedtrange)
+        AND NOT istrigger
+    THEN
+        RAISE NOTICE 'Modifying Constraints';
+        RAISE NOTICE 'Existing % %', cdtrange, cedtrange;
+        RAISE NOTICE 'New      % %', dtrange, edtrange;
+        PERFORM drop_table_constraints(_partition);
+        PERFORM create_table_constraints(_partition, dtrange, edtrange);
+    END IF;
+    REFRESH MATERIALIZED VIEW partitions;
+    REFRESH MATERIALIZED VIEW partition_steps;
+    RAISE NOTICE 'Checking if we need to update collection extents.';
+    IF get_setting_bool('update_collection_extent') THEN
+        RAISE NOTICE 'updating collection extent for %', collection;
+        PERFORM run_or_queue(format($q$
+            UPDATE collections
+            SET content = jsonb_set_lax(
+                content,
+                '{extent}'::text[],
+                collection_extent(%L, FALSE),
+                true,
+                'use_json_null'
+            ) WHERE id=%L
+            ;
+        $q$, collection, collection));
+    ELSE
+        RAISE NOTICE 'Not updating collection extent for %', collection;
+    END IF;
+
+END;
+$$ LANGUAGE PLPGSQL STRICT SECURITY DEFINER;
+
+
+CREATE OR REPLACE FUNCTION partition_name( IN collection text, IN dt timestamptz, OUT partition_name text, OUT partition_range tstzrange) AS $$
+DECLARE
+    c RECORD;
+    parent_name text;
+BEGIN
+    SELECT * INTO c FROM pgstac.collections WHERE id=collection;
+    IF NOT FOUND THEN
+        RAISE EXCEPTION 'Collection % does not exist', collection USING ERRCODE = 'foreign_key_violation', HINT = 'Make sure collection exists before adding items';
+    END IF;
+    parent_name := format('_items_%s', c.key);
+
+
+    IF c.partition_trunc = 'year' THEN
+        partition_name := format('%s_%s', parent_name, to_char(dt,'YYYY'));
+    ELSIF c.partition_trunc = 'month' THEN
+        partition_name := format('%s_%s', parent_name, to_char(dt,'YYYYMM'));
+    ELSE
+        partition_name := parent_name;
+        partition_range := tstzrange('-infinity'::timestamptz, 'infinity'::timestamptz, '[]');
+    END IF;
+    IF partition_range IS NULL THEN
+        partition_range := tstzrange(
+            date_trunc(c.partition_trunc::text, dt),
+            date_trunc(c.partition_trunc::text, dt) + concat('1 ', c.partition_trunc)::interval
+        );
+    END IF;
+    RETURN;
+
+END;
+$$ LANGUAGE PLPGSQL STABLE;
+
+
+CREATE OR REPLACE FUNCTION drop_table_constraints(t text) RETURNS text AS $$
+DECLARE
+    q text;
+BEGIN
+    IF NOT EXISTS (SELECT 1 FROM partitions_view WHERE partition=t) THEN
+        RETURN NULL;
+    END IF;
+    FOR q IN SELECT FORMAT(
+        $q$
+            ALTER TABLE %I DROP CONSTRAINT IF EXISTS %I;
+        $q$,
+        t,
+        conname
+    ) FROM pg_constraint
+        WHERE conrelid=t::regclass::oid AND contype='c'
+    LOOP
+        EXECUTE q;
+    END LOOP;
+    RETURN t;
+END;
+$$ LANGUAGE PLPGSQL SECURITY DEFINER;
+
+CREATE OR REPLACE FUNCTION create_table_constraints(t text, _dtrange tstzrange, _edtrange tstzrange) RETURNS text AS $$
+DECLARE
+    q text;
+BEGIN
+    IF NOT EXISTS (SELECT 1 FROM partitions_view WHERE partition=t) THEN
+        RETURN NULL;
+    END IF;
+    RAISE NOTICE 'Creating Table Constraints for % % %', t, _dtrange, _edtrange;
+    IF _dtrange = 'empty' AND _edtrange = 'empty' THEN
+        q :=format(
+            $q$
+                DO $block$
+                BEGIN
+                    ALTER TABLE %I DROP CONSTRAINT IF EXISTS %I;
+                    ALTER TABLE %I
+                        ADD CONSTRAINT %I
+                            CHECK (((datetime IS NULL) AND (end_datetime IS NULL))) NOT VALID
+                    ;
+                    ALTER TABLE %I
+                        VALIDATE CONSTRAINT %I
+                    ;
+
+
+
+                EXCEPTION WHEN others THEN
+                    RAISE WARNING '%%, Issue Altering Constraints. Please run update_partition_stats(%I)', SQLERRM USING ERRCODE = SQLSTATE;
+                END;
+                $block$;
+            $q$,
+            t,
+            format('%s_dt', t),
+            t,
+            format('%s_dt', t),
+            t,
+            format('%s_dt', t),
+            t
+        );
+    ELSE
+        q :=format(
+            $q$
+                DO $block$
+                BEGIN
+
+                    ALTER TABLE %I DROP CONSTRAINT IF EXISTS %I;
+                    ALTER TABLE %I
+                        ADD CONSTRAINT %I
+                            CHECK (
+                                (datetime >= %L)
+                                AND (datetime <= %L)
+                                AND (end_datetime >= %L)
+                                AND (end_datetime <= %L)
+                            ) NOT VALID
+                    ;
+                    ALTER TABLE %I
+                        VALIDATE CONSTRAINT %I
+                    ;
+
+
+
+                EXCEPTION WHEN others THEN
+                    RAISE WARNING '%%, Issue Altering Constraints. Please run update_partition_stats(%I)', SQLERRM USING ERRCODE = SQLSTATE;
+                END;
+                $block$;
+            $q$,
+            t,
+            format('%s_dt', t),
+            t,
+            format('%s_dt', t),
+            lower(_dtrange),
+            upper(_dtrange),
+            lower(_edtrange),
+            upper(_edtrange),
+            t,
+            format('%s_dt', t),
+            t
+        );
+    END IF;
+    PERFORM run_or_queue(q);
+    RETURN t;
+END;
+$$ LANGUAGE PLPGSQL SECURITY DEFINER;
+
+
+CREATE OR REPLACE FUNCTION check_partition(
+    _collection text,
+    _dtrange tstzrange,
+    _edtrange tstzrange
+) RETURNS text AS $$
+DECLARE
+    c RECORD;
+    pm RECORD;
+    _partition_name text;
+    _partition_dtrange tstzrange;
+    _constraint_dtrange tstzrange;
+    _constraint_edtrange tstzrange;
+    q text;
+    deferrable_q text;
+    err_context text;
+BEGIN
+    SELECT * INTO c FROM pgstac.collections WHERE id=_collection;
+    IF NOT FOUND THEN
+        RAISE EXCEPTION 'Collection % does not exist', _collection USING ERRCODE = 'foreign_key_violation', HINT = 'Make sure collection exists before adding items';
+    END IF;
+
+    IF c.partition_trunc IS NOT NULL THEN
+        _partition_dtrange := tstzrange(
+            date_trunc(c.partition_trunc, lower(_dtrange)),
+            date_trunc(c.partition_trunc, lower(_dtrange)) + (concat('1 ', c.partition_trunc))::interval,
+            '[)'
+        );
+    ELSE
+        _partition_dtrange :=  '[-infinity, infinity]'::tstzrange;
+    END IF;
+
+    IF NOT _partition_dtrange @> _dtrange THEN
+        RAISE EXCEPTION 'dtrange % is greater than the partition size % for collection %', _dtrange, c.partition_trunc, _collection;
+    END IF;
+
+
+    IF c.partition_trunc = 'year' THEN
+        _partition_name := format('_items_%s_%s', c.key, to_char(lower(_partition_dtrange),'YYYY'));
+    ELSIF c.partition_trunc = 'month' THEN
+        _partition_name := format('_items_%s_%s', c.key, to_char(lower(_partition_dtrange),'YYYYMM'));
+    ELSE
+        _partition_name := format('_items_%s', c.key);
+    END IF;
+
+    SELECT * INTO pm FROM partition_sys_meta WHERE collection=_collection AND partition_dtrange @> _dtrange;
+    IF FOUND THEN
+        RAISE NOTICE '% % %', _edtrange, _dtrange, pm;
+        _constraint_edtrange :=
+            tstzrange(
+                least(
+                    lower(_edtrange),
+                    nullif(lower(pm.constraint_edtrange), '-infinity')
+                ),
+                greatest(
+                    upper(_edtrange),
+                    nullif(upper(pm.constraint_edtrange), 'infinity')
+                ),
+                '[]'
+            );
+        _constraint_dtrange :=
+            tstzrange(
+                least(
+                    lower(_dtrange),
+                    nullif(lower(pm.constraint_dtrange), '-infinity')
+                ),
+                greatest(
+                    upper(_dtrange),
+                    nullif(upper(pm.constraint_dtrange), 'infinity')
+                ),
+                '[]'
+            );
+
+        IF pm.constraint_edtrange @> _edtrange AND pm.constraint_dtrange @> _dtrange THEN
+            RETURN pm.partition;
+        ELSE
+            PERFORM drop_table_constraints(_partition_name);
+        END IF;
+    ELSE
+        _constraint_edtrange := _edtrange;
+        _constraint_dtrange := _dtrange;
+    END IF;
+    RAISE NOTICE 'EXISTING CONSTRAINTS % %, NEW % %', pm.constraint_dtrange, pm.constraint_edtrange, _constraint_dtrange, _constraint_edtrange;
+    RAISE NOTICE 'Creating partition % %', _partition_name, _partition_dtrange;
+    IF c.partition_trunc IS NULL THEN
+        q := format(
+            $q$
+                CREATE TABLE IF NOT EXISTS %I partition OF items FOR VALUES IN (%L);
+                CREATE UNIQUE INDEX IF NOT EXISTS %I ON %I (id);
+                GRANT ALL ON %I to pgstac_ingest;
+            $q$,
+            _partition_name,
+            _collection,
+            concat(_partition_name,'_pk'),
+            _partition_name,
+            _partition_name
+        );
+    ELSE
+        q := format(
+            $q$
+                CREATE TABLE IF NOT EXISTS %I partition OF items FOR VALUES IN (%L) PARTITION BY RANGE (datetime);
+                CREATE TABLE IF NOT EXISTS %I partition OF %I FOR VALUES FROM (%L) TO (%L);
+                CREATE UNIQUE INDEX IF NOT EXISTS %I ON %I (id);
+                GRANT ALL ON %I TO pgstac_ingest;
+            $q$,
+            format('_items_%s', c.key),
+            _collection,
+            _partition_name,
+            format('_items_%s', c.key),
+            lower(_partition_dtrange),
+            upper(_partition_dtrange),
+            format('%s_pk', _partition_name),
+            _partition_name,
+            _partition_name
+        );
+    END IF;
+
+    BEGIN
+        EXECUTE q;
+    EXCEPTION
+        WHEN duplicate_table THEN
+            RAISE NOTICE 'Partition % already exists.', _partition_name;
+        WHEN others THEN
+            GET STACKED DIAGNOSTICS err_context = PG_EXCEPTION_CONTEXT;
+            RAISE INFO 'Error Name:%',SQLERRM;
+            RAISE INFO 'Error State:%', SQLSTATE;
+            RAISE INFO 'Error Context:%', err_context;
+    END;
+    PERFORM maintain_partitions(_partition_name);
+    PERFORM update_partition_stats_q(_partition_name, true);
+    REFRESH MATERIALIZED VIEW partitions;
+    REFRESH MATERIALIZED VIEW partition_steps;
+    RETURN _partition_name;
+END;
+$$ LANGUAGE PLPGSQL SECURITY DEFINER;
+
+
+CREATE OR REPLACE FUNCTION repartition(_collection text, _partition_trunc text, triggered boolean DEFAULT FALSE) RETURNS text AS $$
+DECLARE
+    c RECORD;
+    q text;
+    from_trunc text;
+BEGIN
+    SELECT * INTO c FROM pgstac.collections WHERE id=_collection;
+    IF NOT FOUND THEN
+        RAISE EXCEPTION 'Collection % does not exist', _collection USING ERRCODE = 'foreign_key_violation', HINT = 'Make sure collection exists before adding items';
+    END IF;
+    IF triggered THEN
+        RAISE NOTICE 'Converting % to % partitioning via Trigger', _collection, _partition_trunc;
+    ELSE
+        RAISE NOTICE 'Converting % from using % to % partitioning', _collection, c.partition_trunc, _partition_trunc;
+        IF c.partition_trunc IS NOT DISTINCT FROM _partition_trunc THEN
+            RAISE NOTICE 'Collection % already set to use partition by %', _collection, _partition_trunc;
+            RETURN _collection;
+        END IF;
+    END IF;
+
+    IF EXISTS (SELECT 1 FROM partitions_view WHERE collection=_collection LIMIT 1) THEN
+        EXECUTE format(
+            $q$
+                CREATE TEMP TABLE changepartitionstaging ON COMMIT DROP AS SELECT * FROM %I;
+                DROP TABLE IF EXISTS %I CASCADE;
+                WITH p AS (
+                    SELECT
+                        collection,
+                        CASE
+                            WHEN %L IS NULL THEN '-infinity'::timestamptz
+                            ELSE date_trunc(%L, datetime)
+                        END as d,
+                        tstzrange(min(datetime),max(datetime),'[]') as dtrange,
+                        tstzrange(min(end_datetime),max(end_datetime),'[]') as edtrange
+                    FROM changepartitionstaging
+                    GROUP BY 1,2
+                ) SELECT check_partition(collection, dtrange, edtrange) FROM p;
+                INSERT INTO items SELECT * FROM changepartitionstaging;
+                DROP TABLE changepartitionstaging;
+            $q$,
+            concat('_items_', c.key),
+            concat('_items_', c.key),
+            c.partition_trunc,
+            c.partition_trunc
+        );
+    END IF;
+    RETURN _collection;
+END;
+$$ LANGUAGE PLPGSQL SECURITY DEFINER;
+
+CREATE OR REPLACE FUNCTION collections_trigger_func() RETURNS TRIGGER AS $$
+DECLARE
+    q text;
+    partition_name text := format('_items_%s', NEW.key);
+    partition_exists boolean := false;
+    partition_empty boolean := true;
+    err_context text;
+    loadtemp boolean := FALSE;
+BEGIN
+    RAISE NOTICE 'Collection Trigger. % %', NEW.id, NEW.key;
+    IF TG_OP = 'UPDATE' AND NEW.partition_trunc IS DISTINCT FROM OLD.partition_trunc THEN
+        PERFORM repartition(NEW.id, NEW.partition_trunc, TRUE);
+    END IF;
+    RETURN NEW;
+END;
+$$ LANGUAGE PLPGSQL;
+
+
+CREATE TRIGGER collections_trigger AFTER
+INSERT
+OR
+UPDATE ON collections
+FOR EACH ROW EXECUTE FUNCTION collections_trigger_func();
+
+CREATE OR REPLACE FUNCTION chunker(
+    IN _where text,
+    OUT s timestamptz,
+    OUT e timestamptz
+) RETURNS SETOF RECORD AS $$
+DECLARE
+    explain jsonb;
+BEGIN
+    IF _where IS NULL THEN
+        _where := ' TRUE ';
+    END IF;
+    EXECUTE format('EXPLAIN (format json) SELECT 1 FROM items WHERE %s;', _where)
+    INTO explain;
+    RAISE DEBUG 'EXPLAIN: %', explain;
+
+    RETURN QUERY
+    WITH t AS (
+        SELECT j->>0 as p FROM
+            jsonb_path_query(
+                explain,
+                'strict $.**."Relation Name" ? (@ != null)'
+            ) j
+    ),
+    parts AS (
+        SELECT sdate, edate FROM t JOIN partition_steps ON (t.p = name)
+    ),
+    times AS (
+        SELECT sdate FROM parts
+        UNION
+        SELECT edate FROM parts
+    ),
+    uniq AS (
+        SELECT DISTINCT sdate FROM times ORDER BY sdate
+    ),
+    last AS (
+    SELECT sdate, lead(sdate, 1) over () as edate FROM uniq
+    )
+    SELECT sdate, edate FROM last WHERE edate IS NOT NULL;
+END;
+$$ LANGUAGE PLPGSQL;
+
+CREATE OR REPLACE FUNCTION partition_queries(
+    IN _where text DEFAULT 'TRUE',
+    IN _orderby text DEFAULT 'datetime DESC, id DESC',
+    IN partitions text[] DEFAULT NULL
+) RETURNS SETOF text AS $$
+DECLARE
+    query text;
+    sdate timestamptz;
+    edate timestamptz;
+BEGIN
+IF _where IS NULL OR trim(_where) = '' THEN
+    _where = ' TRUE ';
+END IF;
+RAISE NOTICE 'Getting chunks for % %', _where, _orderby;
+IF _orderby ILIKE 'datetime d%' THEN
+    FOR sdate, edate IN SELECT * FROM chunker(_where) ORDER BY 1 DESC LOOP
+        RETURN NEXT format($q$
+            SELECT * FROM items
+            WHERE
+            datetime >= %L AND datetime < %L
+            AND (%s)
+            ORDER BY %s
+            $q$,
+            sdate,
+            edate,
+            _where,
+            _orderby
+        );
+    END LOOP;
+ELSIF _orderby ILIKE 'datetime a%' THEN
+    FOR sdate, edate IN SELECT * FROM chunker(_where) ORDER BY 1 ASC LOOP
+        RETURN NEXT format($q$
+            SELECT * FROM items
+            WHERE
+            datetime >= %L AND datetime < %L
+            AND (%s)
+            ORDER BY %s
+            $q$,
+            sdate,
+            edate,
+            _where,
+            _orderby
+        );
+    END LOOP;
+ELSE
+    query := format($q$
+        SELECT * FROM items
+        WHERE %s
+        ORDER BY %s
+    $q$, _where, _orderby
+    );
+
+    RETURN NEXT query;
+    RETURN;
+END IF;
+
+RETURN;
+END;
+$$ LANGUAGE PLPGSQL SET SEARCH_PATH TO pgstac,public;
+
+CREATE OR REPLACE FUNCTION partition_query_view(
+    IN _where text DEFAULT 'TRUE',
+    IN _orderby text DEFAULT 'datetime DESC, id DESC',
+    IN _limit int DEFAULT 10
+) RETURNS text AS $$
+    WITH p AS (
+        SELECT * FROM partition_queries(_where, _orderby) p
+    )
+    SELECT
+        CASE WHEN EXISTS (SELECT 1 FROM p) THEN
+            (SELECT format($q$
+                SELECT * FROM (
+                    %s
+                ) total LIMIT %s
+                $q$,
+                string_agg(
+                    format($q$ SELECT * FROM ( %s ) AS sub $q$, p),
+                    '
+                    UNION ALL
+                    '
+                ),
+                _limit
+            ))
+        ELSE NULL
+        END FROM p;
+$$ LANGUAGE SQL IMMUTABLE;
+
+
+CREATE OR REPLACE FUNCTION q_to_tsquery (jinput jsonb)
+    RETURNS tsquery
+    AS $$
+DECLARE
+    input text;
+    processed_text text;
+    temp_text text;
+    quote_array text[];
+    placeholder text := '@QUOTE@';
+BEGIN
+    IF jsonb_typeof(jinput) = 'string' THEN
+        input := jinput->>0;
+    ELSIF jsonb_typeof(jinput) = 'array' THEN
+        input := array_to_string(
+            array(select jsonb_array_elements_text(jinput)),
+            ' OR '
+        );
+    ELSE
+        RAISE EXCEPTION 'Input must be a string or an array of strings.';
+    END IF;
+    -- Extract all quoted phrases and store in array
+    quote_array := regexp_matches(input, '"[^"]*"', 'g');
+
+    -- Replace each quoted part with a unique placeholder if there are any quoted phrases
+    IF array_length(quote_array, 1) IS NOT NULL THEN
+        processed_text := input;
+        FOR i IN array_lower(quote_array, 1) .. array_upper(quote_array, 1) LOOP
+            processed_text := replace(processed_text, quote_array[i], placeholder || i || placeholder);
+        END LOOP;
+    ELSE
+        processed_text := input;
+    END IF;
+
+    -- Replace non-quoted text using regular expressions
+
+    -- , -> |
+    processed_text := regexp_replace(processed_text, ',(?=(?:[^"]*"[^"]*")*[^"]*$)', ' | ', 'g');
+
+    -- and -> &
+    processed_text := regexp_replace(processed_text, '\s+AND\s+', ' & ', 'gi');
+
+    -- or -> |
+    processed_text := regexp_replace(processed_text, '\s+OR\s+', ' | ', 'gi');
+
+    -- + ->
+    processed_text := regexp_replace(processed_text, '^\s*\+([a-zA-Z0-9_]+)', '\1', 'g'); -- +term at start
+    processed_text := regexp_replace(processed_text, '\s*\+([a-zA-Z0-9_]+)', ' & \1', 'g'); -- +term elsewhere
+
+    -- - ->  !
+    processed_text := regexp_replace(processed_text, '^\s*\-([a-zA-Z0-9_]+)', '! \1', 'g'); -- -term at start
+    processed_text := regexp_replace(processed_text, '\s*\-([a-zA-Z0-9_]+)', ' & ! \1', 'g'); -- -term elsewhere
+
+    -- terms separated with spaces are assumed to represent adjacent terms. loop through these
+    -- occurrences and replace them with the adjacency operator (<->)
+    LOOP
+        temp_text := regexp_replace(processed_text, '([a-zA-Z0-9_]+)\s+([a-zA-Z0-9_]+)(?!\s*[&|<>])', '\1 <-> \2', 'g');
+        IF temp_text = processed_text THEN
+            EXIT; -- No more replacements were made
+        END IF;
+        processed_text := temp_text;
+    END LOOP;
+
+
+    -- Replace placeholders back with quoted phrases if there were any
+    IF array_length(quote_array, 1) IS NOT NULL THEN
+        FOR i IN array_lower(quote_array, 1) .. array_upper(quote_array, 1) LOOP
+            processed_text := replace(processed_text, placeholder || i || placeholder, '''' || substring(quote_array[i] from 2 for length(quote_array[i]) - 2) || '''');
+        END LOOP;
+    END IF;
+
+    -- Print processed_text to the console for debugging purposes
+    RAISE NOTICE 'processed_text: %', processed_text;
+
+    RETURN to_tsquery('english', processed_text);
+END;
+$$
+LANGUAGE plpgsql;
+
+
+CREATE OR REPLACE FUNCTION stac_search_to_where(j jsonb) RETURNS text AS $$
+DECLARE
+    where_segments text[];
+    _where text;
+    dtrange tstzrange;
+    collections text[];
+    geom geometry;
+    sdate timestamptz;
+    edate timestamptz;
+    filterlang text;
+    filter jsonb := j->'filter';
+    ft_query tsquery;
+BEGIN
+    IF j ? 'ids' THEN
+        where_segments := where_segments || format('id = ANY (%L) ', to_text_array(j->'ids'));
+    END IF;
+
+    IF j ? 'collections' THEN
+        collections := to_text_array(j->'collections');
+        where_segments := where_segments || format('collection = ANY (%L) ', collections);
+    END IF;
+
+    IF j ? 'datetime' THEN
+        dtrange := parse_dtrange(j->'datetime');
+        sdate := lower(dtrange);
+        edate := upper(dtrange);
+
+        where_segments := where_segments || format(' datetime <= %L::timestamptz AND end_datetime >= %L::timestamptz ',
+            edate,
+            sdate
+        );
+    END IF;
+
+    IF j ? 'q' THEN
+        ft_query := q_to_tsquery(j->'q');
+        where_segments := where_segments || format(
+            $quote$
+            (
+                to_tsvector('english', content->'properties'->>'description') ||
+                to_tsvector('english', coalesce(content->'properties'->>'title', '')) ||
+                to_tsvector('english', coalesce(content->'properties'->>'keywords', ''))
+            ) @@ %L
+            $quote$,
+            ft_query
+        );
+    END IF;
+
+    geom := stac_geom(j);
+    IF geom IS NOT NULL THEN
+        where_segments := where_segments || format('st_intersects(geometry, %L)',geom);
+    END IF;
+
+    filterlang := COALESCE(
+        j->>'filter-lang',
+        get_setting('default_filter_lang', j->'conf')
+    );
+    IF NOT filter @? '$.**.op' THEN
+        filterlang := 'cql-json';
+    END IF;
+
+    IF filterlang NOT IN ('cql-json','cql2-json') AND j ? 'filter' THEN
+        RAISE EXCEPTION '% is not a supported filter-lang. Please use cql-json or cql2-json.', filterlang;
+    END IF;
+
+    IF j ? 'query' AND j ? 'filter' THEN
+        RAISE EXCEPTION 'Can only use either query or filter at one time.';
+    END IF;
+
+    IF j ? 'query' THEN
+        filter := query_to_cql2(j->'query');
+    ELSIF filterlang = 'cql-json' THEN
+        filter := cql1_to_cql2(filter);
+    END IF;
+    RAISE NOTICE 'FILTER: %', filter;
+    where_segments := where_segments || cql2_query(filter);
+    IF cardinality(where_segments) < 1 THEN
+        RETURN ' TRUE ';
+    END IF;
+
+    _where := array_to_string(array_remove(where_segments, NULL), ' AND ');
+
+    IF _where IS NULL OR BTRIM(_where) = '' THEN
+        RETURN ' TRUE ';
+    END IF;
+    RETURN _where;
+
+END;
+$$ LANGUAGE PLPGSQL STABLE;
+
+
+CREATE OR REPLACE FUNCTION parse_sort_dir(_dir text, reverse boolean default false) RETURNS text AS $$
+    WITH t AS (
+        SELECT COALESCE(upper(_dir), 'ASC') as d
+    ) SELECT
+        CASE
+            WHEN NOT reverse THEN d
+            WHEN d = 'ASC' THEN 'DESC'
+            WHEN d = 'DESC' THEN 'ASC'
+        END
+    FROM t;
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION sort_dir_to_op(_dir text, prev boolean default false) RETURNS text AS $$
+    WITH t AS (
+        SELECT COALESCE(upper(_dir), 'ASC') as d
+    ) SELECT
+        CASE
+            WHEN d = 'ASC' AND prev THEN '<='
+            WHEN d = 'DESC' AND prev THEN '>='
+            WHEN d = 'ASC' THEN '>='
+            WHEN d = 'DESC' THEN '<='
+        END
+    FROM t;
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+
+CREATE OR REPLACE FUNCTION sort_sqlorderby(
+    _search jsonb DEFAULT NULL,
+    reverse boolean DEFAULT FALSE
+) RETURNS text AS $$
+    WITH sortby AS (
+        SELECT coalesce(_search->'sortby','[{"field":"datetime", "direction":"desc"}]') as sort
+    ), withid AS (
+        SELECT CASE
+            WHEN sort @? '$[*] ? (@.field == "id")' THEN sort
+            ELSE sort || '[{"field":"id", "direction":"desc"}]'::jsonb
+            END as sort
+        FROM sortby
+    ), withid_rows AS (
+        SELECT jsonb_array_elements(sort) as value FROM withid
+    ),sorts AS (
+        SELECT
+            coalesce(
+                (queryable(value->>'field')).expression
+            ) as key,
+            parse_sort_dir(value->>'direction', reverse) as dir
+        FROM withid_rows
+    )
+    SELECT array_to_string(
+        array_agg(concat(key, ' ', dir)),
+        ', '
+    ) FROM sorts;
+$$ LANGUAGE SQL;
+
+CREATE OR REPLACE FUNCTION get_sort_dir(sort_item jsonb) RETURNS text AS $$
+    SELECT CASE WHEN sort_item->>'direction' ILIKE 'desc%' THEN 'DESC' ELSE 'ASC' END;
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+
+CREATE OR REPLACE FUNCTION  get_token_val_str(
+    _field text,
+    _item items
+) RETURNS text AS $$
+DECLARE
+    q text;
+    literal text;
+BEGIN
+    q := format($q$ SELECT quote_literal(%s) FROM (SELECT $1.*) as r;$q$, _field);
+    EXECUTE q INTO literal USING _item;
+    RETURN literal;
+END;
+$$ LANGUAGE PLPGSQL;
+
+
+
+CREATE OR REPLACE FUNCTION get_token_record(IN _token text, OUT prev BOOLEAN, OUT item items) RETURNS RECORD AS $$
+DECLARE
+    _itemid text := _token;
+    _collectionid text;
+BEGIN
+    IF _token IS NULL THEN
+        RETURN;
+    END IF;
+    RAISE NOTICE 'Looking for token: %', _token;
+    prev := FALSE;
+    IF _token ILIKE 'prev:%' THEN
+        _itemid := replace(_token, 'prev:','');
+        prev := TRUE;
+    ELSIF _token ILIKE 'next:%' THEN
+        _itemid := replace(_token, 'next:', '');
+    END IF;
+    SELECT id INTO _collectionid FROM collections WHERE _itemid LIKE concat(id,':%');
+    IF FOUND THEN
+        _itemid := replace(_itemid, concat(_collectionid,':'), '');
+        SELECT * INTO item FROM items WHERE id=_itemid AND collection=_collectionid;
+    ELSE
+        SELECT * INTO item FROM items WHERE id=_itemid;
+    END IF;
+    IF item IS NULL THEN
+        RAISE EXCEPTION 'Could not find item using token: % item: % collection: %', _token, _itemid, _collectionid;
+    END IF;
+    RETURN;
+END;
+$$ LANGUAGE PLPGSQL STABLE STRICT;
+
+
+CREATE OR REPLACE FUNCTION get_token_filter(
+    _sortby jsonb DEFAULT '[{"field":"datetime","direction":"desc"}]'::jsonb,
+    token_item items DEFAULT NULL,
+    prev boolean DEFAULT FALSE,
+    inclusive boolean DEFAULT FALSE
+) RETURNS text AS $$
+DECLARE
+    ltop text := '<';
+    gtop text := '>';
+    dir text;
+    sort record;
+    orfilter text := '';
+    orfilters text[] := '{}'::text[];
+    andfilters text[] := '{}'::text[];
+    output text;
+    token_where text;
+BEGIN
+    IF _sortby IS NULL OR _sortby = '[]'::jsonb THEN
+        _sortby := '[{"field":"datetime","direction":"desc"}]'::jsonb;
+    END IF;
+    _sortby := _sortby || jsonb_build_object('field','id','direction',_sortby->0->>'direction');
+    RAISE NOTICE 'Getting Token Filter. % %', _sortby, token_item;
+    IF inclusive THEN
+        orfilters := orfilters || format('( id=%L AND collection=%L )' , token_item.id, token_item.collection);
+    END IF;
+
+    FOR sort IN
+        WITH s1 AS (
+            SELECT
+                _row,
+                (queryable(value->>'field')).expression as _field,
+                (value->>'field' = 'id') as _isid,
+                get_sort_dir(value) as _dir
+            FROM jsonb_array_elements(_sortby)
+            WITH ORDINALITY AS t(value, _row)
+        )
+        SELECT
+            _row,
+            _field,
+            _dir,
+            get_token_val_str(_field, token_item) as _val
+        FROM s1
+        WHERE _row <= (SELECT min(_row) FROM s1 WHERE _isid)
+    LOOP
+        orfilter := NULL;
+        RAISE NOTICE 'SORT: %', sort;
+        IF sort._val IS NOT NULL AND  ((prev AND sort._dir = 'ASC') OR (NOT prev AND sort._dir = 'DESC')) THEN
+            orfilter := format($f$(
+                (%s %s %s) OR (%s IS NULL)
+            )$f$,
+            sort._field,
+            ltop,
+            sort._val,
+            sort._val
+            );
+        ELSIF sort._val IS NULL AND  ((prev AND sort._dir = 'ASC') OR (NOT prev AND sort._dir = 'DESC')) THEN
+            RAISE NOTICE '< but null';
+            orfilter := format('%s IS NOT NULL', sort._field);
+        ELSIF sort._val IS NULL THEN
+            RAISE NOTICE '> but null';
+        ELSE
+            orfilter := format($f$(
+                (%s %s %s) OR (%s IS NULL)
+            )$f$,
+            sort._field,
+            gtop,
+            sort._val,
+            sort._field
+            );
+        END IF;
+        RAISE NOTICE 'ORFILTER: %', orfilter;
+
+        IF orfilter IS NOT NULL THEN
+            IF sort._row = 1 THEN
+                orfilters := orfilters || orfilter;
+            ELSE
+                orfilters := orfilters || format('(%s AND %s)', array_to_string(andfilters, ' AND '), orfilter);
+            END IF;
+        END IF;
+        IF sort._val IS NOT NULL THEN
+            andfilters := andfilters || format('%s = %s', sort._field, sort._val);
+        ELSE
+            andfilters := andfilters || format('%s IS NULL', sort._field);
+        END IF;
+    END LOOP;
+
+    output := array_to_string(orfilters, ' OR ');
+
+    token_where := concat('(',coalesce(output,'true'),')');
+    IF trim(token_where) = '' THEN
+        token_where := NULL;
+    END IF;
+    RAISE NOTICE 'TOKEN_WHERE: %',token_where;
+    RETURN token_where;
+    END;
+$$ LANGUAGE PLPGSQL SET transform_null_equals TO TRUE
+;
+
+CREATE OR REPLACE FUNCTION search_hash(jsonb, jsonb) RETURNS text AS $$
+    SELECT md5(concat(($1 - '{token,limit,context,includes,excludes}'::text[])::text,$2::text));
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+DROP FUNCTION IF EXISTS search_tohash(jsonb);
+
+CREATE TABLE IF NOT EXISTS searches(
+    hash text GENERATED ALWAYS AS (search_hash(search, metadata)) STORED PRIMARY KEY,
+    search jsonb NOT NULL,
+    _where text,
+    orderby text,
+    lastused timestamptz DEFAULT now(),
+    usecount bigint DEFAULT 0,
+    metadata jsonb DEFAULT '{}'::jsonb NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS search_wheres(
+    id bigint generated always as identity primary key,
+    _where text NOT NULL,
+    lastused timestamptz DEFAULT now(),
+    usecount bigint DEFAULT 0,
+    statslastupdated timestamptz,
+    estimated_count bigint,
+    estimated_cost float,
+    time_to_estimate float,
+    total_count bigint,
+    time_to_count float,
+    partitions text[]
+);
+
+CREATE INDEX IF NOT EXISTS search_wheres_partitions ON search_wheres USING GIN (partitions);
+CREATE UNIQUE INDEX IF NOT EXISTS search_wheres_where ON search_wheres ((md5(_where)));
+
+CREATE OR REPLACE FUNCTION where_stats(
+    inwhere text,
+    updatestats boolean default false,
+    conf jsonb default null
+) RETURNS search_wheres AS $$
+DECLARE
+    t timestamptz;
+    i interval;
+    explain_json jsonb;
+    partitions text[];
+    sw search_wheres%ROWTYPE;
+    inwhere_hash text := md5(inwhere);
+    _context text := lower(context(conf));
+    _stats_ttl interval := context_stats_ttl(conf);
+    _estimated_cost_threshold float := context_estimated_cost(conf);
+    _estimated_count_threshold int := context_estimated_count(conf);
+    ro bool := pgstac.readonly(conf);
+BEGIN
+    -- If updatestats is true then set ttl to 0
+    IF updatestats THEN
+        RAISE DEBUG 'Updatestats set to TRUE, setting TTL to 0';
+        _stats_ttl := '0'::interval;
+    END IF;
+
+    -- If we don't need to calculate context, just return
+    IF _context = 'off' THEN
+        sw._where = inwhere;
+        RETURN sw;
+    END IF;
+
+    -- Get any stats that we have.
+    IF NOT ro THEN
+        -- If there is a lock where another process is
+        -- updating the stats, wait so that we don't end up calculating a bunch of times.
+        SELECT * INTO sw FROM search_wheres WHERE md5(_where)=inwhere_hash FOR UPDATE;
+    ELSE
+        SELECT * INTO sw FROM search_wheres WHERE md5(_where)=inwhere_hash;
+    END IF;
+
+    -- If there is a cached row, figure out if we need to update
+    IF
+        sw IS NOT NULL
+        AND sw.statslastupdated IS NOT NULL
+        AND sw.total_count IS NOT NULL
+        AND now() - sw.statslastupdated <= _stats_ttl
+    THEN
+        -- we have a cached row with data that is within our ttl
+        RAISE DEBUG 'Stats present in table and lastupdated within ttl: %', sw;
+        IF NOT ro THEN
+            RAISE DEBUG 'Updating search_wheres only bumping lastused and usecount';
+            UPDATE search_wheres SET
+                lastused = now(),
+                usecount = search_wheres.usecount + 1
+            WHERE md5(_where) = inwhere_hash
+            RETURNING * INTO sw;
+        END IF;
+        RAISE DEBUG 'Returning cached counts. %', sw;
+        RETURN sw;
+    END IF;
+
+    -- Calculate estimated cost and rows
+    -- Use explain to get estimated count/cost
+    IF sw.estimated_count IS NULL OR sw.estimated_cost IS NULL THEN
+        RAISE DEBUG 'Calculating estimated stats';
+        t := clock_timestamp();
+        EXECUTE format('EXPLAIN (format json) SELECT 1 FROM items WHERE %s', inwhere)
+            INTO explain_json;
+        RAISE DEBUG 'Time for just the explain: %', clock_timestamp() - t;
+        i := clock_timestamp() - t;
+
+        sw.estimated_count := explain_json->0->'Plan'->'Plan Rows';
+        sw.estimated_cost := explain_json->0->'Plan'->'Total Cost';
+        sw.time_to_estimate := extract(epoch from i);
+    END IF;
+
+    RAISE DEBUG 'ESTIMATED_COUNT: %, THRESHOLD %', sw.estimated_count, _estimated_count_threshold;
+    RAISE DEBUG 'ESTIMATED_COST: %, THRESHOLD %', sw.estimated_cost, _estimated_cost_threshold;
+
+    -- If context is set to auto and the costs are within the threshold return the estimated costs
+    IF
+        _context = 'auto'
+        AND sw.estimated_count >= _estimated_count_threshold
+        AND sw.estimated_cost >= _estimated_cost_threshold
+    THEN
+        IF NOT ro THEN
+            INSERT INTO search_wheres (
+                _where,
+                lastused,
+                usecount,
+                statslastupdated,
+                estimated_count,
+                estimated_cost,
+                time_to_estimate,
+                total_count,
+                time_to_count
+            ) VALUES (
+                inwhere,
+                now(),
+                1,
+                now(),
+                sw.estimated_count,
+                sw.estimated_cost,
+                sw.time_to_estimate,
+                null,
+                null
+            ) ON CONFLICT ((md5(_where)))
+            DO UPDATE SET
+                lastused = EXCLUDED.lastused,
+                usecount = search_wheres.usecount + 1,
+                statslastupdated = EXCLUDED.statslastupdated,
+                estimated_count = EXCLUDED.estimated_count,
+                estimated_cost = EXCLUDED.estimated_cost,
+                time_to_estimate = EXCLUDED.time_to_estimate,
+                total_count = EXCLUDED.total_count,
+                time_to_count = EXCLUDED.time_to_count
+            RETURNING * INTO sw;
+        END IF;
+        RAISE DEBUG 'Estimates are within thresholds, returning estimates. %', sw;
+        RETURN sw;
+    END IF;
+
+    -- Calculate Actual Count
+    t := clock_timestamp();
+    RAISE NOTICE 'Calculating actual count...';
+    EXECUTE format(
+        'SELECT count(*) FROM items WHERE %s',
+        inwhere
+    ) INTO sw.total_count;
+    i := clock_timestamp() - t;
+    RAISE NOTICE 'Actual Count: % -- %', sw.total_count, i;
+    sw.time_to_count := extract(epoch FROM i);
+
+    IF NOT ro THEN
+        INSERT INTO search_wheres (
+            _where,
+            lastused,
+            usecount,
+            statslastupdated,
+            estimated_count,
+            estimated_cost,
+            time_to_estimate,
+            total_count,
+            time_to_count
+        ) VALUES (
+            inwhere,
+            now(),
+            1,
+            now(),
+            sw.estimated_count,
+            sw.estimated_cost,
+            sw.time_to_estimate,
+            sw.total_count,
+            sw.time_to_count
+        ) ON CONFLICT ((md5(_where)))
+        DO UPDATE SET
+            lastused = EXCLUDED.lastused,
+            usecount = search_wheres.usecount + 1,
+            statslastupdated = EXCLUDED.statslastupdated,
+            estimated_count = EXCLUDED.estimated_count,
+            estimated_cost = EXCLUDED.estimated_cost,
+            time_to_estimate = EXCLUDED.time_to_estimate,
+            total_count = EXCLUDED.total_count,
+            time_to_count = EXCLUDED.time_to_count
+        RETURNING * INTO sw;
+    END IF;
+    RAISE DEBUG 'Returning with actual count. %', sw;
+    RETURN sw;
+END;
+$$ LANGUAGE PLPGSQL SECURITY DEFINER;
+
+
+CREATE OR REPLACE FUNCTION search_query(
+    _search jsonb = '{}'::jsonb,
+    updatestats boolean = false,
+    _metadata jsonb = '{}'::jsonb
+) RETURNS searches AS $$
+DECLARE
+    search searches%ROWTYPE;
+    cached_search searches%ROWTYPE;
+    pexplain jsonb;
+    t timestamptz;
+    i interval;
+    doupdate boolean := FALSE;
+    insertfound boolean := FALSE;
+    ro boolean := pgstac.readonly();
+    found_search text;
+BEGIN
+    RAISE NOTICE 'SEARCH: %', _search;
+    -- Calculate hash, where clause, and order by statement
+    search.search := _search;
+    search.metadata := _metadata;
+    search.hash := search_hash(_search, _metadata);
+    search._where := stac_search_to_where(_search);
+    search.orderby := sort_sqlorderby(_search);
+    search.lastused := now();
+    search.usecount := 1;
+
+    -- If we are in read only mode, directly return search
+    IF ro THEN
+        RETURN search;
+    END IF;
+
+    RAISE NOTICE 'Updating Statistics for search: %s', search;
+    -- Update statistics for times used and and when last used
+    -- If the entry is locked, rather than waiting, skip updating the stats
+    INSERT INTO searches (search, lastused, usecount, metadata)
+        VALUES (search.search, now(), 1, search.metadata)
+        ON CONFLICT DO NOTHING
+        RETURNING * INTO cached_search
+    ;
+
+    IF NOT FOUND OR cached_search IS NULL THEN
+        UPDATE searches SET
+            lastused = now(),
+            usecount = searches.usecount + 1
+        WHERE hash = (
+            SELECT hash FROM searches WHERE hash=search.hash FOR UPDATE SKIP LOCKED
+        )
+        RETURNING * INTO cached_search
+        ;
+    END IF;
+
+    IF cached_search IS NOT NULL THEN
+        cached_search._where = search._where;
+        cached_search.orderby = search.orderby;
+        RETURN cached_search;
+    END IF;
+    RETURN search;
+
+END;
+$$ LANGUAGE PLPGSQL SECURITY DEFINER;
+
+CREATE OR REPLACE FUNCTION search_fromhash(
+    _hash text
+) RETURNS searches AS $$
+    SELECT * FROM search_query((SELECT search FROM searches WHERE hash=_hash LIMIT 1));
+$$ LANGUAGE SQL STRICT;
+
+CREATE OR REPLACE FUNCTION search_rows(
+    IN _where text DEFAULT 'TRUE',
+    IN _orderby text DEFAULT 'datetime DESC, id DESC',
+    IN partitions text[] DEFAULT NULL,
+    IN _limit int DEFAULT 10
+) RETURNS SETOF items AS $$
+DECLARE
+    base_query text;
+    query text;
+    sdate timestamptz;
+    edate timestamptz;
+    n int;
+    records_left int := _limit;
+    timer timestamptz := clock_timestamp();
+    full_timer timestamptz := clock_timestamp();
+BEGIN
+IF _where IS NULL OR trim(_where) = '' THEN
+    _where = ' TRUE ';
+END IF;
+RAISE NOTICE 'Getting chunks for % %', _where, _orderby;
+
+base_query := $q$
+    SELECT * FROM items
+    WHERE
+    datetime >= %L AND datetime < %L
+    AND (%s)
+    ORDER BY %s
+    LIMIT %L
+$q$;
+
+IF _orderby ILIKE 'datetime d%' THEN
+    FOR sdate, edate IN SELECT * FROM chunker(_where) ORDER BY 1 DESC LOOP
+        RAISE NOTICE 'Running Query for % to %. %', sdate, edate, age_ms(full_timer);
+        query := format(
+            base_query,
+            sdate,
+            edate,
+            _where,
+            _orderby,
+            records_left
+        );
+        RAISE DEBUG 'QUERY: %', query;
+        timer := clock_timestamp();
+        RETURN QUERY EXECUTE query;
+
+        GET DIAGNOSTICS n = ROW_COUNT;
+        records_left := records_left - n;
+        RAISE NOTICE 'Returned %/% Rows From % to %. % to go. Time: %ms', n, _limit, sdate, edate, records_left, age_ms(timer);
+        timer := clock_timestamp();
+        IF records_left <= 0 THEN
+            RAISE NOTICE 'SEARCH_ROWS TOOK %ms', age_ms(full_timer);
+            RETURN;
+        END IF;
+    END LOOP;
+ELSIF _orderby ILIKE 'datetime a%' THEN
+    FOR sdate, edate IN SELECT * FROM chunker(_where) ORDER BY 1 ASC LOOP
+        RAISE NOTICE 'Running Query for % to %. %', sdate, edate, age_ms(full_timer);
+        query := format(
+            base_query,
+            sdate,
+            edate,
+            _where,
+            _orderby,
+            records_left
+        );
+        RAISE DEBUG 'QUERY: %', query;
+        timer := clock_timestamp();
+        RETURN QUERY EXECUTE query;
+
+        GET DIAGNOSTICS n = ROW_COUNT;
+        records_left := records_left - n;
+        RAISE NOTICE 'Returned %/% Rows From % to %. % to go. Time: %ms', n, _limit, sdate, edate, records_left, age_ms(timer);
+        timer := clock_timestamp();
+        IF records_left <= 0 THEN
+            RAISE NOTICE 'SEARCH_ROWS TOOK %ms', age_ms(full_timer);
+            RETURN;
+        END IF;
+    END LOOP;
+ELSE
+    query := format($q$
+        SELECT * FROM items
+        WHERE %s
+        ORDER BY %s
+        LIMIT %L
+    $q$, _where, _orderby, _limit
+    );
+    RAISE DEBUG 'QUERY: %', query;
+    timer := clock_timestamp();
+    RETURN QUERY EXECUTE query;
+    RAISE NOTICE 'FULL QUERY TOOK %ms', age_ms(timer);
+END IF;
+RAISE NOTICE 'SEARCH_ROWS TOOK %ms', age_ms(full_timer);
+RETURN;
+END;
+$$ LANGUAGE PLPGSQL SET SEARCH_PATH TO pgstac,public;
+
+
+CREATE UNLOGGED TABLE format_item_cache(
+    id text,
+    collection text,
+    fields text,
+    hydrated bool,
+    output jsonb,
+    lastused timestamptz DEFAULT now(),
+    usecount int DEFAULT 1,
+    timetoformat float,
+    PRIMARY KEY (collection, id, fields, hydrated)
+);
+CREATE INDEX ON format_item_cache (lastused);
+
+CREATE OR REPLACE FUNCTION format_item(_item items, _fields jsonb DEFAULT '{}', _hydrated bool DEFAULT TRUE) RETURNS jsonb AS $$
+DECLARE
+    cache bool := get_setting_bool('format_cache');
+    _output jsonb := null;
+    t timestamptz := clock_timestamp();
+BEGIN
+    IF cache THEN
+        SELECT output INTO _output FROM format_item_cache
+        WHERE id=_item.id AND collection=_item.collection AND fields=_fields::text AND hydrated=_hydrated;
+    END IF;
+    IF _output IS NULL THEN
+        IF _hydrated THEN
+            _output := content_hydrate(_item, _fields);
+        ELSE
+            _output := content_nonhydrated(_item, _fields);
+        END IF;
+    END IF;
+    IF cache THEN
+        INSERT INTO format_item_cache (id, collection, fields, hydrated, output, timetoformat)
+            VALUES (_item.id, _item.collection, _fields::text, _hydrated, _output, age_ms(t))
+            ON CONFLICT(collection, id, fields, hydrated) DO
+                UPDATE
+                    SET lastused=now(), usecount = format_item_cache.usecount + 1
+        ;
+    END IF;
+    RETURN _output;
+
+END;
+$$ LANGUAGE PLPGSQL SECURITY DEFINER;
+
+
+CREATE OR REPLACE FUNCTION search(_search jsonb = '{}'::jsonb) RETURNS jsonb AS $$
+DECLARE
+    searches searches%ROWTYPE;
+    _where text;
+    orderby text;
+    search_where search_wheres%ROWTYPE;
+    total_count bigint;
+    token record;
+    token_prev boolean;
+    token_item items%ROWTYPE;
+    token_where text;
+    full_where text;
+    init_ts timestamptz := clock_timestamp();
+    timer timestamptz := clock_timestamp();
+    hydrate bool := NOT (_search->'conf'->>'nohydrate' IS NOT NULL AND (_search->'conf'->>'nohydrate')::boolean = true);
+    prev text;
+    next text;
+    context jsonb;
+    collection jsonb;
+    out_records jsonb;
+    out_len int;
+    _limit int := coalesce((_search->>'limit')::int, 10);
+    _querylimit int;
+    _fields jsonb := coalesce(_search->'fields', '{}'::jsonb);
+    has_prev boolean := FALSE;
+    has_next boolean := FALSE;
+    links jsonb := '[]'::jsonb;
+    base_url text:= concat(rtrim(base_url(_search->'conf'),'/'));
+BEGIN
+    searches := search_query(_search);
+    _where := searches._where;
+    orderby := searches.orderby;
+    search_where := where_stats(_where);
+    total_count := coalesce(search_where.total_count, search_where.estimated_count);
+    RAISE NOTICE 'SEARCH:TOKEN: %', _search->>'token';
+    token := get_token_record(_search->>'token');
+    RAISE NOTICE '***TOKEN: %', token;
+    _querylimit := _limit + 1;
+    IF token IS NOT NULL THEN
+        token_prev := token.prev;
+        token_item := token.item;
+        token_where := get_token_filter(_search->'sortby', token_item, token_prev, FALSE);
+        RAISE DEBUG 'TOKEN_WHERE: % (%ms from search start)', token_where, age_ms(timer);
+        IF token_prev THEN -- if we are using a prev token, we know has_next is true
+            RAISE DEBUG 'There is a previous token, so automatically setting has_next to true';
+            has_next := TRUE;
+            orderby := sort_sqlorderby(_search, TRUE);
+        ELSE
+            RAISE DEBUG 'There is a next token, so automatically setting has_prev to true';
+            has_prev := TRUE;
+
+        END IF;
+    ELSE -- if there was no token, we know there is no prev
+        RAISE DEBUG 'There is no token, so we know there is no prev. setting has_prev to false';
+        has_prev := FALSE;
+    END IF;
+
+    full_where := concat_ws(' AND ', _where, token_where);
+    RAISE NOTICE 'FULL WHERE CLAUSE: %', full_where;
+    RAISE NOTICE 'Time to get counts and build query %', age_ms(timer);
+    timer := clock_timestamp();
+
+    IF hydrate THEN
+        RAISE NOTICE 'Getting hydrated data.';
+    ELSE
+        RAISE NOTICE 'Getting non-hydrated data.';
+    END IF;
+    RAISE NOTICE 'CACHE SET TO %', get_setting_bool('format_cache');
+    RAISE NOTICE 'Time to set hydration/formatting %', age_ms(timer);
+    timer := clock_timestamp();
+    SELECT jsonb_agg(format_item(i, _fields, hydrate)) INTO out_records
+    FROM search_rows(
+        full_where,
+        orderby,
+        search_where.partitions,
+        _querylimit
+    ) as i;
+
+    RAISE NOTICE 'Time to fetch rows %', age_ms(timer);
+    timer := clock_timestamp();
+
+
+    IF token_prev THEN
+        out_records := flip_jsonb_array(out_records);
+    END IF;
+
+    RAISE NOTICE 'Query returned % records.', jsonb_array_length(out_records);
+    RAISE DEBUG 'TOKEN:   % %', token_item.id, token_item.collection;
+    RAISE DEBUG 'RECORD_1: % %', out_records->0->>'id', out_records->0->>'collection';
+    RAISE DEBUG 'RECORD-1: % %', out_records->-1->>'id', out_records->-1->>'collection';
+
+    -- REMOVE records that were from our token
+    IF out_records->0->>'id' = token_item.id AND out_records->0->>'collection' = token_item.collection THEN
+        out_records := out_records - 0;
+    ELSIF out_records->-1->>'id' = token_item.id AND out_records->-1->>'collection' = token_item.collection THEN
+        out_records := out_records - -1;
+    END IF;
+
+    out_len := jsonb_array_length(out_records);
+
+    IF out_len = _limit + 1 THEN
+        IF token_prev THEN
+            has_prev := TRUE;
+            out_records := out_records - 0;
+        ELSE
+            has_next := TRUE;
+            out_records := out_records - -1;
+        END IF;
+    END IF;
+
+
+    links := links || jsonb_build_object(
+        'rel', 'root',
+        'type', 'application/json',
+        'href', base_url
+    ) || jsonb_build_object(
+        'rel', 'self',
+        'type', 'application/json',
+        'href', concat(base_url, '/search')
+    );
+
+    IF has_next THEN
+        next := concat(out_records->-1->>'collection', ':', out_records->-1->>'id');
+        RAISE NOTICE 'HAS NEXT | %', next;
+        links := links || jsonb_build_object(
+            'rel', 'next',
+            'type', 'application/geo+json',
+            'method', 'GET',
+            'href', concat(base_url, '/search?token=next:', next)
+        );
+    END IF;
+
+    IF has_prev THEN
+        prev := concat(out_records->0->>'collection', ':', out_records->0->>'id');
+        RAISE NOTICE 'HAS PREV | %', prev;
+        links := links || jsonb_build_object(
+            'rel', 'prev',
+            'type', 'application/geo+json',
+            'method', 'GET',
+            'href', concat(base_url, '/search?token=prev:', prev)
+        );
+    END IF;
+
+    RAISE NOTICE 'Time to get prev/next %', age_ms(timer);
+    timer := clock_timestamp();
+
+
+    collection := jsonb_build_object(
+        'type', 'FeatureCollection',
+        'features', coalesce(out_records, '[]'::jsonb),
+        'links', links
+    );
+
+
+
+    IF context(_search->'conf') != 'off' THEN
+        collection := collection || jsonb_strip_nulls(jsonb_build_object(
+            'numberMatched', total_count,
+            'numberReturned', coalesce(jsonb_array_length(out_records), 0)
+        ));
+    ELSE
+        collection := collection || jsonb_strip_nulls(jsonb_build_object(
+            'numberReturned', coalesce(jsonb_array_length(out_records), 0)
+        ));
+    END IF;
+
+    IF get_setting_bool('timing', _search->'conf') THEN
+        collection = collection || jsonb_build_object('timing', age_ms(init_ts));
+    END IF;
+
+    RAISE NOTICE 'Time to build final json %', age_ms(timer);
+    timer := clock_timestamp();
+
+    RAISE NOTICE 'Total Time: %', age_ms(current_timestamp);
+    RAISE NOTICE 'RETURNING % records. NEXT: %. PREV: %', collection->>'numberReturned', collection->>'next', collection->>'prev';
+    RETURN collection;
+END;
+$$ LANGUAGE PLPGSQL;
+
+
+CREATE OR REPLACE FUNCTION search_cursor(_search jsonb = '{}'::jsonb) RETURNS refcursor AS $$
+DECLARE
+    curs refcursor;
+    searches searches%ROWTYPE;
+    _where text;
+    _orderby text;
+    q text;
+
+BEGIN
+    searches := search_query(_search);
+    _where := searches._where;
+    _orderby := searches.orderby;
+
+    OPEN curs FOR
+        WITH p AS (
+            SELECT * FROM partition_queries(_where, _orderby) p
+        )
+        SELECT
+            CASE WHEN EXISTS (SELECT 1 FROM p) THEN
+                (SELECT format($q$
+                    SELECT * FROM (
+                        %s
+                    ) total
+                    $q$,
+                    string_agg(
+                        format($q$ SELECT * FROM ( %s ) AS sub $q$, p),
+                        '
+                        UNION ALL
+                        '
+                    )
+                ))
+            ELSE NULL
+            END FROM p;
+    RETURN curs;
+END;
+$$ LANGUAGE PLPGSQL;
+CREATE OR REPLACE VIEW collections_asitems AS
+SELECT
+    id,
+    geometry,
+    'collections' AS collection,
+    datetime,
+    end_datetime,
+    jsonb_build_object(
+        'properties', content - '{links,assets,stac_version,stac_extensions}',
+        'links', content->'links',
+        'assets', content->'assets',
+        'stac_version', content->'stac_version',
+        'stac_extensions', content->'stac_extensions'
+    ) AS content,
+    content as collectionjson
+FROM collections;
+
+
+CREATE OR REPLACE FUNCTION collection_search_matched(
+    IN _search jsonb DEFAULT '{}'::jsonb,
+    OUT matched bigint
+) RETURNS bigint AS $$
+DECLARE
+    _where text := stac_search_to_where(_search);
+BEGIN
+    EXECUTE format(
+        $query$
+            SELECT
+                count(*)
+            FROM
+                collections_asitems
+            WHERE %s
+            ;
+        $query$,
+        _where
+    ) INTO matched;
+    RETURN;
+END;
+$$ LANGUAGE PLPGSQL STABLE PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION collection_search_rows(
+    _search jsonb DEFAULT '{}'::jsonb
+) RETURNS SETOF jsonb AS $$
+DECLARE
+    _where text := stac_search_to_where(_search);
+    _limit int := coalesce((_search->>'limit')::int, 10);
+    _fields jsonb := coalesce(_search->'fields', '{}'::jsonb);
+    _orderby text;
+    _offset int := COALESCE((_search->>'offset')::int, 0);
+BEGIN
+    _orderby := sort_sqlorderby(
+        jsonb_build_object(
+            'sortby',
+            coalesce(
+                _search->'sortby',
+                '[{"field": "id", "direction": "asc"}]'::jsonb
+            )
+        )
+    );
+    RETURN QUERY EXECUTE format(
+        $query$
+            SELECT
+                jsonb_fields(collectionjson, %L) as c
+            FROM
+                collections_asitems
+            WHERE %s
+            ORDER BY %s
+            LIMIT %L
+            OFFSET %L
+            ;
+        $query$,
+        _fields,
+        _where,
+        _orderby,
+        _limit,
+        _offset
+    );
+END;
+$$ LANGUAGE PLPGSQL;
+
+CREATE OR REPLACE FUNCTION collection_search(
+    _search jsonb DEFAULT '{}'::jsonb
+) RETURNS jsonb AS $$
+DECLARE
+    out_records jsonb;
+    number_matched bigint := collection_search_matched(_search);
+    number_returned bigint;
+    _limit int := coalesce((_search->>'limit')::float::int, 10);
+    _offset int := coalesce((_search->>'offset')::float::int, 0);
+    links jsonb := '[]';
+    ret jsonb;
+    base_url text:= concat(rtrim(base_url(_search->'conf'),'/'), '/collections');
+    prevoffset int;
+    nextoffset int;
+BEGIN
+    SELECT
+        coalesce(jsonb_agg(c), '[]')
+    INTO out_records
+    FROM collection_search_rows(_search) c;
+
+    number_returned := jsonb_array_length(out_records);
+    RAISE DEBUG 'nm: %, nr: %, l:%, o:%', number_matched, number_returned, _limit, _offset;
+
+
+
+    IF _limit <= number_matched AND number_matched > 0 THEN --need to have paging links
+        nextoffset := least(_offset + _limit, number_matched - 1);
+        prevoffset := greatest(_offset - _limit, 0);
+
+        IF _offset > 0 THEN
+            links := links || jsonb_build_object(
+                    'rel', 'prev',
+                    'type', 'application/json',
+                    'method', 'GET' ,
+                    'href', base_url,
+                    'body', jsonb_build_object('offset', prevoffset),
+                    'merge', TRUE
+                );
+        END IF;
+
+        IF (_offset + _limit < number_matched)  THEN
+            links := links || jsonb_build_object(
+                    'rel', 'next',
+                    'type', 'application/json',
+                    'method', 'GET' ,
+                    'href', base_url,
+                    'body', jsonb_build_object('offset', nextoffset),
+                    'merge', TRUE
+                );
+        END IF;
+
+    END IF;
+
+    ret := jsonb_build_object(
+        'collections', out_records,
+        'numberMatched', number_matched,
+        'numberReturned', number_returned,
+        'links', links
+    );
+    RETURN ret;
+
+END;
+$$ LANGUAGE PLPGSQL STABLE PARALLEL SAFE;
+SET SEARCH_PATH TO pgstac, public;
+
+CREATE OR REPLACE FUNCTION tileenvelope(zoom int, x int, y int) RETURNS geometry AS $$
+WITH t AS (
+    SELECT
+        20037508.3427892 as merc_max,
+        -20037508.3427892 as merc_min,
+        (2 * 20037508.3427892) / (2 ^ zoom) as tile_size
+)
+SELECT st_makeenvelope(
+    merc_min + (tile_size * x),
+    merc_max - (tile_size * (y + 1)),
+    merc_min + (tile_size * (x + 1)),
+    merc_max - (tile_size * y),
+    3857
+) FROM t;
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;DROP FUNCTION IF EXISTS mercgrid;
+
+
+CREATE OR REPLACE FUNCTION ftime() RETURNS interval as $$
+SELECT age(clock_timestamp(), transaction_timestamp());
+$$ LANGUAGE SQL;
+SET SEARCH_PATH to pgstac, public;
+
+DROP FUNCTION IF EXISTS geometrysearch;
+CREATE OR REPLACE FUNCTION geometrysearch(
+    IN geom geometry,
+    IN queryhash text,
+    IN fields jsonb DEFAULT NULL,
+    IN _scanlimit int DEFAULT 10000,
+    IN _limit int DEFAULT 100,
+    IN _timelimit interval DEFAULT '5 seconds'::interval,
+    IN exitwhenfull boolean DEFAULT TRUE, -- Return as soon as the passed in geometry is full covered
+    IN skipcovered boolean DEFAULT TRUE -- Skip any items that would show up completely under the previous items
+) RETURNS jsonb AS $$
+DECLARE
+    search searches%ROWTYPE;
+    curs refcursor;
+    _where text;
+    query text;
+    iter_record items%ROWTYPE;
+    out_records jsonb := '{}'::jsonb[];
+    exit_flag boolean := FALSE;
+    counter int := 1;
+    scancounter int := 1;
+    remaining_limit int := _scanlimit;
+    tilearea float;
+    unionedgeom geometry;
+    clippedgeom geometry;
+    unionedgeom_area float := 0;
+    prev_area float := 0;
+    excludes text[];
+    includes text[];
+
+BEGIN
+    DROP TABLE IF EXISTS pgstac_results;
+    CREATE TEMP TABLE pgstac_results (content jsonb) ON COMMIT DROP;
+
+    -- If the passed in geometry is not an area set exitwhenfull and skipcovered to false
+    IF ST_GeometryType(geom) !~* 'polygon' THEN
+        RAISE NOTICE 'GEOMETRY IS NOT AN AREA';
+        skipcovered = FALSE;
+        exitwhenfull = FALSE;
+    END IF;
+
+    -- If skipcovered is true then you will always want to exit when the passed in geometry is full
+    IF skipcovered THEN
+        exitwhenfull := TRUE;
+    END IF;
+
+    search := search_fromhash(queryhash);
+
+    IF search IS NULL THEN
+        RAISE EXCEPTION 'Search with Query Hash % Not Found', queryhash;
+    END IF;
+
+    tilearea := st_area(geom);
+    _where := format('%s AND st_intersects(geometry, %L::geometry)', search._where, geom);
+
+
+    FOR query IN SELECT * FROM partition_queries(_where, search.orderby) LOOP
+        query := format('%s LIMIT %L', query, remaining_limit);
+        RAISE NOTICE '%', query;
+        OPEN curs FOR EXECUTE query;
+        LOOP
+            FETCH curs INTO iter_record;
+            EXIT WHEN NOT FOUND;
+            IF exitwhenfull OR skipcovered THEN -- If we are not using exitwhenfull or skipcovered, we do not need to do expensive geometry operations
+                clippedgeom := st_intersection(geom, iter_record.geometry);
+
+                IF unionedgeom IS NULL THEN
+                    unionedgeom := clippedgeom;
+                ELSE
+                    unionedgeom := st_union(unionedgeom, clippedgeom);
+                END IF;
+
+                unionedgeom_area := st_area(unionedgeom);
+
+                IF skipcovered AND prev_area = unionedgeom_area THEN
+                    scancounter := scancounter + 1;
+                    CONTINUE;
+                END IF;
+
+                prev_area := unionedgeom_area;
+
+                RAISE NOTICE '% % % %', unionedgeom_area/tilearea, counter, scancounter, ftime();
+            END IF;
+            RAISE NOTICE '% %', iter_record, content_hydrate(iter_record, fields);
+            INSERT INTO pgstac_results (content) VALUES (content_hydrate(iter_record, fields));
+
+            IF counter >= _limit
+                OR scancounter > _scanlimit
+                OR ftime() > _timelimit
+                OR (exitwhenfull AND unionedgeom_area >= tilearea)
+            THEN
+                exit_flag := TRUE;
+                EXIT;
+            END IF;
+            counter := counter + 1;
+            scancounter := scancounter + 1;
+
+        END LOOP;
+        CLOSE curs;
+        EXIT WHEN exit_flag;
+        remaining_limit := _scanlimit - scancounter;
+    END LOOP;
+
+    SELECT jsonb_agg(content) INTO out_records FROM pgstac_results WHERE content IS NOT NULL;
+
+    RETURN jsonb_build_object(
+        'type', 'FeatureCollection',
+        'features', coalesce(out_records, '[]'::jsonb)
+    );
+END;
+$$ LANGUAGE PLPGSQL;
+
+DROP FUNCTION IF EXISTS geojsonsearch;
+CREATE OR REPLACE FUNCTION geojsonsearch(
+    IN geojson jsonb,
+    IN queryhash text,
+    IN fields jsonb DEFAULT NULL,
+    IN _scanlimit int DEFAULT 10000,
+    IN _limit int DEFAULT 100,
+    IN _timelimit interval DEFAULT '5 seconds'::interval,
+    IN exitwhenfull boolean DEFAULT TRUE,
+    IN skipcovered boolean DEFAULT TRUE
+) RETURNS jsonb AS $$
+    SELECT * FROM geometrysearch(
+        st_geomfromgeojson(geojson),
+        queryhash,
+        fields,
+        _scanlimit,
+        _limit,
+        _timelimit,
+        exitwhenfull,
+        skipcovered
+    );
+$$ LANGUAGE SQL;
+
+DROP FUNCTION IF EXISTS xyzsearch;
+CREATE OR REPLACE FUNCTION xyzsearch(
+    IN _x int,
+    IN _y int,
+    IN _z int,
+    IN queryhash text,
+    IN fields jsonb DEFAULT NULL,
+    IN _scanlimit int DEFAULT 10000,
+    IN _limit int DEFAULT 100,
+    IN _timelimit interval DEFAULT '5 seconds'::interval,
+    IN exitwhenfull boolean DEFAULT TRUE,
+    IN skipcovered boolean DEFAULT TRUE
+) RETURNS jsonb AS $$
+    SELECT * FROM geometrysearch(
+        st_transform(tileenvelope(_z, _x, _y), 4326),
+        queryhash,
+        fields,
+        _scanlimit,
+        _limit,
+        _timelimit,
+        exitwhenfull,
+        skipcovered
+    );
+$$ LANGUAGE SQL;
+
+CREATE OR REPLACE PROCEDURE analyze_items() AS $$
+DECLARE
+    q text;
+    timeout_ts timestamptz;
+BEGIN
+    timeout_ts := statement_timestamp() + queue_timeout();
+    WHILE clock_timestamp() < timeout_ts LOOP
+        SELECT format('ANALYZE (VERBOSE, SKIP_LOCKED) %I;', relname) INTO q
+        FROM pg_stat_user_tables
+        WHERE relname like '_item%' AND (n_mod_since_analyze>0 OR last_analyze IS NULL) LIMIT 1;
+        IF NOT FOUND THEN
+            EXIT;
+        END IF;
+        RAISE NOTICE '%', q;
+        EXECUTE q;
+        COMMIT;
+    END LOOP;
+END;
+$$ LANGUAGE PLPGSQL;
+
+
+CREATE OR REPLACE PROCEDURE validate_constraints() AS $$
+DECLARE
+    q text;
+BEGIN
+    FOR q IN
+    SELECT
+        FORMAT(
+            'ALTER TABLE %I.%I VALIDATE CONSTRAINT %I;',
+            nsp.nspname,
+            cls.relname,
+            con.conname
+        )
+
+    FROM pg_constraint AS con
+        JOIN pg_class AS cls
+        ON con.conrelid = cls.oid
+        JOIN pg_namespace AS nsp
+        ON cls.relnamespace = nsp.oid
+    WHERE convalidated = FALSE AND contype in ('c','f')
+    AND nsp.nspname = 'pgstac'
+    LOOP
+        RAISE NOTICE '%', q;
+        PERFORM run_or_queue(q);
+        COMMIT;
+    END LOOP;
+END;
+$$ LANGUAGE PLPGSQL;
+
+
+CREATE OR REPLACE FUNCTION collection_extent(_collection text, runupdate boolean default false) RETURNS jsonb AS $$
+DECLARE
+    geom_extent geometry;
+    mind timestamptz;
+    maxd timestamptz;
+    extent jsonb;
+BEGIN
+    IF runupdate THEN
+        PERFORM update_partition_stats_q(partition)
+        FROM partitions_view WHERE collection=_collection;
+    END IF;
+    SELECT
+        min(lower(dtrange)),
+        max(upper(edtrange)),
+        st_extent(spatial)
+    INTO
+        mind,
+        maxd,
+        geom_extent
+    FROM partitions_view
+    WHERE collection=_collection;
+
+    IF geom_extent IS NOT NULL AND mind IS NOT NULL AND maxd IS NOT NULL THEN
+        extent := jsonb_build_object(
+                'spatial', jsonb_build_object(
+                    'bbox', to_jsonb(array[array[st_xmin(geom_extent), st_ymin(geom_extent), st_xmax(geom_extent), st_ymax(geom_extent)]])
+                ),
+                'temporal', jsonb_build_object(
+                    'interval', to_jsonb(array[array[mind, maxd]])
+                )
+        );
+        RETURN extent;
+    END IF;
+    RETURN NULL;
+END;
+$$ LANGUAGE PLPGSQL;
+DO $$
+  BEGIN
+    INSERT INTO queryables (name, definition, property_wrapper, property_index_type) VALUES
+    ('id', '{"title": "Item ID","description": "Item identifier","$ref": "https://schemas.stacspec.org/v1.0.0/item-spec/json-schema/item.json#/definitions/core/allOf/2/properties/id"}', null, null);
+  EXCEPTION WHEN unique_violation THEN
+    RAISE NOTICE '%', SQLERRM USING ERRCODE = SQLSTATE;
+  END
+$$;
+
+DO $$
+  BEGIN
+    INSERT INTO queryables (name, definition, property_wrapper, property_index_type) VALUES
+    ('geometry', '{"title": "Item Geometry","description": "Item Geometry","$ref": "https://geojson.org/schema/Feature.json"}', null, null);
+  EXCEPTION WHEN unique_violation THEN
+    RAISE NOTICE '%', SQLERRM USING ERRCODE = SQLSTATE;
+  END
+$$;
+
+DO $$
+  BEGIN
+    INSERT INTO queryables (name, definition, property_wrapper, property_index_type) VALUES
+    ('datetime','{"description": "Datetime","type": "string","title": "Acquired","format": "date-time","pattern": "(\\+00:00|Z)$"}', null, null);
+  EXCEPTION WHEN unique_violation THEN
+    RAISE NOTICE '%', SQLERRM USING ERRCODE = SQLSTATE;
+  END
+$$;
+
+DELETE FROM queryables a USING queryables b
+  WHERE a.name = b.name AND a.collection_ids IS NOT DISTINCT FROM b.collection_ids AND a.id > b.id;
+
+
+INSERT INTO pgstac_settings (name, value) VALUES
+  ('context', 'off'),
+  ('context_estimated_count', '100000'),
+  ('context_estimated_cost', '100000'),
+  ('context_stats_ttl', '1 day'),
+  ('default_filter_lang', 'cql2-json'),
+  ('additional_properties', 'true'),
+  ('use_queue', 'false'),
+  ('queue_timeout', '10 minutes'),
+  ('update_collection_extent', 'false'),
+  ('format_cache', 'false'),
+  ('readonly', 'false')
+ON CONFLICT DO NOTHING
+;
+
+
+INSERT INTO cql2_ops (op, template, types) VALUES
+    ('eq', '%s = %s', NULL),
+    ('neq', '%s != %s', NULL),
+    ('ne', '%s != %s', NULL),
+    ('!=', '%s != %s', NULL),
+    ('<>', '%s != %s', NULL),
+    ('lt', '%s < %s', NULL),
+    ('lte', '%s <= %s', NULL),
+    ('gt', '%s > %s', NULL),
+    ('gte', '%s >= %s', NULL),
+    ('le', '%s <= %s', NULL),
+    ('ge', '%s >= %s', NULL),
+    ('=', '%s = %s', NULL),
+    ('<', '%s < %s', NULL),
+    ('<=', '%s <= %s', NULL),
+    ('>', '%s > %s', NULL),
+    ('>=', '%s >= %s', NULL),
+    ('like', '%s LIKE %s', NULL),
+    ('ilike', '%s ILIKE %s', NULL),
+    ('+', '%s + %s', NULL),
+    ('-', '%s - %s', NULL),
+    ('*', '%s * %s', NULL),
+    ('/', '%s / %s', NULL),
+    ('not', 'NOT (%s)', NULL),
+    ('between', '%s BETWEEN %s AND %s', NULL),
+    ('isnull', '%s IS NULL', NULL),
+    ('upper', 'upper(%s)', NULL),
+    ('lower', 'lower(%s)', NULL),
+    ('casei', 'upper(%s)', NULL),
+    ('accenti', 'unaccent(%s)', NULL)
+ON CONFLICT (op) DO UPDATE
+    SET
+        template = EXCLUDED.template
+;
+
+
+ALTER FUNCTION to_text COST 5000;
+ALTER FUNCTION to_float COST 5000;
+ALTER FUNCTION to_int COST 5000;
+ALTER FUNCTION to_tstz COST 5000;
+ALTER FUNCTION to_text_array COST 5000;
+
+ALTER FUNCTION update_partition_stats SECURITY DEFINER;
+ALTER FUNCTION partition_after_triggerfunc SECURITY DEFINER;
+ALTER FUNCTION drop_table_constraints SECURITY DEFINER;
+ALTER FUNCTION create_table_constraints SECURITY DEFINER;
+ALTER FUNCTION check_partition SECURITY DEFINER;
+ALTER FUNCTION repartition SECURITY DEFINER;
+ALTER FUNCTION where_stats SECURITY DEFINER;
+ALTER FUNCTION search_query SECURITY DEFINER;
+ALTER FUNCTION format_item SECURITY DEFINER;
+ALTER FUNCTION maintain_index SECURITY DEFINER;
+
+GRANT USAGE ON SCHEMA pgstac to pgstac_read;
+GRANT ALL ON SCHEMA pgstac to pgstac_ingest;
+GRANT ALL ON SCHEMA pgstac to pgstac_admin;
+
+-- pgstac_read role limited to using function apis
+GRANT EXECUTE ON FUNCTION search TO pgstac_read;
+GRANT EXECUTE ON FUNCTION search_query TO pgstac_read;
+GRANT EXECUTE ON FUNCTION item_by_id TO pgstac_read;
+GRANT EXECUTE ON FUNCTION get_item TO pgstac_read;
+GRANT SELECT ON ALL TABLES IN SCHEMA pgstac TO pgstac_read;
+
+
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA pgstac to pgstac_ingest;
+GRANT ALL ON ALL TABLES IN SCHEMA pgstac to pgstac_ingest;
+GRANT USAGE ON ALL SEQUENCES IN SCHEMA pgstac to pgstac_ingest;
+
+REVOKE ALL PRIVILEGES ON PROCEDURE run_queued_queries FROM public;
+GRANT ALL ON PROCEDURE run_queued_queries TO pgstac_admin;
+
+REVOKE ALL PRIVILEGES ON FUNCTION run_queued_queries_intransaction FROM public;
+GRANT ALL ON FUNCTION run_queued_queries_intransaction TO pgstac_admin;
+
+RESET ROLE;
+
+SET ROLE pgstac_ingest;
+SELECT update_partition_stats_q(partition) FROM partitions_view;
+SELECT set_version('unreleased');
diff --git a/src/pgstac/pgstac.sql b/src/pgstac/pgstac.sql
index af4ad13a..4c836762 100644
--- a/src/pgstac/pgstac.sql
+++ b/src/pgstac/pgstac.sql
@@ -4656,4 +4656,4 @@ RESET ROLE;
 
 SET ROLE pgstac_ingest;
 SELECT update_partition_stats_q(partition) FROM partitions_view;
-SELECT set_version('0.9.11');
+SELECT set_version('unreleased');
diff --git a/src/pgstac/sql/999_version.sql b/src/pgstac/sql/999_version.sql
index 24240500..ecd86ef1 100644
--- a/src/pgstac/sql/999_version.sql
+++ b/src/pgstac/sql/999_version.sql
@@ -1 +1 @@
-SELECT set_version('0.9.11');
+SELECT set_version('unreleased');
diff --git a/src/pypgstac/pyproject.toml b/src/pypgstac/pyproject.toml
index e958554e..af375097 100644
--- a/src/pypgstac/pyproject.toml
+++ b/src/pypgstac/pyproject.toml
@@ -1,9 +1,9 @@
 [project]
 name = "pypgstac"
-version = "0.9.11"
+version = "0.9.11-dev"
 description = "Schema, functions and a python library for storing and accessing STAC collections and items in PostgreSQL"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.11"
 license = "MIT"
 authors = [{ name = "David Bitner", email = "bitner@dbspatial.com" }]
 keywords = ["STAC", "Postgresql", "PgSTAC"]
@@ -12,18 +12,19 @@ classifiers = [
     "Intended Audience :: Information Technology",
     "Intended Audience :: Science/Research",
     "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
 ]
 dependencies = [
-    "cachetools>=5.3.0,<6.1",
+    "cachetools>=5.3.0",
     "fire>=0.7.0",
     "hydraters>=0.1.0",
-    "orjson>=3.9.0",
+    "orjson>=3.11.0",
     "plpygis>=0.5.0",
-    "pydantic>=1.10,<3",
+    "pydantic>=2.10,<3",
+    "pydantic-settings>=2,<3",
     "python-dateutil>=2.8.0",
     "smart-open>=5.0",
     "tenacity>=8.1.0",
@@ -37,15 +38,13 @@ test = [
     "pytest-benchmark==5.1.*",
     "pytest-cov==6.0.*",
     "pystac[validation]==1.*",
-    "types-cachetools==5.5.*",
+    "types-cachetools>=5.5",
 ]
 dev = [
-    "flake8==7.1.1",
-    "black>=24.10.0",
-    "mypy>=1.13.0",
     "types-setuptools",
-    "ruff==0.8.2",
-    "pre-commit",
+    "ruff==0.15.11",
+    "ty==0.0.31",
+    "pre-commit==3.5.0",
 ]
 psycopg = ["psycopg[binary]>=3.1.0", "psycopg-pool>=3.1.0"]
 migrations = ["psycopg2-binary", "migra"]
@@ -79,30 +78,29 @@ parallel = true
 [tool.coverage.report]
 exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:"]
 
+[tool.ruff]
+target-version = "py311"
+line-length = 88
+
 [tool.ruff.lint]
 select = [
     "E", # pycodestyle errors
     "W", # pycodestyle warnings
     "F", # pyflakes
     "I", # isort
-    "C", # flake8-comprehensions
     "B", # flake8-bugbear
-    # "D",  # pydocstyle
     "C4",  # flake8-comprehensions
     "T20", # flake8-print
-    # "PT", # flake8-pytest-style
     "Q", # flake8-quotes
-    # "SIM", # flake8-simplify
     "DTZ", # flake8-datetimez
     "ERA", # eradicate
     "PLC",
     "PLE",
-    # "PLR",
     "PLW",
     "COM", # flake8-commas
 ]
 ignore = [
-    # "E501",  # line too long, handled by black
+    "E501", # line too long, handled by formatter
     "B008", # do not perform function calls in argument defaults
     "C901", # too complex
     "B905",
@@ -111,11 +109,11 @@ ignore = [
 [tool.ruff.lint.isort]
 known-first-party = ["pypgstac"]
 
-[tool.mypy]
-strict_optional = true
-ignore_missing_imports = true
-disallow_untyped_defs = true
-namespace_packages = true
+[tool.ty.environment]
+python-version = "3.11"
+
+[tool.ty.src]
+include = ["src/pypgstac", "tests"]
 
 [tool.pydocstyle]
 select = "D1"
diff --git a/src/pypgstac/src/pypgstac/__init__.py b/src/pypgstac/src/pypgstac/__init__.py
index 9886933d..4f4e0438 100644
--- a/src/pypgstac/src/pypgstac/__init__.py
+++ b/src/pypgstac/src/pypgstac/__init__.py
@@ -1,4 +1,5 @@
 """pyPgSTAC Version."""
+
 from pypgstac.version import __version__
 
 __all__ = ["__version__"]
diff --git a/src/pypgstac/src/pypgstac/db.py b/src/pypgstac/src/pypgstac/db.py
index fc863260..a10e6209 100644
--- a/src/pypgstac/src/pypgstac/db.py
+++ b/src/pypgstac/src/pypgstac/db.py
@@ -1,21 +1,21 @@
 """Base library for database interaction with PgSTAC."""
+
 import atexit
 import logging
 import time
+from collections.abc import Generator
+from pathlib import Path
 from types import TracebackType
-from typing import Any, Generator, List, Optional, Tuple, Type, Union
+from typing import Any
 
 import orjson
 import psycopg
-from psycopg import Connection, sql
+from psycopg import Connection, rows, sql
+from psycopg.abc import Params
+from psycopg.types import json as psycopg_json
 from psycopg.types.json import set_json_dumps, set_json_loads
 from psycopg_pool import ConnectionPool
-
-try:
-    from pydantic.v1 import BaseSettings  # type:ignore
-except ImportError:
-    from pydantic import BaseSettings  # type:ignore
-
+from pydantic_settings import BaseSettings, SettingsConfigDict
 from tenacity import retry, retry_if_exception_type, stop_after_attempt
 
 logger = logging.getLogger(__name__)
@@ -46,7 +46,7 @@ class Settings(BaseSettings):
     db_num_workers: int = 1
     db_retries: int = 3
 
-    model_config = {"env_file": ".env", "extra": "ignore"}
+    model_config = SettingsConfigDict(env_file=Path(".env"), extra="ignore")
 
 
 settings = Settings()
@@ -57,9 +57,9 @@ class PgstacDB:
 
     def __init__(
         self,
-        dsn: Optional[str] = "",
-        pool: Optional[ConnectionPool] = None,
-        connection: Optional[Connection] = None,
+        dsn: str | None = "",
+        pool: ConnectionPool | None = None,
+        connection: Connection | None = None,
         commit_on_exit: bool = True,
         debug: bool = False,
         use_queue: bool = False,
@@ -179,9 +179,9 @@ def __enter__(self) -> Any:
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc: Optional[BaseException],
-        traceback: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: TracebackType | None,
     ) -> None:
         """Exit used for context."""
         self.disconnect()
@@ -193,9 +193,9 @@ def __exit__(
     )
     def query(
         self,
-        query: Union[str, sql.Composed],
-        args: Optional[List[Any]] = None,
-        row_factory: psycopg.rows.BaseRowFactory = psycopg.rows.tuple_row,
+        query: Any,
+        args: Params | None = None,
+        row_factory: rows.BaseRowFactory = rows.tuple_row,
     ) -> Generator:
         """Query the database with parameters."""
         conn = self.connect()
@@ -223,7 +223,7 @@ def query(
                 conn.rollback()
             raise e
 
-    def query_one(self, *args: Any, **kwargs: Any) -> Union[Tuple, str, None]:
+    def query_one(self, *args: Any, **kwargs: Any) -> tuple[Any, ...] | str | None:
         """Return results from a query that returns a single row."""
         try:
             r = next(self.query(*args, **kwargs))
@@ -246,7 +246,7 @@ def run_queued(self) -> str:
             return f"Error Running Queued Queries: {e}"
 
     @property
-    def version(self) -> Optional[str]:
+    def version(self) -> str | None:
         """Get the current version number from a pgstac database."""
         try:
             version = self.query_one(
@@ -280,9 +280,11 @@ def pg_version(self) -> str:
         if isinstance(version, str):
             if int(version) < 130000:
                 major, minor, patch = tuple(
-                    map(int, [version[i:i + 2] for i in range(0, len(version), 2)]),
+                    map(int, [version[i : i + 2] for i in range(0, len(version), 2)]),
                 )
-                raise Exception(f"PgSTAC requires PostgreSQL 13+, current version is: {major}.{minor}.{patch}")  # noqa: E501
+                raise Exception(
+                    f"PgSTAC requires PostgreSQL 13+, current version is: {major}.{minor}.{patch}",
+                )  # noqa: E501
             return version
         else:
             if self.connection is not None:
@@ -296,12 +298,12 @@ def func(self, function_name: str, *args: Any) -> Generator:
         cleaned_args = []
         for arg in args:
             if isinstance(arg, dict):
-                cleaned_args.append(psycopg.types.json.Jsonb(arg))
+                cleaned_args.append(psycopg_json.Jsonb(arg))
             else:
                 cleaned_args.append(arg)
         base_query = sql.SQL("SELECT * FROM {}({});").format(func, placeholders)
         return self.query(base_query, cleaned_args)
 
-    def search(self, query: Union[dict, str, psycopg.types.json.Jsonb] = "{}") -> str:
+    def search(self, query: dict | str | psycopg_json.Jsonb = "{}") -> str:
         """Search PgSTAC."""
         return dumps(next(self.func("search", query))[0])
diff --git a/src/pypgstac/src/pypgstac/hydration.py b/src/pypgstac/src/pypgstac/hydration.py
index 30798489..f0239a59 100644
--- a/src/pypgstac/src/pypgstac/hydration.py
+++ b/src/pypgstac/src/pypgstac/hydration.py
@@ -1,7 +1,7 @@
 """Hydrate data in pypgstac rather than on the database."""
 
 from copy import deepcopy
-from typing import Any, Dict
+from typing import Any, Mapping, cast
 
 from hydraters import hydrate
 
@@ -9,7 +9,7 @@
 DO_NOT_MERGE_MARKER = "𒍟※"
 
 
-def hydrate_py(base_item: Dict[str, Any], item: Dict[str, Any]) -> Dict[str, Any]:
+def hydrate_py(base_item: dict[str, Any], item: dict[str, Any]) -> dict[str, Any]:
     """Hydrate item in-place with base_item properties.
 
     This will not perform a deep copy; values of the original item will be referenced
@@ -19,7 +19,7 @@ def hydrate_py(base_item: Dict[str, Any], item: Dict[str, Any]) -> Dict[str, Any
     # Merge will mutate i, but create deep copies of values in the base item
     # This will prevent the base item values from being mutated, e.g. by
     # filtering out fields in `filter_fields`.
-    def merge(b: Dict[str, Any], i: Dict[str, Any]) -> None:
+    def merge(b: dict[str, Any], i: dict[str, Any]) -> None:
         for key, _ in b.items():
             if key in i:
                 if isinstance(b[key], dict) and isinstance(i.get(key), dict):
@@ -52,7 +52,7 @@ def merge(b: Dict[str, Any], i: Dict[str, Any]) -> None:
     return item
 
 
-def dehydrate(base_item: Dict[str, Any], full_item: Dict[str, Any]) -> Dict[str, Any]:
+def dehydrate(base_item: dict[str, Any], full_item: dict[str, Any]) -> dict[str, Any]:
     """
     Get a recursive difference between a base item and an incoming item to dehydrate.
 
@@ -62,7 +62,10 @@ def dehydrate(base_item: Dict[str, Any], full_item: Dict[str, Any]) -> Dict[str,
     collection item-assets to contain keys that may not be present on individual items.
     """
 
-    def strip(base_value: Dict[str, Any], item_value: Dict[str, Any]) -> Dict[str, Any]:
+    def strip(
+        base_value: Mapping[str, Any],
+        item_value: Mapping[str, Any],
+    ) -> dict[str, Any]:
         out: dict = {}
         for key, value in item_value.items():
             if base_value is None or key not in base_value:
@@ -81,8 +84,10 @@ def strip(base_value: Dict[str, Any], item_value: Dict[str, Any]) -> Dict[str, A
                     out[key] = []
                     for bv, v in zip(base_value[key], value):
                         if isinstance(bv, dict) and isinstance(v, dict):
-                            dehydrated = strip(bv, v)
-                            apply_marked_keys(bv, v, dehydrated)
+                            bv_mapping = cast(Mapping[str, Any], bv)
+                            v_mapping = cast(Mapping[str, Any], v)
+                            dehydrated = strip(bv_mapping, v_mapping)
+                            apply_marked_keys(bv_mapping, v_mapping, dehydrated)
                             out[key].append(dehydrated)
                         else:
                             out[key].append(v)
@@ -96,7 +101,7 @@ def strip(base_value: Dict[str, Any], item_value: Dict[str, Any]) -> Dict[str, A
                 # Don't keep empty values
                 continue
 
-            if isinstance(value, dict):
+            if isinstance(value, dict) and isinstance(base_value[key], Mapping):
                 # After dehdrating a dict, mark any keys that are present on the
                 # base item but not in the incoming item as `do-not-merge` during
                 # rehydration
@@ -117,9 +122,9 @@ def strip(base_value: Dict[str, Any], item_value: Dict[str, Any]) -> Dict[str, A
 
 
 def apply_marked_keys(
-    base_item: Dict[str, Any],
-    full_item: Dict[str, Any],
-    dehydrated: Dict[str, Any],
+    base_item: Mapping[str, Any],
+    full_item: Mapping[str, Any],
+    dehydrated: dict[str, Any],
 ) -> None:
     """Mark keys.
 
@@ -130,8 +135,8 @@ def apply_marked_keys(
     This modifies the dehydrated item in-place.
     """
     try:
-        marked_keys = [key for key in base_item if key not in full_item.keys()]
-        marked_dict = {k: DO_NOT_MERGE_MARKER for k in marked_keys}
+        marked_keys = [key for key in base_item if key not in full_item]
+        marked_dict = dict.fromkeys(marked_keys, DO_NOT_MERGE_MARKER)
         dehydrated.update(marked_dict)
     except TypeError:
         pass
diff --git a/src/pypgstac/src/pypgstac/load.py b/src/pypgstac/src/pypgstac/load.py
index 467676a0..76e39502 100644
--- a/src/pypgstac/src/pypgstac/load.py
+++ b/src/pypgstac/src/pypgstac/load.py
@@ -7,20 +7,16 @@
 import sys
 import time
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import UTC, datetime
 from enum import Enum
 from pathlib import Path
 from typing import (
     Any,
     BinaryIO,
-    Dict,
     Generator,
     Iterable,
     Iterator,
-    Optional,
     TextIO,
-    Tuple,
-    Union,
 )
 
 import orjson
@@ -44,6 +40,9 @@
 
 logger = logging.getLogger(__name__)
 
+MIN_DATETIME_UTC = datetime.min.replace(tzinfo=UTC)
+MAX_DATETIME_UTC = datetime.max.replace(tzinfo=UTC)
+
 
 def _normalize_version_for_parse(version: str) -> str:
     """Extract the numeric semver prefix for version_parser compatibility."""
@@ -64,7 +63,7 @@ class Partition:
     requires_update: bool
 
 
-def chunked_iterable(iterable: Iterable, size: Optional[int] = 10000) -> Iterable:
+def chunked_iterable(iterable: Iterable, size: int | None = 10000) -> Iterable:
     """Chunk an iterable."""
     it = iter(iterable)
     while True:
@@ -99,7 +98,7 @@ def open_std(
     **kwargs: Any,
 ) -> Generator[Any, None, None]:
     """Open files and i/o streams transparently."""
-    fh: Union[TextIO, BinaryIO]
+    fh: TextIO | BinaryIO
     if (
         filename is None
         or filename == "-"
@@ -123,7 +122,7 @@ def open_std(
                 pass
 
 
-def read_json(file: Union[Path, str, Iterator[Any]] = "stdin") -> Iterable:
+def read_json(file: Path | str | Iterator[Any] = "stdin") -> Iterable:
     """Load data from an ndjson or json file."""
     if file is None:
         file = "stdin"
@@ -151,21 +150,23 @@ def read_json(file: Union[Path, str, Iterator[Any]] = "stdin") -> Iterable:
                     raise
     elif isinstance(file, Iterable):
         for line in file:
-            if isinstance(line, Dict):
+            if isinstance(line, dict):
                 yield line
-            else:
+            elif isinstance(line, (str, bytes, bytearray, memoryview)):
                 yield orjson.loads(line)
+            else:
+                raise TypeError("Unsupported json input type in iterable.")
 
 
 class Loader:
     """Utilities for loading data."""
 
     db: PgstacDB
-    _partition_cache: Dict[str, Partition]
+    _partition_cache: dict[str, Partition]
 
     def __init__(self, db: PgstacDB):
         self.db = db
-        self._partition_cache: Dict[str, Partition] = {}
+        self._partition_cache: dict[str, Partition] = {}
 
     def check_version(self) -> None:
         db_version = self.db.version
@@ -187,7 +188,7 @@ def check_version(self) -> None:
                 )
 
     @lru_cache(maxsize=128)
-    def collection_json(self, collection_id: str) -> Tuple[Dict[str, Any], int, str]:
+    def collection_json(self, collection_id: str) -> tuple[dict[str, Any], int, str]:
         """Get collection."""
         res = self.db.query_one(
             "SELECT base_item, key, partition_trunc FROM collections WHERE id=%s",
@@ -206,8 +207,8 @@ def collection_json(self, collection_id: str) -> Tuple[Dict[str, Any], int, str]
 
     def load_collections(
         self,
-        file: Union[Path, str, Iterator[Any]] = "stdin",
-        insert_mode: Optional[Methods] = Methods.insert,
+        file: Path | str | Iterator[Any] = "stdin",
+        insert_mode: Methods | None = Methods.insert,
     ) -> None:
         """Load a collections json or ndjson file."""
         self.check_version()
@@ -297,8 +298,8 @@ def load_collections(
     def load_partition(
         self,
         partition: Partition,
-        items: Iterable[Dict[str, Any]],
-        insert_mode: Optional[Methods] = Methods.insert,
+        items: Iterable[dict[str, Any]],
+        insert_mode: Methods | None = Methods.insert,
     ) -> None:
         """Load items data for a single partition."""
         conn = self.db.connect()
@@ -484,7 +485,7 @@ def load_partition(
             f"Copying data for {partition} took {time.perf_counter() - t} seconds",
         )
 
-    def _partition_update(self, item: Dict[str, Any]) -> str:
+    def _partition_update(self, item: dict[str, Any]) -> str:
         """Update the cached partition with the item information and return the name.
 
         This method will mark the partition as dirty if the bounds of the partition
@@ -505,7 +506,7 @@ def _partition_update(self, item: Dict[str, Any]) -> str:
 
         partition_name: str = p
 
-        partition: Optional[Partition] = None
+        partition: Partition | None = None
 
         if partition_name not in self._partition_cache:
             # Read the partition information from the database if it exists
@@ -527,10 +528,10 @@ def _partition_update(self, item: Dict[str, Any]) -> str:
                 ),
             )
             if db_rows:
-                datetime_range_min: datetime = db_rows[0][0] or datetime.min
-                datetime_range_max: datetime = db_rows[0][1] or datetime.max
-                end_datetime_range_min: datetime = db_rows[0][2] or datetime.min
-                end_datetime_range_max: datetime = db_rows[0][3] or datetime.max
+                datetime_range_min: datetime = db_rows[0][0] or MIN_DATETIME_UTC
+                datetime_range_max: datetime = db_rows[0][1] or MAX_DATETIME_UTC
+                end_datetime_range_min: datetime = db_rows[0][2] or MIN_DATETIME_UTC
+                end_datetime_range_max: datetime = db_rows[0][3] or MAX_DATETIME_UTC
 
                 partition = Partition(
                     name=partition_name,
@@ -575,7 +576,7 @@ def _partition_update(self, item: Dict[str, Any]) -> str:
 
         return partition_name
 
-    def read_dehydrated(self, file: Union[Path, str] = "stdin") -> Generator:
+    def read_dehydrated(self, file: Path | str = "stdin") -> Generator:
         if file is None:
             file = "stdin"
         if isinstance(file, str):
@@ -611,7 +612,7 @@ def read_dehydrated(self, file: Union[Path, str] = "stdin") -> Generator:
 
     def read_hydrated(
         self,
-        file: Union[Path, str, Iterator[Any]] = "stdin",
+        file: Path | str | Iterator[Any] = "stdin",
     ) -> Generator:
         for line in read_json(file):
             item = self.format_item(line)
@@ -620,10 +621,10 @@ def read_hydrated(
 
     def load_items(
         self,
-        file: Union[Path, str, Iterator[Any]] = "stdin",
-        insert_mode: Optional[Methods] = Methods.insert,
-        dehydrated: Optional[bool] = False,
-        chunksize: Optional[int] = 10000,
+        file: Path | str | Iterator[Any] = "stdin",
+        insert_mode: Methods | None = Methods.insert,
+        dehydrated: bool | None = False,
+        chunksize: int | None = 10000,
     ) -> None:
         """Load items json records."""
         self.check_version()
@@ -646,10 +647,10 @@ def load_items(
 
         logger.debug(f"Adding data to database took {time.perf_counter() - t} seconds.")
 
-    def format_item(self, _item: Union[Path, str, Dict[str, Any]]) -> Dict[str, Any]:
+    def format_item(self, _item: Path | str | dict[str, Any]) -> dict[str, Any]:
         """Format an item to insert into a record."""
-        out: Dict[str, Any] = {}
-        item: Dict[str, Any]
+        out: dict[str, Any] = {}
+        item: dict[str, Any]
         if not isinstance(_item, dict):
             try:
                 item = orjson.loads(str(_item).replace("\\\\", "\\"))
@@ -662,11 +663,11 @@ def format_item(self, _item: Union[Path, str, Dict[str, Any]]) -> Dict[str, Any]
 
         out["id"] = item.get("id")
         out["collection"] = item.get("collection")
-        properties: Dict[str, Any] = item.get("properties", {})
+        properties: dict[str, Any] = item.get("properties", {})
 
-        dt: Optional[str] = properties.get("datetime")
-        edt: Optional[str] = properties.get("end_datetime")
-        sdt: Optional[str] = properties.get("start_datetime")
+        dt: str | None = properties.get("datetime")
+        edt: str | None = properties.get("end_datetime")
+        sdt: str | None = properties.get("start_datetime")
 
         if edt is not None and sdt is not None:
             out["datetime"] = sdt
diff --git a/src/pypgstac/src/pypgstac/migrate.py b/src/pypgstac/src/pypgstac/migrate.py
index ea4c1244..2dbb97cd 100644
--- a/src/pypgstac/src/pypgstac/migrate.py
+++ b/src/pypgstac/src/pypgstac/migrate.py
@@ -1,10 +1,12 @@
 """Utilities to help migrate pgstac schema."""
+
 import glob
 import logging
 import os
 import re
 from collections import defaultdict
-from typing import Any, Dict, Iterator, List, Optional
+from collections.abc import Iterator
+from typing import Any, cast
 
 from smart_open import open
 
@@ -33,10 +35,11 @@ def __init__(self, path: str, f: str, t: str) -> None:
         self.f = f
         self.t = t
 
-    def parse_filename(self, filename: str) -> List[str]:
+    def parse_filename(self, filename: str) -> list[str]:
         """Get version numbers from filename."""
         filename = os.path.splitext(os.path.basename(filename))[0].replace(
-            "pgstac.", "",
+            "pgstac.",
+            "",
         )
         return filename.split("-")
 
@@ -45,7 +48,7 @@ def get_files(self) -> Iterator[str]:
         path = self.path.rstrip("/")
         return glob.iglob(f"{path}/*.sql")
 
-    def build_graph(self) -> Dict:
+    def build_graph(self) -> dict[str, list[str]]:
         """Build a graph to get from one version to another."""
         graph = defaultdict(list)
         for file in self.get_files():
@@ -56,10 +59,10 @@ def build_graph(self) -> Dict:
                 graph["init"].append(parts[0])
         return graph
 
-    def build_path(self) -> Optional[List[str]]:
+    def build_path(self) -> list[str] | None:
         """Create the path of ordered files needed to migrate."""
         graph = self.build_graph()
-        explored: List = []
+        explored: list[str] = []
         q = [[self.f]]
 
         while q:
@@ -76,7 +79,7 @@ def build_path(self) -> Optional[List[str]]:
                 explored.append(node)
         return None
 
-    def migrations(self) -> List[str]:
+    def migrations(self) -> list[str]:
         """Return the list of migrations needed in order."""
         path = self.build_path()
         if path is None:
@@ -87,16 +90,16 @@ def migrations(self) -> List[str]:
             return [f"pgstac.{path[0]}.sql"]
         files = []
         for idx in range(len(path) - 1):
-            f = f"pgstac.{path[idx]}-{path[idx+1]}.sql"
+            f = f"pgstac.{path[idx]}-{path[idx + 1]}.sql"
             f = f.replace("--init", "")
-            files.append(f"pgstac.{path[idx]}-{path[idx+1]}.sql")
+            files.append(f"pgstac.{path[idx]}-{path[idx + 1]}.sql")
         return files
 
 
 def get_sql(file: str) -> str:
     """Get sql from a file as a string."""
     sqlstrs = []
-    file = re.sub("[0-9]+[.][0-9]+[.][0-9]+-dev","unreleased",file)
+    file = re.sub("[0-9]+[.][0-9]+[.][0-9]+-dev", "unreleased", file)
     fp = os.path.join(migrations_dir, file)
     file_handle: Any = open(fp)
 
@@ -113,12 +116,12 @@ def __init__(self, db: PgstacDB, schema: str = "pgstac"):
         self.db = db
         self.schema = schema
 
-    def run_migration(self, toversion: Optional[str] = None) -> str:
+    def run_migration(self, toversion: str | None = None) -> str:
         """Migrate a pgstac database to current version."""
         if toversion is None:
             toversion = __version__
         files = []
-        if re.search(r"-dev$",toversion):
+        if re.search(r"-dev$", toversion):
             logger.info("using unreleased version")
             toversion = "unreleased"
 
@@ -126,7 +129,7 @@ def run_migration(self, toversion: Optional[str] = None) -> str:
             map(
                 int,
                 [
-                    self.db.pg_version[i:i + 2]
+                    self.db.pg_version[i : i + 2]
                     for i in range(0, len(self.db.pg_version), 2)
                 ],
             ),
@@ -154,7 +157,8 @@ def run_migration(self, toversion: Optional[str] = None) -> str:
             for file in files:
                 logger.debug(f"Running migration file {file}.")
                 migration_sql = get_sql(file)
-                cur.execute(migration_sql)
+                # Migration SQL is loaded from trusted local migration files.
+                cur.execute(cast(Any, migration_sql))
                 logger.debug(cur.statusmessage)
                 logger.debug(cur.rowcount)
 
@@ -171,5 +175,6 @@ def run_migration(self, toversion: Optional[str] = None) -> str:
                 )
 
         logger.debug(f"New Version: {newversion}")
-
+        if newversion is None:
+            raise Exception("Migration failed to report a new version.")
         return newversion
diff --git a/src/pypgstac/src/pypgstac/pypgstac.py b/src/pypgstac/src/pypgstac/pypgstac.py
index e0720850..c4c1b6fa 100644
--- a/src/pypgstac/src/pypgstac/pypgstac.py
+++ b/src/pypgstac/src/pypgstac/pypgstac.py
@@ -2,7 +2,6 @@
 
 import logging
 import sys
-from typing import Optional
 
 import fire
 import orjson
@@ -18,7 +17,7 @@ class PgstacCLI:
 
     def __init__(
         self,
-        dsn: Optional[str] = "",
+        dsn: str | None = "",
         version: bool = False,
         debug: bool = False,
         usequeue: bool = False,
@@ -39,7 +38,7 @@ def initversion(self) -> str:
         return "0.1.9"
 
     @property
-    def version(self) -> Optional[str]:
+    def version(self) -> str | None:
         """Get PgSTAC version installed on database."""
         return self._db.version
 
@@ -56,7 +55,7 @@ def search(self, query: str) -> str:
         """Search PgSTAC."""
         return self._db.search(query)
 
-    def migrate(self, toversion: Optional[str] = None) -> str:
+    def migrate(self, toversion: str | None = None) -> str:
         """Migrate PgSTAC Database."""
         migrator = Migrate(self._db)
         return migrator.run_migration(toversion=toversion)
@@ -65,9 +64,9 @@ def load(
         self,
         table: Tables,
         file: str,
-        method: Optional[Methods] = Methods.insert,
-        dehydrated: Optional[bool] = False,
-        chunksize: Optional[int] = 10000,
+        method: Methods | None = Methods.insert,
+        dehydrated: bool | None = False,
+        chunksize: int | None = 10000,
     ) -> None:
         """Load collections or items into PgSTAC."""
         loader = Loader(db=self._db)
@@ -123,9 +122,9 @@ def loadextensions(self) -> None:
     def load_queryables(
         self,
         file: str,
-        collection_ids: Optional[list[str]] = None,
-        delete_missing: Optional[bool] = False,
-        index_fields: Optional[list[str]] = None,
+        collection_ids: list[str] | None = None,
+        delete_missing: bool | None = False,
+        index_fields: list[str] | None = None,
     ) -> None:
         """Load queryables from a JSON file.
 
@@ -297,7 +296,7 @@ def load_queryables(
                     cur.execute("SELECT maintain_partitions();")
 
 
-def cli() -> fire.Fire:
+def cli() -> None:
     """Wrap fire call for CLI."""
     fire.Fire(PgstacCLI)
 
diff --git a/src/pypgstac/src/pypgstac/version.py b/src/pypgstac/src/pypgstac/version.py
index 9d70cab6..1b38aa5c 100644
--- a/src/pypgstac/src/pypgstac/version.py
+++ b/src/pypgstac/src/pypgstac/version.py
@@ -1,3 +1,3 @@
 """Version."""
 
-__version__ = "0.9.11"
+__version__ = "0.9.11-dev"
diff --git a/src/pypgstac/tests/conftest.py b/src/pypgstac/tests/conftest.py
index d7536799..eec48b68 100644
--- a/src/pypgstac/tests/conftest.py
+++ b/src/pypgstac/tests/conftest.py
@@ -1,4 +1,5 @@
 """Fixtures for pypgstac tests."""
+
 import os
 from typing import Generator
 
@@ -40,11 +41,11 @@ def db() -> Generator:
                 try:
                     conn.execute("DROP DATABASE pypgstactestdb;")
                     conn.execute(
-                    """
+                        """
                     CREATE DATABASE pypgstactestdb
                     TEMPLATE pgstac_test_db_template;
                     """,
-                )
+                    )
                 except Exception:
                     pass
 
@@ -68,7 +69,7 @@ def db() -> Generator:
 
 
 @pytest.fixture(scope="function")
-def loader(db: PgstacDB) -> Generator:
+def loader(db: PgstacDB) -> Loader:
     """Fixture to get a loader and an empty pgstac."""
     if False:
         db.query("DROP SCHEMA IF EXISTS pgstac CASCADE;")
diff --git a/src/pypgstac/tests/hydration/test_dehydrate_pg.py b/src/pypgstac/tests/hydration/test_dehydrate_pg.py
index 0734eead..8646c08b 100644
--- a/src/pypgstac/tests/hydration/test_dehydrate_pg.py
+++ b/src/pypgstac/tests/hydration/test_dehydrate_pg.py
@@ -36,7 +36,9 @@ def db(self) -> Generator:
         os.environ["PGDATABASE"] = origdb
 
     def dehydrate(
-        self, base_item: Dict[str, Any], item: Dict[str, Any],
+        self,
+        base_item: Dict[str, Any],
+        item: Dict[str, Any],
     ) -> Dict[str, Any]:
         """Dehydrate item using pgstac."""
         with self.db() as db:
diff --git a/src/pypgstac/tests/hydration/test_hydrate_pg.py b/src/pypgstac/tests/hydration/test_hydrate_pg.py
index 7f7ddc05..99e9e5f7 100644
--- a/src/pypgstac/tests/hydration/test_hydrate_pg.py
+++ b/src/pypgstac/tests/hydration/test_hydrate_pg.py
@@ -1,4 +1,5 @@
 """Test Hydration in PgSTAC."""
+
 import os
 from contextlib import contextmanager
 from typing import Any, Dict, Generator
@@ -37,7 +38,9 @@ def db(self) -> Generator[PgstacDB, None, None]:
         os.environ["PGDATABASE"] = origdb
 
     def hydrate(
-        self, base_item: Dict[str, Any], item: Dict[str, Any],
+        self,
+        base_item: Dict[str, Any],
+        item: Dict[str, Any],
     ) -> Dict[str, Any]:
         """Hydrate using pgstac."""
         with self.db() as db:
diff --git a/src/pypgstac/tests/test_benchmark.py b/src/pypgstac/tests/test_benchmark.py
index d264898b..0bce4911 100644
--- a/src/pypgstac/tests/test_benchmark.py
+++ b/src/pypgstac/tests/test_benchmark.py
@@ -82,7 +82,7 @@ def search_hashes(loader: Loader) -> Dict[float, str]:
         }
 
         loader.load_collections(
-            [collection],
+            iter([collection]),
             insert_mode=Methods.insert,
         )
         loader.load_items(
@@ -145,6 +145,8 @@ def xyzsearch_test():
                         True,  # skipcovered
                     ),
                 )
-                _ = cursor.fetchone()[0]
+                row = cursor.fetchone()
+                assert row is not None
+                _ = row[0]
 
     _ = benchmark(xyzsearch_test)
diff --git a/src/pypgstac/tests/test_load.py b/src/pypgstac/tests/test_load.py
index 870b9a9c..f8ab233b 100644
--- a/src/pypgstac/tests/test_load.py
+++ b/src/pypgstac/tests/test_load.py
@@ -496,6 +496,7 @@ def test_valid_srid(loader: Loader) -> None:
         SELECT st_srid(geometry) from items LIMIT 1;
     """,
     )
+    assert isinstance(srid, int)
     assert srid > 0
 
 
@@ -600,10 +601,10 @@ def load_one_item(item_idx: int) -> None:
     # Report any errors from threads
     if errors:
         error_msgs = [f"Item {idx}: {type(e).__name__}: {e}" for idx, e in errors]
-        pytest.fail(
-            f"{len(errors)}/{num_items} concurrent loads failed:\n"
-            + "\n".join(error_msgs),
+        message = f"{len(errors)}/{num_items} concurrent loads failed:\n" + "\n".join(
+            error_msgs,
         )
+        assert not errors, message
 
     count = db.query_one("SELECT count(*) FROM items;")
     assert count == num_items, (
diff --git a/src/pypgstac/tests/test_queryables.py b/src/pypgstac/tests/test_queryables.py
index 31241818..67ae3e2b 100644
--- a/src/pypgstac/tests/test_queryables.py
+++ b/src/pypgstac/tests/test_queryables.py
@@ -6,7 +6,7 @@
 import pytest
 
 from pypgstac.db import PgstacDB
-from pypgstac.load import Loader
+from pypgstac.load import Loader, Methods
 from pypgstac.pypgstac import PgstacCLI
 
 HERE = Path(__file__).parent
@@ -223,7 +223,8 @@ def test_maintain_partitions_called_only_with_index_fields(mock_connect):
 
     # Check that maintain_partitions was called
     maintain_calls = [
-        call_args for call_args in mock_cursor.execute.call_args_list
+        call_args
+        for call_args in mock_cursor.execute.call_args_list
         if "maintain_partitions" in str(call_args)
     ]
     assert len(maintain_calls) == 1
@@ -236,7 +237,8 @@ def test_maintain_partitions_called_only_with_index_fields(mock_connect):
 
     # Check that maintain_partitions was not called
     maintain_calls = [
-        call_args for call_args in mock_cursor.execute.call_args_list
+        call_args
+        for call_args in mock_cursor.execute.call_args_list
         if "maintain_partitions" in str(call_args)
     ]
     assert len(maintain_calls) == 0
@@ -250,7 +252,7 @@ def test_load_queryables_with_collections(db: PgstacDB, loader: Loader) -> None:
     # Load test collections first
     loader.load_collections(
         str(TEST_COLLECTIONS_JSON),
-        insert_mode="insert",
+        insert_mode=Methods.insert,
     )
 
     # Get collection IDs from the database
@@ -425,13 +427,14 @@ def test_load_queryables_delete_missing(db: PgstacDB) -> None:
 
 
 def test_load_queryables_delete_missing_with_collections(
-    db: PgstacDB, loader: Loader,
+    db: PgstacDB,
+    loader: Loader,
 ) -> None:
     """Test loading queryables with delete_missing=True and specific collections."""
     # Load test collections first
     loader.load_collections(
         str(TEST_COLLECTIONS_JSON),
-        insert_mode="insert",
+        insert_mode=Methods.insert,
     )
 
     # Get collection IDs from the database