diff --git a/.cargo/config b/.cargo/config
new file mode 100644
index 00000000000..a16ed45ce85
--- /dev/null
+++ b/.cargo/config
@@ -0,0 +1,25 @@
+[build]
+# enable tokio-console and some other goodies
+rustflags = [
+    "--cfg", "tokio_unstable",
+]
+
+# sparse protocol opt-in
+# See https://blog.rust-lang.org/2023/03/09/Rust-1.68.0.html#cargos-sparse-protocol
+[registries.crates-io]
+protocol = "sparse"
+
+[target.x86_64-unknown-linux-gnu]
+rustflags = [
+    # see above
+    "--cfg", "tokio_unstable",
+    # Faster linker.
+    "-C", "link-arg=-fuse-ld=lld",
+    # Fix `perf` as suggested by https://github.com/flamegraph-rs/flamegraph/blob/2d19a162df4066f37d58d5471634f0bd9f0f4a62/README.md?plain=1#L18
+    # Also see https://bugs.chromium.org/p/chromium/issues/detail?id=919499#c16
+    "-C", "link-arg=-Wl,--no-rosegment",
+    # Enable all features supported by CPUs more recent than haswell (2013)
+    "-C", "target-cpu=haswell",
+    # Enable framepointers because profiling and debugging is a nightmare w/o it and it is generally not considered a performance advantage on modern x86_64 CPUs.
+    "-C", "force-frame-pointers=yes",
+]
diff --git a/.circleci/config.yml b/.circleci/config.yml
new file mode 100644
index 00000000000..b8597819b24
--- /dev/null
+++ b/.circleci/config.yml
@@ -0,0 +1,284 @@
+---
+# CI Overview
+# -----------
+#
+# Every commit:
+#
+# The CI for every PR and merge to main runs tests, fmt, lints and compiles debug binaries
+#
+# On main if all these checks pass it will then additionally compile in "release" mode and
+# publish a docker image to quay.io/influxdb/influxdb3:$COMMIT_SHA
+#
+# Manually trigger build and push of container image for a branch:
+#
+# Navigate to https://app.circleci.com/pipelines/github/influxdata/influxdb?branch=<branch-name> (<- change this!)
+# Then:
+#
+# - Click "Run Pipeline" in the top-right
+# - Expand "Add Parameters"
+# - Add a "boolean" parameter called "release_branch" with the value true
+# - Click "Run Pipeline"
+#
+# You can also do this using the CircleCI API:
+#
+# Using `xh`:
+#
+#   # e.g. using 'xh' (https://github.com/ducaale/xh)
+#   $ xh -a '<your personal circleCI token>:' POST \
+#       https://circleci.com/api/v2/project/github/influxdata/influxdb/pipeline \
+#       parameters:='{"release_branch": true}' branch=chore/ci-tidy-up
+#
+# ...or equivalent with `curl`:
+#   $ curl -XPOST -H "Content-Type: application/json" -H "Circle-Token: <your personal circleCI token>" \
+#       -d '{"parameters": {"release_branch": true}, "branch": "chore/ci-tidy-up"}' \
+#       https://circleci.com/api/v2/project/github/influxdata/influxdb/pipeline
+
+version: 2.1
+
+commands:
+  rust_components:
+    description: Verify installed components
+    steps:
+      - run:
+          name: Verify installed components
+          command: |
+            rustup --version
+            rustup show
+            cargo fmt --version
+            cargo clippy --version
+
+  login_to_gcloud:
+    steps:
+      - run:
+          name: Login to gcloud
+          command: |
+            echo "${GCLOUD_SERVICE_ACCOUNT_KEY}" >/tmp/gcloud.json
+            gcloud auth activate-service-account "${GCLOUD_SERVICE_ACCOUNT_EMAIL}" --key-file /tmp/gcloud.json --quiet
+            rm -f /tmp/gcloud.json
+            gcloud auth configure-docker us-docker.pkg.dev
+
+jobs:
+  fmt:
+    docker:
+      - image: quay.io/influxdb/rust:ci
+    environment:
+      # Disable incremental compilation to avoid overhead. We are not preserving these files anyway.
+      CARGO_INCREMENTAL: "0"
+      # Disable full debug symbol generation to speed up CI build
+      # "1" means line tables only, which is useful for panic tracebacks.
+      CARGO_PROFILE_DEV_DEBUG: "1"
+      # https://github.com/rust-lang/cargo/issues/10280
+      CARGO_NET_GIT_FETCH_WITH_CLI: "true"
+    steps:
+      - checkout
+      - rust_components
+      - run:
+          name: Rust fmt
+          command: cargo fmt --all -- --check
+  lint:
+    docker:
+      - image: quay.io/influxdb/rust:ci
+    environment:
+      # Disable incremental compilation to avoid overhead. We are not preserving these files anyway.
+      CARGO_INCREMENTAL: "0"
+      # Disable full debug symbol generation to speed up CI build
+      # "1" means line tables only, which is useful for panic tracebacks.
+      CARGO_PROFILE_DEV_DEBUG: "1"
+      # https://github.com/rust-lang/cargo/issues/10280
+      CARGO_NET_GIT_FETCH_WITH_CLI: "true"
+    steps:
+      - checkout
+      - rust_components
+      - run:
+          name: Clippy
+          command: cargo clippy --all-targets --all-features --workspace -- -D warnings
+      - run:
+          name: Yamllint
+          command: yamllint --config-file .circleci/yamllint.yml --strict .
+  cargo_audit:
+    docker:
+      - image: quay.io/influxdb/rust:ci
+    environment:
+      # Disable incremental compilation to avoid overhead. We are not preserving these files anyway.
+      CARGO_INCREMENTAL: "0"
+      # Disable full debug symbol generation to speed up CI build
+      # "1" means line tables only, which is useful for panic tracebacks.
+      CARGO_PROFILE_DEV_DEBUG: "1"
+      # https://github.com/rust-lang/cargo/issues/10280
+      CARGO_NET_GIT_FETCH_WITH_CLI: "true"
+    steps:
+      - checkout
+      - rust_components
+      - run:
+          name: Install cargo-deny
+          command: cargo install cargo-deny --locked
+      - run:
+          name: cargo-deny Checks
+          command: cargo deny check -s
+  doc:
+    docker:
+      - image: quay.io/influxdb/rust:ci
+    resource_class: large # use of a smaller executor runs out of memory
+    environment:
+      # Disable incremental compilation to avoid overhead. We are not preserving these files anyway.
+      CARGO_INCREMENTAL: "0"
+      # Disable full debug symbol generation to speed up CI build
+      # "1" means line tables only, which is useful for panic tracebacks.
+      CARGO_PROFILE_DEV_DEBUG: "1"
+      # https://github.com/rust-lang/cargo/issues/10280
+      CARGO_NET_GIT_FETCH_WITH_CLI: "true"
+      # Turn warnings into errors
+      RUSTDOCFLAGS: "-D warnings -A rustdoc::private-intra-doc-links"
+    steps:
+      - checkout
+      - rust_components
+      - run:
+          name: Cargo doc
+          command: cargo doc --document-private-items --no-deps --workspace
+      - run:
+          name: Compress Docs
+          command: tar -cvzf rustdoc.tar.gz target/doc/
+      - store_artifacts:
+          path: rustdoc.tar.gz
+
+  # Run all tests
+  test:
+    docker:
+      - image: quay.io/influxdb/rust:ci
+    resource_class: 2xlarge+ # use of a smaller executor tends crashes on link
+    environment:
+      # Disable incremental compilation to avoid overhead. We are not preserving these files anyway.
+      CARGO_INCREMENTAL: "0"
+      # Disable full debug symbol generation to speed up CI build
+      # "1" means line tables only, which is useful for panic tracebacks.
+      CARGO_PROFILE_DEV_DEBUG: "1"
+      # https://github.com/rust-lang/cargo/issues/10280
+      CARGO_NET_GIT_FETCH_WITH_CLI: "true"
+      RUST_BACKTRACE: "1"
+    steps:
+      - checkout
+      - rust_components
+      - run:
+          name: cargo test --workspace
+          command: cargo test --workspace
+
+  # end to end tests with Heappy (heap profiling enabled)
+  test_heappy:
+    docker:
+      - image: quay.io/influxdb/rust:ci
+    resource_class: xlarge # use of a smaller executor tends crashes on link
+    environment:
+      # Disable incremental compilation to avoid overhead. We are not preserving these files anyway.
+      CARGO_INCREMENTAL: "0"
+      # Disable full debug symbol generation to speed up CI build
+      # "1" means line tables only, which is useful for panic tracebacks.
+      CARGO_PROFILE_DEV_DEBUG: "1"
+      # https://github.com/rust-lang/cargo/issues/10280
+      CARGO_NET_GIT_FETCH_WITH_CLI: "true"
+      RUST_BACKTRACE: "1"
+    steps:
+      - checkout
+      - rust_components
+      - run:
+          name: cargo test --no-default-features --features=heappy --workspace
+          command: cargo test --no-default-features --features=heappy --workspace
+
+  # Build a dev binary.
+  #
+  # Compiles a binary with the default ("dev") cargo profile from the influxdb3 source
+  # using the latest ci_image (influxdb/rust) and ensures various targets compile successfully
+  build_dev:
+    docker:
+      - image: quay.io/influxdb/rust:ci
+    resource_class: 2xlarge # use of a smaller executor tends crashes on link
+    environment:
+      # Disable incremental compilation to avoid overhead. We are not preserving these files anyway.
+      CARGO_INCREMENTAL: "0"
+      # Disable full debug symbol generation to speed up CI build
+      # "1" means line tables only, which is useful for panic tracebacks.
+      CARGO_PROFILE_DEV_DEBUG: "1"
+      # https://github.com/rust-lang/cargo/issues/10280
+      CARGO_NET_GIT_FETCH_WITH_CLI: "true"
+      # The `2xlarge` resource class that we use has 32GB RAM but also 16 CPUs. This means we have 2GB RAM per core on
+      # avarage. At peak this is a bit tight, so lower the CPU count for cargo a bit.
+      CARGO_BUILD_JOBS: "12"
+    steps:
+      - checkout
+      - rust_components
+      - run:
+          name: Cargo build
+          command: cargo build --workspace
+      - run:
+          name: Check benches compile
+          command: cargo check --workspace --benches
+      - run:
+          name: Check extra features (like prod image)
+          command: cargo check --no-default-features --features="aws,gcp,azure,jemalloc_replacing_malloc,tokio_console,pprof"
+
+  # Compile cargo "release" profile binaries for influxdb3 & data generator
+  #
+  # Uses the latest ci_image (influxdb/rust) to build a release binary and
+  # copies it to a minimal container image based upon `rust:slim-buster`. This
+  # minimal image is then pushed to `quay.io/influxdb/influxdb3:${BRANCH}`.
+  build_release:
+    # need a machine executor to have a full-powered docker daemon (the `setup_remote_docker` system just provides a
+    # kinda small node)
+    machine:
+      image: default
+    resource_class: 2xlarge # CPU bound, so make it fast
+    steps:
+      - checkout
+      - run:
+          name: Cargo release build
+          command: |
+            COMMIT_SHA="$(git rev-parse HEAD)"
+
+            .circleci/docker_build_release.bash \
+              "influxdb3" \
+              "aws,gcp,azure,jemalloc_replacing_malloc,tokio_console,pprof" \
+              "quay.io/influxdb/influxdb3:$COMMIT_SHA"
+
+            mkdir /tmp/images
+            docker save quay.io/influxdb/influxdb3:"$COMMIT_SHA" | gzip > /tmp/images/influxdb3.tar.gz
+          # linking might take a while and doesn't produce CLI output
+          no_output_timeout: 30m
+      - store_artifacts:
+          path: /tmp/images
+      - persist_to_workspace:
+          root: /tmp/images
+          paths:
+            - "*.tar.gz"
+
+parameters:
+  release_branch:
+    description: "Build and push container image for non-main branch"
+    type: boolean
+    default: false
+
+workflows:
+  version: 2
+
+  # CI for all pull requests.
+  ci:
+    when:
+      and:
+        - not: << pipeline.parameters.release_branch >>
+    jobs:
+      - fmt
+      - lint
+      - cargo_audit
+      - test
+      - test_heappy
+      - build_dev
+      - doc
+      - build_release:
+          filters:
+            branches:
+              only: main
+
+  # Force build and push of container image for non-main branch.
+  # See instructions at the top of this file
+  release_branch:
+    when: << pipeline.parameters.release_branch >>
+    jobs:
+      - build_release
diff --git a/.circleci/docker_build_release.bash b/.circleci/docker_build_release.bash
new file mode 100755
index 00000000000..70c5e32fe84
--- /dev/null
+++ b/.circleci/docker_build_release.bash
@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+readonly PACKAGE="$1"
+readonly FEATURES="$2"
+readonly TAG="$3"
+
+RUST_VERSION="$(sed -E -ne 's/channel = "(.*)"/\1/p' rust-toolchain.toml)"
+COMMIT_SHA="$(git rev-parse HEAD)"
+COMMIT_TS="$(env TZ=UTC0 git show --quiet --date='format-local:%Y-%m-%dT%H:%M:%SZ' --format="%cd" HEAD)"
+NOW="$(date --utc --iso-8601=seconds)"
+REPO_URL="https://github.com/influxdata/influxdb_iox"
+
+exec docker buildx build \
+  --build-arg CARGO_INCREMENTAL="no" \
+  --build-arg CARGO_NET_GIT_FETCH_WITH_CLI="true" \
+  --build-arg FEATURES="$FEATURES" \
+  --build-arg RUST_VERSION="$RUST_VERSION" \
+  --build-arg PACKAGE="$PACKAGE" \
+  --label org.opencontainers.image.created="$NOW" \
+  --label org.opencontainers.image.url="$REPO_URL" \
+  --label org.opencontainers.image.revision="$COMMIT_SHA" \
+  --label org.opencontainers.image.vendor="InfluxData Inc." \
+  --label org.opencontainers.image.title="InfluxDB IOx, '$PACKAGE'" \
+  --label org.opencontainers.image.description="InfluxDB IOx production image for package '$PACKAGE'" \
+  --label com.influxdata.image.commit-date="$COMMIT_TS" \
+  --label com.influxdata.image.package="$PACKAGE" \
+  --progress plain \
+  --tag "$TAG" \
+  .
diff --git a/.circleci/yamllint.yml b/.circleci/yamllint.yml
new file mode 100644
index 00000000000..b32765b6d79
--- /dev/null
+++ b/.circleci/yamllint.yml
@@ -0,0 +1,3 @@
+rules:
+  truthy:
+    check-keys: false
diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 00000000000..c755c6fb398
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,13 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+
+[{Dockerfile*,*.proto}]
+indent_size = 2
+
+[{*.rs,*.toml,*.sh,*.bash}]
+indent_size = 4
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 00000000000..0248cc6d2dc
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,4 @@
+generated_types/protos/google/ linguist-generated=true
+generated_types/protos/grpc/ linguist-generated=true
+generated_types/src/wal_generated.rs linguist-generated=true
+trace_exporters/src/thrift/ linguist-generated=true
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 00000000000..edda9ebc12c
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1,5 @@
+# This file allows teams or people to be assigned as
+# automatic code-reviewers for files or directories.
+#
+# Here is information about how to configure this file:
+# https://help.github.com/en/articles/about-code-owners
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 00000000000..5f95d77e1cd
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,50 @@
+---
+name: Bug report
+about: Create a report to help us improve
+---
+
+<!--
+
+Thank you for reporting a bug in InfluxDB IOx.
+
+Have you read the contributing section of the README? Please do if you haven't.
+https://github.com/influxdata/influxdb/blob/main/README.md
+
+* Please ask usage questions in the Influx Slack (there is an #influxdb-iox channel).
+    * https://influxdata.com/slack
+* Please don't open duplicate issues; use the search. If there is an existing issue please don't add "+1" or "me too" comments; only add comments with new information.
+* Please check whether the bug can be reproduced with tip of main.
+* The fastest way to fix a bug is to open a Pull Request.
+    * https://github.com/influxdata/influxdb/pulls
+
+-->
+
+__Steps to reproduce:__
+List the minimal actions needed to reproduce the behaviour.
+
+1. ...
+2. ...
+3. ...
+
+__Expected behaviour:__
+Describe what you expected to happen.
+
+__Actual behaviour:__
+Describe What actually happened.
+
+__Environment info:__
+
+* Please provide the command you used to build the project, including any `RUSTFLAGS`.
+* System info: Run `uname -srm` or similar and copy the output here (we want to know your OS, architecture etc).
+* If you're running IOx in a containerised environment then details about that would be helpful.
+* Other relevant environment details: disk info, hardware setup etc.
+
+__Config:__
+Copy any non-default config values here or attach the full config as a gist or file.
+
+<!-- The following sections are only required if relevant. -->
+
+__Logs:__
+Include snippet of errors in logs or stack traces here.
+Sometimes you can get useful information by running the program with the `RUST_BACKTRACE=full` environment variable.
+Finally, the IOx server has a `-vv` for verbose logging.
diff --git a/.github/ISSUE_TEMPLATE/developer_experience.md b/.github/ISSUE_TEMPLATE/developer_experience.md
new file mode 100644
index 00000000000..987ad619c8e
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/developer_experience.md
@@ -0,0 +1,99 @@
+---
+name: Developer experience problem
+about: Tell us about slow builds, tests, and code editing
+---
+
+<!--
+Thank you for sharing your development experience concerns with the InfluxDB IOx team.
+
+Have your read the contributing guide?
+https://github.com/influxdata/influxdb/blob/main/CONTRIBUTING.md
+
+We welcome your thoughts and feedback on the IOx developer experience.
+
+In particular:
+- Is your code editor sluggish?
+- How long does your edit-build or edit-test cycle take?
+- Is your cardboard sword wearing out faster than usual?
+
+We especially welcome your experience improving your development environment.
+- Which hardware tradeoffs work best?
+- Which code editor and plugins have been helpful?
+- Suggest build configuration or code organization tweaks?
+
+Thank you!
+-->
+
+## Describe Development Experience Issue:
+
+<!--
+Be descriptive, write a few sentences describing the difficult (or positive) developer experience.
+-->
+
+### Steps to reproduce:
+
+<!--
+For example:
+1. git checkout deadbeef
+2. cargo clean
+3. cargo build --offline
+4. ...
+-->
+
+1. ...
+2. ...
+3. ...
+4. ...
+
+### Desired result:
+
+<!--
+For example:
+Build time less than 5 minutes
+-->
+
+### Actual result:
+<!--
+For example:
+Build time 15m32s
+-->
+
+## Hardware Environment:
+
+<!--
+Describe the hardware you are developing on.
+-->
+
+- Package: ... <!-- laptop, workstation, cloud VM, etc -->
+- CPU: ...
+- Memory: ...
+- Block Device: ...
+
+## Operating System:
+
+<!--
+If Unix-like, then the command `uname -a` is ideal.
+-->
+
+## Code Editing Tool:
+
+<!--
+Describe your IDE or code editor, with version.
+Some examples:
+- vim 8.2
+- IntelliJ CLion 2021.2.3
+- VS Code 1.61.0
+-->
+
+## Build Environment:
+
+[ ] I'm using sccache
+
+<!--
+Describe your build environment.
+Some examples:
+- IDE build trigger
+- IDE debug trigger
+- bash: cargo build
+- zsh: cargo build --release
+-->
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 00000000000..08617fa8f4e
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,31 @@
+---
+name: Feature request
+about: Opening a feature request kicks off a discussion
+---
+
+<!--
+
+Thank you for suggesting an idea to improve InfluxDB IOx.
+
+Have you read the contributing section of the README? Please do if you haven't.
+https://github.com/influxdata/influxdb/blob/main/README.md
+
+* Please ask usage questions in the Influx Slack (there is an #influxdb-iox channel).
+    * https://influxdata.com/slack
+* If the feature you're interested in already has an open *or* closed ticket associated with it (please search) please don't add "+1" or "me too" comments. The Github reaction emojis are a way to indicate your support for something and will contribute to prioritisation.
+
+-->
+__Use case:__
+Why is this important (helps with prioritizing requests)?
+
+__Proposal:__
+Short summary of the feature.
+
+__Current behaviour:__
+Describe what currently happens.
+
+__Desired behaviour:__
+Describe what you want.
+
+__Alternatives considered:__
+Describe other solutions or features you considered.
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
new file mode 100644
index 00000000000..ec003d26881
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,6 @@
+Closes #
+
+Describe your proposed changes here.
+
+- [ ] I've read the contributing section of the project [README](https://github.com/influxdata/influxdb/blob/main/README.md).
+- [ ] Signed [CLA](https://influxdata.com/community/cla/) (if not already signed).
diff --git a/.github/stale.yml b/.github/stale.yml
new file mode 100644
index 00000000000..b99dabf6154
--- /dev/null
+++ b/.github/stale.yml
@@ -0,0 +1,22 @@
+# Configuration for https://probot.github.io/apps/stale/
+#
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 90
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - security
+  - stale-exempt
+# Label to use when marking an issue as stale
+staleLabel: wontfix
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: >
+  This issue has been automatically closed because it has not had
+  recent activity. Please reopen if this issue is still
+  important to you. Thank you for your contributions.
diff --git a/.github/workflows/semantic.yml b/.github/workflows/semantic.yml
new file mode 100644
index 00000000000..5fbae6dc995
--- /dev/null
+++ b/.github/workflows/semantic.yml
@@ -0,0 +1,10 @@
+---
+name: "Semantic PR and Commit Messages"
+
+on:
+  pull_request:
+    types: [opened, reopened, synchronize, edited]
+
+jobs:
+  semantic:
+    uses: influxdata/validate-semantic-github-messages/.github/workflows/semantic.yml@main
diff --git a/.gitignore b/.gitignore
index 6985cf1bd09..16724a53a35 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,14 +1,20 @@
-# Generated by Cargo
-# will have compiled files and executables
-debug/
-target/
-
-# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
-# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
-Cargo.lock
-
-# These are backup files generated by rustfmt
 **/*.rs.bk
-
-# MSVC Windows builds of rustc generate these, which store debugging information
+**/*.rs.bk
+**/.DS_Store
+**/.vscode
+**/target
 *.pdb
+*.pending-snap
+*.tsm
+.env
+.gdb_history
+.idea/
+Cargo.lock
+debug/
+heaptrack.*
+massif.out.*
+perf.data*
+perf.svg
+perf.txt
+results/
+valgrind-out.txt
diff --git a/.kodiak.toml b/.kodiak.toml
new file mode 100644
index 00000000000..f96092d0482
--- /dev/null
+++ b/.kodiak.toml
@@ -0,0 +1,2 @@
+version = 1
+merge.method = "squash"
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 00000000000..f296fe1fc5a
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,200 @@
+# Contributing
+
+Thank you for thinking of contributing! We very much welcome contributions from the community.
+To make the process easier and more valuable for everyone involved we have a few rules and guidelines to follow.
+
+Anyone with a Github account is free to file issues on the project.
+However, if you want to contribute documentation or code then you will need to sign InfluxData's Individual Contributor License Agreement (CLA), which can be found with more information [on our website].
+
+[on our website]: https://www.influxdata.com/legal/cla/
+
+## Submitting Issues and Feature Requests
+
+Before you file an [issue], please search existing issues in case the same or similar issues have already been filed.
+If you find an existing open ticket covering your issue then please avoid adding "👍" or "me too" comments; Github notifications can cause a lot of noise for the project maintainers who triage the back-log.
+However, if you have a new piece of information for an existing ticket and you think it may help the investigation or resolution, then please do add it as a comment!
+You can signal to the team that you're experiencing an existing issue with one of Github's emoji reactions (these are a good way to add "weight" to an issue from a prioritisation perspective).
+
+### Submitting an Issue
+
+The [New Issue] page has templates for both bug reports and feature requests.
+Please fill one of them out!
+The issue templates provide details on what information we will find useful to help us fix an issue.
+In short though, the more information you can provide us about your environment and what behaviour you're seeing, the easier we can fix the issue.
+If you can push a PR with test cases that trigger a defect or bug, even better!
+P.S, if you have never written a bug report before, or if you want to brush up on your bug reporting skills, we recommend reading Simon Tatham's essay [How to Report Bugs Effectively].
+
+As well as bug reports we also welcome feature requests (there is a dedicated issue template for these).
+Typically, the maintainers will periodically review community feature requests and make decisions about if we want to add them.
+For features we don't plan to support we will close the feature request ticket (so, again, please check closed tickets for feature requests before submitting them).
+
+[issue]: https://github.com/influxdata/influxdb/issues/new
+[New Issue]: https://github.com/influxdata/influxdb/issues/new
+[How to Report Bugs Effectively]: https://www.chiark.greenend.org.uk/~sgtatham/bugs.html
+
+## Contributing Changes
+
+InfluxDB IOx is written mostly in idiomatic Rust—please see the [Style Guide] for more details.
+All code must adhere to the `rustfmt` format, and pass all of the `clippy` checks we run in CI (there are more details further down this README).
+
+[Style Guide]: docs/style_guide.md
+
+### Finding Issues To Work On
+
+The [good first issue](https://github.com/influxdata/influxdb/issues?q=is%3Aopen+is%3Aissue+label%3Agood-first-issue) and the [help wanted](https://github.com/influxdata/influxdb/issues?q=is%3Aopen+is%3Aissue+label%3A%22help+wanted) labels are used to identify issues where we encourage community contributions.
+They both indicate issues for which we would welcome independent community contributions, but the former indicates a sub-set of these that are especially good for first-time contributors.
+If you want some clarifications or guidance for working on one of these issues, or you simply want to let others know that you're working on one, please leave a comment on the ticket.
+
+[good first issue]: https://github.com/influxdata/influxdb/issues?q=is%3Aopen+is%3Aissue+label%3Agood-first-issue
+[help wanted]: https://github.com/influxdata/influxdb/issues?q=is%3Aopen+is%3Aissue+label%3A%22help+wanted
+
+### Bigger Changes
+
+If you're planning to submit significant changes, even if it relates to existing tickets **please** talk to the project maintainers first!
+The easiest way to do this is to open up a new ticket, describing the changes you plan to make and *why* you plan to make them. Changes that may seem obviously good to you, are not always obvious to everyone else.
+Example of changes where we would encourage up-front communication:
+
+* new IOx features;
+* significant refactors that move code between modules/crates etc;
+* performance improvements involving new concurrency patterns or the use of `unsafe` code;
+* API-breaking changes, or changes that require a data migration;
+* any changes that risk the durability or correctness of data.
+
+We are always excited to have community involvement but we can't accept everything.
+To avoid having your hard work rejected the best approach to start a discussion first.
+Further, please don't expect us to accept significant changes without new test coverage, and/or in the case of performance changes benchmarks that show the improvements.
+
+### Making a PR
+
+To open a PR you will need to have a Github account.
+Fork the `influxdb` repo and work on a branch on your fork.
+When you have completed your changes, or you want some incremental feedback make a Pull Request to InfluxDB IOx [here].
+
+If you want to discuss some work in progress then please prefix `[WIP]` to the
+PR title.
+
+For PRs that you consider ready for review, verify the following locally before you submit it:
+
+* you have a coherent set of logical commits, with messages conforming to the [Conventional Commits] specification;
+* all the tests and/or benchmarks pass, including documentation tests;
+* the code is correctly formatted and all `clippy` checks pass; and
+* you haven't left any "code cruft" (commented out code blocks etc).
+
+There are some tips on verifying the above in the [next section](#running-tests).
+
+**After** submitting a PR, you should:
+
+* verify that all CI status checks pass and the PR is 💚;
+* ask for help on the PR if any of the status checks are 🔴, and you don't know why;
+* wait patiently for one of the team to review your PR, which could take a few days.
+
+[here]: https://github.com/influxdata/influxdb/compare
+[Conventional Commits]: https://www.conventionalcommits.org/en/v1.0.0/
+
+## Running Tests
+
+The `cargo` build tool runs tests as well. Run:
+
+```shell
+cargo test --workspace
+```
+
+### Enabling logging in tests
+
+To enable logging to stderr during a run of `cargo test` set the Rust
+`RUST_LOG` environment variable. For example, to see all INFO messages:
+
+```shell
+RUST_LOG=info cargo test --workspace
+```
+
+Since this feature uses
+[`EnvFilter`](https://docs.rs/tracing-subscriber/0.2.15/tracing_subscriber/filter/struct.EnvFilter.html) internally, you
+can use all the features of that crate. For example, to disable the
+(somewhat noisy) logs in some h2 modules, you can use a value of
+`RUST_LOG` such as:
+
+```shell
+RUST_LOG=debug,hyper::proto::h1=info,h2=info cargo test --workspace
+```
+
+See [logging.md](docs/logging.md) for more information on logging.
+
+### End-to-End Tests
+
+There are end-to-end tests that spin up a server and make requests via the client library and API. They can be found in `tests/end_to_end_cases`
+
+These require additional setup as described in [testing.md](docs/testing.md).
+
+### Visually showing explain plans
+
+Some query plans are output in the log in [graphviz](https://graphviz.org/) format. To display them you can use the `tools/iplan` helper.
+
+For example, if you want to display this plan:
+
+```
+// Begin DataFusion GraphViz Plan (see https://graphviz.org)
+digraph {
+  subgraph cluster_1
+  {
+    graph[label="LogicalPlan"]
+    2[shape=box label="SchemaPivot"]
+    3[shape=box label="Projection: "]
+    2 -> 3 [arrowhead=none, arrowtail=normal, dir=back]
+    4[shape=box label="Filter: Int64(0) LtEq #time And #time Lt Int64(10000) And #host Eq Utf8(_server01_)"]
+    3 -> 4 [arrowhead=none, arrowtail=normal, dir=back]
+    5[shape=box label="TableScan: attributes projection=None"]
+    4 -> 5 [arrowhead=none, arrowtail=normal, dir=back]
+  }
+  subgraph cluster_6
+  {
+    graph[label="Detailed LogicalPlan"]
+    7[shape=box label="SchemaPivot\nSchema: [non_null_column:Utf8]"]
+    8[shape=box label="Projection: \nSchema: []"]
+    7 -> 8 [arrowhead=none, arrowtail=normal, dir=back]
+    9[shape=box label="Filter: Int64(0) LtEq #time And #time Lt Int64(10000) And #host Eq Utf8(_server01_)\nSchema: [color:Utf8;N, time:Int64]"]
+    8 -> 9 [arrowhead=none, arrowtail=normal, dir=back]
+    10[shape=box label="TableScan: attributes projection=None\nSchema: [color:Utf8;N, time:Int64]"]
+    9 -> 10 [arrowhead=none, arrowtail=normal, dir=back]
+  }
+}
+// End DataFusion GraphViz Plan
+```
+
+You can pipe it to `iplan` and render as a .pdf
+
+
+## Running `rustfmt` and `clippy`
+
+CI will check the code formatting with [`rustfmt`] and Rust best practices with [`clippy`].
+
+To automatically format your code according to `rustfmt` style, first make sure `rustfmt` is installed using `rustup`:
+
+```shell
+rustup component add rustfmt
+```
+
+Then, whenever you make a change and want to reformat, run:
+
+```shell
+cargo fmt --all
+```
+
+Similarly with `clippy`, install with:
+
+```shell
+rustup component add clippy
+```
+
+And run with:
+
+```shell
+cargo clippy --all-targets --workspace -- -D warnings
+```
+
+[`rustfmt`]: https://github.com/rust-lang/rustfmt
+[`clippy`]: https://github.com/rust-lang/rust-clippy
+
+## Distributed Tracing
+
+See [tracing.md](docs/tracing.md) for more information on the distributed tracing functionality within IOx
diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 00000000000..96c53a9c0e0
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,6994 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "addr2line"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
+dependencies = [
+ "gimli",
+]
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "ahash"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
+dependencies = [
+ "cfg-if",
+ "const-random",
+ "getrandom",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "alloc-no-stdlib"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+
+[[package]]
+name = "alloc-stdlib"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
+dependencies = [
+ "alloc-no-stdlib",
+]
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
+
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anstream"
+version = "0.6.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d96bd03f33fe50a863e394ee9718a706f988b9079b20c3784fb726e7678b62fb"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8901269c6307e8d93993578286ac0edf7f195079ffff5ebdeea6a59ffb7e36bc"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c75ac65da39e5fe5ab759307499ddad880d724eed2f6ce5b5e8a26f4f387928c"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e28923312444cdd728e4738b3f9c9cac739500909bb3d3c94b43551b16517648"
+dependencies = [
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cd54b81ec8d6180e24654d0b371ad22fc3dd083b6ff8ba325b72e00c87660a7"
+dependencies = [
+ "anstyle",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.82"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f538837af36e6f6a9be0faa67f9a314f8119e4e4b5867c6ab40ed60360142519"
+
+[[package]]
+name = "arc-swap"
+version = "1.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69f7f8c3906b62b754cd5326047894316021dcfe5a194c8ea52bdd94934a3457"
+
+[[package]]
+name = "arrayref"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b4930d2cb77ce62f89ee5d5289b4ac049559b1c45539271f5ed4fdc7db34545"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+
+[[package]]
+name = "arrow"
+version = "50.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa285343fba4d829d49985bdc541e3789cf6000ed0e84be7c039438df4a4e78c"
+dependencies = [
+ "arrow-arith 50.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast 50.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "arrow-csv",
+ "arrow-data",
+ "arrow-ipc",
+ "arrow-json",
+ "arrow-ord 50.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "arrow-row 50.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "arrow-schema",
+ "arrow-select 50.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "arrow-string 50.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "arrow-arith"
+version = "50.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "753abd0a5290c1bcade7c6623a556f7d1659c5f4148b140b5b63ce7bd1a45705"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "half",
+ "num",
+]
+
+[[package]]
+name = "arrow-arith"
+version = "50.0.0"
+source = "git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0#e8ead57e97ed2edae8a5617ef45946d8d5b1d91f"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "half",
+ "num",
+]
+
+[[package]]
+name = "arrow-array"
+version = "50.0.0"
+source = "git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0#e8ead57e97ed2edae8a5617ef45946d8d5b1d91f"
+dependencies = [
+ "ahash",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "chrono-tz",
+ "half",
+ "hashbrown 0.14.3",
+ "num",
+]
+
+[[package]]
+name = "arrow-buffer"
+version = "50.0.0"
+source = "git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0#e8ead57e97ed2edae8a5617ef45946d8d5b1d91f"
+dependencies = [
+ "bytes",
+ "half",
+ "num",
+]
+
+[[package]]
+name = "arrow-cast"
+version = "50.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e448e5dd2f4113bf5b74a1f26531708f5edcacc77335b7066f9398f4bcf4cdef"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select 50.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "base64 0.21.7",
+ "chrono",
+ "comfy-table",
+ "half",
+ "lexical-core",
+ "num",
+]
+
+[[package]]
+name = "arrow-cast"
+version = "50.0.0"
+source = "git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0#e8ead57e97ed2edae8a5617ef45946d8d5b1d91f"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select 50.0.0 (git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0)",
+ "base64 0.21.7",
+ "chrono",
+ "half",
+ "lexical-core",
+ "num",
+]
+
+[[package]]
+name = "arrow-csv"
+version = "50.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46af72211f0712612f5b18325530b9ad1bfbdc87290d5fbfd32a7da128983781"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast 50.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "csv",
+ "csv-core",
+ "lazy_static",
+ "lexical-core",
+ "regex",
+]
+
+[[package]]
+name = "arrow-data"
+version = "50.0.0"
+source = "git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0#e8ead57e97ed2edae8a5617ef45946d8d5b1d91f"
+dependencies = [
+ "arrow-buffer",
+ "arrow-schema",
+ "half",
+ "num",
+]
+
+[[package]]
+name = "arrow-flight"
+version = "50.0.0"
+source = "git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0#e8ead57e97ed2edae8a5617ef45946d8d5b1d91f"
+dependencies = [
+ "arrow-arith 50.0.0 (git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0)",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast 50.0.0 (git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0)",
+ "arrow-data",
+ "arrow-ipc",
+ "arrow-ord 50.0.0 (git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0)",
+ "arrow-row 50.0.0 (git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0)",
+ "arrow-schema",
+ "arrow-select 50.0.0 (git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0)",
+ "arrow-string 50.0.0 (git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0)",
+ "base64 0.21.7",
+ "bytes",
+ "futures",
+ "once_cell",
+ "paste",
+ "prost 0.12.4",
+ "tokio",
+ "tonic 0.10.2",
+]
+
+[[package]]
+name = "arrow-ipc"
+version = "50.0.0"
+source = "git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0#e8ead57e97ed2edae8a5617ef45946d8d5b1d91f"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast 50.0.0 (git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0)",
+ "arrow-data",
+ "arrow-schema",
+ "flatbuffers",
+ "lz4_flex",
+]
+
+[[package]]
+name = "arrow-json"
+version = "50.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8950719280397a47d37ac01492e3506a8a724b3fb81001900b866637a829ee0f"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast 50.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "half",
+ "indexmap 2.2.6",
+ "lexical-core",
+ "num",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "arrow-ord"
+version = "50.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ed9630979034077982d8e74a942b7ac228f33dd93a93b615b4d02ad60c260be"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select 50.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "half",
+ "num",
+]
+
+[[package]]
+name = "arrow-ord"
+version = "50.0.0"
+source = "git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0#e8ead57e97ed2edae8a5617ef45946d8d5b1d91f"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select 50.0.0 (git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0)",
+ "half",
+ "num",
+]
+
+[[package]]
+name = "arrow-row"
+version = "50.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "007035e17ae09c4e8993e4cb8b5b96edf0afb927cd38e2dff27189b274d83dcf"
+dependencies = [
+ "ahash",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "half",
+ "hashbrown 0.14.3",
+]
+
+[[package]]
+name = "arrow-row"
+version = "50.0.0"
+source = "git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0#e8ead57e97ed2edae8a5617ef45946d8d5b1d91f"
+dependencies = [
+ "ahash",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "half",
+ "hashbrown 0.14.3",
+]
+
+[[package]]
+name = "arrow-schema"
+version = "50.0.0"
+source = "git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0#e8ead57e97ed2edae8a5617ef45946d8d5b1d91f"
+
+[[package]]
+name = "arrow-select"
+version = "50.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ce20973c1912de6514348e064829e50947e35977bb9d7fb637dc99ea9ffd78c"
+dependencies = [
+ "ahash",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "num",
+]
+
+[[package]]
+name = "arrow-select"
+version = "50.0.0"
+source = "git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0#e8ead57e97ed2edae8a5617ef45946d8d5b1d91f"
+dependencies = [
+ "ahash",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "num",
+]
+
+[[package]]
+name = "arrow-string"
+version = "50.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00f3b37f2aeece31a2636d1b037dabb69ef590e03bdc7eb68519b51ec86932a7"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select 50.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num",
+ "regex",
+ "regex-syntax 0.8.3",
+]
+
+[[package]]
+name = "arrow-string"
+version = "50.0.0"
+source = "git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0#e8ead57e97ed2edae8a5617ef45946d8d5b1d91f"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select 50.0.0 (git+https://github.com/erratic-pattern/arrow-rs.git?branch=50.0.0)",
+ "num",
+ "regex",
+ "regex-syntax 0.8.3",
+]
+
+[[package]]
+name = "arrow_util"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "ahash",
+ "arrow",
+ "chrono",
+ "comfy-table",
+ "hashbrown 0.14.3",
+ "num-traits",
+ "once_cell",
+ "regex",
+ "snafu 0.8.2",
+ "uuid",
+ "workspace-hack",
+]
+
+[[package]]
+name = "assert-json-diff"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47e4f2b81832e72834d7518d8487a0396a28cc408186a2e8854c0f98011faf12"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "assert_cmd"
+version = "2.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed72493ac66d5804837f480ab3766c72bdfab91a65e565fc54fa9e42db0073a8"
+dependencies = [
+ "anstyle",
+ "bstr",
+ "doc-comment",
+ "predicates",
+ "predicates-core",
+ "predicates-tree",
+ "wait-timeout",
+]
+
+[[package]]
+name = "assert_matches"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b34d609dfbaf33d6889b2b7106d3ca345eacad44200913df5ba02bfd31d2ba9"
+
+[[package]]
+name = "async-channel"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "136d4d23bcc79e27423727b36823d86233aad06dfea531837b038394d11e9928"
+dependencies = [
+ "concurrent-queue",
+ "event-listener 5.3.0",
+ "event-listener-strategy 0.5.1",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-compression"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07dbbf24db18d609b1462965249abdf49129ccad073ec257da372adc83259c60"
+dependencies = [
+ "bzip2",
+ "flate2",
+ "futures-core",
+ "futures-io",
+ "memchr",
+ "pin-project-lite",
+ "tokio",
+ "xz2",
+ "zstd",
+ "zstd-safe",
+]
+
+[[package]]
+name = "async-lock"
+version = "3.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d034b430882f8381900d3fe6f0aaa3ad94f2cb4ac519b429692a1bc2dda4ae7b"
+dependencies = [
+ "event-listener 4.0.3",
+ "event-listener-strategy 0.4.0",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-stream"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd56dd203fef61ac097dd65721a419ddccb106b2d2b70ba60a6b529f03961a51"
+dependencies = [
+ "async-stream-impl",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-stream-impl"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16e62a023e7c117e27523144c5d2459f4397fcc3cab0085af8e2224f643a0193"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "async-trait"
+version = "0.1.80"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6fa2087f2753a7da8cc1c0dbfcf89579dd57458e36769de5ac750b4671737ca"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "atoi"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f28d99ec8bfea296261ca1af174f24225171fea9664ba9003cbebee704810528"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "authz"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "async-trait",
+ "backoff 0.1.0",
+ "base64 0.22.0",
+ "generated_types",
+ "http",
+ "iox_time",
+ "metric",
+ "observability_deps",
+ "snafu 0.8.2",
+ "tonic 0.10.2",
+ "workspace-hack",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80"
+
+[[package]]
+name = "axum"
+version = "0.6.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b829e4e32b91e643de6eafe82b1d90675f5874230191a4ffbc1b336dec4d6bf"
+dependencies = [
+ "async-trait",
+ "axum-core",
+ "bitflags 1.3.2",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "hyper",
+ "itoa",
+ "matchit",
+ "memchr",
+ "mime",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustversion",
+ "serde",
+ "sync_wrapper",
+ "tower",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "axum-core"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "759fa577a247914fd3f7f76d62972792636412fbfd634cd452f6a385a74d2d2c"
+dependencies = [
+ "async-trait",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "mime",
+ "rustversion",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "backoff"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "observability_deps",
+ "rand",
+ "snafu 0.8.2",
+ "tokio",
+ "workspace-hack",
+]
+
+[[package]]
+name = "backoff"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b62ddb9cb1ec0a098ad4bbf9344d0713fa193ae1a80af55febcff2627b6a00c1"
+dependencies = [
+ "getrandom",
+ "instant",
+ "rand",
+]
+
+[[package]]
+name = "backtrace"
+version = "0.3.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d"
+dependencies = [
+ "addr2line",
+ "cc",
+ "cfg-if",
+ "libc",
+ "miniz_oxide",
+ "object",
+ "rustc-demangle",
+]
+
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
+[[package]]
+name = "base64"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9475866fec1451be56a3c2400fd081ff546538961565ccb5b7142cbd22bc7a51"
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "blake2"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "blake3"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30cca6d3674597c30ddf2c587bf8d9d65c9a84d2326d941cc79c9842dfe0ef52"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "cc",
+ "cfg-if",
+ "constant_time_eq",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "brotli"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d640d25bc63c50fb1f0b545ffd80207d2e10a4c965530809b40ba3386825c391"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "2.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e2e4afe60d7dd600fdd3de8d0f08c2b7ec039712e3b6137ff98b7004e82de4f"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
+[[package]]
+name = "bstr"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05efc5cfd9110c8416e471df0e96702d58690178e206e61b7173706673c93706"
+dependencies = [
+ "memchr",
+ "regex-automata 0.4.6",
+ "serde",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
+
+[[package]]
+name = "bytemuck"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d6d68c57235a3a081186990eca2867354726650f42f7516ca50c28d6281fd15"
+dependencies = [
+ "bytemuck_derive",
+]
+
+[[package]]
+name = "bytemuck_derive"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4da9a32f3fed317401fa3c862968128267c3106685286e15d5aaa3d7389c2f60"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"
+
+[[package]]
+name = "bzip2"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdb116a6ef3f6c3698828873ad02c3014b3c85cadb88496095628e3ef1e347f8"
+dependencies = [
+ "bzip2-sys",
+ "libc",
+]
+
+[[package]]
+name = "bzip2-sys"
+version = "0.1.11+1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "736a955f3fa7875102d57c82b8cac37ec45224a07fd32d58f9f7a186b6cd4cdc"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "catalog_cache"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "bytes",
+ "dashmap",
+ "futures",
+ "hyper",
+ "metric",
+ "observability_deps",
+ "reqwest",
+ "snafu 0.8.2",
+ "tokio",
+ "tokio-util",
+ "url",
+ "workspace-hack",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d32a725bc159af97c3e629873bb9f88fb8cf8a4867175f76dc987815ea07c83b"
+dependencies = [
+ "jobserver",
+ "libc",
+ "once_cell",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
+
+[[package]]
+name = "chrono"
+version = "0.4.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "serde",
+ "wasm-bindgen",
+ "windows-targets 0.52.5",
+]
+
+[[package]]
+name = "chrono-tz"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d59ae0466b83e838b81a54256c39d5d7c20b9d7daa10510a242d9b75abd5936e"
+dependencies = [
+ "chrono",
+ "chrono-tz-build",
+ "phf",
+]
+
+[[package]]
+name = "chrono-tz-build"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "433e39f13c9a060046954e0592a8d0a4bcb1040125cbf91cb8ee58964cfb350f"
+dependencies = [
+ "parse-zoneinfo",
+ "phf",
+ "phf_codegen",
+]
+
+[[package]]
+name = "clap"
+version = "4.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90bc066a67923782aa8515dbaea16946c5bcc5addbd668bb80af688e53e548a0"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_blocks"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "clap",
+ "ed25519-dalek",
+ "futures",
+ "http",
+ "humantime",
+ "iox_catalog",
+ "iox_time",
+ "itertools 0.12.1",
+ "metric",
+ "non-empty-string",
+ "object_store",
+ "observability_deps",
+ "parquet_cache",
+ "snafu 0.8.2",
+ "sysinfo",
+ "trace_exporters",
+ "trogging",
+ "url",
+ "uuid",
+ "workspace-hack",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae129e2e766ae0ec03484e609954119f123cc1fe650337e155d03b022f24f7b4"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim 0.11.1",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "528131438037fd55894f62d6e9f068b8f45ac57ffa77517819645d10aed04f64"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98cc8fbded0c607b7ba9dd60cd98df59af97e84d24e49c8557331cfc26d301ce"
+
+[[package]]
+name = "client_util"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "http",
+ "reqwest",
+ "thiserror",
+ "tonic 0.10.2",
+ "tower",
+ "workspace-hack",
+]
+
+[[package]]
+name = "colorchoice"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
+
+[[package]]
+name = "comfy-table"
+version = "7.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b34115915337defe99b2aff5c2ce6771e5fbc4079f4b506301f5cf394c8452f7"
+dependencies = [
+ "strum",
+ "strum_macros",
+ "unicode-width",
+]
+
+[[package]]
+name = "concurrent-queue"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d16048cd947b08fa32c24458a22f5dc5e835264f689f4f5653210c69fd107363"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "console"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
+dependencies = [
+ "encode_unicode",
+ "lazy_static",
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "console-api"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2895653b4d9f1538a83970077cb01dfc77a4810524e51a110944688e916b18e"
+dependencies = [
+ "prost 0.11.9",
+ "prost-types 0.11.9",
+ "tonic 0.9.2",
+ "tracing-core",
+]
+
+[[package]]
+name = "console-subscriber"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4cf42660ac07fcebed809cfe561dd8730bcd35b075215e6479c516bcd0d11cb"
+dependencies = [
+ "console-api",
+ "crossbeam-channel",
+ "crossbeam-utils",
+ "futures",
+ "hdrhistogram",
+ "humantime",
+ "parking_lot",
+ "prost-types 0.11.9",
+ "serde",
+ "serde_json",
+ "thread_local",
+ "tokio",
+ "tokio-stream",
+ "tonic 0.9.2",
+ "tracing",
+ "tracing-core",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "const-random"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359"
+dependencies = [
+ "const-random-macro",
+]
+
+[[package]]
+name = "const-random-macro"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
+dependencies = [
+ "getrandom",
+ "once_cell",
+ "tiny-keccak",
+]
+
+[[package]]
+name = "constant_time_eq"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7144d30dcf0fafbce74250a3963025d8d52177934239851c917d29f1df280c2"
+
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+
+[[package]]
+name = "cpp_demangle"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e8227005286ec39567949b33df9896bcadfa6051bccca2488129f108ca23119"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc"
+version = "3.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69e6e4d7b33a94f0991c26729976b10ebde1d34c3ee82408fb536164fa10d636"
+dependencies = [
+ "crc-catalog",
+]
+
+[[package]]
+name = "crc-catalog"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
+
+[[package]]
+name = "crc32fast"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "croaring"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7266f0a7275b00ce4c4f4753e8c31afdefe93828101ece83a06e2ddab1dd1010"
+dependencies = [
+ "byteorder",
+ "croaring-sys",
+]
+
+[[package]]
+name = "croaring-sys"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e47112498c394a7067949ebc07ef429b7384a413cf0efcf675846a47bcd307fb"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab3db02a9c5b5121e1e42fbdb1aeb65f5e02624cc58c43f2884c6ccac0b82f95"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-queue"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df0346b5d5e76ac2fe4e327c5fd1118d6be7c51dfb18f9b7922923f287471e35"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
+
+[[package]]
+name = "crunchy"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "csv"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac574ff4d437a7b5ad237ef331c17ccca63c46479e5b5453eb8e10bb99a759fe"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "curve25519-dalek"
+version = "4.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a677b8922c94e01bdbb12126b0bc852f00447528dee1782229af9c720c3f348"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "curve25519-dalek-derive",
+ "digest",
+ "fiat-crypto",
+ "platforms",
+ "rustc_version",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "curve25519-dalek-derive"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "darling"
+version = "0.20.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54e36fcd13ed84ffdfda6f5be89b31287cbb80c439841fe69e04841435464391"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c2cf1c23a687a1feeb728783b993c4e1ad83d99f351801977dd809b48d0a70f"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim 0.10.0",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.20.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a668eda54683121533a393014d8692171709ff57a7d61f187b6e782719f8933f"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "dashmap"
+version = "5.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
+dependencies = [
+ "cfg-if",
+ "hashbrown 0.14.3",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "data_types"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow-buffer",
+ "bytes",
+ "chrono",
+ "croaring",
+ "generated_types",
+ "influxdb-line-protocol",
+ "iox_time",
+ "murmur3",
+ "observability_deps",
+ "once_cell",
+ "ordered-float 4.2.0",
+ "percent-encoding",
+ "prost 0.12.4",
+ "schema",
+ "serde_json",
+ "sha2",
+ "siphasher 1.0.1",
+ "snafu 0.8.2",
+ "sqlx",
+ "thiserror",
+ "uuid",
+ "workspace-hack",
+]
+
+[[package]]
+name = "datafusion"
+version = "36.0.0"
+source = "git+https://github.com/influxdata/arrow-datafusion.git?rev=581e74785b876615d6a63db8c2e5ba372bf78828#581e74785b876615d6a63db8c2e5ba372bf78828"
+dependencies = [
+ "ahash",
+ "arrow",
+ "arrow-array",
+ "arrow-ipc",
+ "arrow-schema",
+ "async-compression",
+ "async-trait",
+ "bytes",
+ "bzip2",
+ "chrono",
+ "dashmap",
+ "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-functions",
+ "datafusion-functions-array",
+ "datafusion-optimizer",
+ "datafusion-physical-expr",
+ "datafusion-physical-plan",
+ "datafusion-sql",
+ "flate2",
+ "futures",
+ "glob",
+ "half",
+ "hashbrown 0.14.3",
+ "indexmap 2.2.6",
+ "itertools 0.12.1",
+ "log",
+ "num_cpus",
+ "object_store",
+ "parking_lot",
+ "parquet",
+ "pin-project-lite",
+ "rand",
+ "sqlparser",
+ "tempfile",
+ "tokio",
+ "tokio-util",
+ "url",
+ "uuid",
+ "xz2",
+ "zstd",
+]
+
+[[package]]
+name = "datafusion-common"
+version = "36.0.0"
+source = "git+https://github.com/influxdata/arrow-datafusion.git?rev=581e74785b876615d6a63db8c2e5ba372bf78828#581e74785b876615d6a63db8c2e5ba372bf78828"
+dependencies = [
+ "ahash",
+ "arrow",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-schema",
+ "chrono",
+ "half",
+ "instant",
+ "libc",
+ "num_cpus",
+ "object_store",
+ "parquet",
+ "sqlparser",
+]
+
+[[package]]
+name = "datafusion-common-runtime"
+version = "36.0.0"
+source = "git+https://github.com/influxdata/arrow-datafusion.git?rev=581e74785b876615d6a63db8c2e5ba372bf78828#581e74785b876615d6a63db8c2e5ba372bf78828"
+dependencies = [
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-execution"
+version = "36.0.0"
+source = "git+https://github.com/influxdata/arrow-datafusion.git?rev=581e74785b876615d6a63db8c2e5ba372bf78828#581e74785b876615d6a63db8c2e5ba372bf78828"
+dependencies = [
+ "arrow",
+ "chrono",
+ "dashmap",
+ "datafusion-common",
+ "datafusion-expr",
+ "futures",
+ "hashbrown 0.14.3",
+ "log",
+ "object_store",
+ "parking_lot",
+ "rand",
+ "tempfile",
+ "url",
+]
+
+[[package]]
+name = "datafusion-expr"
+version = "36.0.0"
+source = "git+https://github.com/influxdata/arrow-datafusion.git?rev=581e74785b876615d6a63db8c2e5ba372bf78828#581e74785b876615d6a63db8c2e5ba372bf78828"
+dependencies = [
+ "ahash",
+ "arrow",
+ "arrow-array",
+ "chrono",
+ "datafusion-common",
+ "paste",
+ "sqlparser",
+ "strum",
+ "strum_macros",
+]
+
+[[package]]
+name = "datafusion-functions"
+version = "36.0.0"
+source = "git+https://github.com/influxdata/arrow-datafusion.git?rev=581e74785b876615d6a63db8c2e5ba372bf78828#581e74785b876615d6a63db8c2e5ba372bf78828"
+dependencies = [
+ "arrow",
+ "arrow-array",
+ "base64 0.22.0",
+ "chrono",
+ "datafusion-common",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-physical-expr",
+ "hex",
+ "itertools 0.12.1",
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "datafusion-functions-array"
+version = "36.0.0"
+source = "git+https://github.com/influxdata/arrow-datafusion.git?rev=581e74785b876615d6a63db8c2e5ba372bf78828#581e74785b876615d6a63db8c2e5ba372bf78828"
+dependencies = [
+ "arrow",
+ "datafusion-common",
+ "datafusion-execution",
+ "datafusion-expr",
+ "log",
+ "paste",
+]
+
+[[package]]
+name = "datafusion-optimizer"
+version = "36.0.0"
+source = "git+https://github.com/influxdata/arrow-datafusion.git?rev=581e74785b876615d6a63db8c2e5ba372bf78828#581e74785b876615d6a63db8c2e5ba372bf78828"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "chrono",
+ "datafusion-common",
+ "datafusion-expr",
+ "datafusion-physical-expr",
+ "hashbrown 0.14.3",
+ "itertools 0.12.1",
+ "log",
+ "regex-syntax 0.8.3",
+]
+
+[[package]]
+name = "datafusion-physical-expr"
+version = "36.0.0"
+source = "git+https://github.com/influxdata/arrow-datafusion.git?rev=581e74785b876615d6a63db8c2e5ba372bf78828#581e74785b876615d6a63db8c2e5ba372bf78828"
+dependencies = [
+ "ahash",
+ "arrow",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-ord 50.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "arrow-schema",
+ "arrow-string 50.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "base64 0.22.0",
+ "blake2",
+ "blake3",
+ "chrono",
+ "datafusion-common",
+ "datafusion-execution",
+ "datafusion-expr",
+ "half",
+ "hashbrown 0.14.3",
+ "hex",
+ "indexmap 2.2.6",
+ "itertools 0.12.1",
+ "log",
+ "md-5",
+ "paste",
+ "petgraph",
+ "rand",
+ "regex",
+ "sha2",
+ "unicode-segmentation",
+ "uuid",
+]
+
+[[package]]
+name = "datafusion-physical-plan"
+version = "36.0.0"
+source = "git+https://github.com/influxdata/arrow-datafusion.git?rev=581e74785b876615d6a63db8c2e5ba372bf78828#581e74785b876615d6a63db8c2e5ba372bf78828"
+dependencies = [
+ "ahash",
+ "arrow",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-schema",
+ "async-trait",
+ "chrono",
+ "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-physical-expr",
+ "futures",
+ "half",
+ "hashbrown 0.14.3",
+ "indexmap 2.2.6",
+ "itertools 0.12.1",
+ "log",
+ "once_cell",
+ "parking_lot",
+ "pin-project-lite",
+ "rand",
+ "tokio",
+ "uuid",
+]
+
+[[package]]
+name = "datafusion-proto"
+version = "36.0.0"
+source = "git+https://github.com/influxdata/arrow-datafusion.git?rev=581e74785b876615d6a63db8c2e5ba372bf78828#581e74785b876615d6a63db8c2e5ba372bf78828"
+dependencies = [
+ "arrow",
+ "chrono",
+ "datafusion",
+ "datafusion-common",
+ "datafusion-expr",
+ "object_store",
+ "prost 0.12.4",
+]
+
+[[package]]
+name = "datafusion-sql"
+version = "36.0.0"
+source = "git+https://github.com/influxdata/arrow-datafusion.git?rev=581e74785b876615d6a63db8c2e5ba372bf78828#581e74785b876615d6a63db8c2e5ba372bf78828"
+dependencies = [
+ "arrow",
+ "arrow-schema",
+ "datafusion-common",
+ "datafusion-expr",
+ "log",
+ "sqlparser",
+]
+
+[[package]]
+name = "datafusion_util"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "async-trait",
+ "datafusion",
+ "futures",
+ "object_store",
+ "observability_deps",
+ "pin-project",
+ "schema",
+ "tokio",
+ "tokio-stream",
+ "url",
+ "workspace-hack",
+]
+
+[[package]]
+name = "debugid"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef552e6f588e446098f6ba40d89ac146c8c7b64aade83c051ee00bb5d2bc18d"
+dependencies = [
+ "uuid",
+]
+
+[[package]]
+name = "delegate"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "082a24a9967533dc5d743c602157637116fc1b52806d694a5a45e6f32567fcdd"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "der"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
+dependencies = [
+ "const-oid",
+ "pem-rfc7468",
+ "zeroize",
+]
+
+[[package]]
+name = "derivative"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "diff"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
+
+[[package]]
+name = "difflib"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "dml"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow_util",
+ "data_types",
+ "hashbrown 0.14.3",
+ "mutable_batch",
+ "schema",
+ "trace",
+ "workspace-hack",
+]
+
+[[package]]
+name = "doc-comment"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
+
+[[package]]
+name = "dotenvy"
+version = "0.15.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"
+
+[[package]]
+name = "dyn-clone"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125"
+
+[[package]]
+name = "ed25519"
+version = "2.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "115531babc129696a58c64a4fef0a8bf9e9698629fb97e9e40767d235cfbcd53"
+dependencies = [
+ "pkcs8",
+ "signature",
+]
+
+[[package]]
+name = "ed25519-dalek"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a3daa8e81a3963a60642bcc1f90a670680bd4a77535faa384e9d1c79d620871"
+dependencies = [
+ "curve25519-dalek",
+ "ed25519",
+ "serde",
+ "sha2",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "either"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a47c1c47d2f5964e29c61246e81db715514cd532db6b5116a25ea3c03d6780a2"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "encode_unicode"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+
+[[package]]
+name = "errno"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "etcetera"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "136d1b5283a1ab77bd9257427ffd09d8667ced0570b6f938942bc7568ed5b943"
+dependencies = [
+ "cfg-if",
+ "home",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "event-listener"
+version = "2.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
+
+[[package]]
+name = "event-listener"
+version = "4.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b215c49b2b248c855fb73579eb1f4f26c38ffdc12973e20e07b91d78d5646e"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d9944b8ca13534cdfb2800775f8dd4902ff3fc75a50101466decadfdf322a24"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "958e4d70b6d5e81971bebec42271ec641e7ff4e170a6fa605f2b8a8b65cb97d3"
+dependencies = [
+ "event-listener 4.0.3",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "332f51cb23d20b0de8458b86580878211da09bcd4503cb579c225b3d124cabb3"
+dependencies = [
+ "event-listener 5.3.0",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "executor"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "futures",
+ "libc",
+ "metric",
+ "observability_deps",
+ "once_cell",
+ "parking_lot",
+ "pin-project",
+ "snafu 0.8.2",
+ "tokio",
+ "tokio-util",
+ "tokio_metrics_bridge",
+ "tokio_watchdog",
+ "workspace-hack",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "658bd65b1cf4c852a3cc96f18a8ce7b5640f6b703f905c7d74532294c2a63984"
+
+[[package]]
+name = "fiat-crypto"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38793c55593b33412e3ae40c2c9781ffaa6f438f6f8c10f24e71846fbd7ae01e"
+
+[[package]]
+name = "filetime"
+version = "0.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ee447700ac8aa0b2f2bd7bc4462ad686ba06baa6727ac149a2d6277f0d240fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "findshlibs"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40b9e59cd0f7e0806cca4be089683ecb6434e602038df21fe6bf6711b2f07f64"
+dependencies = [
+ "cc",
+ "lazy_static",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "finl_unicode"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fcfdc7a0362c9f4444381a9e697c79d435fe65b52a37466fc2c1184cee9edc6"
+
+[[package]]
+name = "fixedbitset"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+
+[[package]]
+name = "flatbuffers"
+version = "23.5.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4dac53e22462d78c16d64a1cd22371b54cc3fe94aa15e7886a2fa6e5d1ab8640"
+dependencies = [
+ "bitflags 1.3.2",
+ "rustc_version",
+]
+
+[[package]]
+name = "flate2"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "flightsql"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow",
+ "arrow-flight",
+ "arrow_util",
+ "bytes",
+ "datafusion",
+ "futures",
+ "generated_types",
+ "iox_query",
+ "iox_query_params",
+ "observability_deps",
+ "once_cell",
+ "prost 0.12.4",
+ "snafu 0.8.2",
+ "tonic 0.10.2",
+ "workspace-hack",
+]
+
+[[package]]
+name = "flume"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55ac459de2512911e4b674ce33cf20befaba382d05b62b008afc1c8b57cbf181"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+ "spin 0.9.8",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "fsevent-sys"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76ee7a02da4d231650c7cea31349b889be2f45ddb3ef3032d2ec8185f6313fd2"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "futures"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-intrusive"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d930c203dd0b6ff06e0201a4a2fe9149b43c684fd4420555b26d21b1a02956f"
+dependencies = [
+ "futures-core",
+ "lock_api",
+ "parking_lot",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
+
+[[package]]
+name = "futures-task"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
+
+[[package]]
+name = "futures-util"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
+[[package]]
+name = "generated_types"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "observability_deps",
+ "once_cell",
+ "pbjson",
+ "pbjson-build",
+ "pbjson-types",
+ "prost 0.12.4",
+ "prost-build",
+ "prost-types 0.12.4",
+ "serde",
+ "tonic 0.10.2",
+ "tonic-build",
+ "uuid",
+ "workspace-hack",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "gimli"
+version = "0.28.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
+
+[[package]]
+name = "glob"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+
+[[package]]
+name = "h2"
+version = "0.3.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81fe527a889e1532da5c525686d96d4c2e74cdd345badf8dfef9f6b39dd5f5e8"
+dependencies = [
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "http",
+ "indexmap 2.2.6",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "half"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
+dependencies = [
+ "bytemuck",
+ "cfg-if",
+ "crunchy",
+ "num-traits",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
+[[package]]
+name = "hashbrown"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
+dependencies = [
+ "ahash",
+ "allocator-api2",
+]
+
+[[package]]
+name = "hashlink"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8094feaf31ff591f651a2664fb9cfd92bba7a60ce3197265e9482ebe753c8f7"
+dependencies = [
+ "hashbrown 0.14.3",
+]
+
+[[package]]
+name = "hdrhistogram"
+version = "7.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "765c9198f173dd59ce26ff9f95ef0aafd0a0fe01fb9d72841bc5066a4c06511d"
+dependencies = [
+ "base64 0.21.7",
+ "byteorder",
+ "flate2",
+ "nom",
+ "num-traits",
+]
+
+[[package]]
+name = "heappy"
+version = "0.1.0"
+source = "git+https://github.com/mkmik/heappy?rev=01a1f88e1b404c5894f89eb1a57f813f713d7ad1#01a1f88e1b404c5894f89eb1a57f813f713d7ad1"
+dependencies = [
+ "backtrace",
+ "bytes",
+ "lazy_static",
+ "libc",
+ "pprof",
+ "spin 0.9.8",
+ "thiserror",
+ "tikv-jemalloc-sys",
+]
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hermit-abi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hkdf"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
+dependencies = [
+ "hmac",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "home"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
+dependencies = [
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "http"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
+dependencies = [
+ "bytes",
+ "http",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "http-range-header"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "add0ab9360ddbd88cfeb3bd9574a1d85cfdfa14db10b3e21d3700dbc4328758f"
+
+[[package]]
+name = "httparse"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
+
+[[package]]
+name = "httpdate"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
+
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
+[[package]]
+name = "hyper"
+version = "0.14.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80"
+dependencies = [
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http",
+ "http-body",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "socket2",
+ "tokio",
+ "tower-service",
+ "tracing",
+ "want",
+]
+
+[[package]]
+name = "hyper-rustls"
+version = "0.24.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
+dependencies = [
+ "futures-util",
+ "http",
+ "hyper",
+ "log",
+ "rustls",
+ "rustls-native-certs",
+ "tokio",
+ "tokio-rustls",
+]
+
+[[package]]
+name = "hyper-timeout"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbb958482e8c7be4bc3cf272a766a2b0bf1a6755e7a6ae777f017a31d11b13b1"
+dependencies = [
+ "hyper",
+ "pin-project-lite",
+ "tokio",
+ "tokio-io-timeout",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
+dependencies = [
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.14.3",
+]
+
+[[package]]
+name = "inferno"
+version = "0.11.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "321f0f839cd44a4686e9504b0a62b4d69a50b62072144c71c68f5873c167b8d9"
+dependencies = [
+ "ahash",
+ "indexmap 2.2.6",
+ "is-terminal",
+ "itoa",
+ "log",
+ "num-format",
+ "once_cell",
+ "quick-xml 0.26.0",
+ "rgb",
+ "str_stack",
+]
+
+[[package]]
+name = "influxdb-line-protocol"
+version = "1.0.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "bytes",
+ "log",
+ "nom",
+ "smallvec",
+ "snafu 0.8.2",
+]
+
+[[package]]
+name = "influxdb3"
+version = "0.1.0"
+dependencies = [
+ "arrow",
+ "arrow-array",
+ "arrow-flight",
+ "arrow_util",
+ "assert_cmd",
+ "authz",
+ "backtrace",
+ "base64 0.22.0",
+ "clap",
+ "clap_blocks",
+ "console-subscriber",
+ "datafusion_util",
+ "dotenvy",
+ "futures",
+ "hex",
+ "hyper",
+ "influxdb3_client",
+ "influxdb3_process",
+ "influxdb3_server",
+ "influxdb3_write",
+ "influxdb_iox_client",
+ "iox_query",
+ "iox_time",
+ "ioxd_common",
+ "libc",
+ "metric",
+ "num_cpus",
+ "object_store",
+ "observability_deps",
+ "once_cell",
+ "panic_logging",
+ "parking_lot",
+ "parquet_file",
+ "pretty_assertions",
+ "rand",
+ "reqwest",
+ "secrecy",
+ "serde_json",
+ "sha2",
+ "test_helpers",
+ "thiserror",
+ "tokio",
+ "tokio-util",
+ "tokio_metrics_bridge",
+ "tonic 0.10.2",
+ "tower",
+ "trace",
+ "trace_exporters",
+ "trogging",
+ "url",
+ "uuid",
+]
+
+[[package]]
+name = "influxdb3_client"
+version = "0.1.0"
+dependencies = [
+ "bytes",
+ "iox_query_params",
+ "mockito",
+ "reqwest",
+ "secrecy",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "tokio",
+ "url",
+]
+
+[[package]]
+name = "influxdb3_load_generator"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "bytes",
+ "chrono",
+ "clap",
+ "csv",
+ "dotenvy",
+ "humantime",
+ "influxdb3_client",
+ "influxdb3_process",
+ "observability_deps",
+ "parking_lot",
+ "rand",
+ "secrecy",
+ "serde",
+ "serde_json",
+ "sysinfo",
+ "thiserror",
+ "tokio",
+ "trogging",
+ "url",
+]
+
+[[package]]
+name = "influxdb3_process"
+version = "0.1.0"
+dependencies = [
+ "iox_time",
+ "metric",
+ "once_cell",
+ "tikv-jemalloc-ctl",
+ "tikv-jemalloc-sys",
+ "tokio",
+ "tokio_metrics_bridge",
+ "uuid",
+]
+
+[[package]]
+name = "influxdb3_server"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "arrow",
+ "arrow-csv",
+ "arrow-flight",
+ "arrow-json",
+ "arrow-schema",
+ "async-trait",
+ "authz",
+ "base64 0.22.0",
+ "bytes",
+ "chrono",
+ "data_types",
+ "datafusion",
+ "datafusion_util",
+ "flate2",
+ "futures",
+ "hex",
+ "http",
+ "hyper",
+ "influxdb-line-protocol",
+ "influxdb3_process",
+ "influxdb3_write",
+ "iox_catalog",
+ "iox_http",
+ "iox_query",
+ "iox_query_influxql",
+ "iox_query_influxql_rewrite",
+ "iox_query_params",
+ "iox_time",
+ "metric",
+ "metric_exporters",
+ "object_store",
+ "observability_deps",
+ "parking_lot",
+ "parquet",
+ "parquet_file",
+ "pin-project-lite",
+ "pretty_assertions",
+ "schema",
+ "secrecy",
+ "serde",
+ "serde_arrow",
+ "serde_json",
+ "serde_urlencoded",
+ "service_common",
+ "service_grpc_flight",
+ "sha2",
+ "test_helpers",
+ "test_helpers_end_to_end",
+ "thiserror",
+ "tokio",
+ "tokio-util",
+ "tonic 0.10.2",
+ "tower",
+ "trace",
+ "trace_exporters",
+ "trace_http",
+ "tracker",
+ "unicode-segmentation",
+ "urlencoding 1.3.3",
+]
+
+[[package]]
+name = "influxdb3_write"
+version = "0.1.0"
+dependencies = [
+ "arrow",
+ "arrow_util",
+ "async-trait",
+ "byteorder",
+ "bytes",
+ "chrono",
+ "crc32fast",
+ "crossbeam-channel",
+ "data_types",
+ "datafusion",
+ "datafusion_util",
+ "futures-util",
+ "hex",
+ "influxdb-line-protocol",
+ "iox_catalog",
+ "iox_http",
+ "iox_query",
+ "iox_time",
+ "metric",
+ "object_store",
+ "observability_deps",
+ "parking_lot",
+ "parquet",
+ "parquet_file",
+ "pretty_assertions",
+ "schema",
+ "serde",
+ "serde_json",
+ "sha2",
+ "snap",
+ "test_helpers",
+ "thiserror",
+ "tokio",
+ "url",
+ "uuid",
+]
+
+[[package]]
+name = "influxdb_influxql_parser"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "chrono",
+ "chrono-tz",
+ "iox_query_params",
+ "nom",
+ "num-integer",
+ "num-traits",
+ "once_cell",
+ "thiserror",
+ "workspace-hack",
+]
+
+[[package]]
+name = "influxdb_iox_client"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow",
+ "arrow-flight",
+ "arrow_util",
+ "bytes",
+ "client_util",
+ "comfy-table",
+ "futures",
+ "futures-util",
+ "generated_types",
+ "influxdb-line-protocol",
+ "iox_query_params",
+ "prost 0.12.4",
+ "rand",
+ "reqwest",
+ "schema",
+ "serde_json",
+ "thiserror",
+ "tokio",
+ "tokio-stream",
+ "tonic 0.10.2",
+ "tonic-reflection",
+]
+
+[[package]]
+name = "ingester_query_grpc"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow",
+ "base64 0.22.0",
+ "bytes",
+ "data_types",
+ "datafusion",
+ "datafusion-proto",
+ "flatbuffers",
+ "pbjson",
+ "pbjson-build",
+ "predicate",
+ "prost 0.12.4",
+ "prost-build",
+ "query_functions",
+ "serde",
+ "snafu 0.8.2",
+ "tonic 0.10.2",
+ "tonic-build",
+ "workspace-hack",
+]
+
+[[package]]
+name = "inotify"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8069d3ec154eb856955c1c0fbffefbf5f3c40a104ec912d4797314c1801abff"
+dependencies = [
+ "bitflags 1.3.2",
+ "inotify-sys",
+ "libc",
+]
+
+[[package]]
+name = "inotify-sys"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e05c02b5e89bff3b946cedeca278abc628fe811e604f027c45a8aa3cf793d0eb"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "insta"
+version = "1.38.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eab73f58e59ca6526037208f0e98851159ec1633cf17b6cd2e1f2c3fd5d53cc"
+dependencies = [
+ "console",
+ "lazy_static",
+ "linked-hash-map",
+ "serde",
+ "similar",
+]
+
+[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "integer-encoding"
+version = "3.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8bb03732005da905c88227371639bf1ad885cc712789c011c31c5fb3ab3ccf02"
+
+[[package]]
+name = "iox_catalog"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "async-trait",
+ "backoff 0.1.0",
+ "catalog_cache",
+ "client_util",
+ "data_types",
+ "futures",
+ "generated_types",
+ "hashbrown 0.14.3",
+ "http",
+ "iox_time",
+ "log",
+ "metric",
+ "mutable_batch",
+ "observability_deps",
+ "once_cell",
+ "parking_lot",
+ "serde",
+ "siphasher 1.0.1",
+ "snafu 0.8.2",
+ "sqlx",
+ "sqlx-hotswap-pool",
+ "thiserror",
+ "tokio",
+ "tonic 0.10.2",
+ "trace",
+ "trace_http",
+ "uuid",
+ "workspace-hack",
+]
+
+[[package]]
+name = "iox_http"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "async-trait",
+ "authz",
+ "data_types",
+ "hyper",
+ "parking_lot",
+ "serde",
+ "serde_urlencoded",
+ "thiserror",
+ "workspace-hack",
+]
+
+[[package]]
+name = "iox_query"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow",
+ "arrow_util",
+ "async-trait",
+ "bytes",
+ "chrono",
+ "data_types",
+ "datafusion",
+ "datafusion_util",
+ "executor",
+ "futures",
+ "hashbrown 0.14.3",
+ "indexmap 2.2.6",
+ "iox_query_params",
+ "iox_time",
+ "itertools 0.12.1",
+ "metric",
+ "object_store",
+ "observability_deps",
+ "once_cell",
+ "parking_lot",
+ "parquet_file",
+ "predicate",
+ "query_functions",
+ "schema",
+ "snafu 0.8.2",
+ "tokio",
+ "tokio-stream",
+ "trace",
+ "tracker",
+ "uuid",
+ "workspace-hack",
+]
+
+[[package]]
+name = "iox_query_influxql"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow",
+ "chrono-tz",
+ "datafusion",
+ "datafusion_util",
+ "generated_types",
+ "influxdb_influxql_parser",
+ "iox_query",
+ "iox_query_params",
+ "itertools 0.12.1",
+ "observability_deps",
+ "once_cell",
+ "predicate",
+ "query_functions",
+ "regex",
+ "schema",
+ "serde_json",
+ "thiserror",
+ "workspace-hack",
+]
+
+[[package]]
+name = "iox_query_influxql_rewrite"
+version = "0.1.0"
+dependencies = [
+ "influxdb_influxql_parser",
+ "thiserror",
+]
+
+[[package]]
+name = "iox_query_params"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow",
+ "datafusion",
+ "generated_types",
+ "observability_deps",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "workspace-hack",
+]
+
+[[package]]
+name = "iox_time"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "chrono",
+ "parking_lot",
+ "tokio",
+ "workspace-hack",
+]
+
+[[package]]
+name = "ioxd_common"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "async-trait",
+ "authz",
+ "bytes",
+ "clap",
+ "clap_blocks",
+ "flate2",
+ "futures",
+ "generated_types",
+ "hashbrown 0.14.3",
+ "heappy",
+ "http",
+ "hyper",
+ "log",
+ "metric",
+ "metric_exporters",
+ "observability_deps",
+ "parking_lot",
+ "pprof",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "service_grpc_testing",
+ "snafu 0.8.2",
+ "tokio",
+ "tokio-stream",
+ "tokio-util",
+ "tonic 0.10.2",
+ "tonic-health",
+ "tonic-reflection",
+ "tower",
+ "tower-http",
+ "tower_trailer",
+ "trace",
+ "trace_exporters",
+ "trace_http",
+ "workspace-hack",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3"
+
+[[package]]
+name = "is-terminal"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+
+[[package]]
+name = "jobserver"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2b099aaa34a9751c5bf0878add70444e1ed2dd73f347be99003d4577277de6e"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "json-patch"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55ff1e1486799e3f64129f8ccad108b38290df9cd7015cd31bed17239f0789d6"
+dependencies = [
+ "serde",
+ "serde_json",
+ "thiserror",
+ "treediff",
+]
+
+[[package]]
+name = "jsonpath-rust"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96acbc6188d3bd83519d053efec756aa4419de62ec47be7f28dec297f7dc9eb0"
+dependencies = [
+ "pest",
+ "pest_derive",
+ "regex",
+ "serde_json",
+ "thiserror",
+]
+
+[[package]]
+name = "k8s-openapi"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "550f99d93aa4c2b25de527bce492d772caf5e21d7ac9bd4b508ba781c8d91e30"
+dependencies = [
+ "base64 0.21.7",
+ "chrono",
+ "schemars",
+ "serde",
+ "serde-value",
+ "serde_json",
+]
+
+[[package]]
+name = "kqueue"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7447f1ca1b7b563588a205fe93dea8df60fd981423a768bc1c0ded35ed147d0c"
+dependencies = [
+ "kqueue-sys",
+ "libc",
+]
+
+[[package]]
+name = "kqueue-sys"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed9625ffda8729b85e45cf04090035ac368927b8cebc34898e7c120f52e4838b"
+dependencies = [
+ "bitflags 1.3.2",
+ "libc",
+]
+
+[[package]]
+name = "kube"
+version = "0.88.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "462fe330a0617b276ec864c2255810adcdf519ecb6844253c54074b2086a97bc"
+dependencies = [
+ "k8s-openapi",
+ "kube-client",
+ "kube-core",
+ "kube-derive",
+ "kube-runtime",
+]
+
+[[package]]
+name = "kube-client"
+version = "0.88.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fe0d65dd6f3adba29cfb84f19dfe55449c7f6c35425f9d8294bec40313e0b64"
+dependencies = [
+ "base64 0.21.7",
+ "bytes",
+ "chrono",
+ "either",
+ "futures",
+ "home",
+ "http",
+ "http-body",
+ "hyper",
+ "hyper-rustls",
+ "hyper-timeout",
+ "jsonpath-rust",
+ "k8s-openapi",
+ "kube-core",
+ "pem",
+ "pin-project",
+ "rustls",
+ "rustls-pemfile 1.0.4",
+ "secrecy",
+ "serde",
+ "serde_json",
+ "serde_yaml",
+ "thiserror",
+ "tokio",
+ "tokio-util",
+ "tower",
+ "tower-http",
+ "tracing",
+]
+
+[[package]]
+name = "kube-core"
+version = "0.88.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6b42844e9172f631b8263ea9ce003b9251da13beb1401580937ad206dd82f4c"
+dependencies = [
+ "chrono",
+ "form_urlencoded",
+ "http",
+ "json-patch",
+ "k8s-openapi",
+ "once_cell",
+ "schemars",
+ "serde",
+ "serde_json",
+ "thiserror",
+]
+
+[[package]]
+name = "kube-derive"
+version = "0.88.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5b5a111ee287bd237b8190b8c39543ea9fd22f79e9c32a36c24e08234bcda22"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "serde_json",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "kube-runtime"
+version = "0.88.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bc06275064c81056fbb28ea876b3fb339d970e8132282119359afca0835c0ea"
+dependencies = [
+ "ahash",
+ "async-trait",
+ "backoff 0.4.0",
+ "derivative",
+ "futures",
+ "hashbrown 0.14.3",
+ "json-patch",
+ "k8s-openapi",
+ "kube-client",
+ "parking_lot",
+ "pin-project",
+ "serde",
+ "serde_json",
+ "smallvec",
+ "thiserror",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+dependencies = [
+ "spin 0.5.2",
+]
+
+[[package]]
+name = "lexical-core"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2cde5de06e8d4c2faabc400238f9ae1c74d5412d03a7bd067645ccbc47070e46"
+dependencies = [
+ "lexical-parse-float",
+ "lexical-parse-integer",
+ "lexical-util",
+ "lexical-write-float",
+ "lexical-write-integer",
+]
+
+[[package]]
+name = "lexical-parse-float"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683b3a5ebd0130b8fb52ba0bdc718cc56815b6a097e28ae5a6997d0ad17dc05f"
+dependencies = [
+ "lexical-parse-integer",
+ "lexical-util",
+ "static_assertions",
+]
+
+[[package]]
+name = "lexical-parse-integer"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d0994485ed0c312f6d965766754ea177d07f9c00c9b82a5ee62ed5b47945ee9"
+dependencies = [
+ "lexical-util",
+ "static_assertions",
+]
+
+[[package]]
+name = "lexical-util"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5255b9ff16ff898710eb9eb63cb39248ea8a5bb036bea8085b1a767ff6c4e3fc"
+dependencies = [
+ "static_assertions",
+]
+
+[[package]]
+name = "lexical-write-float"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accabaa1c4581f05a3923d1b4cfd124c329352288b7b9da09e766b0668116862"
+dependencies = [
+ "lexical-util",
+ "lexical-write-integer",
+ "static_assertions",
+]
+
+[[package]]
+name = "lexical-write-integer"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1b6f3d1f4422866b68192d62f77bc5c700bee84f3069f2469d7bc8c77852446"
+dependencies = [
+ "lexical-util",
+ "static_assertions",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.153"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
+
+[[package]]
+name = "libm"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
+
+[[package]]
+name = "libsqlite3-sys"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf4e226dcd58b4be396f7bd3c20da8fdee2911400705297ba7d2d7cc2c30f716"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "linked-hash-map"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
+
+[[package]]
+name = "lock_api"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45"
+dependencies = [
+ "autocfg",
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
+
+[[package]]
+name = "logfmt"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "observability_deps",
+ "tracing-subscriber",
+ "workspace-hack",
+]
+
+[[package]]
+name = "lz4_flex"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75761162ae2b0e580d7e7c390558127e5f01b4194debd6221fd8c207fc80e3f5"
+dependencies = [
+ "twox-hash",
+]
+
+[[package]]
+name = "lzma-sys"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fda04ab3764e6cde78b9974eec4f779acaba7c4e84b36eca3cf77c581b85d27"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "matchers"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
+dependencies = [
+ "regex-automata 0.1.10",
+]
+
+[[package]]
+name = "matchit"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94"
+
+[[package]]
+name = "md-5"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
+dependencies = [
+ "cfg-if",
+ "digest",
+]
+
+[[package]]
+name = "memchr"
+version = "2.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"
+
+[[package]]
+name = "memmap2"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe751422e4a8caa417e13c3ea66452215d7d63e19e604f4980461212f3ae1322"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "metric"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "parking_lot",
+ "workspace-hack",
+]
+
+[[package]]
+name = "metric_exporters"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "metric",
+ "observability_deps",
+ "prometheus",
+ "workspace-hack",
+]
+
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7"
+dependencies = [
+ "adler",
+]
+
+[[package]]
+name = "mio"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
+dependencies = [
+ "libc",
+ "log",
+ "wasi",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "mockito"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2f6e023aa5bdf392aa06c78e4a4e6d498baab5138d0c993503350ebbc37bf1e"
+dependencies = [
+ "assert-json-diff",
+ "futures-core",
+ "hyper",
+ "log",
+ "rand",
+ "regex",
+ "serde_json",
+ "serde_urlencoded",
+ "similar",
+ "tokio",
+]
+
+[[package]]
+name = "moka"
+version = "0.12.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e0d88686dc561d743b40de8269b26eaf0dc58781bde087b0984646602021d08"
+dependencies = [
+ "async-lock",
+ "async-trait",
+ "crossbeam-channel",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+ "event-listener 5.3.0",
+ "futures-util",
+ "once_cell",
+ "parking_lot",
+ "quanta",
+ "rustc_version",
+ "smallvec",
+ "tagptr",
+ "thiserror",
+ "triomphe",
+ "uuid",
+]
+
+[[package]]
+name = "mpchash"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdd8199faa645318222f8aeb383fca4216a3f75b144f1e264ac74c0835d871a9"
+dependencies = [
+ "num-traits",
+ "rand",
+ "xxhash-rust",
+]
+
+[[package]]
+name = "multimap"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03"
+
+[[package]]
+name = "murmur3"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9252111cf132ba0929b6f8e030cac2a24b507f3a4d6db6fb2896f27b354c714b"
+
+[[package]]
+name = "mutable_batch"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow",
+ "arrow_util",
+ "data_types",
+ "hashbrown 0.14.3",
+ "iox_time",
+ "itertools 0.12.1",
+ "schema",
+ "snafu 0.8.2",
+ "workspace-hack",
+]
+
+[[package]]
+name = "mutable_batch_lp"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "hashbrown 0.14.3",
+ "influxdb-line-protocol",
+ "itertools 0.12.1",
+ "mutable_batch",
+ "snafu 0.8.2",
+ "workspace-hack",
+]
+
+[[package]]
+name = "mutable_batch_pb"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow_util",
+ "dml",
+ "generated_types",
+ "hashbrown 0.14.3",
+ "mutable_batch",
+ "schema",
+ "snafu 0.8.2",
+ "workspace-hack",
+]
+
+[[package]]
+name = "nix"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "598beaf3cc6fdd9a5dfb1630c2800c7acd31df7aaf0f565796fba2b53ca1af1b"
+dependencies = [
+ "bitflags 1.3.2",
+ "cfg-if",
+ "libc",
+]
+
+[[package]]
+name = "nix"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"
+dependencies = [
+ "bitflags 2.5.0",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "non-empty-string"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55cf0f4060e345ae505219853da9ca1150564158a648a6aa6a528f0d5794bb33"
+dependencies = [
+ "delegate",
+]
+
+[[package]]
+name = "notify"
+version = "6.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6205bd8bb1e454ad2e27422015fb5e4f2bcc7e08fa8f27058670d208324a4d2d"
+dependencies = [
+ "bitflags 2.5.0",
+ "crossbeam-channel",
+ "filetime",
+ "fsevent-sys",
+ "inotify",
+ "kqueue",
+ "libc",
+ "log",
+ "mio",
+ "walkdir",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "ntapi"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8a3895c6391c39d7fe7ebc444a87eb2991b2a0bc718fdabd071eec617fc68e4"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "nu-ansi-term"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+dependencies = [
+ "overload",
+ "winapi",
+]
+
+[[package]]
+name = "num"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3135b08af27d103b0a51f2ae0f8632117b7b185ccf931445affa8df530576a41"
+dependencies = [
+ "num-bigint",
+ "num-complex",
+ "num-integer",
+ "num-iter",
+ "num-rational",
+ "num-traits",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608e7659b5c3d7cba262d894801b9ec9d00de989e8a82bd4bef91d08da45cdc0"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-bigint-dig"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc84195820f291c7697304f3cbdadd1cb7199c0efc917ff5eafd71225c136151"
+dependencies = [
+ "byteorder",
+ "lazy_static",
+ "libm",
+ "num-integer",
+ "num-iter",
+ "num-traits",
+ "rand",
+ "smallvec",
+ "zeroize",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23c6602fda94a57c990fe0df199a035d83576b496aa29f4e634a8ac6004e68a6"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-format"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a652d9771a63711fd3c3deb670acfbe5c30a4072e664d7a3bf5a9e1056ac72c3"
+dependencies = [
+ "arrayvec",
+ "itoa",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-iter"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d869c01cc0c455284163fd0092f1f93835385ccab5a98a0dcc497b2f8bf055a9"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0"
+dependencies = [
+ "autocfg",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "object"
+version = "0.32.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "object_store"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8718f8b65fdf67a45108d1548347d4af7d71fb81ce727bbf9e3b2535e079db3"
+dependencies = [
+ "async-trait",
+ "base64 0.21.7",
+ "bytes",
+ "chrono",
+ "futures",
+ "humantime",
+ "hyper",
+ "itertools 0.12.1",
+ "md-5",
+ "parking_lot",
+ "percent-encoding",
+ "quick-xml 0.31.0",
+ "rand",
+ "reqwest",
+ "ring",
+ "rustls-pemfile 2.1.2",
+ "serde",
+ "serde_json",
+ "snafu 0.7.5",
+ "tokio",
+ "tracing",
+ "url",
+ "walkdir",
+]
+
+[[package]]
+name = "observability_deps"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "tracing",
+ "workspace-hack",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+dependencies = [
+ "parking_lot_core",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
+
+[[package]]
+name = "ordered-float"
+version = "2.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68f19d67e5a2795c94e73e0bb1cc1a7edeb2e28efd39e2e1c9b7a40c1108b11c"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "ordered-float"
+version = "4.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a76df7075c7d4d01fdcb46c912dd17fba5b60c78ea480b475f2b6ab6f666584e"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "overload"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
+
+[[package]]
+name = "panic_logging"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "metric",
+ "observability_deps",
+ "workspace-hack",
+]
+
+[[package]]
+name = "parking"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb813b8af86854136c6922af0598d719255ecb2179515e6e7730d468f05c9cae"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "parquet"
+version = "50.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "547b92ebf0c1177e3892f44c8f79757ee62e678d564a9834189725f2c5b7a750"
+dependencies = [
+ "ahash",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast 50.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "arrow-data",
+ "arrow-ipc",
+ "arrow-schema",
+ "arrow-select 50.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "base64 0.21.7",
+ "brotli",
+ "bytes",
+ "chrono",
+ "flate2",
+ "futures",
+ "half",
+ "hashbrown 0.14.3",
+ "lz4_flex",
+ "num",
+ "num-bigint",
+ "object_store",
+ "paste",
+ "seq-macro",
+ "snap",
+ "thrift",
+ "tokio",
+ "twox-hash",
+ "zstd",
+]
+
+[[package]]
+name = "parquet_cache"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arc-swap",
+ "async-channel",
+ "async-trait",
+ "backoff 0.1.0",
+ "bytes",
+ "chrono",
+ "data_types",
+ "fnv",
+ "futures",
+ "http",
+ "hyper",
+ "iox_catalog",
+ "k8s-openapi",
+ "kube",
+ "moka",
+ "mpchash",
+ "notify",
+ "object_store",
+ "observability_deps",
+ "parking_lot",
+ "parquet",
+ "parquet_file",
+ "pin-project",
+ "reqwest",
+ "schema",
+ "schemars",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "tokio",
+ "tokio-util",
+ "tower",
+ "url",
+ "workspace-hack",
+]
+
+[[package]]
+name = "parquet_file"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow",
+ "base64 0.22.0",
+ "bytes",
+ "data_types",
+ "datafusion",
+ "datafusion_util",
+ "futures",
+ "generated_types",
+ "iox_time",
+ "object_store",
+ "observability_deps",
+ "parquet",
+ "pbjson-types",
+ "prost 0.12.4",
+ "schema",
+ "snafu 0.8.2",
+ "thiserror",
+ "thrift",
+ "tokio",
+ "uuid",
+ "workspace-hack",
+ "zstd",
+]
+
+[[package]]
+name = "parse-zoneinfo"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c705f256449c60da65e11ff6626e0c16a0a0b96aaa348de61376b249bc340f41"
+dependencies = [
+ "regex",
+]
+
+[[package]]
+name = "paste"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c"
+
+[[package]]
+name = "pbjson"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1030c719b0ec2a2d25a5df729d6cff1acf3cc230bf766f4f97833591f7577b90"
+dependencies = [
+ "base64 0.21.7",
+ "serde",
+]
+
+[[package]]
+name = "pbjson-build"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2580e33f2292d34be285c5bc3dba5259542b083cfad6037b6d70345f24dcb735"
+dependencies = [
+ "heck 0.4.1",
+ "itertools 0.11.0",
+ "prost 0.12.4",
+ "prost-types 0.12.4",
+]
+
+[[package]]
+name = "pbjson-types"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18f596653ba4ac51bdecbb4ef6773bc7f56042dc13927910de1684ad3d32aa12"
+dependencies = [
+ "bytes",
+ "chrono",
+ "pbjson",
+ "pbjson-build",
+ "prost 0.12.4",
+ "prost-build",
+ "serde",
+]
+
+[[package]]
+name = "pem"
+version = "3.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e459365e590736a54c3fa561947c84837534b8e9af6fc5bf781307e82658fae"
+dependencies = [
+ "base64 0.22.0",
+ "serde",
+]
+
+[[package]]
+name = "pem-rfc7468"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
+dependencies = [
+ "base64ct",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
+
+[[package]]
+name = "pest"
+version = "2.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "311fb059dee1a7b802f036316d790138c613a4e8b180c822e3925a662e9f0c95"
+dependencies = [
+ "memchr",
+ "thiserror",
+ "ucd-trie",
+]
+
+[[package]]
+name = "pest_derive"
+version = "2.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f73541b156d32197eecda1a4014d7f868fd2bcb3c550d5386087cfba442bf69c"
+dependencies = [
+ "pest",
+ "pest_generator",
+]
+
+[[package]]
+name = "pest_generator"
+version = "2.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c35eeed0a3fab112f75165fdc026b3913f4183133f19b49be773ac9ea966e8bd"
+dependencies = [
+ "pest",
+ "pest_meta",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "pest_meta"
+version = "2.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2adbf29bb9776f28caece835398781ab24435585fe0d4dc1374a61db5accedca"
+dependencies = [
+ "once_cell",
+ "pest",
+ "sha2",
+]
+
+[[package]]
+name = "petgraph"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9"
+dependencies = [
+ "fixedbitset",
+ "indexmap 2.2.6",
+]
+
+[[package]]
+name = "phf"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc"
+dependencies = [
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8d39688d359e6b34654d328e262234662d16cc0f60ec8dcbe5e718709342a5a"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48e4cc64c2ad9ebe670cb8fd69dd50ae301650392e81c05f9bfcb2d5bdbc24b0"
+dependencies = [
+ "phf_shared",
+ "rand",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b"
+dependencies = [
+ "siphasher 0.3.11",
+]
+
+[[package]]
+name = "pin-project"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "pkcs1"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8ffb9f10fa047879315e6625af03c164b16962a5368d724ed16323b68ace47f"
+dependencies = [
+ "der",
+ "pkcs8",
+ "spki",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
+
+[[package]]
+name = "platforms"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db23d408679286588f4d4644f965003d056e3dd5abcaaa938116871d7ce2fee7"
+
+[[package]]
+name = "pprof"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef5c97c51bd34c7e742402e216abdeb44d415fbe6ae41d56b114723e953711cb"
+dependencies = [
+ "backtrace",
+ "cfg-if",
+ "findshlibs",
+ "inferno",
+ "libc",
+ "log",
+ "nix 0.26.4",
+ "once_cell",
+ "parking_lot",
+ "prost 0.12.4",
+ "prost-build",
+ "prost-derive 0.12.4",
+ "protobuf",
+ "sha2",
+ "smallvec",
+ "symbolic-demangle",
+ "tempfile",
+ "thiserror",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+
+[[package]]
+name = "predicate"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow",
+ "chrono",
+ "data_types",
+ "datafusion",
+ "datafusion_util",
+ "itertools 0.12.1",
+ "observability_deps",
+ "query_functions",
+ "schema",
+ "snafu 0.8.2",
+ "sqlparser",
+ "workspace-hack",
+]
+
+[[package]]
+name = "predicates"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68b87bfd4605926cdfefc1c3b5f8fe560e3feca9d5552cf68c466d3d8236c7e8"
+dependencies = [
+ "anstyle",
+ "difflib",
+ "predicates-core",
+]
+
+[[package]]
+name = "predicates-core"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b794032607612e7abeb4db69adb4e33590fa6cf1149e95fd7cb00e634b92f174"
+
+[[package]]
+name = "predicates-tree"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "368ba315fb8c5052ab692e68a0eefec6ec57b23a36959c14496f0b0df2c0cecf"
+dependencies = [
+ "predicates-core",
+ "termtree",
+]
+
+[[package]]
+name = "pretty_assertions"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af7cee1a6c8a5b9208b3cb1061f10c0cb689087b3d8ce85fb9d2dd7a29b6ba66"
+dependencies = [
+ "diff",
+ "yansi",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ac2cf0f2e4f42b49f5ffd07dae8d746508ef7526c13940e5f524012ae6c6550"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d1597b0c024618f09a9c3b8655b7e430397a36d23fdafec26d6965e9eec3eba"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "prometheus"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "449811d15fbdf5ceb5c1144416066429cf82316e2ec8ce0c1f6f8a02e7bbcf8c"
+dependencies = [
+ "cfg-if",
+ "fnv",
+ "lazy_static",
+ "memchr",
+ "parking_lot",
+ "thiserror",
+]
+
+[[package]]
+name = "proptest"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31b476131c3c86cb68032fdc5cb6d5a1045e3e42d96b69fa599fd77701e1f5bf"
+dependencies = [
+ "bitflags 2.5.0",
+ "lazy_static",
+ "num-traits",
+ "rand",
+ "rand_chacha",
+ "rand_xorshift",
+ "regex-syntax 0.8.3",
+ "unarray",
+]
+
+[[package]]
+name = "prost"
+version = "0.11.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b82eaa1d779e9a4bc1c3217db8ffbeabaae1dca241bf70183242128d48681cd"
+dependencies = [
+ "bytes",
+ "prost-derive 0.11.9",
+]
+
+[[package]]
+name = "prost"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0f5d036824e4761737860779c906171497f6d55681139d8312388f8fe398922"
+dependencies = [
+ "bytes",
+ "prost-derive 0.12.4",
+]
+
+[[package]]
+name = "prost-build"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80b776a1b2dc779f5ee0641f8ade0125bc1298dd41a9a0c16d8bd57b42d222b1"
+dependencies = [
+ "bytes",
+ "heck 0.5.0",
+ "itertools 0.12.1",
+ "log",
+ "multimap",
+ "once_cell",
+ "petgraph",
+ "prettyplease",
+ "prost 0.12.4",
+ "prost-types 0.12.4",
+ "regex",
+ "syn 2.0.60",
+ "tempfile",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.11.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5d2d8d10f3c6ded6da8b05b5fb3b8a5082514344d56c9f871412d29b4e075b4"
+dependencies = [
+ "anyhow",
+ "itertools 0.10.5",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19de2de2a00075bf566bee3bd4db014b11587e84184d3f7a791bc17f1a8e9e48"
+dependencies = [
+ "anyhow",
+ "itertools 0.12.1",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "prost-types"
+version = "0.11.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "213622a1460818959ac1181aaeb2dc9c7f63df720db7d788b3e24eacd1983e13"
+dependencies = [
+ "prost 0.11.9",
+]
+
+[[package]]
+name = "prost-types"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3235c33eb02c1f1e212abdbe34c78b264b038fb58ca612664343271e36e55ffe"
+dependencies = [
+ "prost 0.12.4",
+]
+
+[[package]]
+name = "protobuf"
+version = "2.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "106dd99e98437432fed6519dedecfade6a06a73bb7b2a1e019fdd2bee5778d94"
+
+[[package]]
+name = "quanta"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5167a477619228a0b284fac2674e3c388cba90631d7b7de620e6f1fcd08da5"
+dependencies = [
+ "crossbeam-utils",
+ "libc",
+ "once_cell",
+ "raw-cpuid",
+ "wasi",
+ "web-sys",
+ "winapi",
+]
+
+[[package]]
+name = "query_functions"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow",
+ "chrono",
+ "datafusion",
+ "once_cell",
+ "regex",
+ "regex-syntax 0.8.3",
+ "schema",
+ "snafu 0.8.2",
+ "workspace-hack",
+]
+
+[[package]]
+name = "quick-xml"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f50b1c63b38611e7d4d7f68b82d3ad0cc71a2ad2e7f61fc10f1328d917c93cd"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "quick-xml"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1004a344b30a54e2ee58d66a71b32d2db2feb0a31f9a2d302bf0536f15de2a33"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_xorshift"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "raw-cpuid"
+version = "11.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d86a7c4638d42c44551f4791a20e687dbb4c3de1f33c43dd71e355cd429def1"
+dependencies = [
+ "bitflags 2.5.0",
+]
+
+[[package]]
+name = "rayon"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+dependencies = [
+ "bitflags 1.3.2",
+]
+
+[[package]]
+name = "regex"
+version = "1.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata 0.4.6",
+ "regex-syntax 0.8.3",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
+dependencies = [
+ "regex-syntax 0.6.29",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax 0.8.3",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56"
+
+[[package]]
+name = "reqwest"
+version = "0.11.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62"
+dependencies = [
+ "base64 0.21.7",
+ "bytes",
+ "encoding_rs",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http",
+ "http-body",
+ "hyper",
+ "hyper-rustls",
+ "ipnet",
+ "js-sys",
+ "log",
+ "mime",
+ "once_cell",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustls",
+ "rustls-native-certs",
+ "rustls-pemfile 1.0.4",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "system-configuration",
+ "tokio",
+ "tokio-rustls",
+ "tokio-util",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams",
+ "web-sys",
+ "webpki-roots",
+ "winreg",
+]
+
+[[package]]
+name = "rgb"
+version = "0.8.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05aaa8004b64fd573fc9d002f4e632d51ad4f026c2b5ba95fcb6c2f32c2c47d8"
+dependencies = [
+ "bytemuck",
+]
+
+[[package]]
+name = "ring"
+version = "0.17.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom",
+ "libc",
+ "spin 0.9.8",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rsa"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0e5124fcb30e76a7e79bfee683a2746db83784b86289f6251b54b7950a0dfc"
+dependencies = [
+ "const-oid",
+ "digest",
+ "num-bigint-dig",
+ "num-integer",
+ "num-traits",
+ "pkcs1",
+ "pkcs8",
+ "rand_core",
+ "signature",
+ "spki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
+
+[[package]]
+name = "rustc_version"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustix"
+version = "0.38.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
+dependencies = [
+ "bitflags 2.5.0",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rustls"
+version = "0.21.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fecbfb7b1444f477b345853b1fce097a2c6fb637b2bfb87e6bc5db0f043fae4"
+dependencies = [
+ "log",
+ "ring",
+ "rustls-webpki",
+ "sct",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9aace74cb666635c918e9c12bc0d348266037aa8eb599b5cba565709a8dff00"
+dependencies = [
+ "openssl-probe",
+ "rustls-pemfile 1.0.4",
+ "schannel",
+ "security-framework",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
+dependencies = [
+ "base64 0.21.7",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29993a25686778eb88d4189742cd713c9bce943bc54251a33509dc63cbacf73d"
+dependencies = [
+ "base64 0.22.0",
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "beb461507cee2c2ff151784c52762cf4d9ff6a61f3e80968600ed24fa837fa54"
+
+[[package]]
+name = "rustls-webpki"
+version = "0.101.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80af6f9131f277a45a3fba6ce8e2258037bb0477a67e610d3c1fe046ab31de47"
+
+[[package]]
+name = "ryu"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "schannel"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534"
+dependencies = [
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "schema"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow",
+ "hashbrown 0.14.3",
+ "indexmap 2.2.6",
+ "observability_deps",
+ "once_cell",
+ "snafu 0.8.2",
+ "workspace-hack",
+]
+
+[[package]]
+name = "schemars"
+version = "0.8.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45a28f4c49489add4ce10783f7911893516f15afe45d015608d41faca6bc4d29"
+dependencies = [
+ "dyn-clone",
+ "schemars_derive",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars_derive"
+version = "0.8.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c767fd6fa65d9ccf9cf026122c1b555f2ef9a4f0cea69da4d7dbc3e258d30967"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde_derive_internals",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "sct"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
+[[package]]
+name = "secrecy"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9bd1c54ea06cfd2f6b63219704de0b9b4f72dcc2b8fdef820be6cd799780e91e"
+dependencies = [
+ "serde",
+ "zeroize",
+]
+
+[[package]]
+name = "security-framework"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "770452e37cad93e0a50d5abc3990d2bc351c36d0328f86cefec2f2fb206eaef6"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f3cc463c0ef97e11c3461a9d3787412d30e8e7eb907c79180c4a57bf7c04ef"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92d43fe69e652f3df9bdc2b85b2854a0825b86e4fb76bc44d945137d053639ca"
+
+[[package]]
+name = "seq-macro"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3f0bf26fd526d2a95683cd0f87bf103b8539e2ca1ef48ce002d67aad59aa0b4"
+
+[[package]]
+name = "serde"
+version = "1.0.198"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9846a40c979031340571da2545a4e5b7c4163bdae79b301d5f86d03979451fcc"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde-value"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3a1a3341211875ef120e117ea7fd5228530ae7e7036a779fdc9117be6b3282c"
+dependencies = [
+ "ordered-float 2.10.1",
+ "serde",
+]
+
+[[package]]
+name = "serde_arrow"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99e774f158723ad8fe05b884fd2f89355934599a11817edd0dc854cb1ef0e42a"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "bytemuck",
+ "chrono",
+ "half",
+ "serde",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.198"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e88edab869b01783ba905e7d0153f9fc1a6505a96e4ad3018011eedb838566d9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "serde_derive_internals"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85bf8229e7920a9f636479437026331ce11aa132b4dde37d121944a44d6e5f3c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.116"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e17db7126d17feb94eb3fad46bf1a96b034e8aacbc2e775fe81505f8b0b2813"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_urlencoded"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+dependencies = [
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_yaml"
+version = "0.9.34+deprecated"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
+dependencies = [
+ "indexmap 2.2.6",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
+]
+
+[[package]]
+name = "service_common"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow",
+ "datafusion",
+ "executor",
+ "tonic 0.10.2",
+ "workspace-hack",
+]
+
+[[package]]
+name = "service_grpc_flight"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow",
+ "arrow-flight",
+ "authz",
+ "bytes",
+ "data_types",
+ "datafusion",
+ "flightsql",
+ "futures",
+ "generated_types",
+ "iox_query",
+ "iox_query_influxql",
+ "iox_query_params",
+ "observability_deps",
+ "prost 0.12.4",
+ "serde",
+ "serde_json",
+ "service_common",
+ "snafu 0.8.2",
+ "tokio",
+ "tonic 0.10.2",
+ "tower_trailer",
+ "trace",
+ "trace_http",
+ "tracker",
+ "workspace-hack",
+]
+
+[[package]]
+name = "service_grpc_testing"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "generated_types",
+ "observability_deps",
+ "tonic 0.10.2",
+ "workspace-hack",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "digest",
+ "rand_core",
+]
+
+[[package]]
+name = "similar"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa42c91313f1d05da9b26f267f931cf178d4aba455b4c4622dd7355eb80c6640"
+
+[[package]]
+name = "siphasher"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
+
+[[package]]
+name = "siphasher"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
+
+[[package]]
+name = "slab"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+
+[[package]]
+name = "snafu"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4de37ad025c587a29e8f3f5605c00f70b98715ef90b9061a815b9e59e9042d6"
+dependencies = [
+ "doc-comment",
+ "snafu-derive 0.7.5",
+]
+
+[[package]]
+name = "snafu"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75976f4748ab44f6e5332102be424e7c2dc18daeaf7e725f2040c3ebb133512e"
+dependencies = [
+ "snafu-derive 0.8.2",
+]
+
+[[package]]
+name = "snafu-derive"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990079665f075b699031e9c08fd3ab99be5029b96f3b78dc0709e8f77e4efebf"
+dependencies = [
+ "heck 0.4.1",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "snafu-derive"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4b19911debfb8c2fb1107bc6cb2d61868aaf53a988449213959bb1b5b1ed95f"
+dependencies = [
+ "heck 0.4.1",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "snap"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b6b67fb9a61334225b5b790716f609cd58395f895b3fe8b328786812a40bc3b"
+
+[[package]]
+name = "socket2"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05ffd9c0a93b7543e062e759284fcf5f5e3b098501104bfbdde4d404db792871"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "spin"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
+
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+dependencies = [
+ "lock_api",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
+[[package]]
+name = "sqlformat"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce81b7bd7c4493975347ef60d8c7e8b742d4694f4c49f93e0a12ea263938176c"
+dependencies = [
+ "itertools 0.12.1",
+ "nom",
+ "unicode_categories",
+]
+
+[[package]]
+name = "sqlparser"
+version = "0.44.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aaf9c7ff146298ffda83a200f8d5084f08dcee1edfc135fcc1d646a45d50ffd6"
+dependencies = [
+ "log",
+ "sqlparser_derive",
+]
+
+[[package]]
+name = "sqlparser_derive"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01b2e185515564f15375f593fb966b5718bc624ba77fe49fa4616ad619690554"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "sqlx"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9a2ccff1a000a5a59cd33da541d9f2fdcd9e6e8229cc200565942bff36d0aaa"
+dependencies = [
+ "sqlx-core",
+ "sqlx-macros",
+ "sqlx-mysql",
+ "sqlx-postgres",
+ "sqlx-sqlite",
+]
+
+[[package]]
+name = "sqlx-core"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24ba59a9342a3d9bab6c56c118be528b27c9b60e490080e9711a04dccac83ef6"
+dependencies = [
+ "ahash",
+ "atoi",
+ "byteorder",
+ "bytes",
+ "crc",
+ "crossbeam-queue",
+ "either",
+ "event-listener 2.5.3",
+ "futures-channel",
+ "futures-core",
+ "futures-intrusive",
+ "futures-io",
+ "futures-util",
+ "hashlink",
+ "hex",
+ "indexmap 2.2.6",
+ "log",
+ "memchr",
+ "once_cell",
+ "paste",
+ "percent-encoding",
+ "rustls",
+ "rustls-pemfile 1.0.4",
+ "serde",
+ "serde_json",
+ "sha2",
+ "smallvec",
+ "sqlformat",
+ "thiserror",
+ "tokio",
+ "tokio-stream",
+ "tracing",
+ "url",
+ "uuid",
+ "webpki-roots",
+]
+
+[[package]]
+name = "sqlx-hotswap-pool"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "either",
+ "futures",
+ "sqlx",
+ "workspace-hack",
+]
+
+[[package]]
+name = "sqlx-macros"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ea40e2345eb2faa9e1e5e326db8c34711317d2b5e08d0d5741619048a803127"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "sqlx-core",
+ "sqlx-macros-core",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "sqlx-macros-core"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5833ef53aaa16d860e92123292f1f6a3d53c34ba8b1969f152ef1a7bb803f3c8"
+dependencies = [
+ "dotenvy",
+ "either",
+ "heck 0.4.1",
+ "hex",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "serde_json",
+ "sha2",
+ "sqlx-core",
+ "sqlx-mysql",
+ "sqlx-postgres",
+ "sqlx-sqlite",
+ "syn 1.0.109",
+ "tempfile",
+ "tokio",
+ "url",
+]
+
+[[package]]
+name = "sqlx-mysql"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ed31390216d20e538e447a7a9b959e06ed9fc51c37b514b46eb758016ecd418"
+dependencies = [
+ "atoi",
+ "base64 0.21.7",
+ "bitflags 2.5.0",
+ "byteorder",
+ "bytes",
+ "crc",
+ "digest",
+ "dotenvy",
+ "either",
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-util",
+ "generic-array",
+ "hex",
+ "hkdf",
+ "hmac",
+ "itoa",
+ "log",
+ "md-5",
+ "memchr",
+ "once_cell",
+ "percent-encoding",
+ "rand",
+ "rsa",
+ "serde",
+ "sha1",
+ "sha2",
+ "smallvec",
+ "sqlx-core",
+ "stringprep",
+ "thiserror",
+ "tracing",
+ "uuid",
+ "whoami",
+]
+
+[[package]]
+name = "sqlx-postgres"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c824eb80b894f926f89a0b9da0c7f435d27cdd35b8c655b114e58223918577e"
+dependencies = [
+ "atoi",
+ "base64 0.21.7",
+ "bitflags 2.5.0",
+ "byteorder",
+ "crc",
+ "dotenvy",
+ "etcetera",
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-util",
+ "hex",
+ "hkdf",
+ "hmac",
+ "home",
+ "itoa",
+ "log",
+ "md-5",
+ "memchr",
+ "once_cell",
+ "rand",
+ "serde",
+ "serde_json",
+ "sha2",
+ "smallvec",
+ "sqlx-core",
+ "stringprep",
+ "thiserror",
+ "tracing",
+ "uuid",
+ "whoami",
+]
+
+[[package]]
+name = "sqlx-sqlite"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b244ef0a8414da0bed4bb1910426e890b19e5e9bccc27ada6b797d05c55ae0aa"
+dependencies = [
+ "atoi",
+ "flume",
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-intrusive",
+ "futures-util",
+ "libsqlite3-sys",
+ "log",
+ "percent-encoding",
+ "serde",
+ "sqlx-core",
+ "tracing",
+ "url",
+ "urlencoding 2.1.3",
+ "uuid",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
+[[package]]
+name = "str_stack"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9091b6114800a5f2141aee1d1b9d6ca3592ac062dc5decb3764ec5895a47b4eb"
+
+[[package]]
+name = "stringprep"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb41d74e231a107a1b4ee36bd1214b11285b77768d2e3824aedafa988fd36ee6"
+dependencies = [
+ "finl_unicode",
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "strsim"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "strum"
+version = "0.26.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d8cec3501a5194c432b2b7976db6b7d10ec95c253208b45f83f7136aa985e29"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.26.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6cf59daf282c0a494ba14fd21610a0325f9f90ec9d1231dea26bcb1d696c946"
+dependencies = [
+ "heck 0.4.1",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "subtle"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
+
+[[package]]
+name = "symbolic-common"
+version = "12.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cccfffbc6bb3bb2d3a26cd2077f4d055f6808d266f9d4d158797a4c60510dfe"
+dependencies = [
+ "debugid",
+ "memmap2",
+ "stable_deref_trait",
+ "uuid",
+]
+
+[[package]]
+name = "symbolic-demangle"
+version = "12.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76a99812da4020a67e76c4eb41f08c87364c14170495ff780f30dd519c221a68"
+dependencies = [
+ "cpp_demangle",
+ "rustc-demangle",
+ "symbolic-common",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "909518bc7b1c9b779f1bbf07f2929d35af9f0f37e47c6e9ef7f9dddc1e1821f3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "sync_wrapper"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
+
+[[package]]
+name = "sysinfo"
+version = "0.30.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87341a165d73787554941cd5ef55ad728011566fe714e987d1b976c15dbc3a83"
+dependencies = [
+ "cfg-if",
+ "core-foundation-sys",
+ "libc",
+ "ntapi",
+ "once_cell",
+ "rayon",
+ "windows",
+]
+
+[[package]]
+name = "system-configuration"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation",
+ "system-configuration-sys",
+]
+
+[[package]]
+name = "system-configuration-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "tagptr"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
+
+[[package]]
+name = "tempfile"
+version = "3.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "rustix",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "termtree"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76"
+
+[[package]]
+name = "test_helpers"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "async-trait",
+ "dotenvy",
+ "observability_deps",
+ "parking_lot",
+ "tempfile",
+ "tokio",
+ "tracing-log",
+ "tracing-subscriber",
+ "workspace-hack",
+]
+
+[[package]]
+name = "test_helpers_end_to_end"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "arrow",
+ "arrow-flight",
+ "arrow_util",
+ "assert_cmd",
+ "assert_matches",
+ "bytes",
+ "data_types",
+ "dml",
+ "futures",
+ "generated_types",
+ "http",
+ "hyper",
+ "influxdb_iox_client",
+ "ingester_query_grpc",
+ "insta",
+ "iox_catalog",
+ "iox_query_params",
+ "mutable_batch_lp",
+ "mutable_batch_pb",
+ "nix 0.28.0",
+ "observability_deps",
+ "once_cell",
+ "parking_lot",
+ "prost 0.12.4",
+ "rand",
+ "regex",
+ "reqwest",
+ "serde_json",
+ "snafu 0.8.2",
+ "sqlx",
+ "tempfile",
+ "test_helpers",
+ "tokio",
+ "tokio-util",
+ "tonic 0.10.2",
+ "workspace-hack",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.59"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0126ad08bff79f29fc3ae6a55cc72352056dfff61e3ff8bb7129476d44b23aa"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.59"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1cd413b5d558b4c5bf3680e324a6fa5014e7b7c067a51e69dbdf47eb7148b66"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+]
+
+[[package]]
+name = "threadpool"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
+dependencies = [
+ "num_cpus",
+]
+
+[[package]]
+name = "thrift"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e54bc85fc7faa8bc175c4bab5b92ba8d9a3ce893d0e9f42cc455c8ab16a9e09"
+dependencies = [
+ "byteorder",
+ "integer-encoding",
+ "log",
+ "ordered-float 2.10.1",
+ "threadpool",
+]
+
+[[package]]
+name = "tikv-jemalloc-ctl"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "619bfed27d807b54f7f776b9430d4f8060e66ee138a28632ca898584d462c31c"
+dependencies = [
+ "libc",
+ "paste",
+ "tikv-jemalloc-sys",
+]
+
+[[package]]
+name = "tikv-jemalloc-sys"
+version = "0.5.4+5.3.0-patched"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9402443cb8fd499b6f327e40565234ff34dbda27460c5b47db0db77443dd85d1"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "tiny-keccak"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+dependencies = [
+ "crunchy",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "tokio"
+version = "1.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1adbebffeca75fcfd058afa480fb6c0b81e165a0323f9c9d39c9697e37c46787"
+dependencies = [
+ "backtrace",
+ "bytes",
+ "libc",
+ "mio",
+ "num_cpus",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2",
+ "tokio-macros",
+ "tracing",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "tokio-io-timeout"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30b74022ada614a1b4834de765f9bb43877f910cc8ce4be40e89042c9223a8bf"
+dependencies = [
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
+dependencies = [
+ "rustls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-stream"
+version = "0.1.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "267ac89e0bec6e691e5813911606935d77c476ff49024f98abcea3e7b15e37af"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5419f34732d9eb6ee4c3578b7989078579b7f039cbbb9ca2c4da015749371e15"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "slab",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "tokio_metrics_bridge"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "metric",
+ "parking_lot",
+ "tokio",
+ "workspace-hack",
+]
+
+[[package]]
+name = "tokio_watchdog"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "metric",
+ "observability_deps",
+ "tokio",
+ "workspace-hack",
+]
+
+[[package]]
+name = "tonic"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3082666a3a6433f7f511c7192923fa1fe07c69332d3c6a2e6bb040b569199d5a"
+dependencies = [
+ "async-trait",
+ "axum",
+ "base64 0.21.7",
+ "bytes",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http",
+ "http-body",
+ "hyper",
+ "hyper-timeout",
+ "percent-encoding",
+ "pin-project",
+ "prost 0.11.9",
+ "tokio",
+ "tokio-stream",
+ "tower",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tonic"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d560933a0de61cf715926b9cac824d4c883c2c43142f787595e48280c40a1d0e"
+dependencies = [
+ "async-stream",
+ "async-trait",
+ "axum",
+ "base64 0.21.7",
+ "bytes",
+ "h2",
+ "http",
+ "http-body",
+ "hyper",
+ "hyper-timeout",
+ "percent-encoding",
+ "pin-project",
+ "prost 0.12.4",
+ "rustls",
+ "rustls-native-certs",
+ "rustls-pemfile 1.0.4",
+ "tokio",
+ "tokio-rustls",
+ "tokio-stream",
+ "tower",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tonic-build"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d021fc044c18582b9a2408cd0dd05b1596e3ecdb5c4df822bb0183545683889"
+dependencies = [
+ "prettyplease",
+ "proc-macro2",
+ "prost-build",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "tonic-health"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f80db390246dfb46553481f6024f0082ba00178ea495dbb99e70ba9a4fafb5e1"
+dependencies = [
+ "async-stream",
+ "prost 0.12.4",
+ "tokio",
+ "tokio-stream",
+ "tonic 0.10.2",
+]
+
+[[package]]
+name = "tonic-reflection"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fa37c513df1339d197f4ba21d28c918b9ef1ac1768265f11ecb6b7f1cba1b76"
+dependencies = [
+ "prost 0.12.4",
+ "prost-types 0.12.4",
+ "tokio",
+ "tokio-stream",
+ "tonic 0.10.2",
+]
+
+[[package]]
+name = "tower"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "indexmap 1.9.3",
+ "pin-project",
+ "pin-project-lite",
+ "rand",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tower-http"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c5bb1d698276a2443e5ecfabc1008bf15a36c12e6a7176e7bf089ea9131140"
+dependencies = [
+ "base64 0.21.7",
+ "bitflags 2.5.0",
+ "bytes",
+ "futures-core",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-range-header",
+ "mime",
+ "pin-project-lite",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
+
+[[package]]
+name = "tower-service"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
+
+[[package]]
+name = "tower_trailer"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "futures",
+ "http",
+ "http-body",
+ "parking_lot",
+ "pin-project",
+ "tower",
+ "workspace-hack",
+]
+
+[[package]]
+name = "trace"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "chrono",
+ "observability_deps",
+ "parking_lot",
+ "rand",
+ "workspace-hack",
+]
+
+[[package]]
+name = "trace_exporters"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "async-trait",
+ "clap",
+ "futures",
+ "iox_time",
+ "observability_deps",
+ "snafu 0.8.2",
+ "thrift",
+ "tokio",
+ "trace",
+ "workspace-hack",
+]
+
+[[package]]
+name = "trace_http"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "bytes",
+ "futures",
+ "hashbrown 0.14.3",
+ "http",
+ "http-body",
+ "itertools 0.12.1",
+ "metric",
+ "observability_deps",
+ "parking_lot",
+ "pin-project",
+ "snafu 0.8.2",
+ "tower",
+ "trace",
+ "workspace-hack",
+]
+
+[[package]]
+name = "tracing"
+version = "0.1.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
+dependencies = [
+ "log",
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
+dependencies = [
+ "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-serde"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc6b213177105856957181934e4920de57730fc69bf42c37ee5bb664d406d9e1"
+dependencies = [
+ "serde",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
+dependencies = [
+ "matchers",
+ "nu-ansi-term",
+ "once_cell",
+ "parking_lot",
+ "regex",
+ "serde",
+ "serde_json",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing",
+ "tracing-core",
+ "tracing-log",
+ "tracing-serde",
+]
+
+[[package]]
+name = "tracker"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "futures",
+ "hashbrown 0.14.3",
+ "iox_time",
+ "lock_api",
+ "metric",
+ "observability_deps",
+ "parking_lot",
+ "pin-project",
+ "sysinfo",
+ "tokio",
+ "tokio-util",
+ "trace",
+ "workspace-hack",
+]
+
+[[package]]
+name = "treediff"
+version = "4.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d127780145176e2b5d16611cc25a900150e86e9fd79d3bde6ff3a37359c9cb5"
+dependencies = [
+ "serde_json",
+]
+
+[[package]]
+name = "triomphe"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "859eb650cfee7434994602c3a68b25d77ad9e68c8a6cd491616ef86661382eb3"
+
+[[package]]
+name = "trogging"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "clap",
+ "logfmt",
+ "observability_deps",
+ "thiserror",
+ "tracing-log",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+
+[[package]]
+name = "twox-hash"
+version = "1.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
+dependencies = [
+ "cfg-if",
+ "static_assertions",
+]
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+
+[[package]]
+name = "ucd-trie"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
+
+[[package]]
+name = "unarray"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4c87d22b6e3f4a18d4d40ef354e97c90fcb14dd91d7dc0aa9d8a1172ebf7202"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85"
+
+[[package]]
+name = "unicode_categories"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39ec24b3121d976906ece63c9daad25b85969647682eee313cb5779fdd69e14e"
+
+[[package]]
+name = "unsafe-libyaml"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "url"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+]
+
+[[package]]
+name = "urlencoding"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a1f0175e03a0973cf4afd476bef05c26e228520400eb1fd473ad417b1c00ffb"
+
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
+
+[[package]]
+name = "uuid"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "valuable"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "wait-timeout"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "want"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+dependencies = [
+ "try-lock",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+
+[[package]]
+name = "wasm-streams"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b65dc4c90b63b118468cf747d8bf3566c1913ef60be765b5730ead9e0a3ba129"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "0.25.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1"
+
+[[package]]
+name = "whoami"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a44ab49fad634e88f55bf8f9bb3abd2f27d7204172a112c7c9987e01c1c94ea9"
+dependencies = [
+ "redox_syscall",
+ "wasite",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
+dependencies = [
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
+dependencies = [
+ "windows-core",
+ "windows-targets 0.52.5",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
+ "windows-targets 0.52.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.5",
+ "windows_aarch64_msvc 0.52.5",
+ "windows_i686_gnu 0.52.5",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc 0.52.5",
+ "windows_x86_64_gnu 0.52.5",
+ "windows_x86_64_gnullvm 0.52.5",
+ "windows_x86_64_msvc 0.52.5",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"
+
+[[package]]
+name = "winreg"
+version = "0.50.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
+dependencies = [
+ "cfg-if",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "workspace-hack"
+version = "0.1.0"
+source = "git+https://github.com/influxdata/influxdb3_core?rev=b546e7f86ee9adbff0dd3c5e687140848397604a#b546e7f86ee9adbff0dd3c5e687140848397604a"
+dependencies = [
+ "ahash",
+ "arrow-array",
+ "arrow-ipc",
+ "base64 0.21.7",
+ "bitflags 2.5.0",
+ "byteorder",
+ "bytes",
+ "cc",
+ "chrono",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+ "crypto-common",
+ "digest",
+ "either",
+ "fixedbitset",
+ "flatbuffers",
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+ "getrandom",
+ "hashbrown 0.14.3",
+ "heck 0.4.1",
+ "hyper",
+ "hyper-rustls",
+ "indexmap 2.2.6",
+ "itertools 0.11.0",
+ "k8s-openapi",
+ "kube-core",
+ "libc",
+ "lock_api",
+ "log",
+ "md-5",
+ "memchr",
+ "mio",
+ "nom",
+ "num-traits",
+ "object_store",
+ "once_cell",
+ "parking_lot",
+ "percent-encoding",
+ "petgraph",
+ "phf_shared",
+ "proptest",
+ "prost 0.12.4",
+ "prost-types 0.12.4",
+ "rand",
+ "rand_core",
+ "regex",
+ "regex-automata 0.4.6",
+ "regex-syntax 0.8.3",
+ "reqwest",
+ "ring",
+ "rustls",
+ "serde",
+ "serde_json",
+ "sha2",
+ "similar",
+ "spin 0.9.8",
+ "sqlparser",
+ "sqlx",
+ "sqlx-core",
+ "sqlx-macros",
+ "sqlx-macros-core",
+ "sqlx-postgres",
+ "sqlx-sqlite",
+ "syn 1.0.109",
+ "syn 2.0.60",
+ "thrift",
+ "tokio",
+ "tokio-stream",
+ "tokio-util",
+ "tower",
+ "tower-http",
+ "tracing",
+ "tracing-core",
+ "tracing-log",
+ "tracing-subscriber",
+ "unicode-bidi",
+ "unicode-normalization",
+ "url",
+ "uuid",
+ "winapi",
+ "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "xxhash-rust"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "927da81e25be1e1a2901d59b81b37dd2efd1fc9c9345a55007f09bf5a2d3ee03"
+
+[[package]]
+name = "xz2"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "388c44dc09d76f1536602ead6d325eb532f5c122f17782bd57fb47baeeb767e2"
+dependencies = [
+ "lzma-sys",
+]
+
+[[package]]
+name = "yansi"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
+
+[[package]]
+name = "zerocopy"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d"
+
+[[package]]
+name = "zstd"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d789b1514203a1120ad2429eae43a7bd32b90976a7bb8a05f7ec02fa88cc23a"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "7.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cd99b45c6bc03a018c8b8a86025678c87e55526064e38f9df301989dce7ec0a"
+dependencies = [
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.0.10+zstd.1.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c253a4914af5bafc8fa8c86ee400827e83cf6ec01195ec1f1ed8441bf00d65aa"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 00000000000..820056ccd14
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,185 @@
+[workspace]
+# In alphabetical order
+members = [
+    "influxdb3",
+    "influxdb3_client",
+    "influxdb3_load_generator",
+    "influxdb3_process",
+    "influxdb3_server",
+    "influxdb3_write",
+    "iox_query_influxql_rewrite",
+]
+default-members = ["influxdb3"]
+
+resolver = "2"
+
+exclude = [
+    "*.md",
+    "*.txt",
+    ".circleci/",
+    ".editorconfig",
+    ".git*",
+    ".github/",
+    ".kodiak.toml",
+    "LICENSE*",
+]
+
+[workspace.package]
+version = "0.1.0"
+authors = ["influxdata Edge Developers"]
+edition = "2021"
+license = "MIT OR Apache-2.0"
+
+[workspace.dependencies]
+anyhow = "1.0"
+arrow = { version = "50.0.0", features = ["prettyprint", "chrono-tz"] }
+arrow-array = "50.0.0"
+arrow-buffer = "50.0.0"
+arrow-csv = "50.0.0"
+arrow-flight = { version = "50.0.0", features = ["flight-sql-experimental"] }
+arrow-json = "50.0.0"
+arrow-schema = "50.0.0"
+assert_cmd = "2.0.14"
+async-trait = "0.1"
+backtrace = "0.3"
+base64 = "0.22.0"
+byteorder = "1.3.4"
+bytes = "1.5"
+chrono = "0.4"
+clap = { version = "4", features = ["derive", "env", "string"] }
+crc32fast = "1.2.0"
+crossbeam-channel = "0.5.11"
+datafusion = { git = "https://github.com/influxdata/arrow-datafusion.git", rev = "581e74785b876615d6a63db8c2e5ba372bf78828" }
+datafusion-proto = { git = "https://github.com/influxdata/arrow-datafusion.git", rev = "581e74785b876615d6a63db8c2e5ba372bf78828" }
+csv = "1.3.0"
+dotenvy = "0.15.7"
+flate2 = "1.0.27"
+futures = "0.3.28"
+futures-util = "0.3.30"
+hashbrown = "0.14.3"
+hex = "0.4.3"
+http = "0.2.9"
+humantime = "2.1.0"
+hyper = "0.14"
+libc = { version = "0.2" }
+mockito = { version = "1.2.0", default-features = false }
+num_cpus = "1.16.0"
+object_store = "0.9.1"
+once_cell = { version = "1.18", features = ["parking_lot"] }
+parking_lot = "0.12.1"
+parquet = { version = "50.0.0", features = ["object_store"] }
+pbjson = "0.6.0"
+pbjson-build = "0.6.2"
+pbjson-types = "0.6.0"
+pin-project-lite = "0.2"
+pretty_assertions = "1.4.0"
+prost = "0.12.3"
+prost-build = "0.12.2"
+prost-types = "0.12.3"
+rand = "0.8.5"
+reqwest = { version = "0.11.24", default-features = false, features = ["rustls-tls", "stream"] }
+secrecy = "0.8.0"
+serde = { version = "1.0", features = ["derive"] }
+serde_arrow = { version = "0.10", features = ["arrow-50"] }
+serde_json = "1.0"
+serde_urlencoded = "0.7.0"
+sha2 = "0.10.8"
+snap = "1.0.0"
+sqlparser = "0.41.0"
+sysinfo = "0.30.8"
+thiserror = "1.0"
+tokio = { version = "1.35", features = ["full"] }
+tokio-util = "0.7.9"
+tonic = { version = "0.10.2", features = ["tls", "tls-roots"] }
+tonic-build = "0.10.2"
+tonic-health = "0.10.2"
+tonic-reflection = "0.10.2"
+tower = "0.4.13"
+unicode-segmentation = "1.11.0"
+url = "2.5.0"
+urlencoding = "1.1"
+uuid = { version = "1", features = ["v4"] }
+
+# Core.git crates we depend on
+arrow_util = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a"}
+authz = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a", features = ["http"] }
+clap_blocks = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+data_types = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+datafusion_util = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+influxdb-line-protocol = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+influxdb_influxql_parser = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+influxdb_iox_client = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+iox_catalog = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+ioxd_common = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+iox_http = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+iox_query = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+iox_query_params = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+iox_query_influxql = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+iox_time = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+metric = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+metric_exporters = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+observability_deps = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+panic_logging = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+parquet_file = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+schema = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+service_common = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+service_grpc_flight = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+test_helpers = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+test_helpers_end_to_end = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+tokio_metrics_bridge = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+trace = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+trace_exporters = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+trace_http = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+tracker = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a" }
+trogging = { git = "https://github.com/influxdata/influxdb3_core", rev = "b546e7f86ee9adbff0dd3c5e687140848397604a", default-features = true, features = ["clap"] }
+
+[workspace.lints.rust]
+rust_2018_idioms = "deny"
+unreachable_pub = "deny"
+missing_debug_implementations = "deny"
+missing_copy_implementations = "deny"
+
+[workspace.lints.clippy]
+dbg_macro = "deny"
+todo = "deny"
+clone_on_ref_ptr = "deny"
+future_not_send = "deny"
+
+[workspace.lints.rustdoc]
+broken_intra_doc_links = "deny"
+bare_urls = "deny"
+
+# This profile optimizes for runtime performance and small binary size at the expense of longer
+# build times. It's most suitable for final release builds.
+[profile.release]
+codegen-units = 16
+debug = true
+lto = "thin"
+
+[profile.bench]
+debug = true
+
+# This profile optimizes for short build times at the expense of larger binary size and slower
+# runtime performance. It's most suitable for development iterations.
+[profile.quick-release]
+inherits = "release"
+codegen-units = 16
+lto = false
+incremental = true
+
+# Per insta docs: https://insta.rs/docs/quickstart/#optional-faster-runs
+[profile.dev.package.insta]
+opt-level = 3
+
+[profile.dev.package.similar]
+opt-level = 3
+
+# patch arrow-flight crate to allow for prepared statement parameters
+# see related arrow-rs PR https://github.com/apache/arrow-rs/pull/5433
+[patch.crates-io]
+arrow-array = { git = "https://github.com/erratic-pattern/arrow-rs.git", branch = "50.0.0" }
+arrow-schema = { git = "https://github.com/erratic-pattern/arrow-rs.git", branch = "50.0.0" }
+arrow-data = { git = "https://github.com/erratic-pattern/arrow-rs.git", branch = "50.0.0" }
+arrow-buffer = { git = "https://github.com/erratic-pattern/arrow-rs.git", branch = "50.0.0" }
+arrow-ipc = { git = "https://github.com/erratic-pattern/arrow-rs.git", branch = "50.0.0" }
+arrow-flight = { git = "https://github.com/erratic-pattern/arrow-rs.git", branch = "50.0.0" }
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 00000000000..68382d4f61f
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,61 @@
+#syntax=docker/dockerfile:1.2
+ARG RUST_VERSION=1.75
+FROM rust:${RUST_VERSION}-slim-bookworm as build
+
+# cache mounts below may already exist and owned by root
+USER root
+
+RUN apt update \
+    && apt install --yes binutils build-essential pkg-config libssl-dev clang lld git protobuf-compiler \
+    && rm -rf /var/lib/{apt,dpkg,cache,log}
+
+# Build influxdb3
+COPY . /influxdb3
+WORKDIR /influxdb3
+
+ARG CARGO_INCREMENTAL=yes
+ARG CARGO_NET_GIT_FETCH_WITH_CLI=false
+ARG PROFILE=release
+ARG FEATURES=aws,gcp,azure,jemalloc_replacing_malloc
+ARG PACKAGE=influxdb3
+ENV CARGO_INCREMENTAL=$CARGO_INCREMENTAL \
+    CARGO_NET_GIT_FETCH_WITH_CLI=$CARGO_NET_GIT_FETCH_WITH_CLI \
+    PROFILE=$PROFILE \
+    FEATURES=$FEATURES \
+    PACKAGE=$PACKAGE
+
+RUN \
+  --mount=type=cache,id=influxdb3_rustup,sharing=locked,target=/usr/local/rustup \
+  --mount=type=cache,id=influxdb3_registry,sharing=locked,target=/usr/local/cargo/registry \
+  --mount=type=cache,id=influxdb3_git,sharing=locked,target=/usr/local/cargo/git \
+  --mount=type=cache,id=influxdb3_target,sharing=locked,target=/influxdb_iox/target \
+    du -cshx /usr/local/rustup /usr/local/cargo/registry /usr/local/cargo/git /influxdb_iox/target && \
+    cargo build --target-dir /influxdb3/target --package="$PACKAGE" --profile="$PROFILE" --no-default-features --features="$FEATURES" && \
+    objcopy --compress-debug-sections "target/$PROFILE/$PACKAGE" && \
+    cp "/influxdb3/target/$PROFILE/$PACKAGE" /root/$PACKAGE && \
+    du -cshx /usr/local/rustup /usr/local/cargo/registry /usr/local/cargo/git /influxdb_iox/target
+
+
+FROM debian:bookworm-slim
+
+RUN apt update \
+    && apt install --yes ca-certificates gettext-base libssl3 --no-install-recommends \
+    && rm -rf /var/lib/{apt,dpkg,cache,log} \
+    && groupadd --gid 1500 influxdb3 \
+    && useradd --uid 1500 --gid influxdb3 --shell /bin/bash --create-home influxdb3
+
+USER influxdb3
+
+RUN mkdir ~/.influxdb3
+
+ARG PACKAGE=influxdb3
+ENV PACKAGE=$PACKAGE
+
+COPY --from=build "/root/$PACKAGE" "/usr/bin/$PACKAGE"
+COPY docker/entrypoint.sh /usr/bin/entrypoint.sh
+
+EXPOSE 8080 8082
+
+ENTRYPOINT ["/usr/bin/entrypoint.sh"]
+
+CMD ["serve"]
diff --git a/Dockerfile.dockerignore b/Dockerfile.dockerignore
new file mode 100644
index 00000000000..34d63e928ee
--- /dev/null
+++ b/Dockerfile.dockerignore
@@ -0,0 +1,7 @@
+.*/
+target/
+tests/
+docker/
+!.cargo/
+!.git/
+!docker/entrypoint.sh
diff --git a/LICENSE-APACHE b/LICENSE-APACHE
new file mode 100644
index 00000000000..16fe87b06e8
--- /dev/null
+++ b/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/LICENSE-MIT b/LICENSE-MIT
new file mode 100644
index 00000000000..42d41dfd83f
--- /dev/null
+++ b/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2020 InfluxData
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md
index 1e35d4b1fe1..5c96bddb2d3 100644
--- a/README.md
+++ b/README.md
@@ -1 +1 @@
-# influxdb_pro
\ No newline at end of file
+# InfluxDB Pro
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 00000000000..4e017acccc6
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,11 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+InfluxData takes security and our users' trust seriously. If you believe you
+have found a security issue in any of our open source projects, please
+responsibly disclose it by contacting `security@influxdata.com`. More details
+about security vulnerability reporting can be found on the
+[InfluxData How to Report Vulnerabilities page][InfluxData Security].
+
+[InfluxData Security]: https://www.influxdata.com/how-to-report-security-vulnerabilities/
diff --git a/deny.toml b/deny.toml
new file mode 100644
index 00000000000..b97e99ca532
--- /dev/null
+++ b/deny.toml
@@ -0,0 +1,48 @@
+# Configuration documentation:
+#   https://embarkstudios.github.io/cargo-deny/index.html
+
+[advisories]
+vulnerability = "deny"
+yanked = "deny"
+unmaintained = "warn"
+notice = "warn"
+ignore = [
+]
+git-fetch-with-cli = true
+
+[licenses]
+allow-osi-fsf-free = "either"
+copyleft = "deny"
+unlicensed = "deny"
+default = "deny"
+
+exceptions = [
+    # We should probably NOT bundle CA certs but use the OS ones.
+    { name = "webpki-roots", allow = ["MPL-2.0"] },
+]
+
+[[licenses.clarify]]
+name = "ring"
+expression = "BSD-4-Clause AND ISC AND MIT AND OpenSSL"
+license-files = [
+    # https://github.com/briansmith/ring/blob/95948b3977013aed16db92ae32e6b8384496a740/LICENSE
+    { path = "LICENSE", hash = 0xbd0eed23 },
+]
+
+[sources.allow-org]
+github = ["influxdata", "apache"]
+
+[bans]
+multiple-versions = "warn"
+deny = [
+    # We are using rustls as the TLS implementation, so we shouldn't be linking
+    # in OpenSSL too.
+    #
+    # If you're hitting this, you might want to take a look at what new
+    # dependencies you have introduced and check if there's a way to depend on
+    # rustls instead of OpenSSL (tip: check the crate's feature flags).
+    { name = "openssl-sys" },
+    # We've decided to use the `humantime` crate to parse and generate friendly time formats; use
+    # that rather than chrono-english.
+    { name = "chrono-english" },
+]
diff --git a/docker/Dockerfile.ci b/docker/Dockerfile.ci
new file mode 100644
index 00000000000..ccb88ffaea5
--- /dev/null
+++ b/docker/Dockerfile.ci
@@ -0,0 +1,74 @@
+###
+# Dockerfile for the image used in the InfluxDB IOx CI tests
+# As of October 2020, it is rebuilt each night
+#
+# It expects to be run with the repo checked out locally.
+# for example:
+#
+# cd influxdb_iox
+# docker build -f docker/Dockerfile.ci \
+#   --build-arg RUST_VERSION=$(sed -E -ne 's/channel = "(.*)"/\1/p' rust-toolchain.toml) .
+##
+
+ARG RUST_VERSION
+# Build actual image used for CI pipeline
+FROM rust:${RUST_VERSION}-slim-bookworm
+
+# When https://github.com/rust-lang/rustup/issues/2686 is fixed, run the command added that
+# will install everything in rust-toolchain.toml here so that components are in the container
+
+# make Apt non-interactive
+RUN echo 'APT::Get::Assume-Yes "true";' > /etc/apt/apt.conf.d/90ci \
+  && echo 'DPkg::Options "--force-confnew";' >> /etc/apt/apt.conf.d/90ci
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update \
+  && mkdir -p /usr/share/man/man1 \
+  && apt-get install -y \
+    git locales sudo openssh-client ca-certificates tar gzip parallel \
+    unzip zip bzip2 gnupg curl make pkg-config libssl-dev \
+    jq clang lld g++ shellcheck yamllint protobuf-compiler libprotobuf-dev \
+    skopeo openjdk-17-jdk \
+    --no-install-recommends \
+  && curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key --keyring /usr/share/keyrings/cloud.google.gpg add - \
+  && echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] https://packages.cloud.google.com/apt cloud-sdk main" >> /etc/apt/sources.list.d/google-cloud-sdk.list \
+  && apt-get update \
+  && apt-get install google-cloud-cli \
+  && apt-get clean autoclean \
+	&& apt-get autoremove --yes \
+	&& rm -rf /var/lib/{apt,dpkg,cache,log}
+
+ENV CURL_FLAGS="--proto =https --tlsv1.2 -sSf"
+
+# Install InfluxDB 2.0 OSS to enable integration tests of the influxdb2_client crate
+ENV INFLUXDB2_VERSION=2.0.4
+ENV INFLUXDB2_DOWNLOAD_BASE="https://dl.influxdata.com/influxdb/releases"
+RUN curl ${CURL_FLAGS} https://repos.influxdata.com/influxdata-archive_compat.key | gpg --import - \
+    && curl ${CURL_FLAGS} -o influxdb2.tar.gz ${INFLUXDB2_DOWNLOAD_BASE}/influxdb2-${INFLUXDB2_VERSION}-linux-amd64.tar.gz \
+    && curl ${CURL_FLAGS} -O ${INFLUXDB2_DOWNLOAD_BASE}/influxdb2-${INFLUXDB2_VERSION}-linux-amd64.tar.gz.asc \
+    && gpg --verify influxdb2-${INFLUXDB2_VERSION}-linux-amd64.tar.gz.asc influxdb2.tar.gz \
+    && tar xvzf influxdb2.tar.gz \
+    && sudo cp influxdb2-${INFLUXDB2_VERSION}-linux-amd64/influxd /usr/local/bin/ \
+    && rm -rf influxdb2-${INFLUXDB2_VERSION}-linux-amd64 influxdb2-${INFLUXDB2_VERSION}-linux-amd64.tar.gz.asc
+
+# Set timezone to UTC by default
+RUN ln -sf /usr/share/zoneinfo/Etc/UTC /etc/localtime
+# Use unicode
+RUN locale-gen C.UTF-8 || true
+ENV LANG=C.UTF-8
+
+RUN groupadd -g 1500 rust \
+  && useradd -u 1500 -g rust -s /bin/bash -m rust \
+  && echo 'rust ALL=NOPASSWD: ALL' >> /etc/sudoers.d/10-rust \
+  && echo 'Defaults    env_keep += "DEBIAN_FRONTEND"' >> /etc/sudoers.d/env_keep
+
+# Ensure we are ready with cargo hakari and cargo deny
+RUN cargo install cargo-hakari && \
+    cargo install cargo-deny && \
+    chown -R rust:rust /usr/local/cargo
+
+USER rust
+ENV PATH /home/rust/.local/bin:/home/rust/bin:${PATH}
+
+CMD ["/bin/bash"]
diff --git a/docker/Dockerfile.ci.dockerignore b/docker/Dockerfile.ci.dockerignore
new file mode 100644
index 00000000000..484eb504ccf
--- /dev/null
+++ b/docker/Dockerfile.ci.dockerignore
@@ -0,0 +1,2 @@
+# Ignore everything
+**
diff --git a/docker/entrypoint.sh b/docker/entrypoint.sh
new file mode 100755
index 00000000000..0af46f97ed1
--- /dev/null
+++ b/docker/entrypoint.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -eu -o pipefail
+
+args=( "$@" )
+for i in "${!args[@]}"; do
+    args[$i]="$(echo "${args[$i]}" | envsubst)"
+done
+
+exec "$PACKAGE" "${args[@]}"
diff --git a/influxdb3/Cargo.toml b/influxdb3/Cargo.toml
new file mode 100644
index 00000000000..c0c68d1ba08
--- /dev/null
+++ b/influxdb3/Cargo.toml
@@ -0,0 +1,95 @@
+[package]
+name = "influxdb3"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+# Core Crates
+authz.workspace = true
+clap_blocks.workspace = true
+datafusion_util.workspace = true
+iox_query.workspace = true
+iox_time.workspace = true
+ioxd_common.workspace = true
+metric.workspace = true
+object_store.workspace = true
+observability_deps.workspace = true
+panic_logging.workspace = true
+parquet_file.workspace = true
+tokio_metrics_bridge.workspace = true
+trace.workspace = true
+trace_exporters.workspace = true
+trogging.workspace = true
+
+# Local Crates
+influxdb3_client = { path = "../influxdb3_client" }
+influxdb3_process = { path = "../influxdb3_process", default-features = false }
+influxdb3_server = { path = "../influxdb3_server" }
+influxdb3_write = { path = "../influxdb3_write" }
+
+# Crates.io dependencies
+backtrace.workspace = true
+base64.workspace = true
+clap.workspace = true
+dotenvy.workspace = true
+hex.workspace = true
+libc.workspace = true
+num_cpus.workspace = true
+once_cell.workspace = true
+parking_lot.workspace = true
+rand.workspace = true
+secrecy.workspace = true
+sha2.workspace = true
+thiserror.workspace = true
+tokio.workspace = true
+tokio-util.workspace = true
+url.workspace = true
+uuid.workspace = true
+
+# Optional Dependencies
+console-subscriber = { version = "0.1.10", optional = true, features = ["parking_lot"] }
+
+[features]
+default = ["jemalloc_replacing_malloc", "azure", "gcp", "aws"]
+
+azure = ["clap_blocks/azure"] # Optional Azure Object store support
+gcp = ["clap_blocks/gcp"] # Optional GCP object store support
+aws = ["clap_blocks/aws"] # Optional AWS / S3 object store support
+pprof = ["ioxd_common/pprof"] # Optional http://localhost:8080/debug/pprof/profile support
+heappy = ["ioxd_common/heappy", "influxdb3_process/heappy"] # Optional http://localhost:8080/debug/pproc/alloc support
+
+# Enable tokio_console support (https://github.com/tokio-rs/console)
+#
+# Requires enabling trace level tracing events for [tokio,runtime].
+tokio_console = ["console-subscriber", "tokio/tracing", "observability_deps/release_max_level_trace"]
+
+# heappy is an optional feature; Not on by default as it
+# runtime overhead on all allocations (calls to malloc).
+# Cargo cannot currently implement mutually exclusive features so let's force every build
+# to pick either heappy or jemalloc_replacing_malloc feature at least until we figure out something better.
+jemalloc_replacing_malloc = ["influxdb3_process/jemalloc_replacing_malloc"]
+
+# Implicit feature selected when running under `clippy --all-features` to accept mutable exclusive features during
+# linting
+clippy = []
+
+[dev-dependencies]
+# Core Crates
+arrow_util.workspace = true
+influxdb_iox_client.workspace = true
+
+# Crates.io dependencies in alphabetical order:
+arrow.workspace = true
+arrow-array.workspace = true
+arrow-flight.workspace = true
+assert_cmd.workspace = true
+futures.workspace = true
+hyper.workspace = true
+pretty_assertions.workspace = true
+reqwest.workspace = true
+serde_json.workspace = true
+test_helpers.workspace = true
+tonic.workspace = true
+tower.workspace = true
diff --git a/influxdb3/src/commands/common.rs b/influxdb3/src/commands/common.rs
new file mode 100644
index 00000000000..7a443fd9e25
--- /dev/null
+++ b/influxdb3/src/commands/common.rs
@@ -0,0 +1,23 @@
+use clap::Parser;
+use secrecy::Secret;
+use url::Url;
+
+#[derive(Debug, Parser)]
+pub struct InfluxDb3Config {
+    /// The host URL of the running InfluxDB 3.0 server
+    #[clap(
+        short = 'h',
+        long = "host",
+        env = "INFLUXDB3_HOST_URL",
+        default_value = "http://127.0.0.1:8181"
+    )]
+    pub host_url: Url,
+
+    /// The database name to run the query against
+    #[clap(short = 'd', long = "dbname", env = "INFLUXDB3_DATABASE_NAME")]
+    pub database_name: String,
+
+    /// The token for authentication with the InfluxDB 3.0 server
+    #[clap(long = "token", env = "INFLUXDB3_AUTH_TOKEN")]
+    pub auth_token: Option<Secret<String>>,
+}
diff --git a/influxdb3/src/commands/create.rs b/influxdb3/src/commands/create.rs
new file mode 100644
index 00000000000..3252b5b88af
--- /dev/null
+++ b/influxdb3/src/commands/create.rs
@@ -0,0 +1,44 @@
+use base64::engine::general_purpose::URL_SAFE_NO_PAD as B64;
+use base64::Engine as _;
+use rand::rngs::OsRng;
+use rand::RngCore;
+use sha2::Digest;
+use sha2::Sha512;
+use std::error::Error;
+use std::str;
+
+#[derive(Debug, clap::Parser)]
+pub struct Config {
+    #[clap(subcommand)]
+    cmd: SubCommand,
+}
+
+#[derive(Debug, clap::Parser)]
+pub enum SubCommand {
+    Token,
+}
+
+pub fn command(config: Config) -> Result<(), Box<dyn Error>> {
+    match config.cmd {
+        SubCommand::Token => {
+            let token = {
+                let mut token = String::from("apiv3_");
+                let mut key = [0u8; 64];
+                OsRng.fill_bytes(&mut key);
+                token.push_str(&B64.encode(key));
+                token
+            };
+            println!(
+                "\
+                Token: {token}\n\
+                Hashed Token: {hashed}\n\n\
+                Start the server with `influxdb3 serve --bearer-token {hashed}`\n\n\
+                HTTP requests require the following header: \"Authorization: Bearer {token}\"\n\
+                This will grant you access to every HTTP endpoint or deny it otherwise
+            ",
+                hashed = hex::encode(&Sha512::digest(&token)[..])
+            );
+        }
+    }
+    Ok(())
+}
diff --git a/influxdb3/src/commands/query.rs b/influxdb3/src/commands/query.rs
new file mode 100644
index 00000000000..500c3427bf6
--- /dev/null
+++ b/influxdb3/src/commands/query.rs
@@ -0,0 +1,170 @@
+use std::str::Utf8Error;
+
+use clap::{Parser, ValueEnum};
+use secrecy::ExposeSecret;
+use tokio::{
+    fs::OpenOptions,
+    io::{self, AsyncWriteExt},
+};
+
+use super::common::InfluxDb3Config;
+
+#[derive(Debug, thiserror::Error)]
+pub(crate) enum Error {
+    #[error(transparent)]
+    Client(#[from] influxdb3_client::Error),
+
+    #[error(transparent)]
+    Query(#[from] QueryError),
+
+    #[error("invlid UTF8 received from server: {0}")]
+    Utf8(#[from] Utf8Error),
+
+    #[error("io error: {0}")]
+    Io(#[from] io::Error),
+
+    #[error(
+        "must specify an output file path with `--output` parameter when formatting\
+        the output as `parquet`"
+    )]
+    NoOutputFileForParquet,
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Debug, Parser)]
+#[clap(visible_alias = "q", trailing_var_arg = true)]
+pub struct Config {
+    /// Common InfluxDB 3.0 config
+    #[clap(flatten)]
+    influxdb3_config: InfluxDb3Config,
+
+    /// The query language used to format the provided query string
+    #[clap(
+        value_enum,
+        long = "lang",
+        short = 'l',
+        default_value_t = QueryLanguage::Sql,
+    )]
+    language: QueryLanguage,
+
+    /// The format in which to output the query
+    ///
+    /// If `--fmt` is set to `parquet`, then you must also specify an output
+    /// file path with `--output`.
+    #[clap(value_enum, long = "fmt", default_value = "pretty")]
+    output_format: Format,
+
+    /// Put all query output into `output`
+    #[clap(short = 'o', long = "output")]
+    output_file_path: Option<String>,
+
+    /// The query string to execute
+    query: Vec<String>,
+}
+
+#[derive(Debug, ValueEnum, Clone)]
+#[clap(rename_all = "snake_case")]
+enum Format {
+    Pretty,
+    Json,
+    Csv,
+    Parquet,
+}
+
+impl Format {
+    fn is_parquet(&self) -> bool {
+        matches!(self, Self::Parquet)
+    }
+}
+
+impl From<Format> for influxdb3_client::Format {
+    fn from(this: Format) -> Self {
+        match this {
+            Format::Pretty => Self::Pretty,
+            Format::Json => Self::Json,
+            Format::Csv => Self::Csv,
+            Format::Parquet => Self::Parquet,
+        }
+    }
+}
+
+#[derive(Debug, ValueEnum, Clone)]
+enum QueryLanguage {
+    Sql,
+    Influxql,
+}
+
+pub(crate) async fn command(config: Config) -> Result<()> {
+    let InfluxDb3Config {
+        host_url,
+        database_name,
+        auth_token,
+    } = config.influxdb3_config;
+    let mut client = influxdb3_client::Client::new(host_url)?;
+    if let Some(t) = auth_token {
+        client = client.with_auth_token(t.expose_secret());
+    }
+
+    let query = parse_query(config.query)?;
+
+    // make the query using the client
+    let mut resp_bytes = match config.language {
+        QueryLanguage::Sql => {
+            client
+                .api_v3_query_sql(database_name, query)
+                .format(config.output_format.clone().into())
+                .send()
+                .await?
+        }
+        QueryLanguage::Influxql => {
+            client
+                .api_v3_query_influxql(database_name, query)
+                .format(config.output_format.clone().into())
+                .send()
+                .await?
+        }
+    };
+
+    // write to file if output path specified
+    if let Some(path) = &config.output_file_path {
+        let mut f = OpenOptions::new()
+            .write(true)
+            .create(true)
+            .truncate(true)
+            .open(path)
+            .await?;
+        f.write_all_buf(&mut resp_bytes).await?;
+    } else {
+        if config.output_format.is_parquet() {
+            Err(Error::NoOutputFileForParquet)?
+        }
+        println!("{}", std::str::from_utf8(&resp_bytes)?);
+    }
+
+    Ok(())
+}
+
+#[derive(Debug, thiserror::Error)]
+pub(crate) enum QueryError {
+    #[error("no query provided")]
+    NoQuery,
+
+    #[error(
+        "ensure that a single query string is provided as the final \
+        argument, enclosed in quotes"
+    )]
+    MoreThanOne,
+}
+
+/// Parse the user-inputted query string
+fn parse_query(mut input: Vec<String>) -> Result<String> {
+    if input.is_empty() {
+        Err(QueryError::NoQuery)?
+    }
+    if input.len() > 1 {
+        Err(QueryError::MoreThanOne)?
+    } else {
+        Ok(input.remove(0))
+    }
+}
diff --git a/influxdb3/src/commands/serve.rs b/influxdb3/src/commands/serve.rs
new file mode 100644
index 00000000000..f2dd26566dc
--- /dev/null
+++ b/influxdb3/src/commands/serve.rs
@@ -0,0 +1,308 @@
+//! Entrypoint for InfluxDB 3.0 Edge Server
+
+use clap_blocks::{
+    memory_size::MemorySize,
+    object_store::{make_object_store, ObjectStoreConfig},
+    socket_addr::SocketAddr,
+};
+use datafusion_util::config::register_iox_object_store;
+use influxdb3_process::{
+    build_malloc_conf, setup_metric_registry, INFLUXDB3_GIT_HASH, INFLUXDB3_VERSION, PROCESS_UUID,
+};
+use influxdb3_server::{
+    auth::AllOrNothingAuthorizer, builder::ServerBuilder, query_executor::QueryExecutorImpl, serve,
+    CommonServerState,
+};
+use influxdb3_write::persister::PersisterImpl;
+use influxdb3_write::wal::WalImpl;
+use influxdb3_write::write_buffer::WriteBufferImpl;
+use influxdb3_write::SegmentDuration;
+use iox_query::exec::{Executor, ExecutorConfig};
+use iox_time::SystemProvider;
+use ioxd_common::reexport::trace_http::ctx::TraceHeaderParser;
+use object_store::DynObjectStore;
+use observability_deps::tracing::*;
+use panic_logging::SendPanicsToTracing;
+use parquet_file::storage::{ParquetStorage, StorageId};
+use std::collections::HashMap;
+use std::{
+    num::NonZeroUsize,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+use thiserror::Error;
+use tokio_util::sync::CancellationToken;
+use trace_exporters::TracingConfig;
+use trogging::cli::LoggingConfig;
+
+/// The default name of the influxdb_iox data directory
+#[allow(dead_code)]
+pub const DEFAULT_DATA_DIRECTORY_NAME: &str = ".influxdb3";
+
+/// The default bind address for the HTTP API.
+pub const DEFAULT_HTTP_BIND_ADDR: &str = "127.0.0.1:8181";
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("Cannot parse object store config: {0}")]
+    ObjectStoreParsing(#[from] clap_blocks::object_store::ParseError),
+
+    #[error("Tracing config error: {0}")]
+    TracingConfig(#[from] trace_exporters::Error),
+
+    #[error("Server error: {0}")]
+    Server(#[from] influxdb3_server::Error),
+
+    #[error("Wal error: {0}")]
+    Wal(#[from] influxdb3_write::wal::Error),
+
+    #[error("Write buffer error: {0}")]
+    WriteBuffer(#[from] influxdb3_write::write_buffer::Error),
+
+    #[error("invalid token: {0}")]
+    InvalidToken(#[from] hex::FromHexError),
+}
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+#[derive(Debug, clap::Parser)]
+pub struct Config {
+    /// Maximum size of HTTP requests.
+    #[clap(
+    long = "max-http-request-size",
+    env = "INFLUXDB3_MAX_HTTP_REQUEST_SIZE",
+    default_value = "10485760", // 10 MiB
+    action,
+    )]
+    pub max_http_request_size: usize,
+
+    #[clap(flatten)]
+    object_store_config: ObjectStoreConfig,
+
+    /// The directory to store the write ahead log
+    ///
+    /// If not specified, defaults to INFLUXDB3_DB_DIR/wal
+    #[clap(long = "wal-directory", env = "INFLUXDB3_WAL_DIRECTORY", action)]
+    pub wal_directory: Option<PathBuf>,
+
+    /// The address on which InfluxDB will serve HTTP API requests
+    #[clap(
+    long = "http-bind",
+    env = "INFLUXDB3_HTTP_BIND_ADDR",
+    default_value = DEFAULT_HTTP_BIND_ADDR,
+    action,
+    )]
+    pub http_bind_address: SocketAddr,
+
+    /// Size of the RAM cache used to store data in bytes.
+    ///
+    /// Can be given as absolute value or in percentage of the total available memory (e.g. `10%`).
+    #[clap(
+    long = "ram-pool-data-bytes",
+    env = "INFLUXDB3_RAM_POOL_DATA_BYTES",
+    default_value = "1073741824",  // 1GB
+    action
+    )]
+    pub ram_pool_data_bytes: MemorySize,
+
+    /// Size of memory pool used during query exec, in bytes.
+    ///
+    /// Can be given as absolute value or in percentage of the total available memory (e.g. `10%`).
+    #[clap(
+    long = "exec-mem-pool-bytes",
+    env = "INFLUXDB3_EXEC_MEM_POOL_BYTES",
+    default_value = "8589934592",  // 8GB
+    action
+    )]
+    pub exec_mem_pool_bytes: MemorySize,
+
+    /// logging options
+    #[clap(flatten)]
+    pub(crate) logging_config: LoggingConfig,
+
+    /// tracing options
+    #[clap(flatten)]
+    pub(crate) tracing_config: TracingConfig,
+
+    /// DataFusion config.
+    #[clap(
+    long = "datafusion-config",
+    env = "INFLUXDB_IOX_DATAFUSION_CONFIG",
+    default_value = "",
+    value_parser = parse_datafusion_config,
+    action
+    )]
+    pub datafusion_config: HashMap<String, String>,
+
+    /// bearer token to be set for requests
+    #[clap(long = "bearer-token", env = "INFLUXDB3_BEARER_TOKEN", action)]
+    pub bearer_token: Option<String>,
+
+    /// Duration of wal segments that are persisted to object storage. Valid values: 1m, 5m, 10m,
+    /// 15m, 30m, 1h, 2h, 4h.
+    #[clap(
+        long = "segment-duration",
+        env = "INFLUXDB3_SEGMENT_DURATION",
+        default_value = "1h",
+        action
+    )]
+    pub segment_duration: SegmentDuration,
+}
+
+/// If `p` does not exist, try to create it as a directory.
+///
+/// panic's if the directory does not exist and can not be created
+#[allow(dead_code)]
+fn ensure_directory_exists(p: &Path) {
+    if !p.exists() {
+        info!(
+            p=%p.display(),
+            "Creating directory",
+        );
+        std::fs::create_dir_all(p).expect("Could not create default directory");
+    }
+}
+
+pub async fn command(config: Config) -> Result<()> {
+    let num_cpus = num_cpus::get();
+    let build_malloc_conf = build_malloc_conf();
+    info!(
+        git_hash = %INFLUXDB3_GIT_HASH as &str,
+        version = %INFLUXDB3_VERSION.as_ref() as &str,
+        uuid = %PROCESS_UUID.as_ref() as &str,
+        num_cpus,
+        %build_malloc_conf,
+        "InfluxDB3 Edge server starting",
+    );
+
+    let metrics = setup_metric_registry();
+
+    // Install custom panic handler and forget about it.
+    //
+    // This leaks the handler and prevents it from ever being dropped during the
+    // lifetime of the program - this is actually a good thing, as it prevents
+    // the panic handler from being removed while unwinding a panic (which in
+    // turn, causes a panic - see #548)
+    let f = SendPanicsToTracing::new_with_metrics(&metrics);
+    std::mem::forget(f);
+
+    // Construct a token to trigger clean shutdown
+    let frontend_shutdown = CancellationToken::new();
+
+    let object_store: Arc<DynObjectStore> =
+        make_object_store(&config.object_store_config).map_err(Error::ObjectStoreParsing)?;
+
+    let trace_exporter = config.tracing_config.build()?;
+
+    // TODO: make this a parameter
+    let num_threads =
+        NonZeroUsize::new(num_cpus::get()).unwrap_or_else(|| NonZeroUsize::new(1).unwrap());
+
+    info!(%num_threads, "Creating shared query executor");
+    let parquet_store =
+        ParquetStorage::new(Arc::clone(&object_store), StorageId::from("influxdb3"));
+    let exec = Arc::new(Executor::new_with_config(
+        "datafusion",
+        ExecutorConfig {
+            num_threads,
+            target_query_partitions: num_threads,
+            object_stores: [&parquet_store]
+                .into_iter()
+                .map(|store| (store.id(), Arc::clone(store.object_store())))
+                .collect(),
+            metric_registry: Arc::clone(&metrics),
+            mem_pool_size: config.exec_mem_pool_bytes.bytes(),
+        },
+    ));
+    let runtime_env = exec.new_context().inner().runtime_env();
+    register_iox_object_store(runtime_env, parquet_store.id(), Arc::clone(&object_store));
+
+    let trace_header_parser = TraceHeaderParser::new()
+        .with_jaeger_trace_context_header_name(
+            config
+                .tracing_config
+                .traces_jaeger_trace_context_header_name,
+        )
+        .with_jaeger_debug_name(config.tracing_config.traces_jaeger_debug_name);
+
+    let common_state = CommonServerState::new(
+        Arc::clone(&metrics),
+        trace_exporter,
+        trace_header_parser,
+        *config.http_bind_address,
+    )?;
+    let persister = Arc::new(PersisterImpl::new(Arc::clone(&object_store)));
+    let wal: Option<Arc<WalImpl>> = config
+        .wal_directory
+        .map(|dir| WalImpl::new(dir).map(Arc::new))
+        .transpose()?;
+
+    let time_provider = Arc::new(SystemProvider::new());
+    let write_buffer = Arc::new(
+        WriteBufferImpl::new(
+            Arc::clone(&persister),
+            wal,
+            Arc::clone(&time_provider),
+            config.segment_duration,
+            Arc::clone(&exec),
+        )
+        .await?,
+    );
+    let query_executor = Arc::new(QueryExecutorImpl::new(
+        write_buffer.catalog(),
+        Arc::clone(&write_buffer),
+        Arc::clone(&exec),
+        Arc::clone(&metrics),
+        Arc::new(config.datafusion_config),
+        10,
+    ));
+
+    let builder = ServerBuilder::new(common_state)
+        .max_request_size(config.max_http_request_size)
+        .write_buffer(write_buffer)
+        .query_executor(query_executor)
+        .time_provider(time_provider)
+        .persister(persister);
+
+    let server = if let Some(token) = config.bearer_token.map(hex::decode).transpose()? {
+        builder
+            .authorizer(Arc::new(AllOrNothingAuthorizer::new(token)))
+            .build()
+    } else {
+        builder.build()
+    };
+    serve(server, frontend_shutdown).await?;
+
+    Ok(())
+}
+
+fn parse_datafusion_config(
+    s: &str,
+) -> Result<HashMap<String, String>, Box<dyn std::error::Error + Send + Sync + 'static>> {
+    let s = s.trim();
+    if s.is_empty() {
+        return Ok(HashMap::with_capacity(0));
+    }
+
+    let mut out = HashMap::new();
+    for part in s.split(',') {
+        let kv = part.trim().splitn(2, ':').collect::<Vec<_>>();
+        match kv.as_slice() {
+            [key, value] => {
+                let key_owned = key.trim().to_owned();
+                let value_owned = value.trim().to_owned();
+                let existed = out.insert(key_owned, value_owned).is_some();
+                if existed {
+                    return Err(format!("key '{key}' passed multiple times").into());
+                }
+            }
+            _ => {
+                return Err(
+                    format!("Invalid key value pair - expected 'KEY:VALUE' got '{s}'").into(),
+                );
+            }
+        }
+    }
+
+    Ok(out)
+}
diff --git a/influxdb3/src/commands/write.rs b/influxdb3/src/commands/write.rs
new file mode 100644
index 00000000000..ad7556e98f6
--- /dev/null
+++ b/influxdb3/src/commands/write.rs
@@ -0,0 +1,65 @@
+use clap::Parser;
+use secrecy::ExposeSecret;
+use tokio::{
+    fs::File,
+    io::{self, AsyncReadExt},
+};
+
+use super::common::InfluxDb3Config;
+
+#[derive(Debug, thiserror::Error)]
+pub(crate) enum Error {
+    #[error(transparent)]
+    Client(#[from] influxdb3_client::Error),
+
+    #[error("error reading file: {0}")]
+    Io(#[from] io::Error),
+}
+
+pub(crate) type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Debug, Parser)]
+#[clap(visible_alias = "w", trailing_var_arg = true)]
+pub struct Config {
+    /// Common InfluxDB 3.0 config
+    #[clap(flatten)]
+    influxdb3_config: InfluxDb3Config,
+
+    /// File path to load the write data from
+    ///
+    /// Currently, only files containing line protocol are supported.
+    #[clap(short = 'f', long = "file")]
+    file_path: String,
+
+    /// Flag to request the server accept partial writes
+    ///
+    /// Invalid lines in the input data will be ignored by the server.
+    #[clap(long = "accept-partial")]
+    accept_partial_writes: bool,
+}
+
+pub(crate) async fn command(config: Config) -> Result<()> {
+    let InfluxDb3Config {
+        host_url,
+        database_name,
+        auth_token,
+    } = config.influxdb3_config;
+    let mut client = influxdb3_client::Client::new(host_url)?;
+    if let Some(t) = auth_token {
+        client = client.with_auth_token(t.expose_secret());
+    }
+
+    let mut f = File::open(config.file_path).await?;
+    let mut writes = Vec::new();
+    f.read_to_end(&mut writes).await?;
+
+    let mut req = client.api_v3_write_lp(database_name);
+    if config.accept_partial_writes {
+        req = req.accept_partial(true);
+    }
+    req.body(writes).send().await?;
+
+    println!("success");
+
+    Ok(())
+}
diff --git a/influxdb3/src/main.rs b/influxdb3/src/main.rs
new file mode 100644
index 00000000000..8e00d4457da
--- /dev/null
+++ b/influxdb3/src/main.rs
@@ -0,0 +1,279 @@
+//! Entrypoint of InfluxDB IOx binary
+#![recursion_limit = "512"] // required for print_cpu
+#![deny(rustdoc::broken_intra_doc_links, rustdoc::bare_urls, rust_2018_idioms)]
+#![warn(
+missing_debug_implementations,
+clippy::explicit_iter_loop,
+clippy::use_self,
+clippy::clone_on_ref_ptr,
+// See https://github.com/influxdata/influxdb_iox/pull/1671
+clippy::future_not_send
+)]
+
+use dotenvy::dotenv;
+use influxdb3_process::VERSION_STRING;
+use observability_deps::tracing::warn;
+use std::sync::{
+    atomic::{AtomicUsize, Ordering},
+    Arc,
+};
+use tokio::runtime::Runtime;
+use trogging::{
+    cli::LoggingConfigBuilderExt,
+    tracing_subscriber::{prelude::*, Registry},
+    TroggingGuard,
+};
+
+mod commands {
+    pub(crate) mod common;
+    pub mod create;
+    pub mod query;
+    pub mod serve;
+    pub mod write;
+}
+
+enum ReturnCode {
+    Failure = 1,
+}
+
+#[cfg(all(
+    feature = "heappy",
+    feature = "jemalloc_replacing_malloc",
+    not(feature = "clippy")
+))]
+compile_error!("heappy and jemalloc_replacing_malloc features are mutually exclusive");
+
+#[derive(Debug, clap::Parser)]
+#[clap(
+name = "influxdb3",
+version = &VERSION_STRING[..],
+disable_help_flag = true,
+arg(
+clap::Arg::new("help")
+.long("help")
+.help("Print help information")
+.action(clap::ArgAction::Help)
+.global(true)
+),
+about = "InfluxDB 3.0 Edge server and command line tools",
+long_about = r#"InfluxDB 3.0 Edge server and command line tools
+
+Examples:
+    # Run the InfluxDB 3.0 Edge server
+    influxdb3 serve
+
+    # Display all commands
+    influxdb3 --help
+
+    # Run the InfluxDB 3.0 Edge server in all-in-one mode with extra verbose logging
+    influxdb3 serve -v
+
+    # Run InfluxDB 3.0 Edge with full debug logging specified with LOG_FILTER
+    LOG_FILTER=debug influxdb3 serve
+"#
+)]
+struct Config {
+    #[clap(subcommand)]
+    command: Option<Command>,
+}
+
+// Ignoring clippy here since this enum is just used for running
+// the CLI command
+#[allow(clippy::large_enum_variant)]
+#[derive(Debug, clap::Parser)]
+#[allow(clippy::large_enum_variant)]
+enum Command {
+    /// Run the InfluxDB 3.0 server
+    Serve(commands::serve::Config),
+
+    /// Perform a query against a running InfluxDB 3.0 server
+    Query(commands::query::Config),
+
+    /// Perform a set of writes to a running InfluxDB 3.0 server
+    Write(commands::write::Config),
+
+    /// Create new resources
+    Create(commands::create::Config),
+}
+
+fn main() -> Result<(), std::io::Error> {
+    install_crash_handler(); // attempt to render a useful stacktrace to stderr
+
+    // load all environment variables from .env before doing anything
+    load_dotenv();
+
+    let config: Config = clap::Parser::parse();
+
+    let tokio_runtime = get_runtime(None)?;
+    tokio_runtime.block_on(async move {
+        fn handle_init_logs(r: Result<TroggingGuard, trogging::Error>) -> TroggingGuard {
+            match r {
+                Ok(guard) => guard,
+                Err(e) => {
+                    eprintln!("Initializing logs failed: {e}");
+                    std::process::exit(ReturnCode::Failure as _);
+                }
+            }
+        }
+
+        match config.command {
+            None => println!("command required, --help for help"),
+            Some(Command::Serve(config)) => {
+                let _tracing_guard =
+                    handle_init_logs(init_logs_and_tracing(&config.logging_config));
+                if let Err(e) = commands::serve::command(config).await {
+                    eprintln!("Serve command failed: {e}");
+                    std::process::exit(ReturnCode::Failure as _)
+                }
+            }
+            Some(Command::Query(config)) => {
+                if let Err(e) = commands::query::command(config).await {
+                    eprintln!("Query command failed: {e}");
+                    std::process::exit(ReturnCode::Failure as _)
+                }
+            }
+            Some(Command::Write(config)) => {
+                if let Err(e) = commands::write::command(config).await {
+                    eprintln!("Write command failed: {e}");
+                    std::process::exit(ReturnCode::Failure as _)
+                }
+            }
+            Some(Command::Create(config)) => {
+                if let Err(e) = commands::create::command(config) {
+                    eprintln!("Create command failed: {e}");
+                    std::process::exit(ReturnCode::Failure as _)
+                }
+            }
+        }
+    });
+
+    Ok(())
+}
+
+/// Creates the tokio runtime for executing IOx
+///
+/// if nthreads is none, uses the default scheduler
+/// otherwise, creates a scheduler with the number of threads
+fn get_runtime(num_threads: Option<usize>) -> Result<Runtime, std::io::Error> {
+    // NOTE: no log macros will work here!
+    //
+    // That means use eprintln!() instead of error!() and so on. The log emitter
+    // requires a running tokio runtime and is initialised after this function.
+
+    use tokio::runtime::Builder;
+    let kind = std::io::ErrorKind::Other;
+    match num_threads {
+        None => Runtime::new(),
+        Some(num_threads) => {
+            println!("Setting number of threads to '{num_threads}' per command line request");
+
+            let thread_counter = Arc::new(AtomicUsize::new(1));
+            match num_threads {
+                0 => {
+                    let msg =
+                        format!("Invalid num-threads: '{num_threads}' must be greater than zero");
+                    Err(std::io::Error::new(kind, msg))
+                }
+                1 => Builder::new_current_thread().enable_all().build(),
+                _ => Builder::new_multi_thread()
+                    .enable_all()
+                    .thread_name_fn(move || {
+                        format!("IOx main {}", thread_counter.fetch_add(1, Ordering::SeqCst))
+                    })
+                    .worker_threads(num_threads)
+                    .build(),
+            }
+        }
+    }
+}
+
+/// Source the .env file before initialising the Config struct - this sets
+/// any envs in the file, which the Config struct then uses.
+///
+/// Precedence is given to existing env variables.
+fn load_dotenv() {
+    match dotenv() {
+        Ok(_) => {}
+        Err(dotenvy::Error::Io(err)) if err.kind() == std::io::ErrorKind::NotFound => {
+            // Ignore this - a missing env file is not an error, defaults will
+            // be applied when initialising the Config struct.
+        }
+        Err(e) => {
+            eprintln!("FATAL Error loading config from: {e}");
+            eprintln!("Aborting");
+            std::process::exit(1);
+        }
+    };
+}
+
+// Based on ideas from
+// https://github.com/servo/servo/blob/f03ddf6c6c6e94e799ab2a3a89660aea4a01da6f/ports/servo/main.rs#L58-L79
+fn install_crash_handler() {
+    unsafe {
+        set_signal_handler(libc::SIGSEGV, signal_handler); // handle segfaults
+        set_signal_handler(libc::SIGILL, signal_handler); // handle stack overflow and unsupported CPUs
+        set_signal_handler(libc::SIGBUS, signal_handler); // handle invalid memory access
+    }
+}
+
+unsafe extern "C" fn signal_handler(sig: i32) {
+    use backtrace::Backtrace;
+    use std::process::abort;
+    let name = std::thread::current()
+        .name()
+        .map(|n| format!(" for thread \"{n}\""))
+        .unwrap_or_else(|| "".to_owned());
+    eprintln!(
+        "Signal {}, Stack trace{}\n{:?}",
+        sig,
+        name,
+        Backtrace::new()
+    );
+    abort();
+}
+
+// based on https://github.com/adjivas/sig/blob/master/src/lib.rs#L34-L52
+unsafe fn set_signal_handler(signal: libc::c_int, handler: unsafe extern "C" fn(libc::c_int)) {
+    use libc::{sigaction, sigfillset, sighandler_t};
+    let mut sigset = std::mem::zeroed();
+
+    // Block all signals during the handler. This is the expected behavior, but
+    // it's not guaranteed by `signal()`.
+    if sigfillset(&mut sigset) != -1 {
+        // Done because sigaction has private members.
+        // This is safe because sa_restorer and sa_handlers are pointers that
+        // might be null (that is, zero).
+        let mut action: sigaction = std::mem::zeroed();
+
+        // action.sa_flags = 0;
+        action.sa_mask = sigset;
+        action.sa_sigaction = handler as sighandler_t;
+
+        sigaction(signal, &action, std::ptr::null_mut());
+    }
+}
+
+fn init_logs_and_tracing(
+    config: &trogging::cli::LoggingConfig,
+) -> Result<TroggingGuard, trogging::Error> {
+    let log_layer = trogging::Builder::new()
+        .with_default_log_filter("info")
+        .with_logging_config(config)
+        .build()?;
+
+    let layers = log_layer;
+
+    // Optionally enable the tokio console exporter layer, if enabled.
+    //
+    // This spawns a background tokio task to serve the instrumentation data,
+    // and hooks the instrumentation into the tracing pipeline.
+    #[cfg(feature = "tokio_console")]
+    let layers = {
+        use console_subscriber::ConsoleLayer;
+        let console_layer = ConsoleLayer::builder().with_default_env().spawn();
+        layers.and_then(console_layer)
+    };
+
+    let subscriber = Registry::default().with(layers);
+    trogging::install_global(subscriber)
+}
diff --git a/influxdb3/tests/server/auth.rs b/influxdb3/tests/server/auth.rs
new file mode 100644
index 00000000000..2d8a7516f69
--- /dev/null
+++ b/influxdb3/tests/server/auth.rs
@@ -0,0 +1,325 @@
+use arrow_flight::error::FlightError;
+use arrow_util::assert_batches_sorted_eq;
+use influxdb3_client::Precision;
+use reqwest::StatusCode;
+
+use crate::{collect_stream, TestServer};
+
+#[tokio::test]
+async fn auth() {
+    const HASHED_TOKEN: &str = "5315f0c4714537843face80cca8c18e27ce88e31e9be7a5232dc4dc8444f27c0227a9bd64831d3ab58f652bd0262dd8558dd08870ac9e5c650972ce9e4259439";
+    const TOKEN: &str = "apiv3_mp75KQAhbqv0GeQXk8MPuZ3ztaLEaR5JzS8iifk1FwuroSVyXXyrJK1c4gEr1kHkmbgzDV-j3MvQpaIMVJBAiA";
+
+    let server = TestServer::configure()
+        .auth_token(HASHED_TOKEN, TOKEN)
+        .spawn()
+        .await;
+
+    let client = reqwest::Client::new();
+    let base = server.client_addr();
+    let write_lp_url = format!("{base}/api/v3/write_lp");
+    let write_lp_params = [("db", "foo")];
+    let query_sql_url = format!("{base}/api/v3/query_sql");
+    let query_sql_params = [("db", "foo"), ("q", "select * from cpu")];
+
+    assert_eq!(
+        client
+            .post(&write_lp_url)
+            .query(&write_lp_params)
+            .body("cpu,host=a val=1i 123")
+            .send()
+            .await
+            .unwrap()
+            .status(),
+        StatusCode::UNAUTHORIZED
+    );
+    assert_eq!(
+        client
+            .get(&query_sql_url)
+            .query(&query_sql_params)
+            .send()
+            .await
+            .unwrap()
+            .status(),
+        StatusCode::UNAUTHORIZED
+    );
+    assert_eq!(
+        client
+            .post(&write_lp_url)
+            .query(&write_lp_params)
+            .body("cpu,host=a val=1i 123")
+            .bearer_auth(TOKEN)
+            .send()
+            .await
+            .unwrap()
+            .status(),
+        StatusCode::OK
+    );
+    assert_eq!(
+        client
+            .get(&query_sql_url)
+            .query(&query_sql_params)
+            .bearer_auth(TOKEN)
+            .send()
+            .await
+            .unwrap()
+            .status(),
+        StatusCode::OK
+    );
+    // Malformed Header Tests
+    // Test that there is an extra string after the token foo
+    assert_eq!(
+        client
+            .get(&query_sql_url)
+            .query(&query_sql_params)
+            .header("Authorization", format!("Bearer {TOKEN} whee"))
+            .send()
+            .await
+            .unwrap()
+            .status(),
+        StatusCode::BAD_REQUEST
+    );
+    assert_eq!(
+        client
+            .get(&query_sql_url)
+            .query(&query_sql_params)
+            .header("Authorization", format!("bearer {TOKEN}"))
+            .send()
+            .await
+            .unwrap()
+            .status(),
+        StatusCode::BAD_REQUEST
+    );
+    assert_eq!(
+        client
+            .get(&query_sql_url)
+            .query(&query_sql_params)
+            .header("Authorization", "Bearer")
+            .send()
+            .await
+            .unwrap()
+            .status(),
+        StatusCode::BAD_REQUEST
+    );
+    assert_eq!(
+        client
+            .get(&query_sql_url)
+            .query(&query_sql_params)
+            .header("auth", format!("Bearer {TOKEN}"))
+            .send()
+            .await
+            .unwrap()
+            .status(),
+        StatusCode::UNAUTHORIZED
+    );
+}
+
+#[tokio::test]
+async fn auth_grpc() {
+    const HASHED_TOKEN: &str = "5315f0c4714537843face80cca8c18e27ce88e31e9be7a5232dc4dc8444f27c0227a9bd64831d3ab58f652bd0262dd8558dd08870ac9e5c650972ce9e4259439";
+    const TOKEN: &str = "apiv3_mp75KQAhbqv0GeQXk8MPuZ3ztaLEaR5JzS8iifk1FwuroSVyXXyrJK1c4gEr1kHkmbgzDV-j3MvQpaIMVJBAiA";
+
+    let server = TestServer::configure()
+        .auth_token(HASHED_TOKEN, TOKEN)
+        .spawn()
+        .await;
+
+    // Write some data to the server, this will be authorized through the HTTP API
+    server
+        .write_lp_to_db(
+            "foo",
+            "cpu,host=s1,region=us-east usage=0.9 1\n\
+            cpu,host=s1,region=us-east usage=0.89 2\n\
+            cpu,host=s1,region=us-east usage=0.85 3",
+            Precision::Nanosecond,
+        )
+        .await
+        .unwrap();
+
+    // Check that with a valid authorization header, it succeeds:
+    for header in ["authorization", "Authorization"] {
+        // Spin up a FlightSQL client
+        let mut client = server.flight_sql_client("foo").await;
+
+        // Set the authorization header on the client:
+        client
+            .add_header(header, &format!("Bearer {TOKEN}"))
+            .unwrap();
+
+        // Make the query again, this time it should work:
+        let response = client
+            .query("SELECT host, region, time, usage FROM cpu")
+            .await
+            .unwrap();
+        let batches = collect_stream(response).await;
+        assert_batches_sorted_eq!(
+            [
+                "+------+---------+--------------------------------+-------+",
+                "| host | region  | time                           | usage |",
+                "+------+---------+--------------------------------+-------+",
+                "| s1   | us-east | 1970-01-01T00:00:00.000000001Z | 0.9   |",
+                "| s1   | us-east | 1970-01-01T00:00:00.000000002Z | 0.89  |",
+                "| s1   | us-east | 1970-01-01T00:00:00.000000003Z | 0.85  |",
+                "+------+---------+--------------------------------+-------+",
+            ],
+            &batches
+        );
+    }
+
+    // Check that without providing an Authentication header, it gives back
+    // an Unauthenticated error:
+    {
+        let mut client = server.flight_sql_client("foo").await;
+        let error = client.query("SELECT * FROM cpu").await.unwrap_err();
+        assert!(matches!(error, FlightError::Tonic(s) if s.code() == tonic::Code::Unauthenticated));
+    }
+
+    // Create some new clients that set the authorization header incorrectly to
+    // ensure errors are returned:
+
+    // Misspelled "Bearer"
+    {
+        let mut client = server.flight_sql_client("foo").await;
+        client
+            .add_header("authorization", &format!("bearer {TOKEN}"))
+            .unwrap();
+        let error = client.query("SELECT * FROM cpu").await.unwrap_err();
+        assert!(matches!(error, FlightError::Tonic(s) if s.code() == tonic::Code::Unauthenticated));
+    }
+
+    // Invalid token, this actually gives Permission denied
+    {
+        let mut client = server.flight_sql_client("foo").await;
+        client
+            .add_header("authorization", "Bearer invalid-token")
+            .unwrap();
+        let error = client.query("SELECT * FROM cpu").await.unwrap_err();
+        assert!(
+            matches!(error, FlightError::Tonic(s) if s.code() == tonic::Code::PermissionDenied)
+        );
+    }
+
+    // Misspelled header key
+    {
+        let mut client = server.flight_sql_client("foo").await;
+        client
+            .add_header("auth", &format!("Bearer {TOKEN}"))
+            .unwrap();
+        let error = client.query("SELECT * FROM cpu").await.unwrap_err();
+        assert!(matches!(error, FlightError::Tonic(s) if s.code() == tonic::Code::Unauthenticated));
+    }
+}
+
+#[tokio::test]
+async fn v1_password_parameter() {
+    const HASHED_TOKEN: &str = "5315f0c4714537843face80cca8c18e27ce88e31e9be7a5232dc4dc8444f27c0227a9bd64831d3ab58f652bd0262dd8558dd08870ac9e5c650972ce9e4259439";
+    const TOKEN: &str = "apiv3_mp75KQAhbqv0GeQXk8MPuZ3ztaLEaR5JzS8iifk1FwuroSVyXXyrJK1c4gEr1kHkmbgzDV-j3MvQpaIMVJBAiA";
+
+    let server = TestServer::configure()
+        .auth_token(HASHED_TOKEN, TOKEN)
+        .spawn()
+        .await;
+
+    let client = reqwest::Client::new();
+    let query_url = format!("{base}/query", base = server.client_addr());
+    let write_url = format!("{base}/write", base = server.client_addr());
+    // Send requests without any authentication:
+    assert_eq!(
+        client
+            .get(&query_url)
+            .send()
+            .await
+            .expect("send request")
+            .status(),
+        StatusCode::UNAUTHORIZED,
+    );
+    assert_eq!(
+        client
+            .get(&write_url)
+            .send()
+            .await
+            .expect("send request")
+            .status(),
+        StatusCode::UNAUTHORIZED,
+    );
+
+    // Ensure that an invalid token passed in the `p` parameter is still unauthorized:
+    assert_eq!(
+        client
+            .get(&query_url)
+            .query(&[("p", "not-the-token-you-were-looking-for")])
+            .send()
+            .await
+            .expect("send request")
+            .status(),
+        StatusCode::UNAUTHORIZED,
+    );
+    assert_eq!(
+        client
+            .get(&write_url)
+            .query(&[("p", "not-the-token-you-were-looking-for")])
+            .send()
+            .await
+            .expect("send request")
+            .status(),
+        StatusCode::UNAUTHORIZED,
+    );
+
+    // make some writes so that the query API will work below:
+    server
+        .write_lp_to_db("foo", "cpu,host=a usage=0.9", Precision::Second)
+        .await
+        .unwrap();
+
+    // Send request to query API with the token in the v1 `p` parameter:
+    assert_eq!(
+        client
+            .get(&query_url)
+            .query(&[("p", TOKEN), ("q", "SELECT * FROM cpu"), ("db", "foo")])
+            .send()
+            .await
+            .expect("send request")
+            .status(),
+        StatusCode::OK,
+    );
+    // Send request to query API with the token in auth header:
+    assert_eq!(
+        client
+            .get(&query_url)
+            .query(&[("q", "SELECT * FROM cpu"), ("db", "foo")])
+            .bearer_auth(TOKEN)
+            .send()
+            .await
+            .expect("send request")
+            .status(),
+        StatusCode::OK,
+    );
+
+    let valid_write_body = "cpu,host=val usage=0.5";
+
+    // Send request to write API with the token in the v1 `p` parameter:
+    assert_eq!(
+        client
+            .post(&write_url)
+            .query(&[("p", TOKEN), ("db", "foo")])
+            .body(valid_write_body)
+            .send()
+            .await
+            .expect("send request")
+            .status(),
+        StatusCode::OK,
+    );
+    // Send request to write API with the token in auth header:
+    assert_eq!(
+        client
+            .post(&write_url)
+            .bearer_auth(TOKEN)
+            .query(&[("db", "foo")])
+            .body(valid_write_body)
+            .send()
+            .await
+            .expect("send request")
+            .status(),
+        StatusCode::OK,
+    );
+}
diff --git a/influxdb3/tests/server/flight.rs b/influxdb3/tests/server/flight.rs
new file mode 100644
index 00000000000..53811644893
--- /dev/null
+++ b/influxdb3/tests/server/flight.rs
@@ -0,0 +1,228 @@
+use arrow_flight::sql::SqlInfo;
+use arrow_flight::Ticket;
+use arrow_util::assert_batches_sorted_eq;
+use influxdb3_client::Precision;
+use test_helpers::assert_contains;
+
+use crate::collect_stream;
+use crate::TestServer;
+
+#[tokio::test]
+async fn flight() -> Result<(), influxdb3_client::Error> {
+    let server = TestServer::spawn().await;
+
+    server
+        .write_lp_to_db(
+            "foo",
+            "cpu,host=s1,region=us-east usage=0.9 1\n\
+        cpu,host=s1,region=us-east usage=0.89 2\n\
+        cpu,host=s1,region=us-east usage=0.85 3",
+            Precision::Nanosecond,
+        )
+        .await?;
+
+    let mut client = server.flight_sql_client("foo").await;
+
+    // Ad-hoc Query:
+    {
+        let response = client
+            .query("SELECT host, region, time, usage FROM cpu")
+            .await
+            .unwrap();
+
+        let batches = collect_stream(response).await;
+        assert_batches_sorted_eq!(
+            [
+                "+------+---------+--------------------------------+-------+",
+                "| host | region  | time                           | usage |",
+                "+------+---------+--------------------------------+-------+",
+                "| s1   | us-east | 1970-01-01T00:00:00.000000001Z | 0.9   |",
+                "| s1   | us-east | 1970-01-01T00:00:00.000000002Z | 0.89  |",
+                "| s1   | us-east | 1970-01-01T00:00:00.000000003Z | 0.85  |",
+                "+------+---------+--------------------------------+-------+",
+            ],
+            &batches
+        );
+    }
+
+    // Ad-hoc Query error:
+    {
+        let error = client
+            .query("SELECT * FROM invalid_table")
+            .await
+            .unwrap_err();
+
+        assert!(error
+            .to_string()
+            .contains("table 'public.iox.invalid_table' not found"));
+    }
+
+    // Prepared query:
+    {
+        let handle = client
+            .prepare("SELECT host, region, time, usage FROM cpu".into(), None)
+            .await
+            .unwrap();
+        let stream = client.execute(handle).await.unwrap();
+
+        let batches = collect_stream(stream).await;
+        assert_batches_sorted_eq!(
+            [
+                "+------+---------+--------------------------------+-------+",
+                "| host | region  | time                           | usage |",
+                "+------+---------+--------------------------------+-------+",
+                "| s1   | us-east | 1970-01-01T00:00:00.000000001Z | 0.9   |",
+                "| s1   | us-east | 1970-01-01T00:00:00.000000002Z | 0.89  |",
+                "| s1   | us-east | 1970-01-01T00:00:00.000000003Z | 0.85  |",
+                "+------+---------+--------------------------------+-------+",
+            ],
+            &batches
+        );
+    }
+
+    // Get SQL Infos:
+    {
+        let infos = vec![SqlInfo::FlightSqlServerName as u32];
+        let stream = client.get_sql_info(infos).await.unwrap();
+        let batches = collect_stream(stream).await;
+        assert_batches_sorted_eq!(
+            [
+                "+-----------+-----------------------------+",
+                "| info_name | value                       |",
+                "+-----------+-----------------------------+",
+                "| 0         | {string_value=InfluxDB IOx} |",
+                "+-----------+-----------------------------+",
+            ],
+            &batches
+        );
+    }
+
+    // Get Tables
+    {
+        type OptStr = std::option::Option<&'static str>;
+        let stream = client
+            .get_tables(OptStr::None, OptStr::None, OptStr::None, vec![], false)
+            .await
+            .unwrap();
+        let batches = collect_stream(stream).await;
+
+        assert_batches_sorted_eq!(
+            [
+                "+--------------+--------------------+-------------+------------+",
+                "| catalog_name | db_schema_name     | table_name  | table_type |",
+                "+--------------+--------------------+-------------+------------+",
+                "| public       | information_schema | columns     | VIEW       |",
+                "| public       | information_schema | df_settings | VIEW       |",
+                "| public       | information_schema | schemata    | VIEW       |",
+                "| public       | information_schema | tables      | VIEW       |",
+                "| public       | information_schema | views       | VIEW       |",
+                "| public       | iox                | cpu         | BASE TABLE |",
+                "+--------------+--------------------+-------------+------------+",
+            ],
+            &batches
+        );
+    }
+
+    // Get Catalogs
+    {
+        let stream = client.get_catalogs().await.unwrap();
+        let batches = collect_stream(stream).await;
+        assert_batches_sorted_eq!(
+            [
+                "+--------------+",
+                "| catalog_name |",
+                "+--------------+",
+                "| public       |",
+                "+--------------+",
+            ],
+            &batches
+        );
+    }
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn flight_influxql() {
+    let server = TestServer::spawn().await;
+
+    server
+        .write_lp_to_db(
+            "foo",
+            "cpu,host=s1,region=us-east usage=0.9 1\n\
+            cpu,host=s1,region=us-east usage=0.89 2\n\
+            cpu,host=s1,region=us-east usage=0.85 3",
+            Precision::Nanosecond,
+        )
+        .await
+        .unwrap();
+
+    let mut client = server.flight_client().await;
+
+    // Ad-hoc query, using qualified measurement name:
+    {
+        let ticket = Ticket::new(
+            r#"{
+                    "database": "foo",
+                    "sql_query": "SELECT time, host, region, usage FROM foo.autogen.cpu",
+                    "query_type": "influxql"
+                }"#,
+        );
+        let response = client.do_get(ticket).await.unwrap();
+
+        let batches = collect_stream(response).await;
+        assert_batches_sorted_eq!(
+            [
+                "+------------------+--------------------------------+------+---------+-------+",
+                "| iox::measurement | time                           | host | region  | usage |",
+                "+------------------+--------------------------------+------+---------+-------+",
+                "| cpu              | 1970-01-01T00:00:00.000000001Z | s1   | us-east | 0.9   |",
+                "| cpu              | 1970-01-01T00:00:00.000000002Z | s1   | us-east | 0.89  |",
+                "| cpu              | 1970-01-01T00:00:00.000000003Z | s1   | us-east | 0.85  |",
+                "+------------------+--------------------------------+------+---------+-------+",
+            ],
+            &batches
+        );
+    }
+
+    // InfluxQL-specific query to show measurements:
+    {
+        let ticket = Ticket::new(
+            r#"{
+                    "database": "foo",
+                    "sql_query": "SHOW MEASUREMENTS",
+                    "query_type": "influxql"
+                }"#,
+        );
+        let response = client.do_get(ticket).await.unwrap();
+
+        let batches = collect_stream(response).await;
+        assert_batches_sorted_eq!(
+            [
+                "+------------------+------+",
+                "| iox::measurement | name |",
+                "+------------------+------+",
+                "| measurements     | cpu  |",
+                "+------------------+------+",
+            ],
+            &batches
+        );
+    }
+
+    // An InfluxQL query that is not supported over Flight:
+    {
+        let ticket = Ticket::new(
+            r#"{
+                    "database": "foo",
+                    "sql_query": "SHOW DATABASES",
+                    "query_type": "influxql"
+                }"#,
+        );
+        let response = client.do_get(ticket).await.unwrap_err();
+
+        assert_contains!(
+            response.to_string(),
+            "This feature is not implemented: SHOW DATABASES"
+        );
+    }
+}
diff --git a/influxdb3/tests/server/limits.rs b/influxdb3/tests/server/limits.rs
new file mode 100644
index 00000000000..2aca62f077d
--- /dev/null
+++ b/influxdb3/tests/server/limits.rs
@@ -0,0 +1,82 @@
+use crate::TestServer;
+use hyper::StatusCode;
+use influxdb3_client::Error;
+use influxdb3_client::Precision;
+
+#[tokio::test]
+async fn limits() -> Result<(), Error> {
+    let server = TestServer::spawn().await;
+
+    // Test that a server can't have more than 5 DBs
+    for db in ["one", "two", "three", "four", "five"] {
+        server
+            .write_lp_to_db(
+                db,
+                "cpu,host=s1,region=us-east usage=0.9 1\n",
+                Precision::Nanosecond,
+            )
+            .await?;
+    }
+
+    let Err(Error::ApiError { code, .. }) = server
+        .write_lp_to_db(
+            "six",
+            "cpu,host=s1,region=us-east usage=0.9 1\n",
+            Precision::Nanosecond,
+        )
+        .await
+    else {
+        panic!("Did not error when adding 6th db");
+    };
+    assert_eq!(code, StatusCode::UNPROCESSABLE_ENTITY);
+
+    // Test that the server can't have more than 2000 tables
+    // First create the other needed 1995 tables
+    let table_lp = (0..1995).fold(String::new(), |mut acc, i| {
+        acc.push_str("cpu");
+        acc.push_str(&i.to_string());
+        acc.push_str(",host=s1,region=us-east usage=0.9 1\n");
+        acc
+    });
+
+    server
+        .write_lp_to_db("one", &table_lp, Precision::Nanosecond)
+        .await?;
+
+    let Err(Error::ApiError { code, .. }) = server
+        .write_lp_to_db(
+            "six",
+            "cpu2000,host=s1,region=us-east usage=0.9 1\n",
+            Precision::Nanosecond,
+        )
+        .await
+    else {
+        panic!("Did not error when adding 2001st table");
+    };
+    assert_eq!(code, StatusCode::UNPROCESSABLE_ENTITY);
+
+    // Test that we can't add a row 500 columns long
+    let mut lp_500 = String::from("cpu,host=foo,region=bar usage=2");
+    let mut lp_501 = String::from("cpu,host=foo,region=bar usage=2");
+    for i in 5..=500 {
+        let column = format!(",column{}=1", i);
+        lp_500.push_str(&column);
+        lp_501.push_str(&column);
+    }
+    lp_500.push_str(" 0\n");
+    lp_501.push_str(",column501=1 0\n");
+
+    server
+        .write_lp_to_db("one", &lp_500, Precision::Nanosecond)
+        .await?;
+
+    let Err(Error::ApiError { code, .. }) = server
+        .write_lp_to_db("one", &lp_501, Precision::Nanosecond)
+        .await
+    else {
+        panic!("Did not error when adding 501st column");
+    };
+    assert_eq!(code, StatusCode::UNPROCESSABLE_ENTITY);
+
+    Ok(())
+}
diff --git a/influxdb3/tests/server/main.rs b/influxdb3/tests/server/main.rs
new file mode 100644
index 00000000000..775012b67eb
--- /dev/null
+++ b/influxdb3/tests/server/main.rs
@@ -0,0 +1,242 @@
+use std::{
+    net::{SocketAddr, SocketAddrV4, TcpListener},
+    process::{Child, Command, Stdio},
+    time::Duration,
+};
+
+use arrow::record_batch::RecordBatch;
+use arrow_flight::{decode::FlightRecordBatchStream, FlightClient};
+use assert_cmd::cargo::CommandCargoExt;
+use futures::TryStreamExt;
+use influxdb3_client::Precision;
+use influxdb_iox_client::flightsql::FlightSqlClient;
+use reqwest::Response;
+
+mod auth;
+mod flight;
+mod limits;
+mod ping;
+mod query;
+mod write;
+
+/// Configuration for a [`TestServer`]
+#[derive(Debug, Default)]
+pub struct TestConfig {
+    auth_token: Option<(String, String)>,
+}
+
+impl TestConfig {
+    /// Set the auth token for this [`TestServer`]
+    pub fn auth_token<S: Into<String>, R: Into<String>>(
+        mut self,
+        hashed_token: S,
+        raw_token: R,
+    ) -> Self {
+        self.auth_token = Some((hashed_token.into(), raw_token.into()));
+        self
+    }
+
+    /// Spawn a new [`TestServer`] with this configuration
+    ///
+    /// This will run the `influxdb3 serve` command, and bind its HTTP
+    /// address to a random port on localhost.
+    pub async fn spawn(self) -> TestServer {
+        TestServer::spawn_inner(self).await
+    }
+
+    fn as_args(&self) -> Vec<&str> {
+        let mut args = vec![];
+        if let Some((token, _)) = &self.auth_token {
+            args.append(&mut vec!["--bearer-token", token]);
+        }
+        args
+    }
+}
+
+/// A running instance of the `influxdb3 serve` process
+///
+/// Logs will be emitted to stdout/stderr if the TEST_LOG environment
+/// variable is set, e.g.,
+/// ```
+/// TEST_LOG= cargo test
+/// ```
+pub struct TestServer {
+    config: TestConfig,
+    bind_addr: SocketAddr,
+    server_process: Child,
+    http_client: reqwest::Client,
+}
+
+impl TestServer {
+    /// Spawn a new [`TestServer`]
+    ///
+    /// This will run the `influxdb3 serve` command, and bind its HTTP
+    /// address to a random port on localhost.
+    pub async fn spawn() -> Self {
+        Self::spawn_inner(Default::default()).await
+    }
+
+    /// Configure a [`TestServer`] before spawning
+    pub fn configure() -> TestConfig {
+        TestConfig::default()
+    }
+
+    async fn spawn_inner(config: TestConfig) -> Self {
+        let bind_addr = get_local_bind_addr();
+        let mut command = Command::cargo_bin("influxdb3").expect("create the influxdb3 command");
+        let mut command = command
+            .arg("serve")
+            .args(["--http-bind", &bind_addr.to_string()])
+            .args(["--object-store", "memory"])
+            .args(config.as_args());
+
+        // If TEST_LOG env var is not defined, discard stdout/stderr
+        if std::env::var("TEST_LOG").is_err() {
+            command = command.stdout(Stdio::null()).stderr(Stdio::null());
+        }
+
+        let server_process = command.spawn().expect("spawn the influxdb3 server process");
+
+        let server = Self {
+            config,
+            bind_addr,
+            server_process,
+            http_client: reqwest::Client::new(),
+        };
+
+        server.wait_until_ready().await;
+        server
+    }
+
+    /// Get the URL of the running service for use with an HTTP client
+    pub fn client_addr(&self) -> String {
+        format!("http://{addr}", addr = self.bind_addr)
+    }
+
+    /// Get a [`FlightSqlClient`] for making requests to the running service over gRPC
+    pub async fn flight_sql_client(&self, database: &str) -> FlightSqlClient {
+        let channel = tonic::transport::Channel::from_shared(self.client_addr())
+            .expect("create tonic channel")
+            .connect()
+            .await
+            .expect("connect to gRPC client");
+        let mut client = FlightSqlClient::new(channel);
+        client.add_header("database", database).unwrap();
+        client.add_header("iox-debug", "true").unwrap();
+        client
+    }
+
+    /// Get a raw [`FlightClient`] for performing Flight actions directly
+    pub async fn flight_client(&self) -> FlightClient {
+        let channel = tonic::transport::Channel::from_shared(self.client_addr())
+            .expect("create tonic channel")
+            .connect()
+            .await
+            .expect("connect to gRPC client");
+        FlightClient::new(channel)
+    }
+
+    fn kill(&mut self) {
+        self.server_process.kill().expect("kill the server process");
+    }
+
+    async fn wait_until_ready(&self) {
+        while self
+            .http_client
+            .get(format!("{base}/health", base = self.client_addr()))
+            .send()
+            .await
+            .is_err()
+        {
+            tokio::time::sleep(Duration::from_millis(10)).await;
+        }
+    }
+}
+
+impl Drop for TestServer {
+    fn drop(&mut self) {
+        self.kill();
+    }
+}
+
+impl TestServer {
+    /// Write some line protocol to the server
+    pub async fn write_lp_to_db(
+        &self,
+        database: &str,
+        lp: impl ToString,
+        precision: Precision,
+    ) -> Result<(), influxdb3_client::Error> {
+        let mut client = influxdb3_client::Client::new(self.client_addr()).unwrap();
+        if let Some((_, token)) = &self.config.auth_token {
+            client = client.with_auth_token(token);
+        }
+        client
+            .api_v3_write_lp(database)
+            .body(lp.to_string())
+            .precision(precision)
+            .send()
+            .await
+    }
+
+    pub async fn api_v3_query_influxql(&self, params: &[(&str, &str)]) -> Response {
+        self.http_client
+            .get(format!(
+                "{base}/api/v3/query_influxql",
+                base = self.client_addr()
+            ))
+            .query(params)
+            .send()
+            .await
+            .expect("send /api/v3/query_influxql request to server")
+    }
+
+    pub async fn api_v1_query(&self, params: &[(&str, &str)]) -> Response {
+        self.http_client
+            .get(format!("{base}/query", base = self.client_addr(),))
+            .query(params)
+            .send()
+            .await
+            .expect("send /query request to server")
+    }
+}
+
+/// Get an available bind address on localhost
+///
+/// This binds a [`TcpListener`] to 127.0.0.1:0, which will randomly
+/// select an available port, and produces the resulting local address.
+/// The [`TcpListener`] is dropped at the end of the function, thus
+/// freeing the port for use by the caller.
+fn get_local_bind_addr() -> SocketAddr {
+    let ip = std::net::Ipv4Addr::new(127, 0, 0, 1);
+    let port = 0;
+    let addr = SocketAddrV4::new(ip, port);
+    TcpListener::bind(addr)
+        .expect("bind to a socket address")
+        .local_addr()
+        .expect("get local address")
+}
+
+/// Write to the server with the line protocol
+pub async fn write_lp_to_db(
+    server: &TestServer,
+    database: &str,
+    lp: &str,
+    precision: Precision,
+) -> Result<(), influxdb3_client::Error> {
+    let client = influxdb3_client::Client::new(server.client_addr()).unwrap();
+    client
+        .api_v3_write_lp(database)
+        .body(lp.to_string())
+        .precision(precision)
+        .send()
+        .await
+}
+
+#[allow(dead_code)]
+pub async fn collect_stream(stream: FlightRecordBatchStream) -> Vec<RecordBatch> {
+    stream
+        .try_collect()
+        .await
+        .expect("gather record batch stream")
+}
diff --git a/influxdb3/tests/server/ping.rs b/influxdb3/tests/server/ping.rs
new file mode 100644
index 00000000000..837232a6c0a
--- /dev/null
+++ b/influxdb3/tests/server/ping.rs
@@ -0,0 +1,42 @@
+use hyper::Method;
+use serde_json::Value;
+
+use crate::TestServer;
+
+#[tokio::test]
+async fn test_ping() {
+    let server = TestServer::spawn().await;
+    let client = reqwest::Client::new();
+
+    struct TestCase<'a> {
+        url: &'a str,
+        method: Method,
+    }
+
+    let ping_url = format!("{base}/ping", base = server.client_addr());
+
+    let test_cases = [
+        TestCase {
+            url: &ping_url,
+            method: Method::GET,
+        },
+        TestCase {
+            url: &ping_url,
+            method: Method::POST,
+        },
+    ];
+
+    for t in test_cases {
+        let resp = client
+            .request(t.method.clone(), t.url)
+            .send()
+            .await
+            .unwrap();
+        let json = resp.json::<Value>().await.unwrap();
+        println!("Method: {}, URL: {}", t.method, t.url);
+        println!("{json:#}");
+        let map = json.as_object().unwrap();
+        assert!(map.contains_key("version"));
+        assert!(map.contains_key("revision"));
+    }
+}
diff --git a/influxdb3/tests/server/query.rs b/influxdb3/tests/server/query.rs
new file mode 100644
index 00000000000..933e07f3016
--- /dev/null
+++ b/influxdb3/tests/server/query.rs
@@ -0,0 +1,920 @@
+use crate::TestServer;
+use futures::StreamExt;
+use influxdb3_client::Precision;
+use pretty_assertions::assert_eq;
+use serde_json::{json, Value};
+use test_helpers::assert_contains;
+
+#[tokio::test]
+async fn api_v3_query_sql() {
+    let server = TestServer::spawn().await;
+
+    server
+        .write_lp_to_db(
+            "foo",
+            "cpu,host=s1,region=us-east usage=0.9 1\n\
+            cpu,host=s1,region=us-east usage=0.89 2\n\
+            cpu,host=s1,region=us-east usage=0.85 3",
+            Precision::Nanosecond,
+        )
+        .await
+        .unwrap();
+
+    let client = reqwest::Client::new();
+
+    let resp = client
+        .get(format!(
+            "{base}/api/v3/query_sql",
+            base = server.client_addr()
+        ))
+        .query(&[
+            ("db", "foo"),
+            ("q", "SELECT host, region, time, usage FROM cpu"),
+            ("format", "pretty"),
+        ])
+        .send()
+        .await
+        .unwrap()
+        .text()
+        .await
+        .unwrap();
+
+    assert_eq!(
+        "+------+---------+-------------------------------+-------+\n\
+        | host | region  | time                          | usage |\n\
+        +------+---------+-------------------------------+-------+\n\
+        | s1   | us-east | 1970-01-01T00:00:00.000000001 | 0.9   |\n\
+        | s1   | us-east | 1970-01-01T00:00:00.000000002 | 0.89  |\n\
+        | s1   | us-east | 1970-01-01T00:00:00.000000003 | 0.85  |\n\
+        +------+---------+-------------------------------+-------+",
+        resp,
+    );
+}
+
+#[tokio::test]
+async fn api_v3_query_sql_params() {
+    let server = TestServer::spawn().await;
+
+    server
+        .write_lp_to_db(
+            "foo",
+            "cpu,host=a,region=us-east usage=0.9 1
+            cpu,host=b,region=us-east usage=0.50 1
+            cpu,host=a,region=us-east usage=0.80 2
+            cpu,host=b,region=us-east usage=0.60 2
+            cpu,host=a,region=us-east usage=0.70 3
+            cpu,host=b,region=us-east usage=0.70 3
+            cpu,host=a,region=us-east usage=0.50 4
+            cpu,host=b,region=us-east usage=0.80 4",
+            Precision::Second,
+        )
+        .await
+        .unwrap();
+
+    let client = reqwest::Client::new();
+    let url = format!("{base}/api/v3/query_sql", base = server.client_addr());
+
+    // Use a POST request
+    {
+        let resp = client
+            .post(&url)
+            .json(&json!({
+                "db": "foo",
+                "q": "SELECT host, region, time, usage FROM cpu WHERE host = $host AND usage > $usage ORDER BY time",
+                "params": {
+                    "host": "b",
+                    "usage": 0.60,
+                },
+                "format": "pretty",
+            }))
+            .send()
+            .await
+            .unwrap()
+            .text()
+            .await
+            .unwrap();
+
+        assert_eq!(
+            "+------+---------+---------------------+-------+\n\
+            | host | region  | time                | usage |\n\
+            +------+---------+---------------------+-------+\n\
+            | b    | us-east | 1970-01-01T00:00:03 | 0.7   |\n\
+            | b    | us-east | 1970-01-01T00:00:04 | 0.8   |\n\
+            +------+---------+---------------------+-------+",
+            resp
+        );
+    }
+
+    // Use a GET request
+    {
+        let params = serde_json::to_string(&json!({
+            "host": "b",
+            "usage": 0.60,
+        }))
+        .unwrap();
+        let resp = client
+            .get(&url)
+            .query(&[
+                ("db", "foo"),
+                (
+                    "q",
+                    "SELECT host, region, time, usage FROM cpu WHERE host = $host AND usage > $usage ORDER BY time",
+                ),
+                ("format", "pretty"),
+                ("params", params.as_str()),
+            ])
+            .send()
+            .await
+            .unwrap()
+            .text()
+            .await
+            .unwrap();
+
+        assert_eq!(
+            "+------+---------+---------------------+-------+\n\
+            | host | region  | time                | usage |\n\
+            +------+---------+---------------------+-------+\n\
+            | b    | us-east | 1970-01-01T00:00:03 | 0.7   |\n\
+            | b    | us-east | 1970-01-01T00:00:04 | 0.8   |\n\
+            +------+---------+---------------------+-------+",
+            resp
+        );
+    }
+
+    // Check for errors
+    {
+        let resp = client
+            .post(&url)
+            .json(&json!({
+                "db": "foo",
+                "q": "SELECT * FROM cpu WHERE host = $host",
+                "params": {
+                    "not_host": "a"
+                },
+                "format": "pretty",
+            }))
+            .send()
+            .await
+            .unwrap();
+        let status = resp.status();
+        let body = resp.text().await.unwrap();
+
+        // TODO - it would be nice if this was a 4xx error, because this is really
+        //   a user error; however, the underlying error that occurs when Logical
+        //   planning is DatafusionError::Internal, and is not so convenient to deal
+        //   with. This may get addressed in:
+        //
+        //   https://github.com/apache/arrow-datafusion/issues/9738
+        assert!(status.is_server_error());
+        assert_contains!(body, "No value found for placeholder with name $host");
+    }
+}
+
+#[tokio::test]
+async fn api_v3_query_influxql() {
+    let server = TestServer::spawn().await;
+
+    server
+        .write_lp_to_db(
+            "foo",
+            "cpu,host=s1,region=us-east usage=0.9 1\n\
+            cpu,host=s1,region=us-east usage=0.89 2\n\
+            cpu,host=s1,region=us-east usage=0.85 3\n\
+            mem,host=s1,region=us-east usage=0.5 4\n\
+            mem,host=s1,region=us-east usage=0.6 5\n\
+            mem,host=s1,region=us-east usage=0.7 6",
+            Precision::Nanosecond,
+        )
+        .await
+        .unwrap();
+
+    // write to another database for `SHOW DATABASES` and `SHOW RETENTION POLICIES`
+    server
+        .write_lp_to_db(
+            "bar",
+            "cpu,host=s1,region=us-east usage=0.9 1\n\
+            cpu,host=s1,region=us-east usage=0.89 2\n\
+            cpu,host=s1,region=us-east usage=0.85 3\n\
+            mem,host=s1,region=us-east usage=0.5 4\n\
+            mem,host=s1,region=us-east usage=0.6 5\n\
+            mem,host=s1,region=us-east usage=0.7 6",
+            Precision::Nanosecond,
+        )
+        .await
+        .unwrap();
+
+    struct TestCase<'a> {
+        database: Option<&'a str>,
+        query: &'a str,
+        expected: &'a str,
+    }
+
+    let test_cases = [
+        TestCase {
+            database: Some("foo"),
+            query: "SELECT time, host, region, usage FROM cpu",
+            expected:
+                "+------------------+-------------------------------+------+---------+-------+\n\
+                | iox::measurement | time                          | host | region  | usage |\n\
+                +------------------+-------------------------------+------+---------+-------+\n\
+                | cpu              | 1970-01-01T00:00:00.000000001 | s1   | us-east | 0.9   |\n\
+                | cpu              | 1970-01-01T00:00:00.000000002 | s1   | us-east | 0.89  |\n\
+                | cpu              | 1970-01-01T00:00:00.000000003 | s1   | us-east | 0.85  |\n\
+                +------------------+-------------------------------+------+---------+-------+",
+        },
+        TestCase {
+            database: None,
+            query: "SELECT time, host, region, usage FROM foo.autogen.cpu",
+            expected:
+                "+------------------+-------------------------------+------+---------+-------+\n\
+                | iox::measurement | time                          | host | region  | usage |\n\
+                +------------------+-------------------------------+------+---------+-------+\n\
+                | cpu              | 1970-01-01T00:00:00.000000001 | s1   | us-east | 0.9   |\n\
+                | cpu              | 1970-01-01T00:00:00.000000002 | s1   | us-east | 0.89  |\n\
+                | cpu              | 1970-01-01T00:00:00.000000003 | s1   | us-east | 0.85  |\n\
+                +------------------+-------------------------------+------+---------+-------+",
+        },
+        TestCase {
+            database: Some("foo"),
+            query: "SELECT host, region, usage FROM cpu, mem",
+            expected:
+                "+------------------+-------------------------------+------+---------+-------+\n\
+                | iox::measurement | time                          | host | region  | usage |\n\
+                +------------------+-------------------------------+------+---------+-------+\n\
+                | cpu              | 1970-01-01T00:00:00.000000001 | s1   | us-east | 0.9   |\n\
+                | cpu              | 1970-01-01T00:00:00.000000002 | s1   | us-east | 0.89  |\n\
+                | cpu              | 1970-01-01T00:00:00.000000003 | s1   | us-east | 0.85  |\n\
+                | mem              | 1970-01-01T00:00:00.000000004 | s1   | us-east | 0.5   |\n\
+                | mem              | 1970-01-01T00:00:00.000000005 | s1   | us-east | 0.6   |\n\
+                | mem              | 1970-01-01T00:00:00.000000006 | s1   | us-east | 0.7   |\n\
+                +------------------+-------------------------------+------+---------+-------+",
+        },
+        TestCase {
+            database: Some("foo"),
+            query: "SHOW MEASUREMENTS",
+            expected: "+------------------+------+\n\
+                    | iox::measurement | name |\n\
+                    +------------------+------+\n\
+                    | measurements     | cpu  |\n\
+                    | measurements     | mem  |\n\
+                    +------------------+------+",
+        },
+        TestCase {
+            database: None,
+            query: "SHOW MEASUREMENTS ON foo",
+            expected: "+------------------+------+\n\
+                    | iox::measurement | name |\n\
+                    +------------------+------+\n\
+                    | measurements     | cpu  |\n\
+                    | measurements     | mem  |\n\
+                    +------------------+------+",
+        },
+        TestCase {
+            database: Some("foo"),
+            query: "SHOW FIELD KEYS",
+            expected: "+------------------+------------+-----------+\n\
+                    | iox::measurement | fieldKey   | fieldType |\n\
+                    +------------------+------------+-----------+\n\
+                    | cpu              | _series_id | string    |\n\
+                    | cpu              | usage      | float     |\n\
+                    | mem              | _series_id | string    |\n\
+                    | mem              | usage      | float     |\n\
+                    +------------------+------------+-----------+",
+        },
+        TestCase {
+            database: None,
+            query: "SHOW FIELD KEYS ON foo",
+            expected: "+------------------+------------+-----------+\n\
+                    | iox::measurement | fieldKey   | fieldType |\n\
+                    +------------------+------------+-----------+\n\
+                    | cpu              | _series_id | string    |\n\
+                    | cpu              | usage      | float     |\n\
+                    | mem              | _series_id | string    |\n\
+                    | mem              | usage      | float     |\n\
+                    +------------------+------------+-----------+",
+        },
+        TestCase {
+            database: Some("foo"),
+            query: "SHOW TAG KEYS",
+            expected: "+------------------+--------+\n\
+                    | iox::measurement | tagKey |\n\
+                    +------------------+--------+\n\
+                    | cpu              | host   |\n\
+                    | cpu              | region |\n\
+                    | mem              | host   |\n\
+                    | mem              | region |\n\
+                    +------------------+--------+",
+        },
+        TestCase {
+            database: None,
+            query: "SHOW TAG KEYS ON foo",
+            expected: "+------------------+--------+\n\
+                    | iox::measurement | tagKey |\n\
+                    +------------------+--------+\n\
+                    | cpu              | host   |\n\
+                    | cpu              | region |\n\
+                    | mem              | host   |\n\
+                    | mem              | region |\n\
+                    +------------------+--------+",
+        },
+        TestCase {
+            database: Some("foo"),
+            query: "SHOW TAG VALUES WITH KEY = \"host\" WHERE time < 1970-01-02",
+            expected: "+------------------+------+-------+\n\
+                    | iox::measurement | key  | value |\n\
+                    +------------------+------+-------+\n\
+                    | cpu              | host | s1    |\n\
+                    | mem              | host | s1    |\n\
+                    +------------------+------+-------+",
+        },
+        TestCase {
+            database: None,
+            query: "SHOW TAG VALUES ON foo WITH KEY = \"host\" WHERE time < 1970-01-02",
+            expected: "+------------------+------+-------+\n\
+                    | iox::measurement | key  | value |\n\
+                    +------------------+------+-------+\n\
+                    | cpu              | host | s1    |\n\
+                    | mem              | host | s1    |\n\
+                    +------------------+------+-------+",
+        },
+        TestCase {
+            database: None,
+            query: "SHOW DATABASES",
+            expected: "+---------------+\n\
+                    | iox::database |\n\
+                    +---------------+\n\
+                    | bar           |\n\
+                    | foo           |\n\
+                    +---------------+",
+        },
+        TestCase {
+            database: None,
+            query: "SHOW RETENTION POLICIES",
+            expected: "+---------------+---------+----------+\n\
+                    | iox::database | name    | duration |\n\
+                    +---------------+---------+----------+\n\
+                    | bar           | autogen |          |\n\
+                    | foo           | autogen |          |\n\
+                    +---------------+---------+----------+",
+        },
+        TestCase {
+            database: None,
+            query: "SHOW RETENTION POLICIES ON foo",
+            expected: "+---------------+---------+----------+\n\
+                    | iox::database | name    | duration |\n\
+                    +---------------+---------+----------+\n\
+                    | foo           | autogen |          |\n\
+                    +---------------+---------+----------+",
+        },
+        TestCase {
+            database: Some("foo"),
+            query: "SHOW RETENTION POLICIES",
+            expected: "+---------------+---------+----------+\n\
+                    | iox::database | name    | duration |\n\
+                    +---------------+---------+----------+\n\
+                    | foo           | autogen |          |\n\
+                    +---------------+---------+----------+",
+        },
+    ];
+
+    for t in test_cases {
+        let mut params = vec![("q", t.query), ("format", "pretty")];
+        if let Some(db) = t.database {
+            params.push(("db", db))
+        }
+        let resp = server
+            .api_v3_query_influxql(&params)
+            .await
+            .text()
+            .await
+            .unwrap();
+        println!("\n{q}", q = t.query);
+        println!("{resp}");
+        assert_eq!(t.expected, resp, "query failed: {q}", q = t.query);
+    }
+}
+
+#[tokio::test]
+async fn api_v3_query_influxql_params() {
+    let server = TestServer::spawn().await;
+
+    server
+        .write_lp_to_db(
+            "foo",
+            "cpu,host=a,region=us-east usage=0.9 1
+            cpu,host=b,region=us-east usage=0.50 1
+            cpu,host=a,region=us-east usage=0.80 2
+            cpu,host=b,region=us-east usage=0.60 2
+            cpu,host=a,region=us-east usage=0.70 3
+            cpu,host=b,region=us-east usage=0.70 3
+            cpu,host=a,region=us-east usage=0.50 4
+            cpu,host=b,region=us-east usage=0.80 4",
+            Precision::Second,
+        )
+        .await
+        .unwrap();
+
+    let client = reqwest::Client::new();
+    let url = format!("{base}/api/v3/query_influxql", base = server.client_addr());
+
+    // Use a POST request
+    {
+        let resp = client
+            .post(&url)
+            .json(&json!({
+                "db": "foo",
+                "q": "SELECT time, host, region, usage FROM cpu WHERE host = $host AND usage > $usage",
+                "params": {
+                    "host": "b",
+                    "usage": 0.60,
+                },
+                "format": "pretty",
+            }))
+            .send()
+            .await
+            .unwrap()
+            .text()
+            .await
+            .unwrap();
+
+        assert_eq!(
+            "+------------------+---------------------+------+---------+-------+\n\
+            | iox::measurement | time                | host | region  | usage |\n\
+            +------------------+---------------------+------+---------+-------+\n\
+            | cpu              | 1970-01-01T00:00:03 | b    | us-east | 0.7   |\n\
+            | cpu              | 1970-01-01T00:00:04 | b    | us-east | 0.8   |\n\
+            +------------------+---------------------+------+---------+-------+",
+            resp
+        );
+    }
+
+    // Use a GET request
+    {
+        let params = serde_json::to_string(&json!({
+            "host": "b",
+            "usage": 0.60,
+        }))
+        .unwrap();
+        let resp = client
+            .get(&url)
+            .query(&[
+                ("db", "foo"),
+                (
+                    "q",
+                    "SELECT time, host, region, usage FROM cpu WHERE host = $host AND usage > $usage",
+                ),
+                ("format", "pretty"),
+                ("params", params.as_str()),
+            ])
+            .send()
+            .await
+            .unwrap()
+            .text()
+            .await
+            .unwrap();
+
+        assert_eq!(
+            "+------------------+---------------------+------+---------+-------+\n\
+            | iox::measurement | time                | host | region  | usage |\n\
+            +------------------+---------------------+------+---------+-------+\n\
+            | cpu              | 1970-01-01T00:00:03 | b    | us-east | 0.7   |\n\
+            | cpu              | 1970-01-01T00:00:04 | b    | us-east | 0.8   |\n\
+            +------------------+---------------------+------+---------+-------+",
+            resp
+        );
+    }
+
+    // Check for errors
+    {
+        let resp = client
+            .post(&url)
+            .json(&json!({
+                "db": "foo",
+                "q": "SELECT * FROM cpu WHERE host = $host",
+                "params": {
+                    "not_host": "a"
+                },
+                "format": "pretty",
+            }))
+            .send()
+            .await
+            .unwrap();
+        let status = resp.status();
+        let body = resp.text().await.unwrap();
+
+        // TODO - it would be nice if this was a 4xx error, because this is really
+        //   a user error; however, the underlying error that occurs when Logical
+        //   planning is DatafusionError::Internal, and is not so convenient to deal
+        //   with. This may get addressed in:
+        //
+        //   https://github.com/apache/arrow-datafusion/issues/9738
+        assert!(status.is_server_error());
+        assert_contains!(
+            body,
+            "Bind parameter '$host' was referenced in the InfluxQL \
+            statement but its value is undefined"
+        );
+    }
+}
+
+#[tokio::test]
+async fn api_v1_query() {
+    let server = TestServer::spawn().await;
+
+    server
+        .write_lp_to_db(
+            "foo",
+            "cpu,host=a usage=0.9 1\n\
+            cpu,host=a usage=0.89 2\n\
+            cpu,host=a usage=0.85 3\n\
+            mem,host=a usage=0.5 4\n\
+            mem,host=a usage=0.6 5\n\
+            mem,host=a usage=0.7 6",
+            Precision::Second,
+        )
+        .await
+        .unwrap();
+
+    struct TestCase<'a> {
+        database: Option<&'a str>,
+        epoch: Option<&'a str>,
+        query: &'a str,
+        expected: Value,
+    }
+
+    let test_cases = [
+        // Basic Query:
+        TestCase {
+            database: Some("foo"),
+            epoch: None,
+            query: "SELECT time, host, usage FROM cpu",
+            expected: json!({
+              "results": [
+                {
+                  "series": [
+                    {
+                      "columns": [
+                        "time",
+                        "host",
+                        "usage"
+                      ],
+                      "name": "cpu",
+                      "values": [
+                        ["1970-01-01T00:00:01", "a", 0.9],
+                        ["1970-01-01T00:00:02", "a", 0.89],
+                        ["1970-01-01T00:00:03", "a", 0.85]
+                      ]
+                    }
+                  ],
+                  "statement_id": 0
+                }
+              ]
+            }),
+        },
+        // Basic Query with multiple measurements:
+        TestCase {
+            database: Some("foo"),
+            epoch: None,
+            query: "SELECT time, host, usage FROM cpu, mem",
+            expected: json!({
+              "results": [
+                {
+                  "series": [
+                    {
+                      "columns": [
+                        "time",
+                        "host",
+                        "usage"
+                      ],
+                      "name": "mem",
+                      "values": [
+                        ["1970-01-01T00:00:04", "a", 0.5],
+                        ["1970-01-01T00:00:05", "a", 0.6],
+                        ["1970-01-01T00:00:06", "a", 0.7]
+                      ]
+                    },
+                    {
+                      "columns": [
+                        "time",
+                        "host",
+                        "usage"
+                      ],
+                      "name": "cpu",
+                      "values": [
+                        ["1970-01-01T00:00:01", "a", 0.9],
+                        ["1970-01-01T00:00:02", "a", 0.89],
+                        ["1970-01-01T00:00:03", "a", 0.85]
+                      ]
+                    }
+                  ],
+                  "statement_id": 0
+                }
+              ]
+            }),
+        },
+        // Basic Query with db in query string:
+        TestCase {
+            database: None,
+            epoch: None,
+            query: "SELECT time, host, usage FROM foo.autogen.cpu",
+            expected: json!({
+              "results": [
+                {
+                  "series": [
+                    {
+                      "columns": [
+                        "time",
+                        "host",
+                        "usage"
+                      ],
+                      "name": "cpu",
+                      "values": [
+                        ["1970-01-01T00:00:01", "a", 0.9],
+                        ["1970-01-01T00:00:02", "a", 0.89],
+                        ["1970-01-01T00:00:03", "a", 0.85]
+                      ]
+                    }
+                  ],
+                  "statement_id": 0
+                }
+              ]
+            }),
+        },
+        // Basic Query epoch parameter set:
+        TestCase {
+            database: Some("foo"),
+            epoch: Some("s"),
+            query: "SELECT time, host, usage FROM cpu",
+            expected: json!({
+              "results": [
+                {
+                  "series": [
+                    {
+                      "columns": [
+                        "time",
+                        "host",
+                        "usage"
+                      ],
+                      "name": "cpu",
+                      "values": [
+                        [1, "a", 0.9],
+                        [2, "a", 0.89],
+                        [3, "a", 0.85]
+                      ]
+                    }
+                  ],
+                  "statement_id": 0
+                }
+              ]
+            }),
+        },
+    ];
+
+    for t in test_cases {
+        let mut params = vec![("q", t.query)];
+        if let Some(db) = t.database {
+            params.push(("db", db));
+        }
+        if let Some(epoch) = t.epoch {
+            params.push(("epoch", epoch));
+        }
+        let resp = server
+            .api_v1_query(&params)
+            .await
+            .json::<Value>()
+            .await
+            .unwrap();
+        println!("\n{q}", q = t.query);
+        println!("{resp:#}");
+        assert_eq!(t.expected, resp, "query failed: {q}", q = t.query);
+    }
+}
+
+#[tokio::test]
+async fn api_v1_query_chunked() {
+    let server = TestServer::spawn().await;
+
+    server
+        .write_lp_to_db(
+            "foo",
+            "cpu,host=a usage=0.9 1\n\
+            cpu,host=a usage=0.89 2\n\
+            cpu,host=a usage=0.85 3\n\
+            mem,host=a usage=0.5 4\n\
+            mem,host=a usage=0.6 5\n\
+            mem,host=a usage=0.7 6",
+            Precision::Second,
+        )
+        .await
+        .unwrap();
+
+    struct TestCase<'a> {
+        chunk_size: Option<&'a str>,
+        query: &'a str,
+        expected: Vec<Value>,
+    }
+
+    let test_cases = [
+        // Basic Query with default chunking:
+        TestCase {
+            chunk_size: None,
+            query: "SELECT time, host, usage FROM cpu",
+            expected: vec![json!({
+              "results": [
+                {
+                  "series": [
+                    {
+                      "name": "cpu",
+                      "columns": ["time","host","usage"],
+                      "values": [
+                        [1, "a", 0.9],
+                        [2, "a", 0.89],
+                        [3, "a", 0.85]
+                      ]
+                    }
+                  ],
+                  "statement_id": 0
+                }
+              ]
+            })],
+        },
+        // Basic Query with chunk size:
+        TestCase {
+            chunk_size: Some("2"),
+            query: "SELECT time, host, usage FROM cpu",
+            expected: vec![
+                json!({
+                  "results": [
+                    {
+                      "series": [
+                        {
+                          "name": "cpu",
+                          "columns": ["time","host","usage"],
+                          "values": [
+                            [1, "a", 0.9],
+                            [2, "a", 0.89],
+                          ]
+                        }
+                      ],
+                      "statement_id": 0
+                    }
+                  ]
+                }),
+                json!({
+                  "results": [
+                    {
+                      "series": [
+                        {
+                          "name": "cpu",
+                          "columns": ["time","host","usage"],
+                          "values": [
+                            [3, "a", 0.85]
+                          ]
+                        }
+                      ],
+                      "statement_id": 0
+                    }
+                  ]
+                }),
+            ],
+        },
+        // Query with multiple measurements and default chunking:
+        TestCase {
+            chunk_size: None,
+            query: "SELECT time, host, usage FROM cpu, mem",
+            expected: vec![
+                json!({
+                  "results": [
+                    {
+                      "series": [
+                        {
+                          "name": "cpu",
+                          "columns": ["time","host","usage"],
+                          "values": [
+                            [1, "a", 0.9],
+                            [2, "a", 0.89],
+                            [3, "a", 0.85]
+                          ]
+                        }
+                      ],
+                      "statement_id": 0
+                    }
+                  ]
+                }),
+                json!({
+                  "results": [
+                    {
+                      "series": [
+                        {
+                          "name": "mem",
+                          "columns": ["time","host","usage"],
+                          "values": [
+                            [4, "a", 0.5],
+                            [5, "a", 0.6],
+                            [6, "a", 0.7]
+                          ]
+                        }
+                      ],
+                      "statement_id": 0
+                    }
+                  ]
+                }),
+            ],
+        },
+        // Query with multiple measurements and chunk_size specified:
+        TestCase {
+            chunk_size: Some("2"),
+            query: "SELECT time, host, usage FROM cpu, mem",
+            expected: vec![
+                json!({
+                  "results": [
+                    {
+                      "series": [
+                        {
+                          "name": "cpu",
+                          "columns": ["time","host","usage"],
+                          "values": [
+                            [1, "a", 0.9],
+                            [2, "a", 0.89],
+                          ]
+                        }
+                      ],
+                      "statement_id": 0
+                    }
+                  ]
+                }),
+                json!({
+                  "results": [
+                    {
+                      "series": [
+                        {
+                          "name": "cpu",
+                          "columns": ["time","host","usage"],
+                          "values": [
+                            [3, "a", 0.85]
+                          ]
+                        }
+                      ],
+                      "statement_id": 0
+                    }
+                  ]
+                }),
+                json!({
+                  "results": [
+                    {
+                      "series": [
+                        {
+                          "name": "mem",
+                          "columns": ["time","host","usage"],
+                          "values": [
+                            [4, "a", 0.5],
+                            [5, "a", 0.6],
+                          ]
+                        }
+                      ],
+                      "statement_id": 0
+                    }
+                  ]
+                }),
+                json!({
+                  "results": [
+                    {
+                      "series": [
+                        {
+                          "name": "mem",
+                          "columns": ["time","host","usage"],
+                          "values": [
+                            [6, "a", 0.7]
+                          ]
+                        }
+                      ],
+                      "statement_id": 0
+                    }
+                  ]
+                }),
+            ],
+        },
+    ];
+
+    for t in test_cases {
+        let mut params = vec![
+            ("db", "foo"),
+            ("q", t.query),
+            ("epoch", "s"),
+            ("chunked", "true"),
+        ];
+        if let Some(chunk_size) = t.chunk_size {
+            params.push(("chunk_size", chunk_size));
+        }
+        let stream = server.api_v1_query(&params).await.bytes_stream();
+        let values = stream
+            .map(|chunk| {
+                println!("{chunk:?}");
+                serde_json::from_slice(chunk.unwrap().as_ref()).unwrap()
+            })
+            .collect::<Vec<Value>>()
+            .await;
+        println!("\n{q}", q = t.query);
+        assert_eq!(t.expected, values, "query failed: {q}", q = t.query);
+    }
+}
diff --git a/influxdb3/tests/server/write.rs b/influxdb3/tests/server/write.rs
new file mode 100644
index 00000000000..161564ae286
--- /dev/null
+++ b/influxdb3/tests/server/write.rs
@@ -0,0 +1,274 @@
+use hyper::StatusCode;
+use pretty_assertions::assert_eq;
+
+use crate::TestServer;
+
+#[tokio::test]
+async fn api_v1_write_request_parsing() {
+    let server = TestServer::spawn().await;
+    let client = reqwest::Client::new();
+    let write_url = format!("{base}/write", base = server.client_addr());
+    let write_body = "cpu,host=a usage=0.5";
+
+    #[derive(Debug)]
+    struct TestCase {
+        db: Option<&'static str>,
+        precision: Option<&'static str>,
+        rp: Option<&'static str>,
+        expected: StatusCode,
+    }
+
+    let test_cases = [
+        TestCase {
+            db: None,
+            precision: None,
+            rp: None,
+            expected: StatusCode::BAD_REQUEST,
+        },
+        TestCase {
+            db: Some("foo"),
+            precision: None,
+            rp: None,
+            expected: StatusCode::OK,
+        },
+        TestCase {
+            db: Some("foo"),
+            precision: Some("s"),
+            rp: None,
+            expected: StatusCode::OK,
+        },
+        TestCase {
+            db: Some("foo"),
+            precision: Some("ms"),
+            rp: None,
+            expected: StatusCode::OK,
+        },
+        TestCase {
+            db: Some("foo"),
+            precision: Some("us"),
+            rp: None,
+            expected: StatusCode::OK,
+        },
+        TestCase {
+            db: Some("foo"),
+            precision: Some("ns"),
+            rp: None,
+            expected: StatusCode::OK,
+        },
+        TestCase {
+            db: Some("foo"),
+            precision: Some("invalid"),
+            rp: None,
+            expected: StatusCode::BAD_REQUEST,
+        },
+        TestCase {
+            db: Some("foo"),
+            precision: None,
+            rp: Some("bar"),
+            expected: StatusCode::OK,
+        },
+        TestCase {
+            db: Some("foo"),
+            precision: None,
+            rp: Some("default"),
+            expected: StatusCode::OK,
+        },
+        TestCase {
+            db: Some("foo"),
+            precision: None,
+            rp: Some("autogen"),
+            expected: StatusCode::OK,
+        },
+    ];
+
+    for t in test_cases {
+        println!("Test Case: {t:?}");
+        let mut params = vec![];
+        if let Some(db) = t.db {
+            params.push(("db", db));
+        }
+        if let Some(rp) = t.rp {
+            params.push(("rp", rp));
+        }
+        if let Some(precision) = t.precision {
+            params.push(("precision", precision));
+        }
+        let resp = client
+            .post(&write_url)
+            .query(&params)
+            .body(write_body)
+            .send()
+            .await
+            .expect("send /write request");
+        let status = resp.status();
+        let body = resp.text().await.expect("response body as text");
+        println!("Response [{status}]:\n{body}");
+        assert_eq!(t.expected, status);
+    }
+}
+
+#[tokio::test]
+async fn api_v1_write_round_trip() {
+    let server = TestServer::spawn().await;
+    let client = reqwest::Client::new();
+    let write_url = format!("{base}/write", base = server.client_addr());
+
+    client
+        .post(write_url)
+        .query(&[("db", "foo")])
+        .body(
+            "cpu,host=a usage=0.5 1
+            cpu,host=a usage=0.6 2
+            cpu,host=a usage=0.7 3",
+        )
+        .send()
+        .await
+        .expect("send /write request");
+
+    let resp = server
+        .api_v3_query_influxql(&[
+            ("q", "SELECT time, host, usage FROM foo.autogen.cpu"),
+            ("format", "pretty"),
+        ])
+        .await
+        .text()
+        .await
+        .unwrap();
+
+    assert_eq!(
+        resp,
+        "+------------------+-------------------------------+------+-------+\n\
+        | iox::measurement | time                          | host | usage |\n\
+        +------------------+-------------------------------+------+-------+\n\
+        | cpu              | 1970-01-01T00:00:00.000000001 | a    | 0.5   |\n\
+        | cpu              | 1970-01-01T00:00:00.000000002 | a    | 0.6   |\n\
+        | cpu              | 1970-01-01T00:00:00.000000003 | a    | 0.7   |\n\
+        +------------------+-------------------------------+------+-------+"
+    );
+}
+
+#[tokio::test]
+async fn api_v2_write_request_parsing() {
+    let server = TestServer::spawn().await;
+    let client = reqwest::Client::new();
+    let write_url = format!("{base}/api/v2/write", base = server.client_addr());
+    let write_body = "cpu,host=a usage=0.5";
+
+    #[derive(Debug)]
+    struct TestCase {
+        org: Option<&'static str>,
+        bucket: Option<&'static str>,
+        precision: Option<&'static str>,
+        expected: StatusCode,
+    }
+
+    let test_cases = [
+        TestCase {
+            org: None,
+            bucket: None,
+            precision: None,
+            expected: StatusCode::BAD_REQUEST,
+        },
+        TestCase {
+            org: None,
+            bucket: Some("foo"),
+            precision: None,
+            expected: StatusCode::OK,
+        },
+        TestCase {
+            org: Some("bar"),
+            bucket: Some("foo"),
+            precision: None,
+            expected: StatusCode::OK,
+        },
+        TestCase {
+            org: None,
+            bucket: Some("foo"),
+            precision: Some("s"),
+            expected: StatusCode::OK,
+        },
+        TestCase {
+            org: None,
+            bucket: Some("foo"),
+            precision: Some("ms"),
+            expected: StatusCode::OK,
+        },
+        TestCase {
+            org: None,
+            bucket: Some("foo"),
+            precision: Some("us"),
+            expected: StatusCode::OK,
+        },
+        TestCase {
+            org: None,
+            bucket: Some("foo"),
+            precision: Some("ns"),
+            expected: StatusCode::OK,
+        },
+    ];
+
+    for t in test_cases {
+        println!("Test Case: {t:?}");
+        let mut params = vec![];
+        if let Some(bucket) = t.bucket {
+            params.push(("bucket", bucket));
+        }
+        if let Some(org) = t.org {
+            params.push(("org", org));
+        }
+        if let Some(precision) = t.precision {
+            params.push(("precision", precision));
+        }
+        let resp = client
+            .post(&write_url)
+            .query(&params)
+            .body(write_body)
+            .send()
+            .await
+            .expect("send /write request");
+        let status = resp.status();
+        let body = resp.text().await.expect("response body as text");
+        println!("Response [{status}]:\n{body}");
+        assert_eq!(t.expected, status);
+    }
+}
+
+#[tokio::test]
+async fn api_v2_write_round_trip() {
+    let server = TestServer::spawn().await;
+    let client = reqwest::Client::new();
+    let write_url = format!("{base}/api/v2/write", base = server.client_addr());
+
+    client
+        .post(write_url)
+        .query(&[("bucket", "foo")])
+        .body(
+            "cpu,host=a usage=0.5 1
+            cpu,host=a usage=0.6 2
+            cpu,host=a usage=0.7 3",
+        )
+        .send()
+        .await
+        .expect("send /write request");
+
+    let resp = server
+        .api_v3_query_influxql(&[
+            ("q", "SELECT time, host, usage FROM foo.autogen.cpu"),
+            ("format", "pretty"),
+        ])
+        .await
+        .text()
+        .await
+        .unwrap();
+
+    assert_eq!(
+        resp,
+        "+------------------+-------------------------------+------+-------+\n\
+        | iox::measurement | time                          | host | usage |\n\
+        +------------------+-------------------------------+------+-------+\n\
+        | cpu              | 1970-01-01T00:00:00.000000001 | a    | 0.5   |\n\
+        | cpu              | 1970-01-01T00:00:00.000000002 | a    | 0.6   |\n\
+        | cpu              | 1970-01-01T00:00:00.000000003 | a    | 0.7   |\n\
+        +------------------+-------------------------------+------+-------+"
+    );
+}
diff --git a/influxdb3_client/Cargo.toml b/influxdb3_client/Cargo.toml
new file mode 100644
index 00000000000..d3dd6211cdb
--- /dev/null
+++ b/influxdb3_client/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "influxdb3_client"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+# core dependencies
+iox_query_params.workspace = true
+
+# crates.io dependencies
+bytes.workspace = true
+reqwest.workspace = true
+secrecy.workspace = true
+serde.workspace = true
+thiserror.workspace = true
+url.workspace = true
+
+[dev-dependencies]
+# crates.io dependencies
+mockito.workspace = true
+serde_json.workspace = true
+tokio.workspace = true
+
+[lints]
+workspace = true
diff --git a/influxdb3_client/src/lib.rs b/influxdb3_client/src/lib.rs
new file mode 100644
index 00000000000..eb10ceb9052
--- /dev/null
+++ b/influxdb3_client/src/lib.rs
@@ -0,0 +1,787 @@
+use std::{collections::HashMap, fmt::Display, string::FromUtf8Error};
+
+use bytes::Bytes;
+use iox_query_params::StatementParam;
+use reqwest::{Body, IntoUrl, StatusCode};
+use secrecy::{ExposeSecret, Secret};
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+/// Primary error type for the [`Client`]
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("base URL error: {0}")]
+    BaseUrl(#[source] reqwest::Error),
+
+    #[error("request URL error: {0}")]
+    RequestUrl(#[from] url::ParseError),
+
+    #[error("failed to send /api/v3/write_lp request: {0}")]
+    WriteLpSend(#[source] reqwest::Error),
+
+    #[error("failed to send /ping request: {0}")]
+    PingSend(#[source] reqwest::Error),
+
+    #[error("failed to read the API response bytes: {0}")]
+    Bytes(#[source] reqwest::Error),
+
+    #[error("failed to send /api/v3/query_{kind} request: {source}")]
+    QuerySend {
+        kind: QueryKind,
+        #[source]
+        source: reqwest::Error,
+    },
+
+    #[error(
+        "provided parameter ('{name}') could not be converted \
+        to a statment parameter"
+    )]
+    ConvertQueryParam {
+        name: String,
+        #[source]
+        source: iox_query_params::Error,
+    },
+
+    #[error("invalid UTF8 in response: {0}")]
+    InvalidUtf8(#[from] FromUtf8Error),
+
+    #[error("failed to parse JSON response: {0}")]
+    Json(#[source] reqwest::Error),
+
+    #[error("failed to parse plaintext response: {0}")]
+    Text(#[source] reqwest::Error),
+
+    #[error("server responded with error [{code}]: {message}")]
+    ApiError { code: StatusCode, message: String },
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// The InfluxDB 3.0 Client
+///
+/// For programmatic access to the HTTP API of InfluxDB 3.0
+#[derive(Debug, Clone)]
+pub struct Client {
+    /// The base URL for making requests to a running InfluxDB 3.0 server
+    base_url: Url,
+    /// The `Bearer` token to use for authenticating on each request to the server
+    auth_token: Option<Secret<String>>,
+    /// A [`reqwest::Client`] for handling HTTP requests
+    http_client: reqwest::Client,
+}
+
+impl Client {
+    /// Create a new [`Client`]
+    pub fn new<U: IntoUrl>(base_url: U) -> Result<Self> {
+        Ok(Self {
+            base_url: base_url.into_url().map_err(Error::BaseUrl)?,
+            auth_token: None,
+            http_client: reqwest::Client::new(),
+        })
+    }
+
+    /// Set the `Bearer` token that will be sent with each request to the server
+    ///
+    /// # Example
+    /// ```
+    /// # use influxdb3_client::Client;
+    /// # use influxdb3_client::Precision;
+    /// # #[tokio::main]
+    /// # async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    /// let token = "secret-token-string";
+    /// let client = Client::new("http://localhost:8181")?
+    ///     .with_auth_token(token);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn with_auth_token<S: Into<String>>(mut self, auth_token: S) -> Self {
+        self.auth_token = Some(Secret::new(auth_token.into()));
+        self
+    }
+
+    /// Compose a request to the `/api/v3/write_lp` API
+    ///
+    /// # Example
+    /// ```no_run
+    /// # use influxdb3_client::Client;
+    /// # use influxdb3_client::Precision;
+    /// # #[tokio::main]
+    /// # async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    /// let client = Client::new("http://localhost:8181")?;
+    /// client
+    ///     .api_v3_write_lp("db_name")
+    ///     .precision(Precision::Millisecond)
+    ///     .accept_partial(true)
+    ///     .body("cpu,host=s1 usage=0.5")
+    ///     .send()
+    ///     .await
+    ///     .expect("send write_lp request");
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn api_v3_write_lp<S: Into<String>>(&self, db: S) -> WriteRequestBuilder<'_, NoBody> {
+        WriteRequestBuilder {
+            client: self,
+            db: db.into(),
+            precision: None,
+            accept_partial: None,
+            body: NoBody,
+        }
+    }
+
+    /// Compose a request to the `/api/v3/query_sql` API
+    ///
+    /// # Example
+    /// ```no_run
+    /// # use influxdb3_client::Client;
+    /// # #[tokio::main]
+    /// # async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    /// let client = Client::new("http://localhost:8181")?;
+    /// let response_bytes = client
+    ///     .api_v3_query_sql("db_name", "SELECT * FROM foo")
+    ///     .send()
+    ///     .await
+    ///     .expect("send query_sql request");
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn api_v3_query_sql<D: Into<String>, Q: Into<String>>(
+        &self,
+        db: D,
+        query: Q,
+    ) -> QueryRequestBuilder<'_> {
+        QueryRequestBuilder {
+            client: self,
+            kind: QueryKind::Sql,
+            db: db.into(),
+            query: query.into(),
+            format: None,
+            params: None,
+        }
+    }
+
+    /// Compose a request to the `/api/v3/query_influxql` API
+    ///
+    /// # Example
+    /// ```no_run
+    /// # use influxdb3_client::Client;
+    /// # #[tokio::main]
+    /// # async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    /// let client = Client::new("http://localhost:8181")?;
+    /// let response_bytes = client
+    ///     .api_v3_query_influxql("db_name", "SELECT * FROM foo")
+    ///     .send()
+    ///     .await
+    ///     .expect("send query_influxql request");
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn api_v3_query_influxql<D: Into<String>, Q: Into<String>>(
+        &self,
+        db: D,
+        query: Q,
+    ) -> QueryRequestBuilder<'_> {
+        QueryRequestBuilder {
+            client: self,
+            kind: QueryKind::InfluxQl,
+            db: db.into(),
+            query: query.into(),
+            format: None,
+            params: None,
+        }
+    }
+
+    /// Send a `/ping` request to the target `influxdb3` server to check its
+    /// status and gather `version` and `revision` information
+    pub async fn ping(&self) -> Result<PingResponse> {
+        let url = self.base_url.join("/ping")?;
+        let mut req = self.http_client.get(url);
+        if let Some(t) = &self.auth_token {
+            req = req.bearer_auth(t.expose_secret());
+        }
+        let resp = req.send().await.map_err(Error::PingSend)?;
+        if resp.status().is_success() {
+            resp.json().await.map_err(Error::Json)
+        } else {
+            Err(Error::ApiError {
+                code: resp.status(),
+                message: resp.text().await.map_err(Error::Text)?,
+            })
+        }
+    }
+}
+
+/// The response of the `/ping` API on `influxdb3`
+#[derive(Debug, Serialize, Deserialize)]
+pub struct PingResponse {
+    version: String,
+    revision: String,
+}
+
+impl PingResponse {
+    /// Get the `version` from the response
+    pub fn version(&self) -> &str {
+        &self.version
+    }
+
+    /// Get the `revision` from the response
+    pub fn revision(&self) -> &str {
+        &self.revision
+    }
+}
+
+/// The URL parameters of the request to the `/api/v3/write_lp` API
+// TODO - this should re-use a type defined in the server code, or a separate crate,
+//        central to both.
+#[derive(Debug, Serialize)]
+struct WriteParams<'a> {
+    db: &'a str,
+    precision: Option<Precision>,
+    accept_partial: Option<bool>,
+}
+
+impl<'a, B> From<&'a WriteRequestBuilder<'a, B>> for WriteParams<'a> {
+    fn from(builder: &'a WriteRequestBuilder<'a, B>) -> Self {
+        Self {
+            db: &builder.db,
+            precision: builder.precision,
+            accept_partial: builder.accept_partial,
+        }
+    }
+}
+
+/// Time series precision
+// TODO - this should re-use a type defined in the server code, or a separate crate,
+//        central to both.
+#[derive(Debug, Copy, Clone, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Precision {
+    Second,
+    Millisecond,
+    Microsecond,
+    Nanosecond,
+}
+
+/// Builder type for composing a request to `/api/v3/write_lp`
+///
+/// Produced by [`Client::api_v3_write_lp`]
+#[derive(Debug)]
+pub struct WriteRequestBuilder<'c, B> {
+    client: &'c Client,
+    db: String,
+    precision: Option<Precision>,
+    accept_partial: Option<bool>,
+    body: B,
+}
+
+impl<'c, B> WriteRequestBuilder<'c, B> {
+    /// Set the precision
+    pub fn precision(mut self, set_to: Precision) -> Self {
+        self.precision = Some(set_to);
+        self
+    }
+
+    /// Set the `accept_partial` parameter
+    pub fn accept_partial(mut self, set_to: bool) -> Self {
+        self.accept_partial = Some(set_to);
+        self
+    }
+}
+
+impl<'c> WriteRequestBuilder<'c, NoBody> {
+    /// Set the body of the request to the `/api/v3/write_lp` API
+    ///
+    /// This essentially wraps `reqwest`'s [`body`][reqwest::RequestBuilder::body]
+    /// method, and puts the responsibility on the caller for now.
+    pub fn body<T: Into<Body>>(self, body: T) -> WriteRequestBuilder<'c, Body> {
+        WriteRequestBuilder {
+            client: self.client,
+            db: self.db,
+            precision: self.precision,
+            accept_partial: self.accept_partial,
+            body: body.into(),
+        }
+    }
+}
+
+impl<'c> WriteRequestBuilder<'c, Body> {
+    /// Send the request to the server
+    pub async fn send(self) -> Result<()> {
+        let url = self.client.base_url.join("/api/v3/write_lp")?;
+        let params = WriteParams::from(&self);
+        let mut req = self.client.http_client.post(url).query(&params);
+        if let Some(token) = &self.client.auth_token {
+            req = req.bearer_auth(token.expose_secret());
+        }
+        let resp = req
+            .body(self.body)
+            .send()
+            .await
+            .map_err(Error::WriteLpSend)?;
+        let status = resp.status();
+        let content = resp.bytes().await.map_err(Error::Bytes)?;
+        match status {
+            // TODO - handle the OK response content, return to caller, etc.
+            StatusCode::OK => Ok(()),
+            code => Err(Error::ApiError {
+                code,
+                message: String::from_utf8(content.to_vec())?,
+            }),
+        }
+    }
+}
+
+#[doc(hidden)]
+/// Typestate type for [`WriteRequestBuilder`]
+#[derive(Debug, Copy, Clone)]
+pub struct NoBody;
+
+/// Used to compose a request to the `/api/v3/query_sql` API
+///
+/// Produced by [`Client::api_v3_query_sql`] method.
+#[derive(Debug)]
+pub struct QueryRequestBuilder<'c> {
+    client: &'c Client,
+    kind: QueryKind,
+    db: String,
+    query: String,
+    format: Option<Format>,
+    params: Option<HashMap<String, StatementParam>>,
+}
+
+// TODO - for now the send method just returns the bytes from the response.
+//   It may be nicer to have the format parameter dictate how we return from
+//   send, e.g., using types more specific to the format selected.
+impl<'c> QueryRequestBuilder<'c> {
+    /// Specify the format, `json`, `csv`, `pretty`, or `parquet`
+    pub fn format(mut self, format: Format) -> Self {
+        self.format = Some(format);
+        self
+    }
+
+    /// Set a query parameter value with the given `name`
+    ///
+    /// # Example
+    /// ```no_run
+    /// # use influxdb3_client::Client;
+    /// # #[tokio::main]
+    /// # async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    /// let client = Client::new("http://localhost:8181")?;
+    /// let response_bytes = client
+    ///     .api_v3_query_sql("db_name", "SELECT * FROM foo WHERE bar = $bar AND baz > $baz")
+    ///     .with_param("bar", "bop")
+    ///     .with_param("baz", 0.5)
+    ///     .send()
+    ///     .await
+    ///     .expect("send query_sql request");
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn with_param<S: Into<String>, P: Into<StatementParam>>(
+        mut self,
+        name: S,
+        param: P,
+    ) -> Self {
+        self.params
+            .get_or_insert_with(Default::default)
+            .insert(name.into(), param.into());
+        self
+    }
+
+    /// Set a query parameters from the given collection of pairs
+    ///
+    /// # Example
+    /// ```no_run
+    /// # use influxdb3_client::Client;
+    /// # #[tokio::main]
+    /// # async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    /// use serde_json::json;
+    /// use std::collections::HashMap;
+    ///
+    /// let client = Client::new("http://localhost:8181")?;
+    /// let response_bytes = client
+    ///     .api_v3_query_sql("db_name", "SELECT * FROM foo WHERE bar = $bar AND foo > $fooz")
+    ///     .with_params_from([
+    ///         ("bar", json!(false)),
+    ///         ("foo", json!(10)),
+    ///     ])?
+    ///     .send()
+    ///     .await?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn with_params_from<S, P, C>(mut self, params: C) -> Result<Self>
+    where
+        S: Into<String>,
+        P: TryInto<StatementParam, Error = iox_query_params::Error>,
+        C: IntoIterator<Item = (S, P)>,
+    {
+        for (name, param) in params.into_iter() {
+            let name = name.into();
+            let param = param
+                .try_into()
+                .map_err(|source| Error::ConvertQueryParam {
+                    name: name.clone(),
+                    source,
+                })?;
+
+            self.params
+                .get_or_insert_with(Default::default)
+                .insert(name, param);
+        }
+        Ok(self)
+    }
+
+    /// Try to set a query parameter value with the given `name`
+    ///
+    /// # Example
+    /// ```no_run
+    /// # use influxdb3_client::Client;
+    /// # #[tokio::main]
+    /// # async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    /// use serde_json::json;
+    ///
+    /// let client = Client::new("http://localhost:8181")?;
+    /// let response_bytes = client
+    ///     .api_v3_query_sql("db_name", "SELECT * FROM foo WHERE bar = $bar AND baz > $baz")
+    ///     .with_try_param("bar", json!("baz"))?
+    ///     .send()
+    ///     .await?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn with_try_param<S, P>(mut self, name: S, param: P) -> Result<Self>
+    where
+        S: Into<String>,
+        P: TryInto<StatementParam, Error = iox_query_params::Error>,
+    {
+        let name = name.into();
+        let param = param
+            .try_into()
+            .map_err(|source| Error::ConvertQueryParam {
+                name: name.clone(),
+                source,
+            })?;
+        self.params
+            .get_or_insert_with(Default::default)
+            .insert(name, param);
+        Ok(self)
+    }
+
+    /// Send the request to `/api/v3/query_sql` or `/api/v3/query_influxql`
+    pub async fn send(self) -> Result<Bytes> {
+        let url = match self.kind {
+            QueryKind::Sql => self.client.base_url.join("/api/v3/query_sql")?,
+            QueryKind::InfluxQl => self.client.base_url.join("/api/v3/query_influxql")?,
+        };
+        let params = QueryParams::from(&self);
+        let mut req = self.client.http_client.post(url).json(&params);
+        if let Some(token) = &self.client.auth_token {
+            req = req.bearer_auth(token.expose_secret());
+        }
+        let resp = req.send().await.map_err(|source| Error::QuerySend {
+            kind: self.kind,
+            source,
+        })?;
+        let status = resp.status();
+        let content = resp.bytes().await.map_err(Error::Bytes)?;
+
+        match status {
+            StatusCode::OK => Ok(content),
+            code => Err(Error::ApiError {
+                code,
+                message: String::from_utf8(content.to_vec()).map_err(Error::InvalidUtf8)?,
+            }),
+        }
+    }
+}
+
+/// Query parameters for the `/api/v3/query_sql` API
+#[derive(Debug, Serialize)]
+pub struct QueryParams<'a> {
+    db: &'a str,
+    #[serde(rename = "q")]
+    query: &'a str,
+    format: Option<Format>,
+    params: Option<&'a HashMap<String, StatementParam>>,
+}
+
+impl<'a> From<&'a QueryRequestBuilder<'a>> for QueryParams<'a> {
+    fn from(builder: &'a QueryRequestBuilder<'a>) -> Self {
+        Self {
+            db: &builder.db,
+            query: &builder.query,
+            format: builder.format,
+            params: builder.params.as_ref(),
+        }
+    }
+}
+
+/// The type of query, SQL or InfluxQL
+#[derive(Debug, Copy, Clone)]
+pub enum QueryKind {
+    Sql,
+    InfluxQl,
+}
+
+impl Display for QueryKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            QueryKind::Sql => write!(f, "sql"),
+            QueryKind::InfluxQl => write!(f, "influxql"),
+        }
+    }
+}
+
+/// Output format to request from the server in the `/api/v3/query_sql` API
+#[derive(Debug, Serialize, Copy, Clone)]
+#[serde(rename_all = "snake_case")]
+pub enum Format {
+    Json,
+    Csv,
+    Parquet,
+    Pretty,
+}
+
+#[cfg(test)]
+mod tests {
+    use mockito::{Matcher, Server};
+    use serde_json::json;
+
+    use crate::{Client, Format, Precision};
+
+    #[tokio::test]
+    async fn api_v3_write_lp() {
+        let token = "super-secret-token";
+        let db = "stats";
+        let body = "\
+            cpu,host=s1 usage=0.5
+            cpu,host=s1,region=us-west usage=0.7";
+
+        let mut mock_server = Server::new_async().await;
+        let mock = mock_server
+            .mock("POST", "/api/v3/write_lp")
+            .match_header("Authorization", format!("Bearer {token}").as_str())
+            .match_query(Matcher::AllOf(vec![
+                Matcher::UrlEncoded("precision".into(), "millisecond".into()),
+                Matcher::UrlEncoded("db".into(), db.into()),
+                Matcher::UrlEncoded("accept_partial".into(), "true".into()),
+            ]))
+            .match_body(body)
+            .create_async()
+            .await;
+
+        let client = Client::new(mock_server.url())
+            .expect("create client")
+            .with_auth_token(token);
+
+        client
+            .api_v3_write_lp(db)
+            .precision(Precision::Millisecond)
+            .accept_partial(true)
+            .body(body)
+            .send()
+            .await
+            .expect("send write_lp request");
+
+        mock.assert_async().await;
+    }
+
+    #[tokio::test]
+    async fn api_v3_query_sql() {
+        let token = "super-secret-token";
+        let db = "stats";
+        let query = "SELECT * FROM foo";
+        let body = r#"[{"host": "foo", "time": "1990-07-23T06:00:00:000", "val": 1}]"#;
+
+        let mut mock_server = Server::new_async().await;
+        let mock = mock_server
+            .mock("POST", "/api/v3/query_sql")
+            .match_header("Authorization", format!("Bearer {token}").as_str())
+            .match_body(Matcher::Json(serde_json::json!({
+                "db": db,
+                "q": query,
+                "format": "json",
+                "params": null,
+            })))
+            .with_status(200)
+            // TODO - could add content-type header but that may be too brittle
+            //        at the moment
+            //      - this will be JSON Lines at some point
+            .with_body(body)
+            .create_async()
+            .await;
+
+        let client = Client::new(mock_server.url())
+            .expect("create client")
+            .with_auth_token(token);
+
+        let r = client
+            .api_v3_query_sql(db, query)
+            .format(Format::Json)
+            .send()
+            .await
+            .expect("send request to server");
+
+        assert_eq!(&r, body);
+
+        mock.assert_async().await;
+    }
+
+    #[tokio::test]
+    async fn api_v3_query_sql_params() {
+        let db = "stats";
+        let query = "SELECT * FROM foo WHERE bar = $bar";
+        let body = r#"[{"host": "foo", "time": "1990-07-23T06:00:00:000", "val": 1}]"#;
+
+        let mut mock_server = Server::new_async().await;
+        let mock = mock_server
+            .mock("POST", "/api/v3/query_sql")
+            .match_body(Matcher::Json(serde_json::json!({
+                "db": db,
+                "q": query,
+                "params": {
+                    "bar": "baz",
+                    "baz": false,
+                },
+                "format": null
+            })))
+            .with_status(200)
+            .with_body(body)
+            .create_async()
+            .await;
+
+        let client = Client::new(mock_server.url()).expect("create client");
+
+        let r = client
+            .api_v3_query_sql(db, query)
+            .with_param("bar", "baz")
+            .with_param("baz", false)
+            .send()
+            .await;
+
+        mock.assert_async().await;
+
+        r.expect("sent request successfully");
+    }
+
+    #[tokio::test]
+    async fn api_v3_query_influxql() {
+        let db = "stats";
+        let query = "SELECT * FROM foo";
+        let body = r#"[{"host": "foo", "time": "1990-07-23T06:00:00:000", "val": 1}]"#;
+
+        let mut mock_server = Server::new_async().await;
+        let mock = mock_server
+            .mock("POST", "/api/v3/query_influxql")
+            .match_body(Matcher::Json(serde_json::json!({
+                "db": db,
+                "q": query,
+                "format": "json",
+                "params": null,
+            })))
+            .with_status(200)
+            .with_body(body)
+            .create_async()
+            .await;
+
+        let client = Client::new(mock_server.url()).expect("create client");
+
+        let r = client
+            .api_v3_query_influxql(db, query)
+            .format(Format::Json)
+            .send()
+            .await
+            .expect("send request to server");
+
+        assert_eq!(&r, body);
+
+        mock.assert_async().await;
+    }
+    #[tokio::test]
+    async fn api_v3_query_influxql_params() {
+        let db = "stats";
+        let query = "SELECT * FROM foo WHERE a = $a AND b < $b AND c > $c AND d = $d";
+        let body = r#"[{"host": "foo", "time": "1990-07-23T06:00:00:000", "val": 1}]"#;
+
+        let mut mock_server = Server::new_async().await;
+        let mock = mock_server
+            .mock("POST", "/api/v3/query_influxql")
+            .match_body(Matcher::Json(serde_json::json!({
+                "db": db,
+                "q": query,
+                "params": {
+                    "a": "bar",
+                    "b": 123,
+                    "c": 1.5,
+                    "d": false
+                },
+                "format": null
+            })))
+            .with_status(200)
+            .with_body(body)
+            .create_async()
+            .await;
+
+        let client = Client::new(mock_server.url()).expect("create client");
+
+        let mut builder = client.api_v3_query_influxql(db, query);
+
+        for (name, value) in [
+            ("a", json!("bar")),
+            ("b", json!(123)),
+            ("c", json!(1.5)),
+            ("d", json!(false)),
+        ] {
+            builder = builder.with_try_param(name, value).unwrap();
+        }
+        let r = builder.send().await;
+
+        mock.assert_async().await;
+
+        r.expect("sent request successfully");
+    }
+    #[tokio::test]
+    async fn api_v3_query_influxql_with_params_from() {
+        let db = "stats";
+        let query = "SELECT * FROM foo WHERE a = $a AND b < $b AND c > $c AND d = $d";
+        let body = r#"[{"host": "foo", "time": "1990-07-23T06:00:00:000", "val": 1}]"#;
+
+        let mut mock_server = Server::new_async().await;
+        let mock = mock_server
+            .mock("POST", "/api/v3/query_influxql")
+            .match_body(Matcher::Json(serde_json::json!({
+                "db": db,
+                "q": query,
+                "params": {
+                    "a": "bar",
+                    "b": 123,
+                    "c": 1.5,
+                    "d": false
+                },
+                "format": null
+            })))
+            .with_status(200)
+            .with_body(body)
+            .create_async()
+            .await;
+
+        let client = Client::new(mock_server.url()).expect("create client");
+
+        let r = client
+            .api_v3_query_influxql(db, query)
+            .with_params_from([
+                ("a", json!("bar")),
+                ("b", json!(123)),
+                ("c", json!(1.5)),
+                ("d", json!(false)),
+            ])
+            .unwrap()
+            .send()
+            .await;
+
+        mock.assert_async().await;
+
+        r.expect("sent request successfully");
+    }
+}
diff --git a/influxdb3_load_generator/Cargo.toml b/influxdb3_load_generator/Cargo.toml
new file mode 100644
index 00000000000..3f71d86b5bd
--- /dev/null
+++ b/influxdb3_load_generator/Cargo.toml
@@ -0,0 +1,36 @@
+[package]
+name = "influxdb3_load_generator"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+# Core Crates
+observability_deps.workspace = true
+trogging.workspace = true
+
+# Local Deps
+influxdb3_client = { path = "../influxdb3_client" }
+influxdb3_process = { path = "../influxdb3_process", default-features = false }
+
+# crates.io Dependencies
+anyhow.workspace = true
+bytes.workspace = true
+chrono.workspace = true
+clap.workspace = true
+csv.workspace = true
+dotenvy.workspace = true
+humantime.workspace = true
+parking_lot.workspace = true
+rand.workspace = true
+secrecy.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+sysinfo.workspace = true
+tokio.workspace = true
+thiserror.workspace = true
+url.workspace = true
+
+[lints]
+workspace = true
diff --git a/influxdb3_load_generator/analysis/README.md b/influxdb3_load_generator/analysis/README.md
new file mode 100644
index 00000000000..17cfd94a2f3
--- /dev/null
+++ b/influxdb3_load_generator/analysis/README.md
@@ -0,0 +1,21 @@
+# Load Generator Analysis
+
+This directory contains a lightweight Flask app to compare two runs of the load generator. The app is designed to be run locally and is not intended for production use.
+
+## Setup
+
+Make sure you have python and flask installed. You can install flask by running:
+
+```bash
+pip install flask
+```
+
+## Running the app
+
+To run the app, navigate to the `analysis` directory and run:
+
+```bash
+python app.py <path to results directory>
+```
+
+Then open your browser to http://127.0.0.1:5000/ to view the app.
\ No newline at end of file
diff --git a/influxdb3_load_generator/analysis/app.py b/influxdb3_load_generator/analysis/app.py
new file mode 100644
index 00000000000..ccd4455e3f0
--- /dev/null
+++ b/influxdb3_load_generator/analysis/app.py
@@ -0,0 +1,119 @@
+from flask import Flask, jsonify, render_template, request
+import os
+import csv
+import math
+import sys
+import re
+
+app = Flask(__name__)
+
+# Directory path (provided as a command-line argument)
+RESULTS_DIRECTORY = 'results/'
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+@app.route('/api/test-names')
+def get_test_names():
+    test_names = [name for name in os.listdir(RESULTS_DIRECTORY) if os.path.isdir(os.path.join(RESULTS_DIRECTORY, name))]
+    return jsonify(test_names)
+
+@app.route('/api/config-names')
+def get_config_names():
+    test_name = request.args.get('test_name')
+    test_path = os.path.join(RESULTS_DIRECTORY, test_name)
+    config_names = {}
+
+    for config_name in os.listdir(test_path):
+        config_path = os.path.join(test_path, config_name)
+        if os.path.isdir(config_path):
+            run_times = set()
+            for file_name in os.listdir(config_path):
+                match = re.search(r'_(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2})', file_name)
+                if match:
+                    run_time = match.group(1)
+                    run_times.add(run_time)
+            config_names[config_name] = sorted(run_times)
+
+    return jsonify(config_names)
+
+@app.route('/api/aggregated-data')
+def get_aggregated_data():
+    test_name = request.args.get('test_name')
+    config_name = request.args.get('config_name')
+    run_time = request.args.get('run_time')
+
+    config_path = os.path.join(RESULTS_DIRECTORY, test_name, config_name)
+    write_file = os.path.join(config_path, f'write_{run_time}.csv')
+    query_file = os.path.join(config_path, f'query_{run_time}.csv')
+    system_file = os.path.join(config_path, f'system_{run_time}.csv')
+
+    if not os.path.isfile(write_file) and not os.path.isfile(query_file) and not os.path.isfile(system_file):
+        return jsonify({'error': 'Files not found for the specified configuration and run time'})
+
+    write_data = None
+    if os.path.isfile(write_file):
+        write_data = aggregate_data(write_file, 'lines', 'latency_ms')
+    query_data = None
+    if os.path.isfile(query_file):
+        query_data = aggregate_data(query_file, 'rows', 'response_ms')
+    system_data = None
+    if os.path.isfile(system_file):
+        system_data = aggregate_system_data(system_file)
+    
+
+    aggregated_data = {
+        'config_name': config_name,
+        'run_time': run_time,
+        'write_data': write_data,
+        'query_data': query_data,
+        'system_data': system_data
+    }
+
+    return jsonify(aggregated_data)
+
+def aggregate_data(file_path, lines_field, latency_field):
+    aggregated_data = []
+
+    with open(file_path, 'r') as file:
+        reader = csv.DictReader(file)
+        data = list(reader)
+
+    for row in data:
+        test_time = int(row['test_time_ms'])
+        lines = int(row[lines_field])
+        latency = int(row[latency_field])
+
+        aggregated_data.append({
+            'test_time': test_time,
+            'lines': lines,
+            'latency': latency
+        })
+
+    return aggregated_data
+
+def aggregate_system_data(file_path):
+    aggregated_data = []
+
+    with open(file_path, 'r') as file:
+        reader = csv.DictReader(file)
+        data = list(reader)
+
+    for row in data:
+        aggregated_data.append({
+            'test_time': int(row['test_time_ms']),
+            'cpu_usage': float(row['cpu_usage']),
+            'memory_bytes': int(row['memory_bytes']) / 1024 / 1024
+        })
+
+    return aggregated_data
+
+if __name__ == '__main__':
+    if len(sys.argv) != 2:
+        print('Usage: python app.py <results_directory>')
+        print('results directory not provided, defaulting to "results/"')
+    else:
+        RESULTS_DIRECTORY = sys.argv[1]
+
+    app.run()
diff --git a/influxdb3_load_generator/analysis/templates/index.html b/influxdb3_load_generator/analysis/templates/index.html
new file mode 100644
index 00000000000..d2bfdce9b72
--- /dev/null
+++ b/influxdb3_load_generator/analysis/templates/index.html
@@ -0,0 +1,237 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Benchmark Results Comparison</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+        #graph-container {
+            display: grid;
+            grid-template-columns: repeat(2, 1fr);
+            grid-template-rows: repeat(3, 1fr);
+            gap: 20px;
+            width: 100%;
+            height: 600px;
+        }
+        #graph-container canvas {
+            width: 100% !important;
+            height: 100% !important;
+        }
+    </style>
+</head>
+<body>
+<h1>Benchmark Results Comparison</h1>
+<div>
+    <label for="test-name">Test Name:</label>
+    <select id="test-name"></select>
+</div>
+<div>
+    <label for="config-name-1">Configuration 1:</label>
+    <select id="config-name-1"></select>
+</div>
+<div>
+    <label for="config-name-2">Configuration 2:</label>
+    <select id="config-name-2"></select>
+</div>
+<button id="compare-btn">Compare</button>
+<div id="graph-container"></div>
+<script>
+    const testNameSelect = document.getElementById('test-name');
+    const configName1Select = document.getElementById('config-name-1');
+    const configName2Select = document.getElementById('config-name-2');
+    const compareBtn = document.getElementById('compare-btn');
+
+    // Fetch test names and populate the drop-down
+    fetch('/api/test-names')
+        .then(response => response.json())
+        .then(testNames => {
+            testNames.forEach(testName => {
+                const option = document.createElement('option');
+                option.value = testName;
+                option.textContent = testName;
+                testNameSelect.appendChild(option);
+            });
+
+            // If there is only one test, select it and populate the configuration names
+            if (testNames.length === 1) {
+                testNameSelect.value = testNames[0];
+                updateConfigNames(testNames[0]);
+            }
+        });
+
+    // Update configuration names when a test name is selected
+    testNameSelect.addEventListener('change', () => {
+        const selectedTestName = testNameSelect.value;
+        updateConfigNames(selectedTestName);
+    });
+
+    // Fetch configuration names and populate the drop-downs
+    function updateConfigNames(testName) {
+        configName1Select.innerHTML = '';
+        configName2Select.innerHTML = '';
+
+        fetch(`/api/config-names?test_name=${testName}`)
+            .then(response => response.json())
+            .then(configNames => {
+                for (const configName in configNames) {
+                    const runTimes = configNames[configName];
+                    runTimes.forEach(runTime => {
+                        const option1 = document.createElement('option');
+                        option1.value = `${configName}/${runTime}`;
+                        option1.textContent = `${configName}/${runTime}`;
+                        configName1Select.appendChild(option1);
+
+                        const option2 = document.createElement('option');
+                        option2.value = `${configName}/${runTime}`;
+                        option2.textContent = `${configName}/${runTime}`;
+                        configName2Select.appendChild(option2);
+                    });
+                }
+            });
+    }
+
+    // Fetch aggregated data and render graphs when the compare button is clicked
+    compareBtn.addEventListener('click', () => {
+        const selectedTestName = testNameSelect.value;
+        const [selectedConfigName1, selectedRunTime1] = configName1Select.value.split('/');
+        const [selectedConfigName2, selectedRunTime2] = configName2Select.value.split('/');
+
+        Promise.all([
+            fetch(`/api/aggregated-data?test_name=${selectedTestName}&config_name=${selectedConfigName1}&run_time=${selectedRunTime1}`),
+            fetch(`/api/aggregated-data?test_name=${selectedTestName}&config_name=${selectedConfigName2}&run_time=${selectedRunTime2}`)
+        ])
+            .then(responses => Promise.all(responses.map(response => response.json())))
+            .then(data => {
+                const config1Data = data[0];
+                const config2Data = data[1];
+
+                if (config1Data.write_data && config2Data.write_data) {
+                    renderGraph('Lines per Second', config1Data.write_data, config2Data.write_data, 'lines', 10000);
+                    renderGraph('Write Latency (ms)', config1Data.write_data, config2Data.write_data, 'latency', 10000, 'median');
+                }
+                if (config1Data.query_data && config2Data.query_data) {
+                    renderGraph('Queries per Second', config1Data.query_data, config2Data.query_data, 'lines', 10000);
+                    renderGraph('Query Latency (ms)', config1Data.query_data, config2Data.query_data, 'latency', 10000, 'median');
+                }
+                if (config1Data.system_data && config2Data.system_data) {
+                    renderGraph('CPU Usage (%)', config1Data.system_data, config2Data.system_data, 'cpu_usage');
+                    renderGraph('Memory Usage (MB)', config1Data.system_data, config2Data.system_data, 'memory_bytes');
+                }
+            });
+    });
+
+    // Render a graph using Chart.js
+    function renderGraph(title, config1Data, config2Data, yAxisKey, interval = 10000, aggregateFunction = 'sum') {
+        const container = document.getElementById('graph-container');
+        const canvas = document.createElement("canvas");
+        container.appendChild(canvas);
+        const ctx = canvas.getContext('2d');
+
+        const labels = getXLabels(config1Data, interval);
+        const config1Values = getYValues(config1Data, yAxisKey, interval, aggregateFunction);
+        const config2Values = getYValues(config2Data, yAxisKey, interval, aggregateFunction);
+
+        new Chart(ctx, {
+            type: 'line',
+            data: {
+                labels: labels,
+                datasets: [
+                    {
+                        label: configName1Select.value,
+                        data: config1Values,
+                        borderColor: 'blue',
+                        fill: false
+                    },
+                    {
+                        label: configName2Select.value,
+                        data: config2Values,
+                        borderColor: 'orange',
+                        fill: false
+                    }
+                ]
+            },
+            options: {
+                responsive: true,
+                maintainAspectRatio: false,
+                plugins: {
+                    title: {
+                        display: true,
+                        text: title,
+                        font: {
+                            size: 30
+                        }
+                    },
+                    legend: {
+                        labels: {
+                            font: {
+                                size: 26
+                            }
+                        }
+                    }
+                },
+                scales: {
+                    x: {
+                        title: {
+                            display: true,
+                            text: 'Time (seconds)',
+                            font: {
+                                size: 28
+                            }
+                        },
+                        ticks: {
+                            font: {
+                                size: 26
+                            }
+                        }
+                    },
+                    y: {
+                        title: {
+                            display: true,
+                            text: title,
+                            font: {
+                                size: 28
+                            }
+                        },
+                        ticks: {
+                            font: {
+                                size: 26
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    }
+
+    // Get the x-axis labels based on the interval
+    function getXLabels(data, interval) {
+        const labels = [];
+        const numIntervals = Math.ceil(data[data.length - 1].test_time / interval);
+        for (let i = 0; i < numIntervals; i++) {
+            labels.push(i * interval / 1000);
+        }
+        return labels;
+    }
+
+    // Get the y-axis values based on the interval and y-axis key
+    function getYValues(data, yAxisKey, interval, aggregateFunction) {
+        const values = [];
+        const numIntervals = Math.ceil(data[data.length - 1].test_time / interval);
+        for (let i = 0; i < numIntervals; i++) {
+            const startTime = i * interval;
+            const endTime = (i + 1) * interval;
+            const intervalData = data.filter(d => d.test_time >= startTime && d.test_time < endTime);
+            let yValue;
+            if (aggregateFunction === 'sum') {
+                yValue = intervalData.reduce((sum, d) => sum + d[yAxisKey], 0) / (interval / 1000);
+            } else if (aggregateFunction === 'median') {
+                const sortedData = intervalData.map(d => d[yAxisKey]).sort((a, b) => a - b);
+                const middleIndex = Math.floor(sortedData.length / 2);
+                yValue = sortedData.length % 2 === 0 ? (sortedData[middleIndex - 1] + sortedData[middleIndex]) / 2 : sortedData[middleIndex];
+            }
+            values.push(yValue || null);
+        }
+        return values;
+    }
+</script>
+</body>
+</html>
diff --git a/influxdb3_load_generator/src/commands/common.rs b/influxdb3_load_generator/src/commands/common.rs
new file mode 100644
index 00000000000..d768664d757
--- /dev/null
+++ b/influxdb3_load_generator/src/commands/common.rs
@@ -0,0 +1,461 @@
+use std::{fs::File, path::PathBuf, str::FromStr, sync::Arc};
+
+use anyhow::{anyhow, bail, Context};
+use chrono::{DateTime, Local};
+use clap::Parser;
+use influxdb3_client::Client;
+use secrecy::{ExposeSecret, Secret};
+use url::Url;
+
+use crate::{
+    report::{QueryReporter, SystemStatsReporter, WriteReporter},
+    specification::{DataSpec, QuerierSpec},
+};
+
+#[derive(Debug, Parser)]
+pub(crate) struct InfluxDb3Config {
+    /// The host URL of the running InfluxDB 3.0 server
+    #[clap(
+        short = 'h',
+        long = "host",
+        env = "INFLUXDB3_HOST_URL",
+        default_value = "http://127.0.0.1:8181"
+    )]
+    pub(crate) host_url: Url,
+
+    /// The database name to generate load against
+    #[clap(
+        short = 'd',
+        long = "dbname",
+        env = "INFLUXDB3_DATABASE_NAME",
+        default_value = "load_test"
+    )]
+    pub(crate) database_name: String,
+
+    /// The token for authentication with the InfluxDB 3.0 server
+    #[clap(long = "token", env = "INFLUXDB3_AUTH_TOKEN")]
+    pub(crate) auth_token: Option<Secret<String>>,
+
+    /// The name of the builtin spec to run. Use this instead of spec_path if you want to run
+    /// one of the builtin specs as is.
+    #[clap(long = "builtin-spec", env = "INFLUXDB3_LOAD_BUILTIN_SPEC")]
+    pub(crate) builtin_spec: Option<String>,
+
+    /// The name of the builtin spec to print to stdout. This is useful for seeing the structure
+    /// of the builtin as a starting point for creating your own.
+    #[clap(long = "print-spec", default_value_t = false)]
+    pub(crate) print_spec: bool,
+
+    /// The directory to save results to.
+    ///
+    /// If not specified, this will default to `results` in the current directory.
+    ///
+    /// Files saved here will be organized in a directory structure as follows:
+    /// ```text
+    /// results/<s>/<c>/<write|query|system>_<time>.csv`
+    /// ```
+    /// where,
+    /// - `<s>`: the name of the load gen spec, e.g., `one_mil`
+    /// - `<c>`: the provided `configuration_name`, or will default to the revision SHA of the
+    ///   `influxdb3` binary
+    /// - `<write|query|system>`: results for the `write` load, `query` load, or `system` stats of the
+    ///   `influxdb3` binary, respectively.
+    /// - `<time>`: a timestamp of when the test started in `YYYY-MM-DD-HH-MM` format.
+    #[clap(
+        short = 'r',
+        long = "results-dir",
+        env = "INFLUXDB3_LOAD_RESULTS_DIR",
+        default_value = "results"
+    )]
+    pub(crate) results_dir: PathBuf,
+
+    /// Provide a custom `configuration_name` for the generated results directory.
+    ///
+    /// If left blank, this will default to the revision SHA of the target `influxdb3` binary
+    /// under test.
+    #[clap(long = "config-name")]
+    pub(crate) configuration_name: Option<String>,
+
+    /// Generate a system stats file in the specified `results_dir`
+    #[clap(long = "system-stats", default_value_t = false)]
+    pub(crate) system_stats: bool,
+
+    /// Provide an end time to stop the load generation.
+    ///
+    /// This can be a human readable offset, e.g., `10m` (10 minutes), `1h` (1 hour), etc., or an
+    /// exact date-time in RFC3339 form, e.g., `2023-10-30T19:10:00-04:00`.
+    #[clap(long = "end")]
+    pub(crate) end_time: Option<FutureOffsetTime>,
+}
+
+/// A time in the future
+///
+/// Wraps a [`DateTime`], providing a custom [`FromStr`] implementation that parses human
+/// time input and converts it to a date-time in the future.
+#[derive(Debug, Clone, Copy)]
+pub struct FutureOffsetTime(DateTime<Local>);
+
+impl FromStr for FutureOffsetTime {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if let Ok(t) = humantime::parse_rfc3339_weak(s) {
+            Ok(Self(DateTime::<Local>::from(t)))
+        } else {
+            humantime::parse_duration(s)
+                .map(|d| Local::now() + d)
+                .map(Self)
+                .with_context(|| format!("could not parse future offset time value: {s}"))
+        }
+    }
+}
+
+impl From<FutureOffsetTime> for DateTime<Local> {
+    fn from(t: FutureOffsetTime) -> Self {
+        t.0
+    }
+}
+
+/// Can run the load generation tool exclusively in either `query` or `write` mode, or
+/// run both at the same time
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum LoadType {
+    Write,
+    Query,
+    #[allow(dead_code)]
+    Full,
+}
+
+/// A configuration for driving a `write` or `query` load generation run
+#[derive(Debug, Default)]
+pub(crate) struct LoadConfig {
+    /// The target database name on the `influxdb3` server
+    pub(crate) database_name: String,
+    /// The end time of the load generation run
+    pub(crate) end_time: Option<DateTime<Local>>,
+    /// The directory that will store generated results files
+    results_dir: PathBuf,
+    /// If `true`, the configuration will initialize only to print out
+    /// the spec as JSON, it will not create any files
+    print_mode: bool,
+    write_spec: Option<DataSpec>,
+    write_results_file_path: Option<String>,
+    write_results_file: Option<File>,
+    query_spec: Option<QuerierSpec>,
+    query_results_file_path: Option<String>,
+    query_results_file: Option<File>,
+    system_stats_file_path: Option<String>,
+    system_stats_file: Option<File>,
+}
+
+impl LoadConfig {
+    /// Create a new [`LoadConfig`]
+    fn new(
+        database_name: String,
+        results_dir: PathBuf,
+        end_time: Option<impl Into<DateTime<Local>>>,
+        print_mode: bool,
+    ) -> Self {
+        let end_time: Option<DateTime<Local>> = end_time.map(Into::into);
+        if let Some(t) = end_time {
+            println!("running load generation until: {t}");
+        } else {
+            println!("running load generation indefinitely");
+        }
+        Self {
+            database_name,
+            results_dir,
+            print_mode,
+            end_time,
+            ..Default::default()
+        }
+    }
+
+    /// Setup the results directory for the load generation run.
+    ///
+    /// This will be used to store all results files generated.
+    fn setup_dir(&mut self, spec_name: &str, config_name: &str) -> Result<(), anyhow::Error> {
+        if self.print_mode {
+            return Ok(());
+        }
+        self.results_dir = self.results_dir.join(format!("{spec_name}/{config_name}"));
+        std::fs::create_dir_all(&self.results_dir).with_context(|| {
+            format!(
+                "failed to initialize the results directory at '{dir:#?}'",
+                dir = self.results_dir.as_os_str()
+            )
+        })
+    }
+
+    /// Setup the `write` results file along with its path and the [`DataSpec`]
+    fn setup_write(&mut self, time_str: &str, spec: DataSpec) -> Result<(), anyhow::Error> {
+        if self.print_mode {
+            println!("Write Spec:\n{}", spec.to_json_string_pretty()?);
+            return Ok(());
+        }
+        self.write_spec = Some(spec);
+        let file_path = self.results_dir.join(format!("write_{time_str}.csv"));
+        self.write_results_file_path = Some(path_buf_to_string(file_path.clone())?);
+        self.write_results_file =
+            Some(File::create_new(file_path).context("write results file already exists")?);
+        Ok(())
+    }
+
+    /// Setup the `query` results file along with its path and the [`QuerierSpec`]
+    fn setup_query(&mut self, time_str: &str, spec: QuerierSpec) -> Result<(), anyhow::Error> {
+        if self.print_mode {
+            println!("Query Spec:\n{}", spec.to_json_string_pretty()?);
+            return Ok(());
+        }
+        self.query_spec = Some(spec);
+        let file_path = self.results_dir.join(format!("query_{time_str}.csv"));
+        self.query_results_file_path = Some(path_buf_to_string(file_path.clone())?);
+        self.query_results_file =
+            Some(File::create_new(file_path).context("query results file already exists")?);
+        Ok(())
+    }
+
+    /// Setup the `system` stats file along with its path
+    fn setup_system(&mut self, time_str: &str) -> Result<(), anyhow::Error> {
+        let file_path = self.results_dir.join(format!("system_{time_str}.csv"));
+        self.system_stats_file_path = Some(path_buf_to_string(file_path.clone())?);
+        self.system_stats_file =
+            Some(File::create_new(file_path).context("system stats file already exists")?);
+        Ok(())
+    }
+
+    pub(crate) fn query_spec(&mut self) -> Result<QuerierSpec, anyhow::Error> {
+        self.query_spec
+            .take()
+            .context("there is no loaded query spec")
+    }
+
+    pub(crate) fn write_spec(&mut self) -> Result<DataSpec, anyhow::Error> {
+        self.write_spec
+            .take()
+            .context("there is no loaded write spec")
+    }
+
+    /// Get the [`QueryReporter`] along with the path of the file it is generating as a `String`
+    pub(crate) fn query_reporter(&mut self) -> Result<(String, Arc<QueryReporter>), anyhow::Error> {
+        let file = self
+            .query_results_file
+            .take()
+            .context("no generated query results file")?;
+        let path = self
+            .query_results_file_path
+            .take()
+            .context("no generated query results file path")?;
+
+        // set up a results reporter and spawn a thread to flush results
+        println!("generating query results in: {path}");
+        let query_reporter = Arc::new(QueryReporter::new(file));
+        let reporter = Arc::clone(&query_reporter);
+        tokio::task::spawn_blocking(move || {
+            reporter.flush_reports();
+        });
+        Ok((path, query_reporter))
+    }
+
+    /// Get the [`QueryReporter`] along with the path of the file it is generating as a `String`
+    pub(crate) fn write_reporter(&mut self) -> Result<(String, Arc<WriteReporter>), anyhow::Error> {
+        let file = self
+            .write_results_file
+            .take()
+            .context("no generated write results file")?;
+        let path = self
+            .write_results_file_path
+            .take()
+            .context("no generated write results file path")?;
+
+        // set up a results reporter and spawn a thread to flush results
+        println!("generating write results in: {path}");
+        let write_reporter = Arc::new(WriteReporter::new(file)?);
+        let reporter = Arc::clone(&write_reporter);
+        tokio::task::spawn_blocking(move || {
+            reporter.flush_reports();
+        });
+        Ok((path, write_reporter))
+    }
+
+    /// Get a [`SystemStatsReporter`] along with the path of the file it is generating as a `String`
+    pub(crate) fn system_reporter(
+        &mut self,
+    ) -> Result<Option<(String, Arc<SystemStatsReporter>)>, anyhow::Error> {
+        if let (Some(stats_file), Some(stats_file_path)) = (
+            self.system_stats_file.take(),
+            self.system_stats_file_path.take(),
+        ) {
+            println!("generating system stats in: {stats_file_path}");
+            let stats_reporter = Arc::new(SystemStatsReporter::new(stats_file)?);
+            let s = Arc::clone(&stats_reporter);
+            tokio::task::spawn_blocking(move || {
+                s.report_stats();
+            });
+            Ok(Some((stats_file_path, stats_reporter)))
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+fn path_buf_to_string(path: PathBuf) -> Result<String, anyhow::Error> {
+    path.into_os_string()
+        .into_string()
+        .map_err(|os_str| anyhow!("write file path could not be converted to a string: {os_str:?}"))
+}
+
+impl InfluxDb3Config {
+    pub(crate) async fn initialize_query(
+        self,
+        querier_spec_path: Option<PathBuf>,
+    ) -> Result<(Client, LoadConfig), anyhow::Error> {
+        self.initialize(LoadType::Query, querier_spec_path, None)
+            .await
+    }
+
+    pub(crate) async fn initialize_write(
+        self,
+        writer_spec_path: Option<PathBuf>,
+    ) -> Result<(Client, LoadConfig), anyhow::Error> {
+        self.initialize(LoadType::Write, None, writer_spec_path)
+            .await
+    }
+
+    pub(crate) async fn initialize_full(
+        self,
+        querier_spec_path: Option<PathBuf>,
+        writer_spec_path: Option<PathBuf>,
+    ) -> Result<(Client, LoadConfig), anyhow::Error> {
+        self.initialize(LoadType::Full, querier_spec_path, writer_spec_path)
+            .await
+    }
+
+    async fn initialize(
+        self,
+        load_type: LoadType,
+        querier_spec_path: Option<PathBuf>,
+        writer_spec_path: Option<PathBuf>,
+    ) -> Result<(Client, LoadConfig), anyhow::Error> {
+        let Self {
+            host_url,
+            database_name,
+            auth_token,
+            builtin_spec,
+            print_spec,
+            results_dir,
+            configuration_name,
+            system_stats,
+            end_time,
+        } = self;
+
+        match (
+            builtin_spec.as_ref(),
+            load_type,
+            querier_spec_path.as_ref(),
+            writer_spec_path.as_ref(),
+        ) {
+            (None, LoadType::Write | LoadType::Full, _, None)
+            | (None, LoadType::Query | LoadType::Full, None, _) => {
+                if matches!(load_type, LoadType::Write) {
+                    // TODO - print help for query as well
+                    crate::commands::write::print_help();
+                }
+                bail!("You did not provide a spec path or specify a built-in spec");
+            }
+            _ => (),
+        }
+
+        let built_in_specs = crate::specs::built_in_specs();
+
+        // sepcify a time string for generated results file names:
+        let time_str = format!("{}", Local::now().format("%Y-%m-%dT%H-%M-%S"));
+
+        // initialize the influxdb3 client:
+        let client =
+            create_client(host_url, auth_token).context("unable to create influxdb3 client")?;
+
+        // use the user-specified configuration name, or pull it from the running server:
+        let config_name = if let Some(n) = configuration_name {
+            n
+        } else {
+            client
+                .ping()
+                .await
+                .context("influxdb3 server did not respond to ping request")?
+                .revision()
+                .to_owned()
+        };
+
+        // initialize the load config:
+        let mut config = LoadConfig::new(database_name, results_dir, end_time, print_spec);
+
+        // if builtin spec is set, use that instead of the spec path
+        if let Some(b) = builtin_spec {
+            let builtin = built_in_specs
+                .into_iter()
+                .find(|spec| spec.name == *b)
+                .with_context(|| {
+                    let names = crate::specs::built_in_spec_names().join(", ");
+                    format!(
+                        "built-in spec with name '{b}' not found, available built-in specs are: {names}"
+                    )
+                })?;
+            println!("using built-in spec: {}", builtin.name);
+            let spec_name = builtin.name.as_str();
+            config.setup_dir(spec_name, &config_name)?;
+            match load_type {
+                LoadType::Write => {
+                    config.setup_write(&time_str, builtin.write_spec)?;
+                }
+                LoadType::Query => {
+                    config.setup_query(&time_str, builtin.query_spec)?;
+                }
+                LoadType::Full => {
+                    config.setup_write(&time_str, builtin.write_spec)?;
+                    config.setup_query(&time_str, builtin.query_spec)?;
+                }
+            }
+        } else {
+            match load_type {
+                LoadType::Write => {
+                    let spec = DataSpec::from_path(writer_spec_path.unwrap())?;
+                    let spec_name = spec.name.to_owned();
+                    config.setup_dir(&spec_name, &config_name)?;
+                    config.setup_write(&time_str, spec)?;
+                }
+                LoadType::Query => {
+                    let spec = QuerierSpec::from_path(querier_spec_path.unwrap())?;
+                    let spec_name = spec.name.to_owned();
+                    config.setup_dir(&spec_name, &config_name)?;
+                    config.setup_query(&time_str, spec)?;
+                }
+                LoadType::Full => {
+                    bail!("can only run custom specs with the `query` or `write` load directly")
+                }
+            }
+        };
+        // if print spec is set, print the spec and exit
+        if print_spec {
+            bail!("exiting after printing spec");
+        }
+
+        // Setup the system stats file if specified
+        if system_stats {
+            config.setup_system(&time_str)?;
+        }
+
+        Ok((client, config))
+    }
+}
+
+pub(crate) fn create_client(
+    host_url: Url,
+    auth_token: Option<Secret<String>>,
+) -> Result<Client, influxdb3_client::Error> {
+    let mut client = Client::new(host_url)?;
+    if let Some(t) = auth_token {
+        client = client.with_auth_token(t.expose_secret());
+    }
+    Ok(client)
+}
diff --git a/influxdb3_load_generator/src/commands/full.rs b/influxdb3_load_generator/src/commands/full.rs
new file mode 100644
index 00000000000..682f3b6b0fe
--- /dev/null
+++ b/influxdb3_load_generator/src/commands/full.rs
@@ -0,0 +1,90 @@
+use std::sync::Arc;
+
+use clap::Parser;
+use tokio::task::JoinSet;
+
+use crate::commands::{query::run_query_load, write::run_write_load};
+
+use super::{common::InfluxDb3Config, query::QueryConfig, write::WriteConfig};
+
+#[derive(Debug, Parser)]
+pub(crate) struct Config {
+    /// Common InfluxDB 3.0 config
+    #[clap(flatten)]
+    common: InfluxDb3Config,
+
+    /// Query-specific config
+    #[clap(flatten)]
+    query: QueryConfig,
+
+    /// Write-specific config
+    #[clap(flatten)]
+    write: WriteConfig,
+}
+
+pub(crate) async fn command(mut config: Config) -> Result<(), anyhow::Error> {
+    let (client, mut load_config) = config
+        .common
+        .initialize_full(
+            config.query.querier_spec_path.take(),
+            config.write.writer_spec_path.take(),
+        )
+        .await?;
+
+    // spawn system stats collection:
+    let stats = load_config.system_reporter()?;
+    let database_name = load_config.database_name.clone();
+
+    let mut tasks = JoinSet::new();
+
+    // setup query load:
+    let query_spec = load_config.query_spec()?;
+    let (query_results_file_path, query_reporter) = load_config.query_reporter()?;
+    let qr = Arc::clone(&query_reporter);
+    let query_client = client.clone();
+    tasks.spawn(async move {
+        run_query_load(
+            query_spec,
+            qr,
+            query_client,
+            database_name.clone(),
+            load_config.end_time,
+            config.query,
+        )
+        .await
+    });
+
+    // setup write load:
+    let write_spec = load_config.write_spec()?;
+    let (write_results_file_path, write_reporter) = load_config.write_reporter()?;
+    let wr = Arc::clone(&write_reporter);
+    tasks.spawn(async move {
+        run_write_load(
+            write_spec,
+            wr,
+            client,
+            load_config.database_name,
+            load_config.end_time,
+            config.write,
+        )
+        .await
+    });
+
+    while let Some(res) = tasks.join_next().await {
+        res??;
+    }
+
+    write_reporter.shutdown();
+    println!("write results saved in: {write_results_file_path}");
+
+    // shutdown query reporter:
+    query_reporter.shutdown();
+    println!("query results saved in: {query_results_file_path}");
+
+    if let Some((stats_file_path, stats_reporter)) = stats {
+        println!("system stats saved in: {stats_file_path}");
+        stats_reporter.shutdown();
+    }
+
+    Ok(())
+}
diff --git a/influxdb3_load_generator/src/commands/query.rs b/influxdb3_load_generator/src/commands/query.rs
new file mode 100644
index 00000000000..1227d5fdeb3
--- /dev/null
+++ b/influxdb3_load_generator/src/commands/query.rs
@@ -0,0 +1,192 @@
+use std::{collections::HashMap, path::PathBuf, sync::Arc};
+
+use bytes::Bytes;
+use chrono::{DateTime, Local};
+use clap::Parser;
+use influxdb3_client::Client;
+use serde_json::Value;
+use tokio::time::Instant;
+
+use crate::{
+    query_generator::{create_queriers, Format, Querier},
+    report::QueryReporter,
+    specification::QuerierSpec,
+};
+
+use super::common::InfluxDb3Config;
+
+#[derive(Debug, Parser)]
+#[clap(visible_alias = "q", trailing_var_arg = true)]
+pub(crate) struct Config {
+    /// Common InfluxDB 3.0 config
+    #[clap(flatten)]
+    common: InfluxDb3Config,
+
+    /// Query-specific config
+    #[clap(flatten)]
+    query: QueryConfig,
+}
+
+#[derive(Debug, Parser)]
+pub(crate) struct QueryConfig {
+    /// Number of simultaneous queriers. Each querier will perform queries at the specified `interval`.
+    #[clap(
+        short = 'q',
+        long = "querier-count",
+        env = "INFLUXDB3_LOAD_QUERIER_COUNT",
+        default_value = "1"
+    )]
+    querier_count: usize,
+
+    /// The path to the querier spec file to use for this run.
+    ///
+    /// Alternatively, specify a name of a builtin spec to use. If neither are specified, the
+    /// generator will output a list of builtin specs along with help and an example for writing
+    /// your own.
+    #[clap(long = "querier-spec", env = "INFLUXDB3_LOAD_QUERIER_SPEC_PATH")]
+    pub(crate) querier_spec_path: Option<PathBuf>,
+
+    #[clap(
+        long = "query-format",
+        env = "INFLUXDB3_LOAD_QUERY_FORMAT",
+        value_enum,
+        default_value = "json"
+    )]
+    query_response_format: Format,
+}
+
+pub(crate) async fn command(mut config: Config) -> Result<(), anyhow::Error> {
+    let (client, mut load_config) = config
+        .common
+        .initialize_query(config.query.querier_spec_path.take())
+        .await?;
+    let spec = load_config.query_spec()?;
+    let (results_file_path, reporter) = load_config.query_reporter()?;
+
+    // spawn system stats collection
+    let stats = load_config.system_reporter()?;
+
+    run_query_load(
+        spec,
+        Arc::clone(&reporter),
+        client,
+        load_config.database_name,
+        load_config.end_time,
+        config.query,
+    )
+    .await?;
+
+    reporter.shutdown();
+    println!("results saved in: {results_file_path}");
+
+    if let Some((stats_file_path, stats_reporter)) = stats {
+        println!("system stats saved in: {stats_file_path}");
+        stats_reporter.shutdown();
+    }
+
+    Ok(())
+}
+
+pub(crate) async fn run_query_load(
+    spec: QuerierSpec,
+    reporter: Arc<QueryReporter>,
+    client: influxdb3_client::Client,
+    database_name: String,
+    end_time: Option<DateTime<Local>>,
+    config: QueryConfig,
+) -> Result<(), anyhow::Error> {
+    let QueryConfig {
+        querier_count,
+        query_response_format,
+        ..
+    } = config;
+    // spin up the queriers
+    let queriers = create_queriers(&spec, query_response_format, querier_count)?;
+
+    // spawn tasks for each querier
+    let mut tasks = Vec::new();
+    for querier in queriers {
+        let reporter = Arc::clone(&reporter);
+        let task = tokio::spawn(run_querier(
+            querier,
+            client.clone(),
+            database_name.clone(),
+            end_time,
+            reporter,
+        ));
+        tasks.push(task);
+    }
+
+    // await tasks, shutdown reporter and exit
+    for task in tasks {
+        task.await?;
+    }
+    println!("all queriers finished");
+
+    Ok(())
+}
+
+async fn run_querier(
+    mut querier: Querier,
+    client: Client,
+    database_name: String,
+    end_time: Option<DateTime<Local>>,
+    reporter: Arc<QueryReporter>,
+) {
+    loop {
+        if end_time.is_some_and(|t| Local::now() > t) {
+            println!(
+                "querier {id} completed at {time}",
+                id = querier.querier_id,
+                time = Local::now()
+            );
+            break;
+        }
+        for query in &mut querier.queries {
+            let start_request = Instant::now();
+            let mut builder = client
+                .api_v3_query_sql(&database_name, query.query())
+                .format(querier.format.into());
+            for p in query.params_mut() {
+                let v = p.generate();
+                builder = builder
+                    .with_try_param(p.name(), v)
+                    .expect("expected primitive JSON value");
+            }
+            let res = builder.send().await;
+            let response_time = start_request.elapsed().as_millis() as u64;
+            let (status, rows) = match res {
+                Ok(b) => (200, count_rows(b, querier.format)),
+                Err(influxdb3_client::Error::ApiError { code, message: _ }) => (code.as_u16(), 0),
+                Err(other_error) => {
+                    panic!("unexpected error while performing query: {other_error}")
+                }
+            };
+
+            reporter.report(
+                querier.querier_id,
+                status,
+                response_time,
+                rows,
+                Local::now(),
+            );
+        }
+    }
+}
+
+fn count_rows(response: Bytes, format: Format) -> u64 {
+    match format {
+        Format::Json => {
+            let v: Vec<HashMap<String, Value>> =
+                serde_json::from_slice(&response).expect("valid formatted JSON");
+            v.len().try_into().unwrap()
+        }
+        Format::Csv => {
+            let mut count = 0;
+            for _ in response.split(|c| *c == b'\n') {
+                count += 1;
+            }
+            count
+        }
+    }
+}
diff --git a/influxdb3_load_generator/src/commands/write.rs b/influxdb3_load_generator/src/commands/write.rs
new file mode 100644
index 00000000000..76a4c8d18a4
--- /dev/null
+++ b/influxdb3_load_generator/src/commands/write.rs
@@ -0,0 +1,468 @@
+use crate::line_protocol_generator::{create_generators, Generator};
+use crate::report::WriteReporter;
+use crate::specification::DataSpec;
+use anyhow::Context;
+use chrono::{DateTime, Local};
+use clap::Parser;
+use influxdb3_client::{Client, Precision};
+use std::ops::Add;
+use std::path::PathBuf;
+use std::str::FromStr;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::time::Instant;
+
+use super::common::InfluxDb3Config;
+
+#[derive(Debug, Parser)]
+#[clap(visible_alias = "w", trailing_var_arg = true)]
+pub(crate) struct Config {
+    /// Common InfluxDB 3.0 config
+    #[clap(flatten)]
+    common: InfluxDb3Config,
+
+    /// Write-specific config:
+    #[clap(flatten)]
+    write: WriteConfig,
+}
+
+#[derive(Debug, Parser)]
+pub(crate) struct WriteConfig {
+    /// Sampling interval for the writers. They will generate data at this interval and
+    /// sleep for the remainder of the interval. Writers stagger writes by this interval divided
+    /// by the number of writers.
+    #[clap(
+        short = 'i',
+        long = "interval",
+        env = "INFLUXDB3_LOAD_SAMPLING_INTERVAL",
+        default_value = "1s"
+    )]
+    sampling_interval: SamplingInterval,
+
+    /// Number of simultaneous writers. Each writer will generate data at the specified interval.
+    #[clap(
+        short = 'w',
+        long = "writer-count",
+        env = "INFLUXDB3_LOAD_WRITER_COUNT",
+        default_value = "1"
+    )]
+    writer_count: usize,
+
+    /// The path to the writer spec file to use for this run.
+    ///
+    /// Alternatively, specify a name of a builtin spec to use. If neither are specified, the
+    /// generator will output a list of builtin specs along with help and an example for writing
+    /// your own.
+    #[clap(long = "writer-spec", env = "INFLUXDB3_LOAD_WRITER_SPEC_PATH")]
+    pub(crate) writer_spec_path: Option<PathBuf>,
+
+    /// Tells the generator to run a single sample for each writer in `writer-count` and output the data to stdout.
+    #[clap(long = "dry-run", default_value = "false")]
+    dry_run: bool,
+
+    /// The date and time at which to start the timestamps of the generated data.
+    ///
+    /// Can be an exact datetime like `2020-01-01T01:23:45-05:00` or a fuzzy
+    /// specification like `1 hour` in the past. If not specified, defaults to now.
+    #[clap(long = "start", action)]
+    start_time: Option<String>,
+}
+
+#[derive(Debug, Clone, Copy)]
+struct SamplingInterval(humantime::Duration);
+
+impl FromStr for SamplingInterval {
+    type Err = SamplingIntervalError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let d = humantime::Duration::from_str(s)?;
+        if d.is_zero() {
+            Err(SamplingIntervalError::ZeroDuration)
+        } else {
+            Ok(Self(d))
+        }
+    }
+}
+
+impl std::fmt::Display for SamplingInterval {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl From<SamplingInterval> for Duration {
+    fn from(s: SamplingInterval) -> Self {
+        s.0.into()
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+enum SamplingIntervalError {
+    #[error("sampling interval must be greater than 0")]
+    ZeroDuration,
+    #[error(transparent)]
+    Inner(#[from] humantime::DurationError),
+}
+
+pub(crate) async fn command(mut config: Config) -> Result<(), anyhow::Error> {
+    let (client, mut load_config) = config
+        .common
+        .initialize_write(config.write.writer_spec_path.take())
+        .await?;
+    let spec = load_config.write_spec()?;
+    let (results_file_path, reporter) = load_config.write_reporter()?;
+
+    // spawn system stats collection
+    let stats = load_config.system_reporter()?;
+
+    run_write_load(
+        spec,
+        Arc::clone(&reporter),
+        client,
+        load_config.database_name,
+        load_config.end_time,
+        config.write,
+    )
+    .await?;
+
+    reporter.shutdown();
+    println!("results saved in: {results_file_path}");
+
+    if let Some((stats_file_path, stats_reporter)) = stats {
+        println!("system stats saved in: {stats_file_path}");
+        stats_reporter.shutdown();
+    }
+
+    Ok(())
+}
+
+pub(crate) async fn run_write_load(
+    spec: DataSpec,
+    reporter: Arc<WriteReporter>,
+    client: influxdb3_client::Client,
+    database_name: String,
+    end_time: Option<DateTime<Local>>,
+    config: WriteConfig,
+) -> Result<(), anyhow::Error> {
+    let WriteConfig {
+        sampling_interval,
+        writer_count,
+        dry_run,
+        start_time,
+        ..
+    } = config;
+
+    println!(
+        "creating generators for {} concurrent writers",
+        writer_count
+    );
+    println!("each writer will send a write request every {sampling_interval}");
+
+    let mut generators =
+        create_generators(&spec, writer_count).context("failed to create generators")?;
+
+    // if dry run is set, output from each generator its id and then a single sample
+    if dry_run {
+        println!("running dry run for each writer\n");
+        for g in &mut generators {
+            let t = Local::now();
+            let dry_run_output = g.dry_run(t.timestamp_millis());
+            println!("Writer {}:\n{}", g.writer_id, dry_run_output);
+        }
+        return Ok(());
+    }
+
+    let start_time = if let Some(start_time) = start_time {
+        let start_time = parse_time_offset(&start_time, Local::now());
+        println!(
+            "starting writers from a start time of {:?}. Historical replay will happen as \
+            fast as possible until catching up to now or hitting the end time.",
+            start_time
+        );
+        Some(start_time)
+    } else {
+        None
+    };
+
+    // spawn tokio tasks for each writer
+    let mut tasks = Vec::new();
+    for generator in generators {
+        let reporter = Arc::clone(&reporter);
+        let sampling_interval = sampling_interval.into();
+        let task = tokio::spawn(run_generator(
+            generator,
+            client.clone(),
+            database_name.clone(),
+            reporter,
+            sampling_interval,
+            start_time,
+            end_time,
+        ));
+        tasks.push(task);
+    }
+
+    // wait for all tasks to complete
+    for task in tasks {
+        task.await?;
+    }
+    println!("all writers finished");
+
+    Ok(())
+}
+
+fn parse_time_offset(s: &str, now: DateTime<Local>) -> DateTime<Local> {
+    humantime::parse_rfc3339(s)
+        .map(Into::into)
+        .unwrap_or_else(|_| {
+            let std_duration = humantime::parse_duration(s).expect("Could not parse time");
+            let chrono_duration = chrono::Duration::from_std(std_duration)
+                .expect("Could not convert std::time::Duration to chrono::Duration");
+            now - chrono_duration
+        })
+}
+
+async fn run_generator(
+    mut generator: Generator,
+    client: Client,
+    database_name: String,
+    reporter: Arc<WriteReporter>,
+    sampling_interval: Duration,
+    start_time: Option<DateTime<Local>>,
+    end_time: Option<DateTime<Local>>,
+) {
+    // if not generator 1, pause for 100ms to let it start the run to create the schema
+    if generator.writer_id != 1 {
+        tokio::time::sleep(Duration::from_millis(100)).await;
+    }
+
+    let mut sample_buffer = vec![];
+
+    // if the start time is set, load the historical samples as quickly as possible
+    if let Some(mut start_time) = start_time {
+        let mut sample_len = write_sample(
+            &mut generator,
+            sample_buffer,
+            &client,
+            &database_name,
+            start_time,
+            &reporter,
+            true,
+        )
+        .await;
+
+        loop {
+            start_time = start_time.add(sampling_interval);
+            if start_time > Local::now()
+                || end_time
+                    .map(|end_time| start_time > end_time)
+                    .unwrap_or(false)
+            {
+                println!(
+                    "writer {} finished historical replay at: {:?}",
+                    generator.writer_id, start_time
+                );
+                break;
+            }
+
+            sample_buffer = Vec::with_capacity(sample_len);
+            sample_len = write_sample(
+                &mut generator,
+                sample_buffer,
+                &client,
+                &database_name,
+                start_time,
+                &reporter,
+                false,
+            )
+            .await;
+        }
+    }
+
+    // write data until end time or forever
+    let mut interval = tokio::time::interval(sampling_interval);
+    let mut sample_len = 1024 * 1024 * 1024;
+
+    // we only want to print the error the very first time it happens
+    let mut print_err = false;
+
+    loop {
+        interval.tick().await;
+        let now = Local::now();
+        if let Some(end_time) = end_time {
+            if now > end_time {
+                println!("writer {} completed at {}", generator.writer_id, end_time);
+                return;
+            }
+        }
+
+        sample_buffer = Vec::with_capacity(sample_len);
+        sample_len = write_sample(
+            &mut generator,
+            sample_buffer,
+            &client,
+            &database_name,
+            now,
+            &reporter,
+            print_err,
+        )
+        .await;
+        print_err = true;
+    }
+}
+
+async fn write_sample(
+    generator: &mut Generator,
+    mut buffer: Vec<u8>,
+    client: &Client,
+    database_name: &String,
+    sample_time: DateTime<Local>,
+    reporter: &Arc<WriteReporter>,
+    print_err: bool,
+) -> usize {
+    // generate the sample, and keep track of the length to set the buffer size for the next loop
+    let summary = generator
+        .write_sample_to(sample_time.timestamp_millis(), &mut buffer)
+        .expect("failed to write sample");
+    let sample_len = buffer.len();
+
+    // time and send the write request
+    let start_request = Instant::now();
+    let res = client
+        .api_v3_write_lp(database_name)
+        .precision(Precision::Millisecond)
+        .accept_partial(false)
+        .body(buffer)
+        .send()
+        .await;
+    let response_time = start_request.elapsed().as_millis() as u64;
+
+    // log the report
+    match res {
+        Ok(_) => {
+            reporter.report_write(generator.writer_id, summary, response_time, Local::now());
+        }
+        Err(e) => {
+            // if it's the first error, print the details
+            if print_err {
+                eprintln!(
+                    "Error on writer {} writing to server: {:?}",
+                    generator.writer_id, e
+                );
+            }
+            reporter.report_failure(generator.writer_id, response_time, Local::now());
+        }
+    }
+
+    sample_len
+}
+
+pub(crate) fn print_help() {
+    let built_in_specs = crate::specs::built_in_specs();
+    let example = built_in_specs.first().unwrap();
+    let mut generators = create_generators(&example.write_spec, 2).unwrap();
+    let t = 123;
+    let dry_run_output_1 = generators.get_mut(0).unwrap().dry_run(t);
+    let dry_run_output_2 = generators.get_mut(1).unwrap().dry_run(t);
+
+    let builtin_help = built_in_specs
+        .iter()
+        .map(|spec| {
+            format!(
+                "name: {}\ndescription: {}\n",
+                spec.write_spec.name, spec.description
+            )
+        })
+        .collect::<Vec<String>>()
+        .join("\n");
+
+    println!(
+        r#"You didn't provide a spec path, which is required. For more information about the arguments for this command run:
+
+    influxdb_load_generator write --help
+
+There are some built in specs that you can run just by specifying their name. If you want
+to see the JSON for their structure as a starting point, specify their name as the --print-spec
+argument. Here's a list of the builtin specs:
+
+{}
+
+Or, if you need a more detailed writeup on specs and how they work here are details about
+the example. A spec is just a JSON object specifying how to generate measurements and their
+tags and fields. All data will have a millisecond timestamp generated (with that precision
+specified) and aligned with the sampling. The generator will run against a single database
+and can have many concurrent writers. The spec indicates the shape of the data that should
+be generated.
+
+As the generator runs, it will output basic information to stdout. The stats of each
+individual request will be written to a results CSV file that you can use after the run to
+analyze the performance of write requests to the server.
+
+In the data spec there is an array of measurements. Within each is an array of tags
+and an array of fields. Measurements have a name while tags and fields have keys (i.e. tag
+key and field key). Tags and fields are scoped to the measurement they are under. If a
+tag with key 'foo' appears under two different measurements they are considered different
+tags. The same goes for fields. All measurements must have at least 1 field and can have 0
+or more tags.
+
+The measurement, tag and field structs have an option called 'copies' which is an integer.
+When specified, the data generator will create that many copies of the measurement, tag,
+or field and append the copy number to the name/keys. This is useful for generating a large
+schema in a test.
+
+Tags have two options that work together that need explanation: cardinality, and
+lines_per_sample. Cardinality is the number of unique values that the tag will have.
+This cardinality will be split across the number of writers in a test run. Thus if you have
+1,000 cardinality and a single writer, the unique values will all get written by that writer.
+If you have 1,000 cardinality and 10 writers, each writer will write 100 unique values.
+
+The lines_per_sample option on the measurement is used to control how many of the unique
+values are used in a single sampling round. If not specified, all unique values will be used.
+This number will be rounded down to the cardinality of the tag with the highest cardinality
+for the measurement. This is done on a per writer basis. If you have lines_per_sample of 10
+and a tag of 100 cardinality with 1 writer, it will generate 10 lines of that measurement with
+each unique tag value going to the next 10 values on the next sample, taking 10 samples to get
+through the 100 uniques before it cycles back to the beginning.
+
+Separately, cardinality of tags will be split across the number of writers you have. So if
+you have cardinality of 100 and 1 writer, by default it will generate 100 lines of that
+measurement with each unique tag value. If you have 10 writers, each writer will generate 10
+unique tag values. Thus with 10 writers, the lines_per_sample would max at 10 since each
+sample can only generate 10 unique tag values.
+
+The tag spec also has a boolean option called "append_writer_id". Writers are the individual
+threads that run and generate and write samples at the same time. The number is set through
+the parameter --writer-count. If append_writer_id is set to true, the generator will append
+the writer id to the tag value. This is useful for generating unique tag values across
+writers, simulating a host id or something similar.
+
+Fields have options for generating static data, or randomly generated data within a range. For
+strings, you can specify a static string or a random string of a certain length. Another option
+worth noting is the null_probability. This is a float between 0 and 1 that indicates the probability
+that a field will be null. If this option is used, you must have another field that does not use
+this option (i.e. you must always have at least one field that is guaranteed to have a value).
+
+If you're unsure how an option works or what it will produce, the easiest thing to do is to create
+a file and run the generator with the --dry-run option. This will output the data to stdout so you
+can see what it looks like before you run it against a server. It will use the --writer-count
+value and show what each writer would send in a sample.
+
+The example below shows this functionality generating different kinds of tags and
+fields of different value types. First, we show the spec, then we show the output that gets
+generated on a dry-run so you can see how the spec translates into generated line protocol.
+
+Here's the spec:
+
+{}
+
+And when run with writer count set to 2, here's what will be sent in a request by each writer.
+
+Writer 1:
+{}
+Writer 2:
+{}"#,
+        builtin_help,
+        example.write_spec.to_json_string_pretty().unwrap(),
+        dry_run_output_1,
+        dry_run_output_2
+    );
+}
diff --git a/influxdb3_load_generator/src/line_protocol_generator.rs b/influxdb3_load_generator/src/line_protocol_generator.rs
new file mode 100644
index 00000000000..2c631e0d2b7
--- /dev/null
+++ b/influxdb3_load_generator/src/line_protocol_generator.rs
@@ -0,0 +1,552 @@
+//! This contains the logic for creating generators for a given spec for the number of workers.
+
+use crate::specification::{DataSpec, FieldKind, MeasurementSpec};
+use rand::distributions::Alphanumeric;
+use rand::rngs::SmallRng;
+use rand::{Rng, SeedableRng};
+use std::collections::HashMap;
+use std::io::Write;
+use std::ops::Range;
+use std::sync::Arc;
+use tokio::io;
+
+pub type WriterId = usize;
+
+pub fn create_generators(
+    spec: &DataSpec,
+    writer_count: usize,
+) -> Result<Vec<Generator>, anyhow::Error> {
+    let mut generators = vec![];
+    let mut arc_strings = HashMap::new();
+
+    for writer_id in 1..writer_count + 1 {
+        let mut measurements = vec![];
+
+        for m in &spec.measurements {
+            let copies = m.copies.unwrap_or(1);
+
+            for measurement_id in 1..copies + 1 {
+                measurements.push(create_measurement(
+                    m,
+                    writer_id,
+                    writer_count,
+                    measurement_id,
+                    &mut arc_strings,
+                ));
+            }
+        }
+
+        generators.push(Generator {
+            writer_id,
+            measurements,
+        });
+    }
+
+    Ok(generators)
+}
+
+fn create_measurement<'a>(
+    spec: &'a MeasurementSpec,
+    writer_id: WriterId,
+    writer_count: usize,
+    measurement_id: usize,
+    arc_strings: &mut HashMap<&'a str, Arc<str>>,
+) -> Measurement {
+    let name = Arc::clone(arc_strings.entry(spec.name.as_str()).or_insert_with(|| {
+        let m = spec.name.replace(' ', "\\ ").replace(',', "\\,");
+        Arc::from(m.as_str())
+    }));
+
+    let max_cardinality = spec.max_cardinality();
+    let max_cardinality = usize::div_ceil(max_cardinality, writer_count);
+    let lines_per_sample = spec.lines_per_sample.unwrap_or(max_cardinality);
+
+    let mut tags = vec![];
+
+    for t in &spec.tags {
+        let key = Arc::clone(arc_strings.entry(t.key.as_str()).or_insert_with(|| {
+            let k = t
+                .key
+                .replace(' ', "\\ ")
+                .replace(',', "\\,")
+                .replace('=', "\\=");
+            Arc::from(k.as_str())
+        }));
+
+        let value = t.value.as_ref().map(|v| {
+            Arc::clone(arc_strings.entry(v.as_str()).or_insert_with(|| {
+                let v = v
+                    .replace(' ', "\\ ")
+                    .replace(',', "\\,")
+                    .replace('=', "\\=");
+                Arc::from(v.as_str())
+            }))
+        });
+
+        let (cardinality_id_min, cardinality_id_max) = t
+            .cardinality_min_max(writer_id, writer_count)
+            .unwrap_or((0, 0));
+
+        let append_writer_id = t.append_writer_id.unwrap_or(false);
+        let append_copy_id = t.append_copy_id.unwrap_or(false);
+        let copies = t.copies.unwrap_or(1);
+
+        for copy_id in 1..copies + 1 {
+            tags.push(Tag {
+                key: Arc::clone(&key),
+                value: value.clone(),
+                copy_id,
+                cardinality_id_min,
+                cardinality_id_max,
+                cardinality_id_current: cardinality_id_min,
+                append_writer_id,
+                append_copy_id,
+            });
+        }
+    }
+
+    let mut fields = vec![];
+
+    for f in &spec.fields {
+        let key = Arc::clone(arc_strings.entry(f.key.as_str()).or_insert_with(|| {
+            let k = f
+                .key
+                .replace(' ', "\\ ")
+                .replace(',', "\\,")
+                .replace('=', "\\=");
+            Arc::from(k.as_str())
+        }));
+
+        let copies = f.copies.unwrap_or(1);
+
+        for copy_id in 1..copies + 1 {
+            let random_null = f.null_probability.map(|p| (p, SmallRng::from_entropy()));
+
+            match &f.field {
+                FieldKind::Bool(_) => {
+                    fields.push(Field {
+                        key: Arc::clone(&key),
+                        copy_id,
+                        random_null,
+                        field_value: FieldValue::Boolean(BooleanValue::Random(
+                            SmallRng::from_entropy(),
+                        )),
+                    });
+                }
+                FieldKind::String(s) => {
+                    fields.push(Field {
+                        key: Arc::clone(&key),
+                        copy_id,
+                        random_null,
+                        field_value: FieldValue::String(StringValue::Fixed(Arc::clone(
+                            arc_strings
+                                .entry(s.as_str())
+                                .or_insert_with(|| Arc::from(s.as_str())),
+                        ))),
+                    });
+                }
+                FieldKind::StringRandom(size) => {
+                    fields.push(Field {
+                        key: Arc::clone(&key),
+                        copy_id,
+                        random_null,
+                        field_value: FieldValue::String(StringValue::Random(
+                            *size,
+                            SmallRng::from_entropy(),
+                        )),
+                    });
+                }
+                FieldKind::Integer(i) => {
+                    fields.push(Field {
+                        key: Arc::clone(&key),
+                        copy_id,
+                        random_null,
+                        field_value: FieldValue::Integer(IntegerValue::Fixed(*i)),
+                    });
+                }
+                FieldKind::IntegerRange(min, max) => {
+                    fields.push(Field {
+                        key: Arc::clone(&key),
+                        copy_id,
+                        random_null,
+                        field_value: FieldValue::Integer(IntegerValue::Random(
+                            Range {
+                                start: *min,
+                                end: *max,
+                            },
+                            SmallRng::from_entropy(),
+                        )),
+                    });
+                }
+                FieldKind::Float(f) => {
+                    fields.push(Field {
+                        key: Arc::clone(&key),
+                        copy_id,
+                        random_null,
+                        field_value: FieldValue::Float(FloatValue::Fixed(*f)),
+                    });
+                }
+                FieldKind::FloatRange(min, max) => {
+                    fields.push(Field {
+                        key: Arc::clone(&key),
+                        copy_id,
+                        random_null,
+                        field_value: FieldValue::Float(FloatValue::Random(
+                            Range {
+                                start: *min,
+                                end: *max,
+                            },
+                            SmallRng::from_entropy(),
+                        )),
+                    });
+                }
+            }
+        }
+    }
+
+    Measurement {
+        name,
+        copy_id: measurement_id,
+        tags,
+        fields,
+        lines_per_sample,
+    }
+}
+
+/// This struct holds the generator for each writer.
+#[derive(Debug)]
+pub struct Generator {
+    pub writer_id: WriterId,
+    measurements: Vec<Measurement>,
+}
+
+impl Generator {
+    pub fn new(writer_id: WriterId) -> Self {
+        Self {
+            writer_id,
+            measurements: Vec::new(),
+        }
+    }
+
+    /// Return a single sample run from the generator as a string.
+    pub fn dry_run(&mut self, timestamp: i64) -> String {
+        // create a buffer and write a single sample to it
+        let mut buffer = Vec::new();
+        self.write_sample_to(timestamp, &mut buffer)
+            .expect("writing to buffer should succeed");
+
+        // convert the buffer to a string and return it
+        String::from_utf8(buffer).expect("buffer should be valid utf8")
+    }
+
+    pub fn write_sample_to<W: Write>(
+        &mut self,
+        timestamp: i64,
+        mut w: W,
+    ) -> io::Result<WriteSummary> {
+        let mut write_summary = WriteSummary {
+            bytes_written: 0,
+            lines_written: 0,
+            tags_written: 0,
+            fields_written: 0,
+        };
+
+        let mut w = ByteCounter::new(&mut w);
+
+        for measurement in &mut self.measurements {
+            for _ in 0..measurement.lines_per_sample {
+                if measurement.copy_id > 1 {
+                    write!(w, "{}_{}", measurement.name, measurement.copy_id)?;
+                } else {
+                    write!(w, "{}", measurement.name)?;
+                }
+
+                for tag in &mut measurement.tags {
+                    tag.write_to(self.writer_id, &mut w)?;
+                }
+                write_summary.tags_written += measurement.tags.len();
+
+                for (i, field) in measurement.fields.iter_mut().enumerate() {
+                    let separator = if i == 0 { " " } else { "," };
+                    write!(w, "{}", separator)?;
+                    field.write_to(&mut w)?;
+                }
+                write_summary.fields_written += measurement.fields.len();
+
+                writeln!(w, " {}", timestamp)?;
+
+                write_summary.lines_written += 1;
+            }
+        }
+
+        write_summary.bytes_written = w.bytes_written();
+
+        Ok(write_summary)
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct WriteSummary {
+    pub bytes_written: usize,
+    pub lines_written: usize,
+    pub tags_written: usize,
+    pub fields_written: usize,
+}
+
+#[derive(Debug)]
+struct Measurement {
+    name: Arc<str>,
+    copy_id: usize,
+    tags: Vec<Tag>,
+    fields: Vec<Field>,
+    lines_per_sample: usize,
+}
+
+#[derive(Debug)]
+struct Tag {
+    key: Arc<str>,
+    value: Option<Arc<str>>,
+    copy_id: usize,
+    cardinality_id_min: usize,
+    cardinality_id_max: usize,
+    cardinality_id_current: usize,
+    append_writer_id: bool,
+    append_copy_id: bool,
+}
+
+impl Tag {
+    fn write_to<W: Write>(
+        &mut self,
+        writer_id: WriterId,
+        w: &mut ByteCounter<W>,
+    ) -> io::Result<()> {
+        if self.copy_id > 1 {
+            write!(w, ",{}_{}=", self.key, self.copy_id)?;
+        } else {
+            write!(w, ",{}=", self.key)?;
+        }
+
+        if let Some(v) = &self.value {
+            write!(w, "{}", v)?;
+        }
+
+        // append the writer id with a preceding w if we're supposed to
+        if self.append_writer_id {
+            write!(w, "{}", writer_id)?;
+        }
+
+        // append the copy id with a preceding c if we're supposed to
+        if self.append_copy_id {
+            write!(w, "{}", self.copy_id)?;
+        }
+
+        // keep track of the cardinality id if min and max are different
+        if self.cardinality_id_min != 0 && self.cardinality_id_max != 0 {
+            // reset the id back to min if we've cycled through them all
+            if self.cardinality_id_current > self.cardinality_id_max {
+                self.cardinality_id_current = self.cardinality_id_min;
+            }
+
+            // write the cardinality counter value to the tag value
+            write!(w, "{}", self.cardinality_id_current)?;
+
+            self.cardinality_id_current += 1;
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+struct Field {
+    key: Arc<str>,
+    copy_id: usize,
+    random_null: Option<(f64, SmallRng)>,
+    field_value: FieldValue,
+}
+
+#[derive(Debug)]
+enum FieldValue {
+    Integer(IntegerValue),
+    Float(FloatValue),
+    String(StringValue),
+    Boolean(BooleanValue),
+}
+
+impl Field {
+    fn write_to<W: Write>(&mut self, w: &mut ByteCounter<W>) -> io::Result<()> {
+        // if there are random nulls, check and return without writing the field if it hits the
+        // probability
+        if let Some((probability, rng)) = &mut self.random_null {
+            let val: f64 = rng.gen();
+            if val <= *probability {
+                return Ok(());
+            }
+        }
+
+        if self.copy_id > 1 {
+            write!(w, "{}_{}=", self.key, self.copy_id)?;
+        } else {
+            write!(w, "{}=", self.key)?;
+        }
+
+        match &mut self.field_value {
+            FieldValue::Integer(f) => match f {
+                IntegerValue::Fixed(v) => write!(w, "{}i", v)?,
+                IntegerValue::Random(range, rng) => {
+                    let v: i64 = rng.gen_range(range.clone());
+                    write!(w, "{}i", v)?;
+                }
+            },
+            FieldValue::Float(f) => match f {
+                FloatValue::Fixed(v) => write!(w, "{}", v)?,
+                FloatValue::Random(range, rng) => {
+                    let v: f64 = rng.gen_range(range.clone());
+                    write!(w, "{:.3}", v)?;
+                }
+            },
+            FieldValue::String(s) => match s {
+                StringValue::Fixed(v) => write!(w, "\"{}\"", v)?,
+                StringValue::Random(size, rng) => {
+                    let random: String = rng
+                        .sample_iter(&Alphanumeric)
+                        .take(*size)
+                        .map(char::from)
+                        .collect();
+
+                    write!(w, "\"{}\"", random)?;
+                }
+            },
+            FieldValue::Boolean(f) => match f {
+                BooleanValue::Random(rng) => {
+                    let v: bool = rng.gen();
+                    write!(w, "{}", v)?;
+                }
+            },
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+enum IntegerValue {
+    Fixed(i64),
+    Random(Range<i64>, SmallRng),
+}
+
+#[derive(Debug)]
+enum FloatValue {
+    Fixed(f64),
+    Random(Range<f64>, SmallRng),
+}
+
+#[derive(Debug)]
+enum StringValue {
+    Fixed(Arc<str>),
+    Random(usize, SmallRng),
+}
+
+#[derive(Debug)]
+enum BooleanValue {
+    Random(SmallRng),
+}
+
+struct ByteCounter<W> {
+    inner: W,
+    count: usize,
+}
+
+impl<W> ByteCounter<W>
+where
+    W: Write,
+{
+    fn new(inner: W) -> Self {
+        Self { inner, count: 0 }
+    }
+
+    fn bytes_written(&self) -> usize {
+        self.count
+    }
+}
+
+impl<W> Write for ByteCounter<W>
+where
+    W: Write,
+{
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let res = self.inner.write(buf);
+        if let Ok(size) = res {
+            self.count += size
+        }
+        res
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.inner.flush()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::specification::{FieldSpec, TagSpec};
+    #[test]
+    fn example_spec_lp() {
+        let spec = DataSpec {
+            name: "foo".to_string(),
+            measurements: vec![MeasurementSpec {
+                name: "m".to_string(),
+                tags: vec![TagSpec {
+                    key: "t".to_string(),
+                    copies: Some(2),
+                    append_copy_id: None,
+                    value: Some("w".to_string()),
+                    append_writer_id: None,
+                    cardinality: Some(10),
+                }],
+                fields: vec![
+                    FieldSpec {
+                        key: "i".to_string(),
+                        copies: Some(2),
+                        null_probability: None,
+                        field: FieldKind::Integer(42),
+                    },
+                    FieldSpec {
+                        key: "f".to_string(),
+                        copies: None,
+                        null_probability: None,
+                        field: FieldKind::Float(6.8),
+                    },
+                    FieldSpec {
+                        key: "s".to_string(),
+                        copies: None,
+                        null_probability: None,
+                        field: FieldKind::String("hello".to_string()),
+                    },
+                ],
+                copies: Some(1),
+                lines_per_sample: Some(2),
+            }],
+        };
+        let mut generators = create_generators(&spec, 2).unwrap();
+
+        let lp = generators.get_mut(0).unwrap().dry_run(123);
+        let actual: Vec<&str> = lp.split('\n').collect();
+        let expected: Vec<&str> = vec![
+            "m,t=w1,t_2=w1 i=42i,i_2=42i,f=6.8,s=\"hello\" 123",
+            "m,t=w2,t_2=w2 i=42i,i_2=42i,f=6.8,s=\"hello\" 123",
+            "",
+        ];
+        assert_eq!(actual, expected);
+
+        let lp = generators.get_mut(1).unwrap().dry_run(567);
+        let actual: Vec<&str> = lp.split('\n').collect();
+        let expected: Vec<&str> = vec![
+            "m,t=w6,t_2=w6 i=42i,i_2=42i,f=6.8,s=\"hello\" 567",
+            "m,t=w7,t_2=w7 i=42i,i_2=42i,f=6.8,s=\"hello\" 567",
+            "",
+        ];
+        assert_eq!(actual, expected);
+    }
+}
diff --git a/influxdb3_load_generator/src/main.rs b/influxdb3_load_generator/src/main.rs
new file mode 100644
index 00000000000..a756d7d339c
--- /dev/null
+++ b/influxdb3_load_generator/src/main.rs
@@ -0,0 +1,177 @@
+//! Entrypoint of InfluxDB IOx binary
+#![recursion_limit = "512"] // required for print_cpu
+#![deny(rustdoc::broken_intra_doc_links, rustdoc::bare_urls, rust_2018_idioms)]
+#![warn(
+    missing_debug_implementations,
+    clippy::explicit_iter_loop,
+    clippy::use_self,
+    clippy::clone_on_ref_ptr,
+    clippy::future_not_send
+)]
+
+pub mod line_protocol_generator;
+pub mod query_generator;
+pub mod report;
+pub mod specification;
+mod specs;
+
+pub mod commands {
+    pub mod common;
+    pub mod full;
+    pub mod query;
+    pub mod write;
+}
+
+use dotenvy::dotenv;
+use observability_deps::tracing::warn;
+use std::sync::{
+    atomic::{AtomicUsize, Ordering},
+    Arc,
+};
+use tokio::runtime::Runtime;
+
+enum ReturnCode {
+    Failure = 1,
+}
+
+#[derive(Debug, clap::Parser)]
+#[clap(
+name = "influxdb3_load_generator",
+disable_help_flag = true,
+arg(
+clap::Arg::new("help")
+.long("help")
+.help("Print help information")
+.action(clap::ArgAction::Help)
+.global(true)
+),
+about = "InfluxDB 3.0 Load Generator for writes and queries",
+long_about = r#"InfluxDB 3.0 Load Generator for writes and queries
+
+Examples:
+    # Run the write load generator
+    influxdb3_load_generator write --help
+
+    # Generate a sample write spec
+    influxdb3_load_generator write --generate-spec
+
+    # Run the the query load generator
+    influxdb3_load_generator query  --help
+
+    # Generate a sample query spec
+    influxdb3_load_generator query --generate-spec
+
+    # Display all commands
+    influxdb3_load_generator --help
+"#
+)]
+struct Config {
+    #[clap(subcommand)]
+    command: Option<Command>,
+}
+
+// Ignoring clippy here since this enum is just used for running
+// the CLI command
+#[allow(clippy::large_enum_variant)]
+#[derive(Debug, clap::Parser)]
+#[allow(clippy::large_enum_variant)]
+enum Command {
+    /// Perform a query against a running InfluxDB 3.0 server
+    Query(commands::query::Config),
+
+    /// Perform a set of writes to a running InfluxDB 3.0 server
+    Write(commands::write::Config),
+
+    /// Perform both writes and queries against a running InfluxDB 3.0 server
+    Full(commands::full::Config),
+}
+
+fn main() -> Result<(), std::io::Error> {
+    // load all environment variables from .env before doing anything
+    load_dotenv();
+
+    let config: Config = clap::Parser::parse();
+
+    let tokio_runtime = get_runtime(None)?;
+    tokio_runtime.block_on(async move {
+        match config.command {
+            None => println!("command required, --help for help"),
+            Some(Command::Query(config)) => {
+                if let Err(e) = commands::query::command(config).await {
+                    eprintln!("Query command exited: {e:?}");
+                    std::process::exit(ReturnCode::Failure as _)
+                }
+            }
+            Some(Command::Write(config)) => {
+                if let Err(e) = commands::write::command(config).await {
+                    eprintln!("Write command exited: {e:?}");
+                    std::process::exit(ReturnCode::Failure as _)
+                }
+            }
+            Some(Command::Full(config)) => {
+                if let Err(e) = commands::full::command(config).await {
+                    eprintln!("Full Write/Query command exited: {e:?}");
+                    std::process::exit(ReturnCode::Failure as _)
+                }
+            }
+        }
+    });
+
+    Ok(())
+}
+
+/// Creates the tokio runtime for executing
+///
+/// if nthreads is none, uses the default scheduler
+/// otherwise, creates a scheduler with the number of threads
+fn get_runtime(num_threads: Option<usize>) -> Result<Runtime, std::io::Error> {
+    // NOTE: no log macros will work here!
+    //
+    // That means use eprintln!() instead of error!() and so on. The log emitter
+    // requires a running tokio runtime and is initialised after this function.
+
+    use tokio::runtime::Builder;
+    let kind = std::io::ErrorKind::Other;
+    match num_threads {
+        None => Runtime::new(),
+        Some(num_threads) => {
+            println!("Setting number of threads to '{num_threads}' per command line request");
+
+            let thread_counter = Arc::new(AtomicUsize::new(1));
+            match num_threads {
+                0 => {
+                    let msg =
+                        format!("Invalid num-threads: '{num_threads}' must be greater than zero");
+                    Err(std::io::Error::new(kind, msg))
+                }
+                1 => Builder::new_current_thread().enable_all().build(),
+                _ => Builder::new_multi_thread()
+                    .enable_all()
+                    .thread_name_fn(move || {
+                        format!("IOx main {}", thread_counter.fetch_add(1, Ordering::SeqCst))
+                    })
+                    .worker_threads(num_threads)
+                    .build(),
+            }
+        }
+    }
+}
+
+/// Source the .env file before initialising the Config struct - this sets
+/// any envs in the file, which the Config struct then uses.
+///
+/// Precedence is given to existing env variables.
+fn load_dotenv() {
+    match dotenv() {
+        Ok(_) => {}
+        Err(dotenvy::Error::Io(err)) if err.kind() == std::io::ErrorKind::NotFound => {
+            // Ignore this - a missing env file is not an error, defaults will
+            // be applied when initialising the Config struct.
+        }
+        Err(e) => {
+            eprintln!("FATAL Error loading config from: {e}");
+            eprintln!("Aborting");
+            std::process::exit(1);
+        }
+    };
+}
diff --git a/influxdb3_load_generator/src/query_generator.rs b/influxdb3_load_generator/src/query_generator.rs
new file mode 100644
index 00000000000..6b22ee409d0
--- /dev/null
+++ b/influxdb3_load_generator/src/query_generator.rs
@@ -0,0 +1,160 @@
+use std::slice::IterMut;
+
+use clap::ValueEnum;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use crate::specification::{ParamKind, ParamSpec, QuerierSpec, QuerySpec};
+
+pub type QuerierId = usize;
+
+/// Create a set of queriers to perform queries in parallel
+pub fn create_queriers(
+    spec: &QuerierSpec,
+    format: Format,
+    querier_count: usize,
+) -> Result<Vec<Querier>, anyhow::Error> {
+    let mut generators = vec![];
+    for querier_id in 1..querier_count + 1 {
+        let mut queries = vec![];
+        for q in &spec.queries {
+            queries.extend(create_queries(q, querier_id, querier_count))
+        }
+        generators.push(Querier {
+            querier_id,
+            format,
+            queries,
+        })
+    }
+    Ok(generators)
+}
+
+/// Generate a set of queries off of a query spec
+///
+/// This produces a Vec so that certain [`QuerySpec`]s can result in multiple
+/// queries per interval.
+fn create_queries(spec: &QuerySpec, querier_id: QuerierId, querier_count: usize) -> Vec<Query> {
+    let query = spec.query.clone();
+    let mut params = vec![];
+    for p in &spec.params {
+        params.push(Param::initialize(p, querier_id, querier_count));
+    }
+    vec![Query { query, params }]
+}
+
+#[derive(Debug)]
+pub struct Querier {
+    pub querier_id: QuerierId,
+    pub format: Format,
+    pub queries: Vec<Query>,
+}
+
+#[derive(Copy, Clone, Debug, Default, Deserialize, Serialize, ValueEnum)]
+pub enum Format {
+    #[default]
+    Json,
+    Csv,
+}
+
+impl From<Format> for influxdb3_client::Format {
+    fn from(format: Format) -> Self {
+        match format {
+            Format::Json => Self::Json,
+            Format::Csv => Self::Csv,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Query {
+    query: String,
+    params: Vec<Param>,
+}
+
+impl Query {
+    pub fn query(&self) -> &str {
+        &self.query
+    }
+
+    pub fn params_mut(&mut self) -> IterMut<'_, Param> {
+        self.params.iter_mut()
+    }
+}
+
+#[derive(Debug)]
+pub struct Param {
+    name: String,
+    value: ParamValue,
+}
+
+impl Param {
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    pub fn generate(&mut self) -> Value {
+        self.value.generate()
+    }
+
+    fn initialize(spec: &ParamSpec, querier_id: QuerierId, querier_count: usize) -> Self {
+        let name = spec.name.clone();
+        let value = match &spec.param {
+            ParamKind::Static(v) => ParamValue::Static(v.clone()),
+            ParamKind::Cardinality { base, cardinality } => {
+                let (min, max) = cardinality_range(*cardinality, querier_id, querier_count);
+                ParamValue::Cardinality(CardinalityValue {
+                    base: base.to_owned(),
+                    min,
+                    max,
+                    current: min,
+                })
+            }
+        };
+        Self { name, value }
+    }
+}
+
+fn cardinality_range(
+    cardinality: usize,
+    querier_id: QuerierId,
+    querier_count: usize,
+) -> (usize, usize) {
+    let increment = usize::div_ceil(cardinality, querier_count);
+    let min = querier_id * increment - increment + 1;
+    let max = min + increment - 1;
+
+    (min, max)
+}
+
+#[derive(Debug)]
+pub enum ParamValue {
+    Static(Value),
+    Cardinality(CardinalityValue),
+}
+
+impl ParamValue {
+    fn generate(&mut self) -> Value {
+        match self {
+            Self::Static(v) => v.clone(),
+            Self::Cardinality(cv) => {
+                let v = if let Some(base) = &cv.base {
+                    format!("{base}{current}", current = cv.current)
+                } else {
+                    cv.current.to_string()
+                };
+                if cv.current > cv.max {
+                    cv.current = cv.min;
+                }
+                Value::String(v)
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CardinalityValue {
+    base: Option<String>,
+    min: usize,
+    max: usize,
+    current: usize,
+}
diff --git a/influxdb3_load_generator/src/report.rs b/influxdb3_load_generator/src/report.rs
new file mode 100644
index 00000000000..04c8026aee9
--- /dev/null
+++ b/influxdb3_load_generator/src/report.rs
@@ -0,0 +1,428 @@
+//! Trackers and report generators for write and query runs
+
+use crate::line_protocol_generator::{WriteSummary, WriterId};
+use crate::query_generator::QuerierId;
+use anyhow::{bail, Context};
+use chrono::{DateTime, Local};
+use influxdb3_process::INFLUXDB3_PROCESS_NAME;
+use parking_lot::Mutex;
+use serde::Serialize;
+use std::collections::HashMap;
+use std::fs::File;
+use std::time::{Duration, Instant};
+use sysinfo::{Pid, Process, ProcessRefreshKind, System};
+// Logged reports will be flushed to the csv file on this interval
+const REPORT_FLUSH_INTERVAL: Duration = Duration::from_millis(100);
+
+const CONSOLE_REPORT_INTERVAL: Duration = Duration::from_secs(1);
+
+#[derive(Debug, Clone, Copy)]
+pub struct WriterReport {
+    summary: Option<WriteSummary>, // failed write if none
+    write_instant: Instant,
+    wall_time: DateTime<Local>,
+    response_time_ms: u64,
+    writer_id: usize,
+}
+
+#[derive(Debug)]
+pub struct WriteReporter {
+    state: Mutex<Vec<WriterReport>>,
+    csv_writer: Mutex<csv::Writer<File>>,
+    shutdown: Mutex<bool>,
+}
+
+impl WriteReporter {
+    pub fn new(csv_file: File) -> Result<Self, anyhow::Error> {
+        // open csv file for writing
+        let mut csv_writer = csv::Writer::from_writer(csv_file);
+        // write header
+        csv_writer
+            .write_record([
+                "writer_id",
+                "response",
+                "latency_ms",
+                "test_time_ms",
+                "sample_number",
+                "bytes",
+                "lines",
+                "tags",
+                "fields",
+                "wall_time",
+            ])
+            .context("failed to write csv report header")?;
+
+        Ok(Self {
+            state: Mutex::new(Vec::new()),
+            csv_writer: Mutex::new(csv_writer),
+            shutdown: Mutex::new(false),
+        })
+    }
+
+    pub fn report_failure(
+        &self,
+        writer_id: usize,
+        response_time_ms: u64,
+        wall_time: DateTime<Local>,
+    ) {
+        let mut state = self.state.lock();
+        state.push(WriterReport {
+            summary: None,
+            write_instant: Instant::now(),
+            wall_time,
+            response_time_ms,
+            writer_id,
+        });
+    }
+
+    pub fn report_write(
+        &self,
+        writer_id: usize,
+        summary: WriteSummary,
+        response_time_ms: u64,
+        wall_time: DateTime<Local>,
+    ) {
+        let mut state = self.state.lock();
+        state.push(WriterReport {
+            summary: Some(summary),
+            write_instant: Instant::now(),
+            wall_time,
+            response_time_ms,
+            writer_id,
+        });
+    }
+
+    /// Run in a spawn blocking task to flush reports to the csv file
+    pub fn flush_reports(&self) {
+        let start_time = Instant::now();
+        let mut sample_counts: HashMap<WriterId, usize> = HashMap::new();
+        let mut console_stats = ConsoleReportStats::new();
+
+        loop {
+            let reports = {
+                let mut state = self.state.lock();
+                let mut reports = Vec::with_capacity(state.len());
+                std::mem::swap(&mut reports, &mut *state);
+                reports
+            };
+
+            let mut csv_writer = self.csv_writer.lock();
+            for report in reports {
+                let test_time = report.write_instant.duration_since(start_time).as_millis();
+                let sample_number = sample_counts.entry(report.writer_id).or_insert(0);
+                *sample_number += 1;
+
+                if let Some(summary) = report.summary {
+                    csv_writer
+                        .write_record(&[
+                            report.writer_id.to_string(),
+                            "200".to_string(),
+                            report.response_time_ms.to_string(),
+                            test_time.to_string(),
+                            sample_number.to_string(),
+                            summary.bytes_written.to_string(),
+                            summary.lines_written.to_string(),
+                            summary.tags_written.to_string(),
+                            summary.fields_written.to_string(),
+                            report.wall_time.to_string(),
+                        ])
+                        .expect("failed to write csv report record");
+
+                    console_stats.success += 1;
+                    console_stats.lines += summary.lines_written;
+                    console_stats.bytes += summary.bytes_written;
+                } else {
+                    csv_writer
+                        .write_record(&[
+                            report.writer_id.to_string(),
+                            "500".to_string(),
+                            report.response_time_ms.to_string(),
+                            test_time.to_string(),
+                            sample_number.to_string(),
+                            "0".to_string(),
+                            "0".to_string(),
+                            "0".to_string(),
+                            "0".to_string(),
+                            report.wall_time.to_string(),
+                        ])
+                        .expect("failed to write csv report record");
+
+                    console_stats.error += 1;
+                }
+            }
+
+            csv_writer.flush().expect("failed to flush csv reports");
+
+            if *self.shutdown.lock() {
+                return;
+            }
+
+            if console_stats.last_console_output_time.elapsed() > CONSOLE_REPORT_INTERVAL {
+                let elapsed_millis = console_stats.last_console_output_time.elapsed().as_millis();
+
+                println!(
+                    "write: success: {:.0}/s, error: {:.0}/s, lines: {:.0}/s, bytes: {:.0}/s",
+                    console_stats.success as f64 / elapsed_millis as f64 * 1000.0,
+                    console_stats.error as f64 / elapsed_millis as f64 * 1000.0,
+                    console_stats.lines as f64 / elapsed_millis as f64 * 1000.0,
+                    console_stats.bytes as f64 / elapsed_millis as f64 * 1000.0,
+                );
+
+                console_stats = ConsoleReportStats::new();
+            }
+
+            std::thread::sleep(REPORT_FLUSH_INTERVAL);
+        }
+    }
+
+    pub fn shutdown(&self) {
+        *self.shutdown.lock() = true;
+    }
+}
+
+struct ConsoleReportStats {
+    last_console_output_time: Instant,
+    success: usize,
+    error: usize,
+    lines: usize,
+    bytes: usize,
+}
+
+impl ConsoleReportStats {
+    fn new() -> Self {
+        Self {
+            last_console_output_time: Instant::now(),
+            success: 0,
+            error: 0,
+            lines: 0,
+            bytes: 0,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct QuerierReport {
+    query_instant: Instant,
+    wall_time: DateTime<Local>,
+    response_time_ms: u64,
+    response_status: u16,
+    rows_returned: u64,
+    querier_id: QuerierId,
+}
+
+#[derive(Debug)]
+pub struct QueryReporter {
+    state: Mutex<Vec<QuerierReport>>,
+    csv_writer: Mutex<csv::Writer<File>>,
+    shutdown: Mutex<bool>,
+}
+
+impl QueryReporter {
+    pub fn new(csv_file: File) -> Self {
+        let csv_writer = Mutex::new(csv::Writer::from_writer(csv_file));
+        Self {
+            state: Mutex::new(vec![]),
+            csv_writer,
+            shutdown: Mutex::new(false),
+        }
+    }
+
+    pub fn report(
+        &self,
+        querier_id: QuerierId,
+        response_status: u16,
+        response_time_ms: u64,
+        rows_returned: u64,
+        wall_time: DateTime<Local>,
+    ) {
+        let mut state = self.state.lock();
+        state.push(QuerierReport {
+            query_instant: Instant::now(),
+            wall_time,
+            response_time_ms,
+            response_status,
+            rows_returned,
+            querier_id,
+        })
+    }
+
+    pub fn flush_reports(&self) {
+        let start_time = Instant::now();
+        let mut console_stats = QueryConsoleStats::new();
+
+        loop {
+            let reports = {
+                let mut state = self.state.lock();
+                let mut reports = Vec::with_capacity(state.len());
+                std::mem::swap(&mut reports, &mut *state);
+                reports
+            };
+
+            let mut csv_writer = self.csv_writer.lock();
+            for report in reports {
+                let test_time_ms = report.query_instant.duration_since(start_time).as_millis();
+                if report.response_status > 199 && report.response_status < 300 {
+                    console_stats.success += 1;
+                } else {
+                    console_stats.error += 1;
+                }
+                console_stats.rows += report.rows_returned;
+                csv_writer
+                    .serialize(QueryRecord {
+                        test_time_ms,
+                        response_ms: report.response_time_ms,
+                        response_status: report.response_status,
+                        rows: report.rows_returned,
+                        querier_id: report.querier_id,
+                        wall_time: report.wall_time,
+                    })
+                    .expect("failed to write csv report record");
+            }
+            csv_writer.flush().expect("failed to flush csv reports");
+
+            if *self.shutdown.lock() {
+                return;
+            }
+
+            if console_stats.last_console_output_time.elapsed() > CONSOLE_REPORT_INTERVAL {
+                let elapsed_millis = console_stats.last_console_output_time.elapsed().as_millis();
+
+                println!(
+                    "query: success: {:.0}/s, error: {:.0}/s, rows: {:.0}/s",
+                    console_stats.success as f64 / elapsed_millis as f64 * 1000.0,
+                    console_stats.error as f64 / elapsed_millis as f64 * 1000.0,
+                    console_stats.rows as f64 / elapsed_millis as f64 * 1000.0,
+                );
+
+                console_stats = QueryConsoleStats::new();
+            }
+
+            std::thread::sleep(REPORT_FLUSH_INTERVAL);
+        }
+    }
+
+    pub fn shutdown(&self) {
+        *self.shutdown.lock() = true;
+    }
+}
+
+#[derive(Debug, Serialize)]
+struct QueryRecord {
+    querier_id: QuerierId,
+    wall_time: DateTime<Local>,
+    test_time_ms: u128,
+    response_ms: u64,
+    response_status: u16,
+    rows: u64,
+}
+
+struct QueryConsoleStats {
+    last_console_output_time: Instant,
+    success: usize,
+    error: usize,
+    rows: u64,
+}
+
+impl QueryConsoleStats {
+    fn new() -> Self {
+        Self {
+            last_console_output_time: Instant::now(),
+            success: 0,
+            error: 0,
+            rows: 0,
+        }
+    }
+}
+
+const SYSTEM_STATS_REPORT_INTERVAL: Duration = Duration::from_millis(500);
+
+#[derive(Debug, Copy, Clone, Serialize)]
+pub struct SystemStatsRecord {
+    wall_time: DateTime<Local>,
+    test_time_ms: u128,
+    cpu_usage: f32,
+    written_bytes: u64,
+    read_bytes: u64,
+    memory_bytes: u64,
+    virtual_memory_bytes: u64,
+}
+
+#[derive(Debug)]
+pub struct SystemStatsReporter {
+    pid: Pid,
+    system: Mutex<System>,
+    csv_writer: Mutex<csv::Writer<File>>,
+    shutdown: Mutex<bool>,
+}
+
+impl SystemStatsReporter {
+    pub fn new(csv_file: File) -> Result<Self, anyhow::Error> {
+        let csv_writer = Mutex::new(csv::Writer::from_writer(csv_file));
+        let mut system = System::new_all();
+        let mut processes = system
+            .processes_by_exact_name(INFLUXDB3_PROCESS_NAME)
+            .collect::<Vec<&Process>>();
+        if processes.is_empty() {
+            bail!("there is no '{}' process", INFLUXDB3_PROCESS_NAME);
+        }
+        if processes.len() > 1 {
+            bail!(
+                "ensure there is only one '{}' process running on your operating system",
+                INFLUXDB3_PROCESS_NAME
+            );
+        }
+        let pid = processes.pop().unwrap().pid();
+        // refresh the system stats for the process to initialize the baseline:
+        system.refresh_pids(&[pid]);
+        Ok(Self {
+            pid,
+            system: Mutex::new(system),
+            csv_writer,
+            shutdown: Mutex::new(false),
+        })
+    }
+
+    pub fn report_stats(&self) {
+        let start_time = Instant::now();
+
+        loop {
+            let mut system = self.system.lock();
+            system.refresh_pids_specifics(
+                &[self.pid],
+                ProcessRefreshKind::new()
+                    .with_cpu()
+                    .with_memory()
+                    .with_disk_usage(),
+            );
+            let process = system
+                .process(self.pid)
+                .unwrap_or_else(|| panic!("process with pid: {}", self.pid));
+            let mut csv_writer = self.csv_writer.lock();
+            let test_time_ms = Instant::now().duration_since(start_time).as_millis();
+            csv_writer
+                .serialize(SystemStatsRecord {
+                    wall_time: Local::now(),
+                    test_time_ms,
+                    cpu_usage: process.cpu_usage(),
+                    written_bytes: process.disk_usage().written_bytes,
+                    read_bytes: process.disk_usage().read_bytes,
+                    memory_bytes: process.memory(),
+                    virtual_memory_bytes: process.virtual_memory(),
+                })
+                .expect("failed to write csv record for system stats");
+            csv_writer.flush().expect("flush system stats csv reports");
+
+            if *self.shutdown.lock() {
+                return;
+            }
+
+            std::thread::sleep(
+                sysinfo::MINIMUM_CPU_UPDATE_INTERVAL.max(SYSTEM_STATS_REPORT_INTERVAL),
+            );
+        }
+    }
+
+    pub fn shutdown(&self) {
+        *self.shutdown.lock() = true;
+    }
+}
diff --git a/influxdb3_load_generator/src/specification.rs b/influxdb3_load_generator/src/specification.rs
new file mode 100644
index 00000000000..36d92a17039
--- /dev/null
+++ b/influxdb3_load_generator/src/specification.rs
@@ -0,0 +1,235 @@
+use std::path::Path;
+
+use anyhow::Context;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use crate::line_protocol_generator::WriterId;
+
+/// The specification for the data to be generated
+#[derive(Debug, Deserialize, Serialize)]
+pub struct DataSpec {
+    /// The name of this spec
+    pub name: String,
+    /// The measurements to be generated for each sample
+    pub measurements: Vec<MeasurementSpec>,
+}
+
+impl DataSpec {
+    pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self, anyhow::Error> {
+        let contents = std::fs::read_to_string(path)?;
+        let res = serde_json::from_str(&contents)?;
+
+        Ok(res)
+    }
+
+    pub fn to_json_string_pretty(&self) -> Result<String, anyhow::Error> {
+        let res = serde_json::to_string_pretty(&self).context("failed to encode json to string")?;
+        Ok(res)
+    }
+}
+
+/// Specification for a measurement to be generated
+#[derive(Debug, Deserialize, Serialize)]
+pub struct MeasurementSpec {
+    /// The name of the measurement
+    pub name: String,
+    /// The tags to be generated for each line
+    pub tags: Vec<TagSpec>,
+    /// The fields to be generated for each line
+    pub fields: Vec<FieldSpec>,
+    /// Create this many copies of this measurement in each sample. The copy number will be
+    /// appended to the measurement name to uniquely identify it.
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub copies: Option<usize>,
+    /// If this measurement has tags with cardinality, this is the number of lines that will
+    /// be output per sample (up to the highest cardinality tag). If not specified, all unique
+    /// values will be used. Cardinality is split across the number of workers, so the number
+    /// of lines per sample could be less than this number.
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub lines_per_sample: Option<usize>,
+}
+
+impl MeasurementSpec {
+    /// Get the max cardinality accross all tags in the spec
+    pub fn max_cardinality(&self) -> usize {
+        self.tags
+            .iter()
+            .map(|t| t.cardinality.unwrap_or(1))
+            .max()
+            .unwrap_or(1)
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, Default)]
+pub struct TagSpec {
+    /// the key/name of the tag
+    pub key: String,
+
+    /// have this many copies of this tag in the measurement. Random values will be generated
+    /// independently (i.e. copies won't share the same random value). Will add the copy number to
+    /// the key of the tag to uniquely identify it.
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub copies: Option<usize>,
+    /// if set, appends the copy id of the tag to the value of the tag
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub append_copy_id: Option<bool>,
+
+    /// output this string value for every line this tag is present
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub value: Option<String>,
+
+    /// if set, appends the writer id to the value of the tag
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub append_writer_id: Option<bool>,
+
+    /// will add a number to the value of the tag, with this number of unique values
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub cardinality: Option<usize>,
+}
+
+impl TagSpec {
+    pub fn cardinality_min_max(
+        &self,
+        writer_id: WriterId,
+        writer_count: usize,
+    ) -> Option<(usize, usize)> {
+        if let Some(cardinality) = self.cardinality {
+            let cardinality_increment = usize::div_ceil(cardinality, writer_count);
+            let cardinality_id_min = writer_id * cardinality_increment - cardinality_increment + 1;
+            let cardinality_id_max = cardinality_id_min + cardinality_increment - 1;
+
+            Some((cardinality_id_min, cardinality_id_max))
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct FieldSpec {
+    // These options apply to any type of field
+    /// the key/name of the field
+    pub key: String,
+    /// have this many copies of this field in the measurement. Random values will be generated
+    /// independently (i.e. copies won't share the same random value). Will add the copy number to
+    /// the key of the field to uniquely identify it.
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub copies: Option<usize>,
+    /// A float between 0.0 and 1.0 that determines the probability that this field will be null.
+    /// At least one field in a measurement should not have this option set.
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub null_probability: Option<f64>,
+
+    #[serde(flatten)]
+    pub field: FieldKind,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum FieldKind {
+    /// generates a random bool for the value of this field
+    Bool(bool),
+    /// output this string value for every line this field is present
+    String(String),
+    /// generate a random string of this length for every line this field is present
+    StringRandom(usize),
+    /// output this integer value for every line this field is present
+    Integer(i64),
+    /// generate a random integer in this range for every line this field is present
+    IntegerRange(i64, i64),
+    /// output this float value for every line this field is present
+    Float(f64),
+    /// generate a random float in this range for every line this field is present
+    FloatRange(f64, f64),
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct QuerierSpec {
+    /// The name of this spec
+    pub name: String,
+    /// The queries to run on each interval
+    pub queries: Vec<QuerySpec>,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct QuerySpec {
+    /// The literal query string to be executed
+    pub query: String,
+    /// Define parameters that will be injected into `query`
+    #[serde(default)]
+    pub params: Vec<ParamSpec>,
+}
+
+impl QuerierSpec {
+    pub(crate) fn to_json_string_pretty(&self) -> Result<String, anyhow::Error> {
+        serde_json::to_string_pretty(self).context("failed to serialize query spec")
+    }
+
+    pub(crate) fn from_path<P: AsRef<Path>>(path: P) -> Result<Self, anyhow::Error> {
+        let contents = std::fs::read_to_string(path)?;
+        serde_json::from_str(&contents).context("unable to serialize as JSON")
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ParamSpec {
+    /// The literal parameter name
+    ///
+    /// If the parameter appears in the query as `$foo`, specify `"foo"` here.
+    pub name: String,
+    /// The parameter definition
+    #[serde(flatten)]
+    pub param: ParamKind,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "snake_case", tag = "type", content = "def")]
+pub enum ParamKind {
+    Static(Value),
+    Cardinality {
+        #[serde(skip_serializing_if = "Option::is_none", default)]
+        base: Option<String>,
+        cardinality: usize,
+    },
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn tag_spec_splits_cardinality_for_writers() {
+        let mut tag_spec = TagSpec {
+            key: "".to_string(),
+            copies: None,
+            append_copy_id: None,
+            value: None,
+            append_writer_id: None,
+            cardinality: Some(100),
+        };
+
+        let (min, max) = tag_spec.cardinality_min_max(1, 10).unwrap();
+        assert_eq!(min, 1);
+        assert_eq!(max, 10);
+        let (min, max) = tag_spec.cardinality_min_max(2, 10).unwrap();
+        assert_eq!(min, 11);
+        assert_eq!(max, 20);
+        let (min, max) = tag_spec.cardinality_min_max(10, 10).unwrap();
+        assert_eq!(min, 91);
+        assert_eq!(max, 100);
+
+        // if the cardinality is not evenly divisible by the number of writers, the last writer
+        // will go over the cardinality set
+        tag_spec.cardinality = Some(30);
+        let (min, max) = tag_spec.cardinality_min_max(1, 7).unwrap();
+        assert_eq!(min, 1);
+        assert_eq!(max, 5);
+        let (min, max) = tag_spec.cardinality_min_max(4, 7).unwrap();
+        assert_eq!(min, 16);
+        assert_eq!(max, 20);
+        let (min, max) = tag_spec.cardinality_min_max(7, 7).unwrap();
+        assert_eq!(min, 31);
+        assert_eq!(max, 35);
+    }
+}
diff --git a/influxdb3_load_generator/src/specs/example.rs b/influxdb3_load_generator/src/specs/example.rs
new file mode 100644
index 00000000000..48c1b1d0fcd
--- /dev/null
+++ b/influxdb3_load_generator/src/specs/example.rs
@@ -0,0 +1,138 @@
+//! Spec that shows the various elements of the data generator. Gets printed to console when
+//! the generator is run without a spec specified.
+
+use serde_json::json;
+
+use crate::specification::*;
+use crate::specs::BuiltInSpec;
+
+pub(crate) fn spec() -> BuiltInSpec {
+    let name = "sample_spec".to_string();
+    let description =
+        r#"Example that shows the various elements of the data generator."#.to_string();
+
+    let write_spec = DataSpec {
+        name: name.to_owned(),
+        measurements: vec![
+            MeasurementSpec {
+                name: "some_measurement".to_string(),
+                tags: vec![
+                    TagSpec {
+                        key: "some_tag".to_string(),
+                        value: Some("a-value-here".to_string()),
+                        ..Default::default()
+                    },
+                    TagSpec {
+                        key: "random_data_tag".to_string(),
+                        value: Some("card-val-".to_string()),
+                        cardinality: Some(2),
+                        ..Default::default()
+                    },
+                    TagSpec {
+                        key: "higher_cardinality_data_tag".to_string(),
+                        value: Some("card-val-".to_string()),
+                        cardinality: Some(6),
+                        ..Default::default()
+                    },
+                    TagSpec {
+                        key: "copied_tag".to_string(),
+                        copies: Some(3),
+                        append_copy_id: Some(true),
+                        value: Some("copy-val-".to_string()),
+                        ..Default::default()
+                    },
+                    TagSpec {
+                        key: "writer_id".to_string(),
+                        value: Some("writer-id-".to_string()),
+                        append_writer_id: Some(true),
+                        ..Default::default()
+                    },
+                ],
+                fields: vec![
+                    FieldSpec {
+                        key: "f1".to_string(),
+                        copies: None,
+                        null_probability: None,
+                        field: FieldKind::Float(1.2),
+                    },
+                    FieldSpec {
+                        key: "i1".to_string(),
+                        copies: None,
+                        null_probability: Some(0.6),
+                        field: FieldKind::Integer(5),
+                    },
+                ],
+                copies: None,
+                lines_per_sample: None,
+            },
+            MeasurementSpec {
+                name: "copied_measurement".to_string(),
+                tags: vec![],
+                fields: vec![
+                    FieldSpec {
+                        key: "random_string".to_string(),
+                        copies: None,
+                        null_probability: None,
+                        field: FieldKind::StringRandom(10),
+                    },
+                    FieldSpec {
+                        key: "constant_string".to_string(),
+                        copies: None,
+                        null_probability: None,
+                        field: FieldKind::String("a constant string".to_string()),
+                    },
+                    FieldSpec {
+                        key: "random_integer".to_string(),
+                        copies: None,
+                        null_probability: None,
+                        field: FieldKind::IntegerRange(1, 100),
+                    },
+                    FieldSpec {
+                        key: "constant_integer".to_string(),
+                        copies: None,
+                        null_probability: None,
+                        field: FieldKind::Integer(42),
+                    },
+                    FieldSpec {
+                        key: "random_float".to_string(),
+                        copies: None,
+                        null_probability: None,
+                        field: FieldKind::FloatRange(1.0, 100.0),
+                    },
+                    FieldSpec {
+                        key: "constant_float".to_string(),
+                        copies: None,
+                        null_probability: None,
+                        field: FieldKind::Float(6.8),
+                    },
+                    FieldSpec {
+                        key: "random_bool".to_string(),
+                        copies: None,
+                        null_probability: None,
+                        field: FieldKind::Bool(true),
+                    },
+                ],
+                copies: Some(2),
+                lines_per_sample: None,
+            },
+        ],
+    };
+
+    let query_spec = QuerierSpec {
+        name: name.to_owned(),
+        queries: vec![QuerySpec {
+            query: "SELECT f1, i1 FROM some_measurement WHERE some_tag = $some_val".to_string(),
+            params: vec![ParamSpec {
+                name: "some_val".to_string(),
+                param: ParamKind::Static(json!("a-value-here")),
+            }],
+        }],
+    };
+
+    BuiltInSpec {
+        name: name.to_owned(),
+        description,
+        write_spec,
+        query_spec,
+    }
+}
diff --git a/influxdb3_load_generator/src/specs/mod.rs b/influxdb3_load_generator/src/specs/mod.rs
new file mode 100644
index 00000000000..0db6ca5b45b
--- /dev/null
+++ b/influxdb3_load_generator/src/specs/mod.rs
@@ -0,0 +1,27 @@
+//! This module contains the built-in specifications for the load generator.
+
+use crate::specification::{DataSpec, QuerierSpec};
+
+mod example;
+mod one_mil;
+
+/// Get all built-in specs
+pub(crate) fn built_in_specs() -> Vec<BuiltInSpec> {
+    // add new built-in specs here to the end of this vec
+    vec![example::spec(), one_mil::spec()]
+}
+
+pub(crate) fn built_in_spec_names() -> Vec<String> {
+    built_in_specs()
+        .iter()
+        .map(|b| b.name.to_string())
+        .collect()
+}
+
+/// A built-in specification for the load generator
+pub(crate) struct BuiltInSpec {
+    pub(crate) name: String,
+    pub(crate) description: String,
+    pub(crate) write_spec: DataSpec,
+    pub(crate) query_spec: QuerierSpec,
+}
diff --git a/influxdb3_load_generator/src/specs/one_mil.rs b/influxdb3_load_generator/src/specs/one_mil.rs
new file mode 100644
index 00000000000..b57494f26b2
--- /dev/null
+++ b/influxdb3_load_generator/src/specs/one_mil.rs
@@ -0,0 +1,61 @@
+//! Spec for the 1 million series use case
+
+use crate::specification::*;
+use crate::specs::BuiltInSpec;
+
+pub(crate) fn spec() -> BuiltInSpec {
+    let description =
+        r#"1 million series in a single table use case. If you run this with -writer-count=100
+           you'll get all 1M series written every sampling interval. Our primary test is interval=10s"#.to_string();
+
+    let write_spec = DataSpec {
+        name: "one_mil".to_string(),
+        measurements: vec![MeasurementSpec {
+            name: "measurement_data".to_string(),
+            tags: vec![TagSpec {
+                key: "series_id".to_string(),
+                value: Some("series-number-".to_string()),
+                cardinality: Some(1_000_000),
+                ..Default::default()
+            }],
+            fields: vec![
+                FieldSpec {
+                    key: "int_val".to_string(),
+                    copies: Some(10),
+                    null_probability: None,
+                    field: FieldKind::IntegerRange(1, 100_000_000),
+                },
+                FieldSpec {
+                    key: "float_val".to_string(),
+                    copies: Some(10),
+                    null_probability: None,
+                    field: FieldKind::FloatRange(1.0, 100.0),
+                },
+            ],
+            copies: None,
+            lines_per_sample: Some(10_000),
+        }],
+    };
+
+    let query_spec = QuerierSpec {
+        name: "one_mil".to_string(),
+        queries: vec![QuerySpec {
+            query: "SELECT int_val, float_val FROM measurement_data WHERE series_id = $sid"
+                .to_string(),
+            params: vec![ParamSpec {
+                name: "sid".to_string(),
+                param: ParamKind::Cardinality {
+                    base: Some("series-number-".to_string()),
+                    cardinality: 1_000_000,
+                },
+            }],
+        }],
+    };
+
+    BuiltInSpec {
+        name: "one_mil".to_string(),
+        description,
+        write_spec,
+        query_spec,
+    }
+}
diff --git a/influxdb3_process/Cargo.toml b/influxdb3_process/Cargo.toml
new file mode 100644
index 00000000000..8580335c7a7
--- /dev/null
+++ b/influxdb3_process/Cargo.toml
@@ -0,0 +1,40 @@
+[package]
+name = "influxdb3_process"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+# Core Crates
+iox_time.workspace = true
+metric.workspace = true
+tokio_metrics_bridge.workspace = true
+
+# Crates.io dependencies
+once_cell.workspace = true
+tokio.workspace = true
+uuid.workspace = true
+
+# Optional Dependencies
+tikv-jemalloc-ctl = { version = "0.5.4", optional = true }
+tikv-jemalloc-sys = { version = "0.5.4", optional = true, features = ["unprefixed_malloc_on_supported_platforms"] }
+
+[features]
+default = ["jemalloc_replacing_malloc"]
+heappy = []
+
+# heappy is an optional feature; Not on by default as it
+# runtime overhead on all allocations (calls to malloc).
+# Cargo cannot currently implement mutually exclusive features so let's force every build
+# to pick either heappy or jemalloc_replacing_malloc feature at least until we figure out something better.
+jemalloc_replacing_malloc = ["tikv-jemalloc-sys", "tikv-jemalloc-ctl"]
+
+# Implicit feature selected when running under `clippy --all-features` to accept mutable exclusive features during
+# linting
+clippy = []
+
+[lints]
+workspace = true
diff --git a/influxdb3_process/build.rs b/influxdb3_process/build.rs
new file mode 100644
index 00000000000..e4b4f992fff
--- /dev/null
+++ b/influxdb3_process/build.rs
@@ -0,0 +1,40 @@
+// Include the GIT_HASH, in `GIT_HASH` environment variable at build
+// time, panic'ing if it can not be found
+//
+// https://stackoverflow.com/questions/43753491/include-git-commit-hash-as-string-into-rust-program
+use std::process::Command;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("cargo:rerun-if-env-changed=GIT_HASH");
+    // Populate env!(GIT_HASH) with the current git commit
+    println!("cargo:rustc-env=GIT_HASH={}", get_git_hash());
+    // Populate env!(GIT_HASH_SHORT) with the current git commit
+    println!("cargo:rustc-env=GIT_HASH_SHORT={}", get_git_hash_short());
+
+    Ok(())
+}
+
+fn get_git_hash() -> String {
+    let out = match std::env::var("VERSION_HASH") {
+        Ok(v) => v,
+        Err(_) => {
+            let output = Command::new("git")
+                .args(["describe", "--always", "--dirty", "--abbrev=64"])
+                .output()
+                .expect("failed to execute git rev-parse to read the current git hash");
+
+            String::from_utf8(output.stdout).expect("non-utf8 found in git hash")
+        }
+    };
+
+    assert!(!out.is_empty(), "attempting to embed empty git hash");
+    out
+}
+
+fn get_git_hash_short() -> String {
+    let output = Command::new("git")
+        .args(["rev-parse", "--short", "HEAD"])
+        .output()
+        .expect("failed to execute git rev-parse to read the current git hash");
+    String::from_utf8(output.stdout).expect("non-utf8 found in git hash")
+}
diff --git a/influxdb3_process/src/jemalloc.rs b/influxdb3_process/src/jemalloc.rs
new file mode 100644
index 00000000000..d664570b3da
--- /dev/null
+++ b/influxdb3_process/src/jemalloc.rs
@@ -0,0 +1,85 @@
+use std::any::Any;
+
+use tikv_jemalloc_ctl::{epoch, stats};
+
+use metric::{Attributes, MetricKind, Observation, Reporter};
+
+/// A `metric::Instrument` that reports jemalloc memory statistics, specifically:
+///
+/// - a u64 gauge called "jemalloc_memstats_bytes"
+#[derive(Debug, Clone)]
+pub struct JemallocMetrics {
+    active: Attributes,
+    alloc: Attributes,
+    metadata: Attributes,
+    mapped: Attributes,
+    resident: Attributes,
+    retained: Attributes,
+}
+
+impl JemallocMetrics {
+    pub fn new() -> Self {
+        Self {
+            active: Attributes::from(&[("stat", "active")]),
+            alloc: Attributes::from(&[("stat", "alloc")]),
+            metadata: Attributes::from(&[("stat", "metadata")]),
+            mapped: Attributes::from(&[("stat", "mapped")]),
+            resident: Attributes::from(&[("stat", "resident")]),
+            retained: Attributes::from(&[("stat", "retained")]),
+        }
+    }
+}
+
+impl Default for JemallocMetrics {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl metric::Instrument for JemallocMetrics {
+    fn report(&self, reporter: &mut dyn Reporter) {
+        reporter.start_metric(
+            "jemalloc_memstats_bytes",
+            "jemalloc metrics - http://jemalloc.net/jemalloc.3.html#stats.active",
+            MetricKind::U64Gauge,
+        );
+
+        epoch::advance().unwrap();
+
+        reporter.report_observation(
+            &self.active,
+            Observation::U64Gauge(stats::active::read().unwrap() as u64),
+        );
+
+        reporter.report_observation(
+            &self.alloc,
+            Observation::U64Gauge(stats::allocated::read().unwrap() as u64),
+        );
+
+        reporter.report_observation(
+            &self.metadata,
+            Observation::U64Gauge(stats::metadata::read().unwrap() as u64),
+        );
+
+        reporter.report_observation(
+            &self.mapped,
+            Observation::U64Gauge(stats::mapped::read().unwrap() as u64),
+        );
+
+        reporter.report_observation(
+            &self.resident,
+            Observation::U64Gauge(stats::resident::read().unwrap() as u64),
+        );
+
+        reporter.report_observation(
+            &self.retained,
+            Observation::U64Gauge(stats::retained::read().unwrap() as u64),
+        );
+
+        reporter.finish_metric();
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
diff --git a/influxdb3_process/src/lib.rs b/influxdb3_process/src/lib.rs
new file mode 100644
index 00000000000..7d8686b1ff2
--- /dev/null
+++ b/influxdb3_process/src/lib.rs
@@ -0,0 +1,123 @@
+use std::sync::Arc;
+
+use iox_time::{SystemProvider, Time, TimeProvider};
+use metric::U64Gauge;
+use once_cell::sync::Lazy;
+
+/// The process name on the local OS running `influxdb3`
+pub const INFLUXDB3_PROCESS_NAME: &str = "influxdb3";
+
+#[cfg(all(not(feature = "heappy"), feature = "jemalloc_replacing_malloc"))]
+pub mod jemalloc;
+
+#[cfg(tokio_unstable)]
+use tokio_metrics_bridge::setup_tokio_metrics;
+
+#[cfg(all(not(feature = "heappy"), not(feature = "jemalloc_replacing_malloc")))]
+pub fn build_malloc_conf() -> String {
+    "system".to_string()
+}
+
+#[cfg(all(feature = "heappy", not(feature = "jemalloc_replacing_malloc")))]
+pub fn build_malloc_conf() -> String {
+    "heappy".to_string()
+}
+
+#[cfg(all(not(feature = "heappy"), feature = "jemalloc_replacing_malloc"))]
+pub fn build_malloc_conf() -> String {
+    tikv_jemalloc_ctl::config::malloc_conf::mib()
+        .unwrap()
+        .read()
+        .unwrap()
+        .to_string()
+}
+
+#[cfg(all(
+    feature = "heappy",
+    feature = "jemalloc_replacing_malloc",
+    not(feature = "clippy")
+))]
+pub fn build_malloc_conf() -> String {
+    compile_error!("must use exactly one memory allocator")
+}
+
+#[cfg(feature = "clippy")]
+pub fn build_malloc_conf() -> String {
+    "clippy".to_string()
+}
+
+/// Package version.
+pub static INFLUXDB3_VERSION: Lazy<&'static str> =
+    Lazy::new(|| option_env!("CARGO_PKG_VERSION").unwrap_or("UNKNOWN"));
+
+/// Build-time GIT revision hash.
+pub static INFLUXDB3_GIT_HASH: &str = env!(
+    "GIT_HASH",
+    "Can not find find GIT HASH in build environment"
+);
+
+/// Build-time GIT revision hash.
+pub static INFLUXDB3_GIT_HASH_SHORT: &str = env!(
+    "GIT_HASH_SHORT",
+    "Can not find find GIT HASH in build environment"
+);
+
+/// Version string that is combined from [`INFLUXDB3_VERSION`] and [`INFLUXDB3_GIT_HASH`].
+pub static VERSION_STRING: Lazy<&'static str> = Lazy::new(|| {
+    let s = format!(
+        "{}, revision {}",
+        &INFLUXDB3_VERSION[..],
+        INFLUXDB3_GIT_HASH
+    );
+    let s: Box<str> = Box::from(s);
+    Box::leak(s)
+});
+
+/// A UUID that is unique for the process lifetime.
+pub static PROCESS_UUID: Lazy<&'static str> = Lazy::new(|| {
+    let s = uuid::Uuid::new_v4().to_string();
+    let s: Box<str> = Box::from(s);
+    Box::leak(s)
+});
+
+/// Process start time.
+pub static PROCESS_START_TIME: Lazy<Time> = Lazy::new(|| SystemProvider::new().now());
+
+pub fn setup_metric_registry() -> Arc<metric::Registry> {
+    let registry = Arc::new(metric::Registry::default());
+
+    // See https://prometheus.io/docs/instrumenting/writing_clientlibs/#process-metrics
+    registry
+        .register_metric::<U64Gauge>(
+            "process_start_time_seconds",
+            "Start time of the process since unix epoch in seconds.",
+        )
+        .recorder(&[
+            ("version", INFLUXDB3_VERSION.as_ref()),
+            ("git_hash", INFLUXDB3_GIT_HASH),
+            ("uuid", PROCESS_UUID.as_ref()),
+        ])
+        .set(PROCESS_START_TIME.timestamp() as u64);
+
+    // Register jemalloc metrics
+    #[cfg(all(not(feature = "heappy"), feature = "jemalloc_replacing_malloc"))]
+    registry.register_instrument("jemalloc_metrics", crate::jemalloc::JemallocMetrics::new);
+
+    // Register tokio metric for main runtime
+    #[cfg(tokio_unstable)]
+    setup_tokio_metrics(
+        tokio::runtime::Handle::current().metrics(),
+        "main",
+        Arc::clone(&registry),
+    );
+
+    registry
+}
+
+/// String version of [`usize::MAX`].
+#[allow(dead_code)]
+pub static USIZE_MAX: Lazy<&'static str> = Lazy::new(|| {
+    let s = usize::MAX.to_string();
+    let s: Box<str> = Box::from(s);
+    Box::leak(s)
+});
diff --git a/influxdb3_server/Cargo.toml b/influxdb3_server/Cargo.toml
new file mode 100644
index 00000000000..626b372721b
--- /dev/null
+++ b/influxdb3_server/Cargo.toml
@@ -0,0 +1,79 @@
+[package]
+name = "influxdb3_server"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+# Core Crates
+authz.workspace = true
+data_types.workspace = true
+datafusion_util.workspace = true
+influxdb-line-protocol.workspace = true
+iox_catalog.workspace = true
+iox_http.workspace = true
+iox_query.workspace = true
+iox_query_params.workspace = true
+iox_query_influxql.workspace = true
+iox_time.workspace = true
+metric.workspace = true
+metric_exporters.workspace = true
+observability_deps.workspace = true
+schema.workspace = true
+service_common.workspace = true
+service_grpc_flight.workspace = true
+trace.workspace = true
+trace_exporters.workspace = true
+trace_http.workspace = true
+tracker.workspace = true
+
+# Local Deps
+influxdb3_write = { path = "../influxdb3_write" }
+influxdb3_process = { path = "../influxdb3_process", default-features = false }
+iox_query_influxql_rewrite = { path = "../iox_query_influxql_rewrite" }
+
+# crates.io Dependencies
+anyhow.workspace = true
+arrow.workspace = true
+arrow-csv.workspace = true
+arrow-flight.workspace = true
+arrow-json.workspace = true
+arrow-schema.workspace = true
+async-trait.workspace = true
+base64.workspace = true
+bytes.workspace = true
+chrono.workspace = true
+datafusion.workspace = true
+flate2.workspace = true
+futures.workspace = true
+hex.workspace = true
+hyper.workspace = true
+object_store.workspace = true
+parking_lot.workspace = true
+pin-project-lite.workspace = true
+secrecy.workspace = true
+serde.workspace = true
+serde_arrow.workspace = true
+serde_json.workspace = true
+serde_urlencoded.workspace = true
+sha2.workspace = true
+thiserror.workspace = true
+tokio.workspace = true
+tokio-util.workspace = true
+tonic.workspace = true
+tower.workspace = true
+unicode-segmentation.workspace = true
+
+[dev-dependencies]
+# Core Crates
+parquet.workspace = true
+parquet_file.workspace = true
+test_helpers.workspace = true
+test_helpers_end_to_end.workspace = true
+
+# crates.io crates
+http.workspace = true
+hyper.workspace = true
+urlencoding.workspace = true
+pretty_assertions.workspace = true
diff --git a/influxdb3_server/src/auth.rs b/influxdb3_server/src/auth.rs
new file mode 100644
index 00000000000..6c34d743628
--- /dev/null
+++ b/influxdb3_server/src/auth.rs
@@ -0,0 +1,58 @@
+use async_trait::async_trait;
+use authz::{Authorizer, Error, Permission};
+use observability_deps::tracing::{debug, warn};
+use sha2::{Digest, Sha512};
+
+/// An [`Authorizer`] implementation that will grant access to all
+/// requests that provide `token`
+#[derive(Debug)]
+pub struct AllOrNothingAuthorizer {
+    token: Vec<u8>,
+}
+
+impl AllOrNothingAuthorizer {
+    pub fn new(token: Vec<u8>) -> Self {
+        Self { token }
+    }
+}
+
+#[async_trait]
+impl Authorizer for AllOrNothingAuthorizer {
+    async fn permissions(
+        &self,
+        token: Option<Vec<u8>>,
+        perms: &[Permission],
+    ) -> Result<Vec<Permission>, Error> {
+        debug!(?perms, "requesting permissions");
+        let provided = token.as_deref().ok_or(Error::NoToken)?;
+        if Sha512::digest(provided)[..] == self.token {
+            Ok(perms.to_vec())
+        } else {
+            warn!("invalid token provided");
+            Err(Error::InvalidToken)
+        }
+    }
+
+    async fn probe(&self) -> Result<(), Error> {
+        Ok(())
+    }
+}
+
+/// The defult [`Authorizer`] implementation that will authorize all requests
+#[derive(Debug)]
+pub struct DefaultAuthorizer;
+
+#[async_trait]
+impl Authorizer for DefaultAuthorizer {
+    async fn permissions(
+        &self,
+        _token: Option<Vec<u8>>,
+        perms: &[Permission],
+    ) -> Result<Vec<Permission>, Error> {
+        Ok(perms.to_vec())
+    }
+
+    async fn probe(&self) -> Result<(), Error> {
+        Ok(())
+    }
+}
diff --git a/influxdb3_server/src/builder.rs b/influxdb3_server/src/builder.rs
new file mode 100644
index 00000000000..d7000c4944e
--- /dev/null
+++ b/influxdb3_server/src/builder.rs
@@ -0,0 +1,138 @@
+use std::sync::Arc;
+
+use authz::Authorizer;
+
+use crate::{auth::DefaultAuthorizer, http::HttpApi, CommonServerState, Server};
+
+#[derive(Debug)]
+pub struct ServerBuilder<W, Q, P, T> {
+    common_state: CommonServerState,
+    time_provider: T,
+    max_request_size: usize,
+    write_buffer: W,
+    query_executor: Q,
+    persister: P,
+    authorizer: Arc<dyn Authorizer>,
+}
+
+impl ServerBuilder<NoWriteBuf, NoQueryExec, NoPersister, NoTimeProvider> {
+    pub fn new(common_state: CommonServerState) -> Self {
+        Self {
+            common_state,
+            time_provider: NoTimeProvider,
+            max_request_size: usize::MAX,
+            write_buffer: NoWriteBuf,
+            query_executor: NoQueryExec,
+            persister: NoPersister,
+            authorizer: Arc::new(DefaultAuthorizer),
+        }
+    }
+}
+
+impl<W, Q, P, T> ServerBuilder<W, Q, P, T> {
+    pub fn max_request_size(mut self, max_request_size: usize) -> Self {
+        self.max_request_size = max_request_size;
+        self
+    }
+
+    pub fn authorizer(mut self, a: Arc<dyn Authorizer>) -> Self {
+        self.authorizer = a;
+        self
+    }
+}
+
+#[derive(Debug)]
+pub struct NoWriteBuf;
+#[derive(Debug)]
+pub struct WithWriteBuf<W>(Arc<W>);
+#[derive(Debug)]
+pub struct NoQueryExec;
+#[derive(Debug)]
+pub struct WithQueryExec<Q>(Arc<Q>);
+#[derive(Debug)]
+pub struct NoPersister;
+#[derive(Debug)]
+pub struct WithPersister<P>(Arc<P>);
+#[derive(Debug)]
+pub struct NoTimeProvider;
+#[derive(Debug)]
+pub struct WithTimeProvider<T>(Arc<T>);
+
+impl<Q, P, T> ServerBuilder<NoWriteBuf, Q, P, T> {
+    pub fn write_buffer<W>(self, wb: Arc<W>) -> ServerBuilder<WithWriteBuf<W>, Q, P, T> {
+        ServerBuilder {
+            common_state: self.common_state,
+            time_provider: self.time_provider,
+            max_request_size: self.max_request_size,
+            write_buffer: WithWriteBuf(wb),
+            query_executor: self.query_executor,
+            persister: self.persister,
+            authorizer: self.authorizer,
+        }
+    }
+}
+
+impl<W, P, T> ServerBuilder<W, NoQueryExec, P, T> {
+    pub fn query_executor<Q>(self, qe: Arc<Q>) -> ServerBuilder<W, WithQueryExec<Q>, P, T> {
+        ServerBuilder {
+            common_state: self.common_state,
+            time_provider: self.time_provider,
+            max_request_size: self.max_request_size,
+            write_buffer: self.write_buffer,
+            query_executor: WithQueryExec(qe),
+            persister: self.persister,
+            authorizer: self.authorizer,
+        }
+    }
+}
+
+impl<W, Q, T> ServerBuilder<W, Q, NoPersister, T> {
+    pub fn persister<P>(self, p: Arc<P>) -> ServerBuilder<W, Q, WithPersister<P>, T> {
+        ServerBuilder {
+            common_state: self.common_state,
+            time_provider: self.time_provider,
+            max_request_size: self.max_request_size,
+            write_buffer: self.write_buffer,
+            query_executor: self.query_executor,
+            persister: WithPersister(p),
+            authorizer: self.authorizer,
+        }
+    }
+}
+
+impl<W, Q, P> ServerBuilder<W, Q, P, NoTimeProvider> {
+    pub fn time_provider<T>(self, tp: Arc<T>) -> ServerBuilder<W, Q, P, WithTimeProvider<T>> {
+        ServerBuilder {
+            common_state: self.common_state,
+            time_provider: WithTimeProvider(tp),
+            max_request_size: self.max_request_size,
+            write_buffer: self.write_buffer,
+            query_executor: self.query_executor,
+            persister: self.persister,
+            authorizer: self.authorizer,
+        }
+    }
+}
+
+impl<W, Q, P, T>
+    ServerBuilder<WithWriteBuf<W>, WithQueryExec<Q>, WithPersister<P>, WithTimeProvider<T>>
+{
+    pub fn build(self) -> Server<W, Q, P, T> {
+        let persister = Arc::clone(&self.persister.0);
+        let authorizer = Arc::clone(&self.authorizer);
+        let http = Arc::new(HttpApi::new(
+            self.common_state.clone(),
+            Arc::clone(&self.time_provider.0),
+            Arc::clone(&self.write_buffer.0),
+            Arc::clone(&self.query_executor.0),
+            self.max_request_size,
+            Arc::clone(&authorizer),
+        ));
+        Server {
+            common_state: self.common_state,
+            http,
+            persister,
+            authorizer,
+        }
+    }
+}
diff --git a/influxdb3_server/src/grpc.rs b/influxdb3_server/src/grpc.rs
new file mode 100644
index 00000000000..30dbd28a146
--- /dev/null
+++ b/influxdb3_server/src/grpc.rs
@@ -0,0 +1,14 @@
+use std::sync::Arc;
+
+use arrow_flight::flight_service_server::{
+    FlightService as Flight, FlightServiceServer as FlightServer,
+};
+use authz::Authorizer;
+use iox_query::QueryNamespaceProvider;
+
+pub(crate) fn make_flight_server<Q: QueryNamespaceProvider>(
+    server: Arc<Q>,
+    authz: Option<Arc<dyn Authorizer>>,
+) -> FlightServer<impl Flight> {
+    service_grpc_flight::make_server(server, authz)
+}
diff --git a/influxdb3_server/src/http.rs b/influxdb3_server/src/http.rs
new file mode 100644
index 00000000000..ef3562002df
--- /dev/null
+++ b/influxdb3_server/src/http.rs
@@ -0,0 +1,1188 @@
+//! HTTP API service implementations for `server`
+
+use crate::{query_executor, QueryKind};
+use crate::{CommonServerState, QueryExecutor};
+use arrow::record_batch::RecordBatch;
+use arrow::util::pretty;
+use authz::http::AuthorizationHeaderExtension;
+use authz::Authorizer;
+use bytes::{Bytes, BytesMut};
+use data_types::NamespaceName;
+use datafusion::error::DataFusionError;
+use datafusion::execution::memory_pool::UnboundedMemoryPool;
+use datafusion::execution::RecordBatchStream;
+use datafusion::physical_plan::SendableRecordBatchStream;
+use futures::{StreamExt, TryStreamExt};
+use hyper::header::ACCEPT;
+use hyper::header::AUTHORIZATION;
+use hyper::header::CONTENT_ENCODING;
+use hyper::header::CONTENT_TYPE;
+use hyper::http::HeaderValue;
+use hyper::HeaderMap;
+use hyper::{Body, Method, Request, Response, StatusCode};
+use influxdb3_process::{INFLUXDB3_GIT_HASH_SHORT, INFLUXDB3_VERSION};
+use influxdb3_write::catalog::Error as CatalogError;
+use influxdb3_write::persister::TrackedMemoryArrowWriter;
+use influxdb3_write::write_buffer::Error as WriteBufferError;
+use influxdb3_write::BufferedWriteRequest;
+use influxdb3_write::Precision;
+use influxdb3_write::WriteBuffer;
+use iox_http::write::single_tenant::SingleTenantRequestUnifier;
+use iox_http::write::v1::V1_NAMESPACE_RP_SEPARATOR;
+use iox_http::write::{WriteParseError, WriteRequestUnifier};
+use iox_query_influxql_rewrite as rewrite;
+use iox_query_params::StatementParams;
+use iox_time::TimeProvider;
+use observability_deps::tracing::{debug, error, info};
+use serde::de::DeserializeOwned;
+use serde::Deserialize;
+use serde::Serialize;
+use std::convert::Infallible;
+use std::fmt::Debug;
+use std::num::NonZeroI32;
+use std::pin::Pin;
+use std::str::Utf8Error;
+use std::string::FromUtf8Error;
+use std::sync::Arc;
+use thiserror::Error;
+use unicode_segmentation::UnicodeSegmentation;
+
+mod v1;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    /// The requested path has no registered handler.
+    #[error("not found")]
+    NoHandler,
+
+    /// The request body content is not valid utf8.
+    #[error("body content is not valid utf8: {0}")]
+    NonUtf8Body(Utf8Error),
+
+    /// The `Content-Encoding` header is invalid and cannot be read.
+    #[error("invalid content-encoding header: {0}")]
+    NonUtf8ContentHeader(hyper::header::ToStrError),
+
+    /// The specified `Content-Encoding` is not acceptable.
+    #[error("unacceptable content-encoding: {0}")]
+    InvalidContentEncoding(String),
+
+    /// The client disconnected.
+    #[error("client disconnected")]
+    ClientHangup(hyper::Error),
+
+    /// The client sent a request body that exceeds the configured maximum.
+    #[error("max request size ({0} bytes) exceeded")]
+    RequestSizeExceeded(usize),
+
+    /// Decoding a gzip-compressed stream of data failed.
+    #[error("error decoding gzip stream: {0}")]
+    InvalidGzip(std::io::Error),
+
+    /// NamespaceName validation error.
+    #[error("error validating namespace name: {0}")]
+    InvalidNamespaceName(#[from] data_types::NamespaceNameError),
+
+    /// Failure to decode the provided line protocol.
+    #[error("failed to parse line protocol: {0}")]
+    ParseLineProtocol(influxdb_line_protocol::Error),
+
+    /// The router is currently servicing the maximum permitted number of
+    /// simultaneous requests.
+    #[error("this service is overloaded, please try again later")]
+    RequestLimit,
+
+    /// The request has no authentication, but authorization is configured.
+    #[error("authentication required")]
+    Unauthenticated,
+
+    /// The provided authorization is not sufficient to perform the request.
+    #[error("access denied")]
+    Forbidden,
+
+    /// The HTTP request method is not supported for this resource
+    #[error("unsupported method")]
+    UnsupportedMethod,
+
+    /// PProf support is not compiled
+    #[error("pprof support is not compiled")]
+    PProfIsNotCompiled,
+
+    /// Heappy support is not compiled
+    #[error("heappy support is not compiled")]
+    HeappyIsNotCompiled,
+
+    #[cfg(feature = "heappy")]
+    #[error("heappy error: {0}")]
+    Heappy(heappy::Error),
+
+    /// Hyper serving error
+    #[error("error serving http: {0}")]
+    ServingHttp(#[from] hyper::Error),
+
+    /// Missing parameters for query
+    #[error("missing query parameters 'db' and 'q'")]
+    MissingQueryParams,
+
+    /// MIssing parameters for write
+    #[error("missing query parameter 'db'")]
+    MissingWriteParams,
+
+    /// Serde decode error
+    #[error("serde error: {0}")]
+    Serde(#[from] serde_urlencoded::de::Error),
+
+    #[error("error in query parameters: {0}")]
+    QueryParams(#[from] QueryParamsError),
+
+    /// Arrow error
+    #[error("arrow error: {0}")]
+    Arrow(#[from] arrow::error::ArrowError),
+
+    /// Hyper error
+    #[error("hyper http error: {0}")]
+    Hyper(#[from] hyper::http::Error),
+
+    /// WriteBuffer error
+    #[error("write buffer error: {0}")]
+    WriteBuffer(#[from] influxdb3_write::write_buffer::Error),
+
+    /// Persister error
+    #[error("persister error: {0}")]
+    Persister(#[from] influxdb3_write::persister::Error),
+
+    // ToStrError
+    #[error("to str error: {0}")]
+    ToStr(#[from] hyper::header::ToStrError),
+
+    // SerdeJsonError
+    #[error("serde json error: {0}")]
+    SerdeJson(#[from] serde_json::Error),
+
+    // Influxdb3 Write
+    #[error("serde json error: {0}")]
+    Influxdb3Write(#[from] influxdb3_write::Error),
+
+    #[error("datafusion error: {0}")]
+    Datafusion(#[from] DataFusionError),
+
+    #[error("io error: {0}")]
+    Io(#[from] std::io::Error),
+
+    #[error("query error: {0}")]
+    Query(#[from] query_executor::Error),
+
+    #[error(transparent)]
+    DbName(#[from] ValidateDbNameError),
+
+    #[error("partial write of line protocol occurred")]
+    PartialLpWrite(BufferedWriteRequest),
+
+    #[error("error in InfluxQL statement: {0}")]
+    InfluxqlRewrite(#[from] rewrite::Error),
+
+    #[error("must provide only one InfluxQl statement per query")]
+    InfluxqlSingleStatement,
+
+    #[error("must specify a 'db' parameter, or provide the database in the InfluxQL query")]
+    InfluxqlNoDatabase,
+
+    #[error(
+        "provided a database in both the parameters ({param_db}) and \
+        query string ({query_db}) that do not match, if providing a query \
+        that specifies the database, you can omit the 'database' parameter \
+        from your request"
+    )]
+    InfluxqlDatabaseMismatch { param_db: String, query_db: String },
+
+    #[error("v1 query API error: {0}")]
+    V1Query(#[from] v1::QueryError),
+}
+
+#[derive(Debug, Error)]
+pub enum AuthorizationError {
+    #[error("the request was not authorized")]
+    Unauthorized,
+    #[error("the request was not in the form of 'Authorization: Bearer <token>'")]
+    MalformedRequest,
+    #[error("requestor is forbidden from requested resource")]
+    Forbidden,
+    #[error("to str error: {0}")]
+    ToStr(#[from] hyper::header::ToStrError),
+}
+
+#[derive(Debug, Serialize)]
+struct ErrorMessage<T: Serialize> {
+    error: String,
+    data: Option<T>,
+}
+
+impl Error {
+    /// Convert this error into an HTTP [`Response`]
+    fn into_response(self) -> Response<Body> {
+        match self {
+            Self::WriteBuffer(WriteBufferError::CatalogUpdateError(
+                err @ (CatalogError::TooManyDbs
+                | CatalogError::TooManyColumns
+                | CatalogError::TooManyTables),
+            )) => {
+                let err: ErrorMessage<()> = ErrorMessage {
+                    error: err.to_string(),
+                    data: None,
+                };
+                let serialized = serde_json::to_string(&err).unwrap();
+                let body = Body::from(serialized);
+                Response::builder()
+                    .status(StatusCode::UNPROCESSABLE_ENTITY)
+                    .body(body)
+                    .unwrap()
+            }
+            Self::WriteBuffer(WriteBufferError::ParseError(err)) => {
+                let err = ErrorMessage {
+                    error: "parsing failed for write_lp endpoint".into(),
+                    data: Some(err),
+                };
+                let serialized = serde_json::to_string(&err).unwrap();
+                let body = Body::from(serialized);
+                Response::builder()
+                    .status(StatusCode::BAD_REQUEST)
+                    .body(body)
+                    .unwrap()
+            }
+            Self::DbName(e) => {
+                let err: ErrorMessage<()> = ErrorMessage {
+                    error: e.to_string(),
+                    data: None,
+                };
+                let serialized = serde_json::to_string(&err).unwrap();
+                let body = Body::from(serialized);
+                Response::builder()
+                    .status(StatusCode::BAD_REQUEST)
+                    .body(body)
+                    .unwrap()
+            }
+            Self::PartialLpWrite(data) => {
+                let err = ErrorMessage {
+                    error: "partial write of line protocol occurred".into(),
+                    data: Some(data.invalid_lines),
+                };
+                let serialized = serde_json::to_string(&err).unwrap();
+                let body = Body::from(serialized);
+                Response::builder()
+                    .status(StatusCode::BAD_REQUEST)
+                    .body(body)
+                    .unwrap()
+            }
+            Self::UnsupportedMethod => {
+                let err: ErrorMessage<()> = ErrorMessage {
+                    error: self.to_string(),
+                    data: None,
+                };
+                let serialized = serde_json::to_string(&err).unwrap();
+                let body = Body::from(serialized);
+                Response::builder()
+                    .status(StatusCode::METHOD_NOT_ALLOWED)
+                    .body(body)
+                    .unwrap()
+            }
+            _ => {
+                let body = Body::from(self.to_string());
+                Response::builder()
+                    .status(StatusCode::INTERNAL_SERVER_ERROR)
+                    .body(body)
+                    .unwrap()
+            }
+        }
+    }
+}
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+#[derive(Debug)]
+pub(crate) struct HttpApi<W, Q, T> {
+    common_state: CommonServerState,
+    write_buffer: Arc<W>,
+    time_provider: Arc<T>,
+    pub(crate) query_executor: Arc<Q>,
+    max_request_bytes: usize,
+    authorizer: Arc<dyn Authorizer>,
+    legacy_write_param_unifier: SingleTenantRequestUnifier,
+}
+
+impl<W, Q, T> HttpApi<W, Q, T> {
+    pub(crate) fn new(
+        common_state: CommonServerState,
+        time_provider: Arc<T>,
+        write_buffer: Arc<W>,
+        query_executor: Arc<Q>,
+        max_request_bytes: usize,
+        authorizer: Arc<dyn Authorizer>,
+    ) -> Self {
+        let legacy_write_param_unifier = SingleTenantRequestUnifier::new(Arc::clone(&authorizer));
+        Self {
+            common_state,
+            time_provider,
+            write_buffer,
+            query_executor,
+            max_request_bytes,
+            authorizer,
+            legacy_write_param_unifier,
+        }
+    }
+}
+
+impl<W, Q, T> HttpApi<W, Q, T>
+where
+    W: WriteBuffer,
+    Q: QueryExecutor,
+    T: TimeProvider,
+    Error: From<<Q as QueryExecutor>::Error>,
+{
+    async fn write_lp(&self, req: Request<Body>) -> Result<Response<Body>> {
+        let query = req.uri().query().ok_or(Error::MissingWriteParams)?;
+        let params: WriteParams = serde_urlencoded::from_str(query)?;
+        self.write_lp_inner(params, req, false).await
+    }
+
+    async fn write_lp_inner(
+        &self,
+        params: WriteParams,
+        req: Request<Body>,
+        accept_rp: bool,
+    ) -> Result<Response<Body>> {
+        validate_db_name(&params.db, accept_rp)?;
+        info!("write_lp to {}", params.db);
+
+        let body = self.read_body(req).await?;
+        let body = std::str::from_utf8(&body).map_err(Error::NonUtf8Body)?;
+
+        let database = NamespaceName::new(params.db)?;
+
+        let default_time = self.time_provider.now();
+
+        let result = self
+            .write_buffer
+            .write_lp(
+                database,
+                body,
+                default_time,
+                params.accept_partial,
+                params.precision,
+            )
+            .await?;
+
+        if result.invalid_lines.is_empty() {
+            Ok(Response::new(Body::empty()))
+        } else {
+            Err(Error::PartialLpWrite(result))
+        }
+    }
+
+    async fn query_sql(&self, req: Request<Body>) -> Result<Response<Body>> {
+        let QueryRequest {
+            database,
+            query_str,
+            format,
+            params,
+        } = self.extract_query_request::<String>(req).await?;
+
+        info!(%database, %query_str, ?format, "handling query_sql");
+
+        let stream = self
+            .query_executor
+            .query(&database, &query_str, params, QueryKind::Sql, None, None)
+            .await?;
+
+        Response::builder()
+            .status(StatusCode::OK)
+            .header(CONTENT_TYPE, format.as_content_type())
+            .body(record_batch_stream_to_body(stream, format).await?)
+            .map_err(Into::into)
+    }
+
+    async fn query_influxql(&self, req: Request<Body>) -> Result<Response<Body>> {
+        let QueryRequest {
+            database,
+            query_str,
+            format,
+            params,
+        } = self.extract_query_request::<Option<String>>(req).await?;
+
+        info!(?database, %query_str, ?format, "handling query_influxql");
+
+        let stream = self
+            .query_influxql_inner(database, &query_str, params)
+            .await?;
+
+        Response::builder()
+            .status(StatusCode::OK)
+            .header(CONTENT_TYPE, format.as_content_type())
+            .body(record_batch_stream_to_body(stream, format).await?)
+            .map_err(Into::into)
+    }
+
+    fn health(&self) -> Result<Response<Body>> {
+        let response_body = "OK";
+        Ok(Response::new(Body::from(response_body.to_string())))
+    }
+
+    fn ping(&self) -> Result<Response<Body>> {
+        #[derive(Debug, Serialize)]
+        struct PingResponse<'a> {
+            version: &'a str,
+            revision: &'a str,
+        }
+
+        let body = serde_json::to_string(&PingResponse {
+            version: &INFLUXDB3_VERSION,
+            revision: INFLUXDB3_GIT_HASH_SHORT,
+        })
+        .unwrap();
+
+        Ok(Response::new(Body::from(body)))
+    }
+
+    fn handle_metrics(&self) -> Result<Response<Body>> {
+        let mut body: Vec<u8> = Default::default();
+        let mut reporter = metric_exporters::PrometheusTextEncoder::new(&mut body);
+        self.common_state.metrics.report(&mut reporter);
+
+        Ok(Response::new(Body::from(body)))
+    }
+
+    /// Parse the request's body into raw bytes, applying the configured size
+    /// limits and decoding any content encoding.
+    async fn read_body(&self, req: hyper::Request<Body>) -> Result<Bytes> {
+        let encoding = req
+            .headers()
+            .get(&CONTENT_ENCODING)
+            .map(|v| v.to_str().map_err(Error::NonUtf8ContentHeader))
+            .transpose()?;
+        let ungzip = match encoding {
+            None | Some("identity") => false,
+            Some("gzip") => true,
+            Some(v) => return Err(Error::InvalidContentEncoding(v.to_string())),
+        };
+
+        let mut payload = req.into_body();
+
+        let mut body = BytesMut::new();
+        while let Some(chunk) = payload.next().await {
+            let chunk = chunk.map_err(Error::ClientHangup)?;
+            // limit max size of in-memory payload
+            if (body.len() + chunk.len()) > self.max_request_bytes {
+                return Err(Error::RequestSizeExceeded(self.max_request_bytes));
+            }
+            body.extend_from_slice(&chunk);
+        }
+        let body = body.freeze();
+
+        // If the body is not compressed, return early.
+        if !ungzip {
+            return Ok(body);
+        }
+
+        // Unzip the gzip-encoded content
+        use std::io::Read;
+        let decoder = flate2::read::GzDecoder::new(&body[..]);
+
+        // Read at most max_request_bytes bytes to prevent a decompression bomb
+        // based DoS.
+        //
+        // In order to detect if the entire stream ahs been read, or truncated,
+        // read an extra byte beyond the limit and check the resulting data
+        // length - see the max_request_size_truncation test.
+        let mut decoder = decoder.take(self.max_request_bytes as u64 + 1);
+        let mut decoded_data = Vec::new();
+        decoder
+            .read_to_end(&mut decoded_data)
+            .map_err(Error::InvalidGzip)?;
+
+        // If the length is max_size+1, the body is at least max_size+1 bytes in
+        // length, and possibly longer, but truncated.
+        if decoded_data.len() > self.max_request_bytes {
+            return Err(Error::RequestSizeExceeded(self.max_request_bytes));
+        }
+
+        Ok(decoded_data.into())
+    }
+
+    async fn authorize_request(&self, req: &mut Request<Body>) -> Result<(), AuthorizationError> {
+        // Extend the request with the authorization token; this is used downstream in some
+        // APIs, such as write, that need the full header value to authorize a request.
+        let auth_header = req.headers().get(AUTHORIZATION).cloned();
+        req.extensions_mut()
+            .insert(AuthorizationHeaderExtension::new(auth_header));
+
+        let auth = if let Some(p) = extract_v1_auth_token(req) {
+            Some(p)
+        } else {
+            // We won't need the authorization header anymore and we don't want to accidentally log it.
+            // Take it out so we can use it and not log it later by accident.
+            req.headers_mut()
+                .remove(AUTHORIZATION)
+                .map(validate_auth_header)
+                .transpose()?
+        };
+
+        // Currently we pass an empty permissions list, but in future we may be able to derive
+        // the permissions based on the incoming request
+        let permissions = self.authorizer.permissions(auth, &[]).await?;
+
+        // Extend the request with the permissions, which may be useful in future
+        req.extensions_mut().insert(permissions);
+
+        Ok(())
+    }
+
+    async fn extract_query_request<D: DeserializeOwned>(
+        &self,
+        req: Request<Body>,
+    ) -> Result<QueryRequest<D, QueryFormat, StatementParams>> {
+        let header_format = QueryFormat::try_from_headers(req.headers())?;
+        let request = match *req.method() {
+            Method::GET => {
+                let query = req.uri().query().ok_or(Error::MissingQueryParams)?;
+                let r = serde_urlencoded::from_str::<QueryRequest<D, Option<QueryFormat>, String>>(
+                    query,
+                )?;
+                QueryRequest {
+                    database: r.database,
+                    query_str: r.query_str,
+                    format: r.format,
+                    params: r.params.map(|s| serde_json::from_str(&s)).transpose()?,
+                }
+            }
+            Method::POST => {
+                let body = self.read_body(req).await?;
+                serde_json::from_slice(body.as_ref())?
+            }
+            _ => return Err(Error::UnsupportedMethod),
+        };
+
+        Ok(QueryRequest {
+            database: request.database,
+            query_str: request.query_str,
+            format: request.format.unwrap_or(header_format),
+            params: request.params,
+        })
+    }
+
+    /// Inner function for performing InfluxQL queries
+    ///
+    /// This is used by both the `/api/v3/query_influxql` and `/api/v1/query`
+    /// APIs.
+    async fn query_influxql_inner(
+        &self,
+        database: Option<String>,
+        query_str: &str,
+        params: Option<StatementParams>,
+    ) -> Result<SendableRecordBatchStream> {
+        let mut statements = rewrite::parse_statements(query_str)?;
+
+        if statements.len() != 1 {
+            return Err(Error::InfluxqlSingleStatement);
+        }
+        let statement = statements.pop().unwrap();
+
+        let database = match (database, statement.resolve_dbrp()) {
+            (None, None) => None,
+            (None, Some(db)) | (Some(db), None) => Some(db),
+            (Some(p), Some(q)) => {
+                if p == q {
+                    Some(p)
+                } else {
+                    return Err(Error::InfluxqlDatabaseMismatch {
+                        param_db: p,
+                        query_db: q,
+                    });
+                }
+            }
+        };
+
+        if statement.statement().is_show_databases() {
+            self.query_executor.show_databases()
+        } else if statement.statement().is_show_retention_policies() {
+            self.query_executor
+                .show_retention_policies(database.as_deref(), None)
+                .await
+        } else {
+            let Some(database) = database else {
+                return Err(Error::InfluxqlNoDatabase);
+            };
+
+            self.query_executor
+                .query(
+                    &database,
+                    // TODO - implement an interface that takes the statement directly,
+                    // so we don't need to double down on the parsing
+                    &statement.to_statement().to_string(),
+                    params,
+                    QueryKind::InfluxQl,
+                    None,
+                    None,
+                )
+                .await
+        }
+        .map_err(Into::into)
+    }
+}
+
+#[derive(Debug, Deserialize)]
+struct V1AuthParameters {
+    #[serde(rename = "p")]
+    password: Option<String>,
+}
+
+/// Extract the authentication token for v1 API requests, which may use the `p` query
+/// parameter to pass the authentication token.
+fn extract_v1_auth_token(req: &mut Request<Body>) -> Option<Vec<u8>> {
+    req.uri()
+        .path_and_query()
+        .and_then(|pq| match pq.path() {
+            "/query" | "/write" => pq.query(),
+            _ => None,
+        })
+        .map(serde_urlencoded::from_str::<V1AuthParameters>)
+        .transpose()
+        .ok()
+        .flatten()
+        .and_then(|params| params.password)
+        .map(String::into_bytes)
+}
+
+fn validate_auth_header(header: HeaderValue) -> Result<Vec<u8>, AuthorizationError> {
+    // Split the header value into two parts
+    let mut header = header.to_str()?.split(' ');
+
+    // Check that the header is the 'Bearer' auth scheme
+    let bearer = header.next().ok_or(AuthorizationError::MalformedRequest)?;
+    if bearer != "Bearer" {
+        return Err(AuthorizationError::MalformedRequest);
+    }
+
+    // Get the token that we want to hash to check the request is valid
+    let token = header.next().ok_or(AuthorizationError::MalformedRequest)?;
+
+    // There should only be two parts the 'Bearer' scheme and the actual
+    // token, error otherwise
+    if header.next().is_some() {
+        return Err(AuthorizationError::MalformedRequest);
+    }
+
+    Ok(token.as_bytes().to_vec())
+}
+
+impl From<authz::Error> for AuthorizationError {
+    fn from(auth_error: authz::Error) -> Self {
+        match auth_error {
+            authz::Error::Forbidden => Self::Forbidden,
+            _ => Self::Unauthorized,
+        }
+    }
+}
+
+/// Validate a database name
+///
+/// A valid name:
+/// - Starts with a letter or a number
+/// - Is ASCII not UTF-8
+/// - Contains only letters, numbers, underscores or hyphens
+/// - if `accept_rp` is true, then a single slash ('/') is allowed, separating the
+///   the database name from the retention policy name, e.g., '<db_name>/<rp_name>'
+fn validate_db_name(name: &str, accept_rp: bool) -> Result<(), ValidateDbNameError> {
+    if name.is_empty() {
+        return Err(ValidateDbNameError::Empty);
+    }
+    let mut is_first_char = true;
+    let mut rp_seperator_found = false;
+    let mut last_char = None;
+    for grapheme in name.graphemes(true) {
+        if grapheme.as_bytes().len() > 1 {
+            // In the case of a unicode we need to handle multibyte chars
+            return Err(ValidateDbNameError::InvalidChar);
+        }
+        let char = grapheme.as_bytes()[0] as char;
+        if !is_first_char {
+            match (accept_rp, rp_seperator_found, char) {
+                (true, true, V1_NAMESPACE_RP_SEPARATOR) => {
+                    return Err(ValidateDbNameError::InvalidRetentionPolicy)
+                }
+                (true, false, V1_NAMESPACE_RP_SEPARATOR) => {
+                    rp_seperator_found = true;
+                }
+                (false, _, char)
+                    if !(char.is_ascii_alphanumeric() || char == '_' || char == '-') =>
+                {
+                    return Err(ValidateDbNameError::InvalidChar)
+                }
+                _ => (),
+            }
+        } else {
+            if !char.is_ascii_alphanumeric() {
+                return Err(ValidateDbNameError::InvalidStartChar);
+            }
+            is_first_char = false;
+        }
+        last_char.replace(char);
+    }
+
+    if last_char.is_some_and(|c| c == '/') {
+        return Err(ValidateDbNameError::InvalidRetentionPolicy);
+    }
+
+    Ok(())
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum ValidateDbNameError {
+    #[error(
+        "invalid character in database name: must be ASCII, \
+        containing only letters, numbers, underscores, or hyphens"
+    )]
+    InvalidChar,
+    #[error("db name did not start with a number or letter")]
+    InvalidStartChar,
+    #[error(
+        "db name with invalid retention policy, if providing a \
+        retention policy name, must be of form '<db_name>/<rp_name>'"
+    )]
+    InvalidRetentionPolicy,
+    #[error("db name cannot be empty")]
+    Empty,
+}
+
+#[derive(Debug, Deserialize)]
+pub(crate) struct QueryRequest<D, F, P> {
+    #[serde(rename = "db")]
+    pub(crate) database: D,
+    #[serde(rename = "q")]
+    pub(crate) query_str: String,
+    pub(crate) format: F,
+    pub(crate) params: Option<P>,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum QueryParamsError {
+    #[error(
+        "invalid mime type ({0}), available types are \
+        application/vnd.apache.parquet, text/csv, text/plain, and application/json"
+    )]
+    InvalidMimeType(String),
+    #[error("the mime type specified was not valid UTF8: {0}")]
+    NonUtf8MimeType(#[from] FromUtf8Error),
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub(crate) enum QueryFormat {
+    Parquet,
+    Csv,
+    Pretty,
+    Json,
+}
+
+impl QueryFormat {
+    fn as_content_type(&self) -> &str {
+        match self {
+            Self::Parquet => "application/vnd.apache.parquet",
+            Self::Csv => "text/csv",
+            Self::Pretty => "text/plain; charset=utf-8",
+            Self::Json => "application/json",
+        }
+    }
+
+    fn try_from_headers(headers: &HeaderMap) -> Result<Self> {
+        match headers.get(ACCEPT).map(HeaderValue::as_bytes) {
+            // Accept Headers use the MIME types maintained by IANA here:
+            // https://www.iana.org/assignments/media-types/media-types.xhtml
+            // Note parquet hasn't been accepted yet just Arrow, but there
+            // is the possibility it will be:
+            // https://issues.apache.org/jira/browse/PARQUET-1889
+            Some(b"application/vnd.apache.parquet") => Ok(Self::Parquet),
+            Some(b"text/csv") => Ok(Self::Csv),
+            Some(b"text/plain") => Ok(Self::Pretty),
+            Some(b"application/json" | b"*/*") | None => Ok(Self::Json),
+            Some(mime_type) => match String::from_utf8(mime_type.to_vec()) {
+                Ok(s) => Err(QueryParamsError::InvalidMimeType(s).into()),
+                Err(e) => Err(QueryParamsError::NonUtf8MimeType(e).into()),
+            },
+        }
+    }
+}
+
+async fn record_batch_stream_to_body(
+    stream: Pin<Box<dyn RecordBatchStream + Send>>,
+    format: QueryFormat,
+) -> Result<Body, Error> {
+    fn to_json(batches: Vec<RecordBatch>) -> Result<Bytes> {
+        let batches: Vec<&RecordBatch> = batches.iter().collect();
+        Ok(Bytes::from(serde_json::to_string(
+            &arrow_json::writer::record_batches_to_json_rows(batches.as_slice())?,
+        )?))
+    }
+
+    fn to_csv(batches: Vec<RecordBatch>) -> Result<Bytes> {
+        let mut writer = arrow_csv::writer::Writer::new(Vec::new());
+        for batch in batches {
+            writer.write(&batch)?;
+        }
+
+        Ok(Bytes::from(writer.into_inner()))
+    }
+
+    fn to_pretty(batches: Vec<RecordBatch>) -> Result<Bytes> {
+        Ok(Bytes::from(format!(
+            "{}",
+            pretty::pretty_format_batches(&batches)?
+        )))
+    }
+
+    fn to_parquet(batches: Vec<RecordBatch>) -> Result<Bytes> {
+        let mut bytes = Vec::new();
+        let mem_pool = Arc::new(UnboundedMemoryPool::default());
+        let mut writer =
+            TrackedMemoryArrowWriter::try_new(&mut bytes, batches[0].schema(), mem_pool)?;
+        for batch in batches {
+            writer.write(batch)?;
+        }
+        writer.close()?;
+        Ok(Bytes::from(bytes))
+    }
+
+    let batches = stream.try_collect::<Vec<RecordBatch>>().await?;
+
+    match format {
+        QueryFormat::Pretty => to_pretty(batches),
+        QueryFormat::Parquet => to_parquet(batches),
+        QueryFormat::Csv => to_csv(batches),
+        QueryFormat::Json => to_json(batches),
+    }
+    .map(Body::from)
+}
+
+// This is a hack around the fact that bool default is false not true
+const fn true_fn() -> bool {
+    true
+}
+#[derive(Debug, Deserialize)]
+pub(crate) struct WriteParams {
+    pub(crate) db: String,
+    #[serde(default = "true_fn")]
+    pub(crate) accept_partial: bool,
+    #[serde(default)]
+    pub(crate) precision: Precision,
+}
+
+impl From<iox_http::write::WriteParams> for WriteParams {
+    fn from(legacy: iox_http::write::WriteParams) -> Self {
+        Self {
+            db: legacy.namespace.to_string(),
+            // legacy behaviour was to not accept partial:
+            accept_partial: false,
+            precision: legacy.precision.into(),
+        }
+    }
+}
+
+pub(crate) async fn route_request<W: WriteBuffer, Q: QueryExecutor, T: TimeProvider>(
+    http_server: Arc<HttpApi<W, Q, T>>,
+    mut req: Request<Body>,
+) -> Result<Response<Body>, Infallible>
+where
+    W: WriteBuffer,
+    Q: QueryExecutor,
+    Error: From<<Q as QueryExecutor>::Error>,
+{
+    if let Err(e) = http_server.authorize_request(&mut req).await {
+        match e {
+            AuthorizationError::Unauthorized => {
+                return Ok(Response::builder()
+                    .status(StatusCode::UNAUTHORIZED)
+                    .body(Body::empty())
+                    .unwrap())
+            }
+            AuthorizationError::MalformedRequest => {
+                return Ok(Response::builder()
+                    .status(StatusCode::BAD_REQUEST)
+                    .body(Body::from("{\"error\":\
+                        \"Authorization header was malformed and should be in the form 'Authorization: Bearer <token>'\"\
+                    }"))
+                    .unwrap());
+            }
+            AuthorizationError::Forbidden => {
+                return Ok(Response::builder()
+                    .status(StatusCode::FORBIDDEN)
+                    .body(Body::empty())
+                    .unwrap())
+            }
+            // We don't expect this to happen, but if the header is messed up
+            // better to handle it then not at all
+            AuthorizationError::ToStr(_) => {
+                return Ok(Response::builder()
+                    .status(StatusCode::INTERNAL_SERVER_ERROR)
+                    .body(Body::empty())
+                    .unwrap())
+            }
+        }
+    }
+    debug!(request = ?req,"Processing request");
+
+    let method = req.method().clone();
+    let uri = req.uri().clone();
+    let content_length = req.headers().get("content-length").cloned();
+
+    let response = match (method.clone(), uri.path()) {
+        (Method::POST, "/write") => {
+            let params = match http_server.legacy_write_param_unifier.parse_v1(&req).await {
+                Ok(p) => p.into(),
+                Err(e) => return Ok(legacy_write_error_to_response(e)),
+            };
+
+            http_server.write_lp_inner(params, req, true).await
+        }
+        (Method::POST, "/api/v2/write") => {
+            let params = match http_server.legacy_write_param_unifier.parse_v2(&req).await {
+                Ok(p) => p.into(),
+                Err(e) => return Ok(legacy_write_error_to_response(e)),
+            };
+
+            http_server.write_lp_inner(params, req, false).await
+        }
+        (Method::POST, "/api/v3/write_lp") => http_server.write_lp(req).await,
+        (Method::GET | Method::POST, "/api/v3/query_sql") => http_server.query_sql(req).await,
+        (Method::GET | Method::POST, "/api/v3/query_influxql") => {
+            http_server.query_influxql(req).await
+        }
+        (Method::GET, "/query") => http_server.v1_query(req).await,
+        (Method::GET, "/health" | "/api/v1/health") => http_server.health(),
+        (Method::GET | Method::POST, "/ping") => http_server.ping(),
+        (Method::GET, "/metrics") => http_server.handle_metrics(),
+        (Method::GET, "/debug/pprof") => pprof_home(req).await,
+        (Method::GET, "/debug/pprof/profile") => pprof_profile(req).await,
+        (Method::GET, "/debug/pprof/allocs") => pprof_heappy_profile(req).await,
+        _ => {
+            let body = Body::from("not found");
+            Ok(Response::builder()
+                .status(StatusCode::NOT_FOUND)
+                .body(body)
+                .unwrap())
+        }
+    };
+
+    // TODO: Move logging to TraceLayer
+    match response {
+        Ok(response) => {
+            debug!(?response, "Successfully processed request");
+            Ok(response)
+        }
+        Err(error) => {
+            error!(%error, %method, %uri, ?content_length, "Error while handling request");
+            Ok(error.into_response())
+        }
+    }
+}
+
+fn legacy_write_error_to_response(e: WriteParseError) -> Response<Body> {
+    let err: ErrorMessage<()> = ErrorMessage {
+        error: e.to_string(),
+        data: None,
+    };
+    let serialized = serde_json::to_string(&err).unwrap();
+    let body = Body::from(serialized);
+    let status = match e {
+        WriteParseError::NotImplemented => StatusCode::NOT_FOUND,
+        WriteParseError::SingleTenantError(e) => StatusCode::from(&e),
+        WriteParseError::MultiTenantError(e) => StatusCode::from(&e),
+    };
+    Response::builder().status(status).body(body).unwrap()
+}
+
+async fn pprof_home(req: Request<Body>) -> Result<Response<Body>> {
+    let default_host = HeaderValue::from_static("localhost");
+    let host = req
+        .headers()
+        .get("host")
+        .unwrap_or(&default_host)
+        .to_str()
+        .unwrap_or_default();
+    let profile_cmd = format!(
+        "/debug/pprof/profile?seconds={}",
+        PProfArgs::default_seconds()
+    );
+    let allocs_cmd = format!(
+        "/debug/pprof/allocs?seconds={}",
+        PProfAllocsArgs::default_seconds()
+    );
+    Ok(Response::new(Body::from(format!(
+        r#"<a href="{profile_cmd}">http://{host}{profile_cmd}</a><br><a href="{allocs_cmd}">http://{host}{allocs_cmd}</a>"#,
+    ))))
+}
+
+#[derive(Debug, Deserialize)]
+struct PProfArgs {
+    #[serde(default = "PProfArgs::default_seconds")]
+    #[allow(dead_code)]
+    seconds: u64,
+    #[serde(default = "PProfArgs::default_frequency")]
+    #[allow(dead_code)]
+    frequency: NonZeroI32,
+}
+
+impl PProfArgs {
+    fn default_seconds() -> u64 {
+        30
+    }
+
+    // 99Hz to avoid coinciding with special periods
+    fn default_frequency() -> NonZeroI32 {
+        NonZeroI32::new(99).unwrap()
+    }
+}
+
+#[derive(Debug, Deserialize)]
+struct PProfAllocsArgs {
+    #[serde(default = "PProfAllocsArgs::default_seconds")]
+    #[allow(dead_code)]
+    seconds: u64,
+    // The sampling interval is a number of bytes that have to cumulatively allocated for a sample to be taken.
+    //
+    // For example if the sampling interval is 99, and you're doing a million of 40 bytes allocations,
+    // the allocations profile will account for 16MB instead of 40MB.
+    // Heappy will adjust the estimate for sampled recordings, but now that feature is not yet implemented.
+    #[serde(default = "PProfAllocsArgs::default_interval")]
+    #[allow(dead_code)]
+    interval: NonZeroI32,
+}
+
+impl PProfAllocsArgs {
+    fn default_seconds() -> u64 {
+        30
+    }
+
+    // 1 means: sample every allocation.
+    fn default_interval() -> NonZeroI32 {
+        NonZeroI32::new(1).unwrap()
+    }
+}
+
+#[cfg(feature = "pprof")]
+async fn pprof_profile(req: Request<Body>) -> Result<Response<Body>, ApplicationError> {
+    use ::pprof::protos::Message;
+    use snafu::ResultExt;
+
+    let query_string = req.uri().query().unwrap_or_default();
+    let query: PProfArgs = serde_urlencoded::from_str(query_string)
+        .context(InvalidQueryStringSnafu { query_string })?;
+
+    let report = self::pprof::dump_rsprof(query.seconds, query.frequency.get())
+        .await
+        .map_err(|e| Box::new(e) as _)
+        .context(PProfSnafu)?;
+
+    let mut body: Vec<u8> = Vec::new();
+
+    // render flamegraph when opening in the browser
+    // otherwise render as protobuf; works great with: go tool pprof http://..../debug/pprof/profile
+    if req
+        .headers()
+        .get_all("Accept")
+        .iter()
+        .flat_map(|i| i.to_str().unwrap_or_default().split(','))
+        .any(|i| i == "text/html" || i == "image/svg+xml")
+    {
+        report
+            .flamegraph(&mut body)
+            .map_err(|e| Box::new(e) as _)
+            .context(PProfSnafu)?;
+        if body.is_empty() {
+            return EmptyFlamegraphSnafu.fail();
+        }
+    } else {
+        let profile = report
+            .pprof()
+            .map_err(|e| Box::new(e) as _)
+            .context(PProfSnafu)?;
+        profile
+            .encode(&mut body)
+            .map_err(|e| Box::new(e) as _)
+            .context(ProstSnafu)?;
+    }
+
+    Ok(Response::new(Body::from(body)))
+}
+
+#[cfg(not(feature = "pprof"))]
+async fn pprof_profile(_req: Request<Body>) -> Result<Response<Body>> {
+    Err(Error::PProfIsNotCompiled)
+}
+
+// If heappy support is enabled, call it
+#[cfg(feature = "heappy")]
+async fn pprof_heappy_profile(req: Request<Body>) -> Result<Response<Body>> {
+    let query_string = req.uri().query().unwrap_or_default();
+    let query: PProfAllocsArgs = serde_urlencoded::from_str(query_string)?;
+
+    let report = self::heappy::dump_heappy_rsprof(query.seconds, query.interval.get()).await?;
+
+    let mut body: Vec<u8> = Vec::new();
+
+    // render flamegraph when opening in the browser
+    // otherwise render as protobuf;
+    // works great with: go tool pprof http://..../debug/pprof/allocs
+    if req
+        .headers()
+        .get_all("Accept")
+        .iter()
+        .flat_map(|i| i.to_str().unwrap_or_default().split(','))
+        .any(|i| i == "text/html" || i == "image/svg+xml")
+    {
+        report.flamegraph(&mut body);
+        if body.is_empty() {
+            return EmptyFlamegraphSnafu.fail();
+        }
+    } else {
+        report.write_pprof(&mut body)?
+    }
+
+    Ok(Response::new(Body::from(body)))
+}
+
+//  Return error if heappy not enabled
+#[cfg(not(feature = "heappy"))]
+async fn pprof_heappy_profile(_req: Request<Body>) -> Result<Response<Body>> {
+    Err(Error::HeappyIsNotCompiled)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::validate_db_name;
+    use super::ValidateDbNameError;
+
+    macro_rules! assert_validate_db_name {
+        ($name:literal, $accept_rp:literal, $expected:pat) => {
+            let actual = validate_db_name($name, $accept_rp);
+            assert!(matches!(&actual, $expected), "got: {actual:?}",);
+        };
+    }
+
+    #[test]
+    fn test_validate_db_name() {
+        assert_validate_db_name!("foo/bar", false, Err(ValidateDbNameError::InvalidChar));
+        assert!(validate_db_name("foo/bar", true).is_ok());
+        assert_validate_db_name!(
+            "foo/bar/baz",
+            true,
+            Err(ValidateDbNameError::InvalidRetentionPolicy)
+        );
+        assert_validate_db_name!(
+            "foo/",
+            true,
+            Err(ValidateDbNameError::InvalidRetentionPolicy)
+        );
+        assert_validate_db_name!("foo/bar", false, Err(ValidateDbNameError::InvalidChar));
+        assert_validate_db_name!("foo/bar/baz", false, Err(ValidateDbNameError::InvalidChar));
+        assert_validate_db_name!("_foo", false, Err(ValidateDbNameError::InvalidStartChar));
+        assert_validate_db_name!("", false, Err(ValidateDbNameError::Empty));
+    }
+}
diff --git a/influxdb3_server/src/http/v1.rs b/influxdb3_server/src/http/v1.rs
new file mode 100644
index 00000000000..c6c13d69a68
--- /dev/null
+++ b/influxdb3_server/src/http/v1.rs
@@ -0,0 +1,487 @@
+use std::{
+    collections::{HashMap, VecDeque},
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+};
+
+use anyhow::Context as AnyhowContext;
+use arrow::{
+    compute::{cast_with_options, CastOptions},
+    record_batch::RecordBatch,
+};
+use arrow_json::writer::record_batches_to_json_rows;
+
+use arrow_schema::DataType;
+use bytes::Bytes;
+use datafusion::physical_plan::SendableRecordBatchStream;
+use futures::{ready, stream::Fuse, Stream, StreamExt};
+use hyper::{Body, Request, Response};
+use influxdb3_write::WriteBuffer;
+use iox_time::TimeProvider;
+use observability_deps::tracing::info;
+use schema::{INFLUXQL_MEASUREMENT_COLUMN_NAME, TIME_COLUMN_NAME};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use crate::QueryExecutor;
+
+use super::{Error, HttpApi, Result};
+
+const DEFAULT_CHUNK_SIZE: usize = 10_000;
+
+impl<W, Q, T> HttpApi<W, Q, T>
+where
+    W: WriteBuffer,
+    Q: QueryExecutor,
+    T: TimeProvider,
+    Error: From<<Q as QueryExecutor>::Error>,
+{
+    /// Implements the v1 query API for InfluxDB
+    ///
+    /// Accepts the URL parameters, defined by [`QueryParams`]), and returns a stream
+    /// of [`QueryResponse`]s. If the `chunked` parameter is set to `true`, then the
+    /// response stream will be chunked into chunks of size `chunk_size`, if provided,
+    /// or 10,000. For InfluxQL queries that select from multiple measurements, chunks
+    /// will be split on the `chunk_size`, or series, whichever comes first.
+    pub(super) async fn v1_query(&self, req: Request<Body>) -> Result<Response<Body>> {
+        let params = QueryParams::from_request(&req)?;
+        info!(?params, "handle v1 query API");
+        let QueryParams {
+            chunk_size,
+            chunked,
+            database,
+            epoch,
+            pretty,
+            query,
+        } = params;
+
+        let chunk_size = chunked.then(|| chunk_size.unwrap_or(DEFAULT_CHUNK_SIZE));
+
+        // TODO - Currently not supporting parameterized queries, see
+        //        https://github.com/influxdata/influxdb/issues/24805
+        let stream = self.query_influxql_inner(database, &query, None).await?;
+        let stream =
+            QueryResponseStream::new(0, stream, chunk_size, pretty, epoch).map_err(QueryError)?;
+        let body = Body::wrap_stream(stream);
+
+        Ok(Response::builder().status(200).body(body).unwrap())
+    }
+}
+
+/// Query parameters for the v1/query API
+///
+/// The original API supports a `u` parameter, for "username", as well as a `p`,
+/// for "password". The password is extracted upstream, and username is ignored.
+#[derive(Debug, Deserialize)]
+struct QueryParams {
+    /// Chunk the response into chunks of size `chunk_size`, or 10,000, or by series
+    #[serde(default)]
+    chunked: bool,
+    /// Define the number of records that will go into a chunk
+    chunk_size: Option<usize>,
+    /// Database to perform the query against
+    ///
+    /// This is optional because the query string may specify the database
+    #[serde(rename = "db")]
+    database: Option<String>,
+    /// Map timestamps to UNIX epoch time, with the given precision
+    #[allow(dead_code)]
+    epoch: Option<Precision>,
+    /// Format the JSON outputted in pretty format
+    #[serde(default)]
+    pretty: bool,
+    /// The InfluxQL query string
+    #[serde(rename = "q")]
+    query: String,
+}
+
+impl QueryParams {
+    /// Extract [`QueryParams`] from an HTTP [`Request`]
+    fn from_request(req: &Request<Body>) -> Result<Self> {
+        let query = req.uri().query().ok_or(Error::MissingQueryParams)?;
+        serde_urlencoded::from_str(query).map_err(Into::into)
+    }
+}
+
+/// UNIX epoch precision
+#[derive(Debug, Deserialize, Clone, Copy)]
+enum Precision {
+    #[serde(rename = "ns")]
+    Nanoseconds,
+    #[serde(rename = "u", alias = "µ")]
+    Microseconds,
+    #[serde(rename = "ms")]
+    Milliseconds,
+    #[serde(rename = "s")]
+    Seconds,
+    #[serde(rename = "m")]
+    Minutes,
+    #[serde(rename = "h")]
+    Hours,
+}
+
+/// Error type for the v1 API
+///
+/// This is used to catch errors that occur during the streaming process.
+/// [`anyhow::Error`] is used as a catch-all because if anything fails during
+/// that process it will result in a 500 INTERNAL ERROR.
+#[derive(Debug, thiserror::Error)]
+#[error("unexpected query error: {0}")]
+pub struct QueryError(#[from] anyhow::Error);
+
+/// The response structure returned by the v1 query API
+///
+/// The `pretty` parameter is used during serizliaztion to determine if JSON
+/// is pretty formatted or not.
+#[derive(Debug, Serialize)]
+struct QueryResponse {
+    results: Vec<StatementResponse>,
+    #[serde(skip_serializing)]
+    pretty: bool,
+}
+
+/// Convert [`QueryResponse`] to [`Bytes`] for `hyper`'s [`Body::wrap_stream`] method
+impl From<QueryResponse> for Bytes {
+    fn from(s: QueryResponse) -> Self {
+        if s.pretty {
+            serde_json::to_vec_pretty(&s)
+        } else {
+            serde_json::to_vec(&s)
+        }
+        .map(|mut b| {
+            b.extend_from_slice(b"\r\n");
+            b
+        })
+        .expect("valid bytes in statement result")
+        .into()
+    }
+}
+
+/// The response to an individual InfluxQL query
+#[derive(Debug, Serialize)]
+struct StatementResponse {
+    statement_id: usize,
+    series: Vec<Series>,
+}
+
+/// The records produced for a single time series (measurement)
+#[derive(Debug, Serialize)]
+struct Series {
+    name: String,
+    columns: Vec<String>,
+    values: Vec<Row>,
+}
+
+/// A single row, or record in a time series
+#[derive(Debug, Serialize)]
+struct Row(Vec<Value>);
+
+/// A buffer for storing records from a stream of [`RecordBatch`]es
+///
+/// The optional `size` indicates whether this is operating in `chunked` mode (see
+/// [`QueryResponseStream`]), and when specified, gives the size of chunks that will
+/// be emitted.
+struct ChunkBuffer {
+    size: Option<usize>,
+    series: VecDeque<(String, Vec<Row>)>,
+}
+
+impl ChunkBuffer {
+    fn new(size: Option<usize>) -> Self {
+        Self {
+            size,
+            series: VecDeque::new(),
+        }
+    }
+
+    /// Get the name of the current measurement [`Series`] being streamed
+    fn current_measurement_name(&self) -> Option<&str> {
+        self.series.front().map(|(n, _)| n.as_str())
+    }
+
+    /// For queries that produce multiple [`Series`], this will be called when
+    /// the current series is completed streaming
+    fn push_next_measurement<S: Into<String>>(&mut self, name: S) {
+        self.series.push_front((name.into(), vec![]));
+    }
+
+    /// Push a new [`Row`] into the current measurement [`Series`]
+    fn push_row(&mut self, row: Row) -> Result<(), anyhow::Error> {
+        self.series
+            .front_mut()
+            .context("tried to push row with no measurements buffered")?
+            .1
+            .push(row);
+        Ok(())
+    }
+
+    /// Flush a single chunk from the [`ChunkBuffer`], if possible
+    fn flush_one(&mut self) -> Option<(String, Vec<Row>)> {
+        if !self.can_flush() {
+            return None;
+        }
+        // we can flush, so unwrap is safe:
+        let size = self.size.unwrap();
+        if self
+            .series
+            .back()
+            .is_some_and(|(_, rows)| rows.len() <= size)
+        {
+            // the back series is smaller than the chunk size, so we just
+            // pop and take the whole thing:
+            self.series.pop_back()
+        } else {
+            // only drain a chunk's worth from the back series:
+            self.series
+                .back_mut()
+                .map(|(name, rows)| (name.to_owned(), rows.drain(..size).collect()))
+        }
+    }
+
+    /// The [`ChunkBuffer`] is operating in chunked mode, and can flush a chunk
+    fn can_flush(&self) -> bool {
+        if let (Some(size), Some(m)) = (self.size, self.series.back()) {
+            m.1.len() >= size || self.series.len() > 1
+        } else {
+            false
+        }
+    }
+
+    /// The [`ChunkBuffer`] is empty
+    fn is_empty(&self) -> bool {
+        self.series.is_empty()
+    }
+}
+
+/// A wrapper around a [`SendableRecordBatchStream`] that buffers streamed
+/// [`RecordBatch`]es and outputs [`QueryResponse`]s
+///
+/// Can operate in `chunked` mode, in which case, the `chunk_size` provided
+/// will determine how often [`QueryResponse`]s are emitted. When not in
+/// `chunked` mode, the entire input stream of [`RecordBatch`]es will be buffered
+/// into memory before being emitted.
+///
+/// `pretty` will emit pretty formatted JSON.
+///
+/// Providing an `epoch` [`Precision`] will have the `time` column values emitted
+/// as UNIX epoch times with the given precision.
+///
+/// The input stream is wrapped in [`Fuse`], because of the [`Stream`] implementation
+/// below, it is possible that the input stream is polled after completion.
+struct QueryResponseStream {
+    buffer: ChunkBuffer,
+    input: Fuse<SendableRecordBatchStream>,
+    column_map: HashMap<String, usize>,
+    statement_id: usize,
+    pretty: bool,
+    epoch: Option<Precision>,
+}
+
+impl QueryResponseStream {
+    /// Create a new [`QueryResponseStream`]
+    ///
+    /// Specifying a `chunk_size` will have the stream operate in `chunked` mode.
+    fn new(
+        statement_id: usize,
+        input: SendableRecordBatchStream,
+        chunk_size: Option<usize>,
+        pretty: bool,
+        epoch: Option<Precision>,
+    ) -> Result<Self, anyhow::Error> {
+        let buffer = ChunkBuffer::new(chunk_size);
+        let schema = input.schema();
+        let column_map = schema
+            .fields
+            .iter()
+            .map(|f| f.name().to_owned())
+            .enumerate()
+            .flat_map(|(i, n)| {
+                if n != INFLUXQL_MEASUREMENT_COLUMN_NAME && i > 0 {
+                    Some((n, i - 1))
+                } else {
+                    None
+                }
+            })
+            .collect();
+        Ok(Self {
+            buffer,
+            column_map,
+            input: input.fuse(),
+            pretty,
+            statement_id,
+            epoch,
+        })
+    }
+
+    fn buffer_record_batch(&mut self, mut batch: RecordBatch) -> Result<(), anyhow::Error> {
+        if self.epoch.is_some() {
+            // If the `epoch` is specified, then we cast the `time` column into an Int64.
+            // This will be in nanoseconds. The conversion to the given epoch precision
+            // happens below, when processing the JSON rows
+            batch = RecordBatch::try_from_iter(batch.schema().fields.iter().map(|f| {
+                let name = f.name();
+                let column = batch.column_by_name(name).unwrap();
+                (
+                    name,
+                    if name == TIME_COLUMN_NAME {
+                        // unwrap should be safe here because the time column cast to Int64
+                        cast_with_options(column, &DataType::Int64, &CastOptions::default())
+                            .unwrap()
+                    } else {
+                        Arc::clone(column)
+                    },
+                )
+            }))
+            .context("failed to cast batch time column with `epoch` parameter specified")?;
+        }
+        let json_rows = record_batches_to_json_rows(&[&batch])
+            .context("failed to convert RecordBatch to JSON rows")?;
+        for json_row in json_rows {
+            let mut row = vec![Value::Null; self.column_map.len()];
+            for (k, v) in json_row {
+                if k == INFLUXQL_MEASUREMENT_COLUMN_NAME
+                    && (self.buffer.current_measurement_name().is_none()
+                        || self
+                            .buffer
+                            .current_measurement_name()
+                            .is_some_and(|n| *n != v))
+                {
+                    // we are on the "iox::measurement" column, which gives the name of the time series
+                    // if we are on the first row, or if the measurement changes, we push into the
+                    // buffer queue
+                    self.buffer
+                        .push_next_measurement(v.as_str().with_context(|| {
+                            format!("{INFLUXQL_MEASUREMENT_COLUMN_NAME} value was not a string")
+                        })?);
+                } else if k == INFLUXQL_MEASUREMENT_COLUMN_NAME {
+                    // we are still working on the current measurement in the buffer, so ignore
+                    continue;
+                } else {
+                    // this is a column value that is part of the time series, add it to the row
+                    let j = self.column_map.get(&k).unwrap();
+                    row[*j] = if let (Some(precision), TIME_COLUMN_NAME) = (self.epoch, k.as_str())
+                    {
+                        // specially handle the time column if `epoch` parameter provided
+                        convert_ns_epoch(v, precision)?
+                    } else {
+                        v
+                    };
+                }
+            }
+            self.buffer.push_row(Row(row))?;
+        }
+        Ok(())
+    }
+
+    fn columns(&self) -> Vec<String> {
+        let mut columns = vec!["".to_string(); self.column_map.len()];
+        self.column_map
+            .iter()
+            .for_each(|(k, i)| columns[*i] = k.to_owned());
+        columns
+    }
+
+    /// Flush a single chunk, or time series, when operating in chunked mode
+    fn flush_one(&mut self) -> QueryResponse {
+        let columns = self.columns();
+        // this unwrap is okay because we only ever call flush_one
+        // after calling can_flush on the buffer:
+        let (name, values) = self.buffer.flush_one().unwrap();
+        let series = vec![Series {
+            name,
+            columns,
+            values,
+        }];
+        QueryResponse {
+            results: vec![StatementResponse {
+                statement_id: self.statement_id,
+                series,
+            }],
+            pretty: self.pretty,
+        }
+    }
+
+    /// Flush the entire buffer
+    fn flush_all(&mut self) -> Result<QueryResponse, anyhow::Error> {
+        let columns = self.columns();
+        let series = self
+            .buffer
+            .series
+            .drain(..)
+            .map(|(name, values)| Series {
+                name,
+                columns: columns.clone(),
+                values,
+            })
+            .collect();
+        Ok(QueryResponse {
+            results: vec![StatementResponse {
+                statement_id: self.statement_id,
+                series,
+            }],
+            pretty: self.pretty,
+        })
+    }
+}
+
+/// Convert an epoch time in nanoseconds to the provided precision
+fn convert_ns_epoch(value: Value, precision: Precision) -> Result<Value, anyhow::Error> {
+    let epoch_ns = value
+        .as_i64()
+        .context("the provided nanosecond epoch time was not a valid i64")?;
+    Ok(match precision {
+        Precision::Nanoseconds => epoch_ns,
+        Precision::Microseconds => epoch_ns / 1_000,
+        Precision::Milliseconds => epoch_ns / 1_000_000,
+        Precision::Seconds => epoch_ns / 1_000_000_000,
+        Precision::Minutes => epoch_ns / (1_000_000_000 * 60),
+        Precision::Hours => epoch_ns / (1_000_000_000 * 60 * 60),
+    }
+    .into())
+}
+
+impl Stream for QueryResponseStream {
+    type Item = Result<QueryResponse, anyhow::Error>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        // check for data in the buffer that can be flushed, if we are operating in chunked mode,
+        // this will drain the buffer as much as possible by repeatedly returning Ready here
+        // until the buffer can no longer flush, and before the input stream is polled again:
+        if self.buffer.can_flush() {
+            return Poll::Ready(Some(Ok(self.flush_one())));
+        }
+        // poll the input record batch stream:
+        match ready!(self.input.poll_next_unpin(cx)) {
+            Some(Ok(batch)) => {
+                // buffer the yielded batch:
+                if let Err(e) = self.buffer_record_batch(batch) {
+                    return Poll::Ready(Some(Err(e)));
+                }
+                if self.buffer.can_flush() {
+                    // if we can flush the buffer, do so now, and return
+                    Poll::Ready(Some(Ok(self.flush_one())))
+                } else {
+                    // otherwise, we want to poll again in order to pull more
+                    // batches from the input record batch stream:
+                    cx.waker().wake_by_ref();
+                    Poll::Pending
+                }
+            }
+            Some(Err(e)) => Poll::Ready(Some(Err(e.into()))),
+            None => {
+                if !self.buffer.is_empty() {
+                    // we only get here if we are not operating in chunked mode and
+                    // we need to flush the entire buffer at once, OR if we are in chunked
+                    // mode, and there is less than a chunk's worth of records left
+                    //
+                    // this is why the input stream is fused, because we will end up
+                    // polling the input stream again if we end up here.
+                    Poll::Ready(Some(self.flush_all()))
+                } else {
+                    Poll::Ready(None)
+                }
+            }
+        }
+    }
+}
diff --git a/influxdb3_server/src/lib.rs b/influxdb3_server/src/lib.rs
new file mode 100644
index 00000000000..2a1f5d268ae
--- /dev/null
+++ b/influxdb3_server/src/lib.rs
@@ -0,0 +1,868 @@
+//! InfluxDB 3.0 Edge server implementation
+//!
+//! The server is responsible for handling the HTTP API
+#![deny(rustdoc::broken_intra_doc_links, rustdoc::bare_urls, rust_2018_idioms)]
+#![warn(
+missing_debug_implementations,
+clippy::explicit_iter_loop,
+clippy::use_self,
+clippy::clone_on_ref_ptr,
+// See https://github.com/influxdata/influxdb_iox/pull/1671
+clippy::future_not_send
+)]
+
+pub mod auth;
+pub mod builder;
+mod grpc;
+mod http;
+pub mod query_executor;
+mod service;
+
+use crate::grpc::make_flight_server;
+use crate::http::route_request;
+use crate::http::HttpApi;
+use async_trait::async_trait;
+use authz::Authorizer;
+use datafusion::execution::SendableRecordBatchStream;
+use hyper::service::service_fn;
+use influxdb3_write::{Persister, WriteBuffer};
+use iox_query::QueryNamespaceProvider;
+use iox_query_params::StatementParams;
+use iox_time::TimeProvider;
+use observability_deps::tracing::{error, info};
+use service::hybrid;
+use std::convert::Infallible;
+use std::fmt::Debug;
+use std::net::SocketAddr;
+use std::sync::Arc;
+use thiserror::Error;
+use tokio_util::sync::CancellationToken;
+use tower::Layer;
+use trace::ctx::SpanContext;
+use trace::TraceCollector;
+use trace_http::ctx::RequestLogContext;
+use trace_http::ctx::TraceHeaderParser;
+use trace_http::metrics::MetricFamily;
+use trace_http::metrics::RequestMetrics;
+use trace_http::tower::TraceLayer;
+
+const TRACE_SERVER_NAME: &str = "influxdb3_http";
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("hyper error: {0}")]
+    Hyper(#[from] hyper::Error),
+
+    #[error("http error: {0}")]
+    Http(#[from] http::Error),
+
+    #[error("database not found {db_name}")]
+    DatabaseNotFound { db_name: String },
+
+    #[error("datafusion error: {0}")]
+    DataFusion(#[from] datafusion::error::DataFusionError),
+
+    #[error("influxdb3_write error: {0}")]
+    InfluxDB3Write(#[from] influxdb3_write::Error),
+
+    #[error("from hex error: {0}")]
+    FromHex(#[from] hex::FromHexError),
+}
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+#[derive(Debug, Clone)]
+pub struct CommonServerState {
+    metrics: Arc<metric::Registry>,
+    trace_exporter: Option<Arc<trace_exporters::export::AsyncExporter>>,
+    trace_header_parser: TraceHeaderParser,
+    http_addr: SocketAddr,
+}
+
+impl CommonServerState {
+    pub fn new(
+        metrics: Arc<metric::Registry>,
+        trace_exporter: Option<Arc<trace_exporters::export::AsyncExporter>>,
+        trace_header_parser: TraceHeaderParser,
+        http_addr: SocketAddr,
+    ) -> Result<Self> {
+        Ok(Self {
+            metrics,
+            trace_exporter,
+            trace_header_parser,
+            http_addr,
+        })
+    }
+
+    pub fn trace_exporter(&self) -> Option<Arc<trace_exporters::export::AsyncExporter>> {
+        self.trace_exporter.clone()
+    }
+
+    pub fn trace_collector(&self) -> Option<Arc<dyn TraceCollector>> {
+        self.trace_exporter
+            .clone()
+            .map(|x| -> Arc<dyn TraceCollector> { x })
+    }
+
+    pub fn trace_header_parser(&self) -> TraceHeaderParser {
+        self.trace_header_parser.clone()
+    }
+
+    pub fn metric_registry(&self) -> Arc<metric::Registry> {
+        Arc::<metric::Registry>::clone(&self.metrics)
+    }
+}
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct Server<W, Q, P, T> {
+    common_state: CommonServerState,
+    http: Arc<HttpApi<W, Q, T>>,
+    persister: Arc<P>,
+    authorizer: Arc<dyn Authorizer>,
+}
+
+#[async_trait]
+pub trait QueryExecutor: QueryNamespaceProvider + Debug + Send + Sync + 'static {
+    type Error;
+
+    async fn query(
+        &self,
+        database: &str,
+        q: &str,
+        params: Option<StatementParams>,
+        kind: QueryKind,
+        span_ctx: Option<SpanContext>,
+        external_span_ctx: Option<RequestLogContext>,
+    ) -> Result<SendableRecordBatchStream, Self::Error>;
+
+    fn show_databases(&self) -> Result<SendableRecordBatchStream, Self::Error>;
+
+    async fn show_retention_policies(
+        &self,
+        database: Option<&str>,
+        span_ctx: Option<SpanContext>,
+    ) -> Result<SendableRecordBatchStream, Self::Error>;
+}
+
+#[derive(Debug)]
+pub enum QueryKind {
+    Sql,
+    InfluxQl,
+}
+impl<W, Q, P, T> Server<W, Q, P, T> {
+    pub fn authorizer(&self) -> Arc<dyn Authorizer> {
+        Arc::clone(&self.authorizer)
+    }
+}
+
+pub async fn serve<W, Q, P, T>(
+    server: Server<W, Q, P, T>,
+    shutdown: CancellationToken,
+) -> Result<()>
+where
+    W: WriteBuffer,
+    Q: QueryExecutor,
+    http::Error: From<<Q as QueryExecutor>::Error>,
+    P: Persister,
+    T: TimeProvider,
+{
+    let req_metrics = RequestMetrics::new(
+        Arc::clone(&server.common_state.metrics),
+        MetricFamily::HttpServer,
+    );
+    let trace_layer = TraceLayer::new(
+        server.common_state.trace_header_parser.clone(),
+        Arc::new(req_metrics),
+        server.common_state.trace_collector().clone(),
+        TRACE_SERVER_NAME,
+    );
+
+    let grpc_service = trace_layer.clone().layer(make_flight_server(
+        Arc::clone(&server.http.query_executor),
+        Some(server.authorizer()),
+    ));
+    let rest_service = hyper::service::make_service_fn(|_| {
+        let http_server = Arc::clone(&server.http);
+        let service = service_fn(move |req: hyper::Request<hyper::Body>| {
+            route_request(Arc::clone(&http_server), req)
+        });
+        let service = trace_layer.layer(service);
+        futures::future::ready(Ok::<_, Infallible>(service))
+    });
+
+    let hybrid_make_service = hybrid(rest_service, grpc_service);
+
+    hyper::Server::bind(&server.common_state.http_addr)
+        .serve(hybrid_make_service)
+        .with_graceful_shutdown(shutdown.cancelled())
+        .await?;
+
+    Ok(())
+}
+
+/// On unix platforms we want to intercept SIGINT and SIGTERM
+/// This method returns if either are signalled
+#[cfg(unix)]
+pub async fn wait_for_signal() {
+    use tokio::signal::unix::{signal, SignalKind};
+    let mut term = signal(SignalKind::terminate()).expect("failed to register signal handler");
+    let mut int = signal(SignalKind::interrupt()).expect("failed to register signal handler");
+
+    tokio::select! {
+        _ = term.recv() => info!("Received SIGTERM"),
+        _ = int.recv() => info!("Received SIGINT"),
+    }
+}
+
+#[cfg(windows)]
+/// ctrl_c is the cross-platform way to intercept the equivalent of SIGINT
+/// This method returns if this occurs
+pub async fn wait_for_signal() {
+    let _ = tokio::signal::ctrl_c().await;
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::auth::DefaultAuthorizer;
+    use crate::builder::ServerBuilder;
+    use crate::serve;
+    use datafusion::parquet::data_type::AsBytes;
+    use hyper::{body, Body, Client, Request, Response, StatusCode};
+    use influxdb3_write::persister::PersisterImpl;
+    use influxdb3_write::SegmentDuration;
+    use iox_query::exec::{Executor, ExecutorConfig};
+    use iox_time::{MockProvider, Time};
+    use object_store::DynObjectStore;
+    use parquet_file::storage::{ParquetStorage, StorageId};
+    use pretty_assertions::assert_eq;
+    use std::collections::HashMap;
+    use std::net::{SocketAddr, SocketAddrV4};
+    use std::num::NonZeroUsize;
+    use std::sync::atomic::{AtomicU16, Ordering};
+    use std::sync::Arc;
+    use tokio_util::sync::CancellationToken;
+
+    static NEXT_PORT: AtomicU16 = AtomicU16::new(8090);
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn write_and_query() {
+        let addr = get_free_port();
+        let trace_header_parser = trace_http::ctx::TraceHeaderParser::new();
+        let metrics = Arc::new(metric::Registry::new());
+        let common_state =
+            crate::CommonServerState::new(Arc::clone(&metrics), None, trace_header_parser, addr)
+                .unwrap();
+        let object_store: Arc<DynObjectStore> = Arc::new(object_store::memory::InMemory::new());
+        let parquet_store =
+            ParquetStorage::new(Arc::clone(&object_store), StorageId::from("influxdb3"));
+        let num_threads = NonZeroUsize::new(2).unwrap();
+        let exec = Arc::new(Executor::new_with_config(
+            "datafusion",
+            ExecutorConfig {
+                num_threads,
+                target_query_partitions: NonZeroUsize::new(1).unwrap(),
+                object_stores: [&parquet_store]
+                    .into_iter()
+                    .map(|store| (store.id(), Arc::clone(store.object_store())))
+                    .collect(),
+                metric_registry: Arc::clone(&metrics),
+                mem_pool_size: usize::MAX,
+            },
+        ));
+        let persister = Arc::new(PersisterImpl::new(Arc::clone(&object_store)));
+        let time_provider = Arc::new(MockProvider::new(Time::from_timestamp_nanos(0)));
+
+        let write_buffer = Arc::new(
+            influxdb3_write::write_buffer::WriteBufferImpl::new(
+                Arc::clone(&persister),
+                None::<Arc<influxdb3_write::wal::WalImpl>>,
+                Arc::clone(&time_provider),
+                SegmentDuration::new_5m(),
+                Arc::clone(&exec),
+            )
+            .await
+            .unwrap(),
+        );
+        let query_executor = Arc::new(crate::query_executor::QueryExecutorImpl::new(
+            write_buffer.catalog(),
+            Arc::clone(&write_buffer),
+            Arc::clone(&exec),
+            Arc::clone(&metrics),
+            Arc::new(HashMap::new()),
+            10,
+        ));
+
+        let server = ServerBuilder::new(common_state)
+            .write_buffer(Arc::clone(&write_buffer))
+            .query_executor(Arc::clone(&query_executor))
+            .persister(Arc::clone(&persister))
+            .authorizer(Arc::new(DefaultAuthorizer))
+            .time_provider(Arc::clone(&time_provider))
+            .build();
+        let frontend_shutdown = CancellationToken::new();
+        let shutdown = frontend_shutdown.clone();
+
+        tokio::spawn(async move { serve(server, frontend_shutdown).await });
+
+        let server = format!("http://{}", addr);
+        write_lp(
+            &server,
+            "foo",
+            "cpu,host=a val=1i 123",
+            None,
+            false,
+            "nanosecond",
+        )
+        .await;
+
+        // Test that we can query the output with a pretty output
+        let res = query(
+            &server,
+            "foo",
+            "select host, time, val from cpu",
+            "pretty",
+            None,
+        )
+        .await;
+        let body = body::to_bytes(res.into_body()).await.unwrap();
+        let body = String::from_utf8(body.as_bytes().to_vec()).unwrap();
+        let expected = vec![
+            "+------+-------------------------------+-----+",
+            "| host | time                          | val |",
+            "+------+-------------------------------+-----+",
+            "| a    | 1970-01-01T00:00:00.000000123 | 1   |",
+            "+------+-------------------------------+-----+",
+        ];
+        let actual: Vec<_> = body.split('\n').collect();
+        assert_eq!(
+            expected, actual,
+            "\n\nexpected:\n\n{:#?}\nactual:\n\n{:#?}\n\n",
+            expected, actual
+        );
+        // Test that we can query the output with a json output
+        let res = query(
+            &server,
+            "foo",
+            "select host, time, val from cpu",
+            "json",
+            None,
+        )
+        .await;
+        let body = body::to_bytes(res.into_body()).await.unwrap();
+        let actual = std::str::from_utf8(body.as_bytes()).unwrap();
+        let expected = r#"[{"host":"a","time":"1970-01-01T00:00:00.000000123","val":1}]"#;
+        assert_eq!(actual, expected);
+        // Test that we can query the output with a csv output
+        let res = query(
+            &server,
+            "foo",
+            "select host, time, val from cpu",
+            "csv",
+            None,
+        )
+        .await;
+        let body = body::to_bytes(res.into_body()).await.unwrap();
+        let actual = std::str::from_utf8(body.as_bytes()).unwrap();
+        let expected = "host,time,val\na,1970-01-01T00:00:00.000000123,1\n";
+        assert_eq!(actual, expected);
+
+        // Test that we can query the output with a parquet
+        use arrow::buffer::Buffer;
+        use parquet::arrow::arrow_reader;
+        let res = query(&server, "foo", "select * from cpu", "parquet", None).await;
+        let body = body::to_bytes(res.into_body()).await.unwrap();
+        let batches = arrow_reader::ParquetRecordBatchReaderBuilder::try_new(body)
+            .unwrap()
+            .build()
+            .unwrap();
+        let batches = batches.into_iter().collect::<Result<Vec<_>, _>>().unwrap();
+        assert_eq!(batches.len(), 1);
+
+        // Check that we only have the columns we expect
+        assert_eq!(batches[0].num_columns(), 4);
+        assert!(batches[0].schema().column_with_name("host").is_some());
+        assert!(batches[0].schema().column_with_name("time").is_some());
+        assert!(batches[0].schema().column_with_name("val").is_some());
+        assert!(batches[0]
+            .schema()
+            .column_with_name("random_name")
+            .is_none());
+
+        assert_eq!(
+            batches[0]["host"].to_data().child_data()[0].buffers()[1],
+            Buffer::from([b'a'].to_vec())
+        );
+
+        assert_eq!(
+            batches[0]["time"].to_data().buffers(),
+            &[Buffer::from(vec![123, 0, 0, 0, 0, 0, 0, 0])]
+        );
+        assert_eq!(
+            batches[0]["val"].to_data().buffers(),
+            &[Buffer::from(1_u64.to_le_bytes().to_vec())]
+        );
+
+        shutdown.cancel();
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn write_lp_tests() {
+        let addr = get_free_port();
+        let trace_header_parser = trace_http::ctx::TraceHeaderParser::new();
+        let metrics = Arc::new(metric::Registry::new());
+        let common_state =
+            crate::CommonServerState::new(Arc::clone(&metrics), None, trace_header_parser, addr)
+                .unwrap();
+        let object_store: Arc<DynObjectStore> = Arc::new(object_store::memory::InMemory::new());
+        let parquet_store =
+            ParquetStorage::new(Arc::clone(&object_store), StorageId::from("influxdb3"));
+        let num_threads = NonZeroUsize::new(2).unwrap();
+        let exec = Arc::new(Executor::new_with_config(
+            "datafusion",
+            ExecutorConfig {
+                num_threads,
+                target_query_partitions: NonZeroUsize::new(1).unwrap(),
+                object_stores: [&parquet_store]
+                    .into_iter()
+                    .map(|store| (store.id(), Arc::clone(store.object_store())))
+                    .collect(),
+                metric_registry: Arc::clone(&metrics),
+                mem_pool_size: usize::MAX,
+            },
+        ));
+        let persister = Arc::new(PersisterImpl::new(Arc::clone(&object_store)));
+        let time_provider = Arc::new(MockProvider::new(Time::from_timestamp_nanos(0)));
+
+        let write_buffer = Arc::new(
+            influxdb3_write::write_buffer::WriteBufferImpl::new(
+                Arc::clone(&persister),
+                None::<Arc<influxdb3_write::wal::WalImpl>>,
+                Arc::clone(&time_provider),
+                SegmentDuration::new_5m(),
+                Arc::clone(&exec),
+            )
+            .await
+            .unwrap(),
+        );
+        let query_executor = crate::query_executor::QueryExecutorImpl::new(
+            write_buffer.catalog(),
+            Arc::clone(&write_buffer),
+            Arc::clone(&exec),
+            Arc::clone(&metrics),
+            Arc::new(HashMap::new()),
+            10,
+        );
+
+        let server = ServerBuilder::new(common_state)
+            .write_buffer(Arc::clone(&write_buffer))
+            .query_executor(Arc::new(query_executor))
+            .persister(persister)
+            .authorizer(Arc::new(DefaultAuthorizer))
+            .time_provider(Arc::clone(&time_provider))
+            .build();
+        let frontend_shutdown = CancellationToken::new();
+        let shutdown = frontend_shutdown.clone();
+
+        tokio::spawn(async move { serve(server, frontend_shutdown).await });
+
+        // Test that only one error comes back
+        let server = format!("http://{}", addr);
+        let resp = write_lp(
+            &server,
+            "foo",
+            "cpu,host=a val= 123\ncpu,host=b val=5 124\ncpu,host=b val= 124",
+            None,
+            false,
+            "nanosecond",
+        )
+        .await;
+
+        let status = resp.status();
+        let body =
+            String::from_utf8(body::to_bytes(resp.into_body()).await.unwrap().to_vec()).unwrap();
+
+        assert_eq!(status, StatusCode::BAD_REQUEST);
+        assert_eq!(
+            body,
+            "{\
+                \"error\":\"parsing failed for write_lp endpoint\",\
+                \"data\":{\
+                    \"original_line\":\"cpu,host=a val= 123\",\
+                    \"line_number\":1,\
+                    \"error_message\":\"No fields were provided\"\
+                }\
+            }"
+        );
+
+        let resp = write_lp(
+            &server,
+            "foo",
+            "cpu,host=b val=2 155\ncpu,host=a val= 123\ncpu,host=b val=5 199",
+            None,
+            true,
+            "nanosecond",
+        )
+        .await;
+
+        let status = resp.status();
+        let body =
+            String::from_utf8(body::to_bytes(resp.into_body()).await.unwrap().to_vec()).unwrap();
+
+        assert_eq!(status, StatusCode::BAD_REQUEST);
+        assert_eq!(
+            body,
+            "{\
+                \"error\":\"partial write of line protocol occurred\",\
+                \"data\":[{\
+                    \"original_line\":\"cpu,host=a val= 123\",\
+                    \"line_number\":2,\
+                    \"error_message\":\"No fields were provided\"\
+                }]\
+            }"
+        );
+
+        // Check that the first write did not partially write any data. We
+        // should only see 2 values from the above write.
+        let res = query(
+            &server,
+            "foo",
+            "select host, time, val from cpu",
+            "csv",
+            None,
+        )
+        .await;
+        let body = body::to_bytes(res.into_body()).await.unwrap();
+        let actual = std::str::from_utf8(body.as_bytes()).unwrap();
+        let expected = "host,time,val\n\
+                        b,1970-01-01T00:00:00.000000155,2.0\n\
+                        b,1970-01-01T00:00:00.000000199,5.0\n";
+        assert_eq!(actual, expected);
+
+        // Check that invalid database names are rejected
+        let resp = write_lp(
+            &server,
+            "this/_is_fine",
+            "cpu,host=b val=2 155\n",
+            None,
+            true,
+            "nanosecond",
+        )
+        .await;
+
+        let status = resp.status();
+        let body =
+            String::from_utf8(body::to_bytes(resp.into_body()).await.unwrap().to_vec()).unwrap();
+
+        assert_eq!(status, StatusCode::BAD_REQUEST);
+        assert_eq!(
+            body,
+            "{\
+                \"error\":\"invalid character in database name: must be ASCII, containing only letters, numbers, underscores, or hyphens\",\
+                \"data\":null\
+            }"
+        );
+
+        let resp = write_lp(
+            &server,
+            "?this_is_fine",
+            "cpu,host=b val=2 155\n",
+            None,
+            true,
+            "nanosecond",
+        )
+        .await;
+
+        let status = resp.status();
+        let body =
+            String::from_utf8(body::to_bytes(resp.into_body()).await.unwrap().to_vec()).unwrap();
+
+        assert_eq!(status, StatusCode::BAD_REQUEST);
+        assert_eq!(
+            body,
+            "{\
+                \"error\":\"db name did not start with a number or letter\",\
+                \"data\":null\
+            }"
+        );
+
+        let resp = write_lp(
+            &server,
+            "",
+            "cpu,host=b val=2 155\n",
+            None,
+            true,
+            "nanosecond",
+        )
+        .await;
+
+        let status = resp.status();
+        let body =
+            String::from_utf8(body::to_bytes(resp.into_body()).await.unwrap().to_vec()).unwrap();
+
+        assert_eq!(status, StatusCode::BAD_REQUEST);
+        assert_eq!(
+            body,
+            "{\
+                \"error\":\"db name cannot be empty\",\
+                \"data\":null\
+            }"
+        );
+
+        shutdown.cancel();
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn write_lp_precision_tests() {
+        let addr = get_free_port();
+        let trace_header_parser = trace_http::ctx::TraceHeaderParser::new();
+        let metrics = Arc::new(metric::Registry::new());
+        let common_state =
+            crate::CommonServerState::new(Arc::clone(&metrics), None, trace_header_parser, addr)
+                .unwrap();
+        let object_store: Arc<DynObjectStore> = Arc::new(object_store::memory::InMemory::new());
+        let parquet_store =
+            ParquetStorage::new(Arc::clone(&object_store), StorageId::from("influxdb3"));
+        let num_threads = NonZeroUsize::new(2).unwrap();
+        let exec = Arc::new(Executor::new_with_config(
+            "datafusion",
+            ExecutorConfig {
+                num_threads,
+                target_query_partitions: NonZeroUsize::new(1).unwrap(),
+                object_stores: [&parquet_store]
+                    .into_iter()
+                    .map(|store| (store.id(), Arc::clone(store.object_store())))
+                    .collect(),
+                metric_registry: Arc::clone(&metrics),
+                mem_pool_size: usize::MAX,
+            },
+        ));
+        let persister = Arc::new(PersisterImpl::new(Arc::clone(&object_store)));
+        let time_provider = Arc::new(MockProvider::new(Time::from_timestamp_nanos(
+            1708473607000000000,
+        )));
+
+        let write_buffer = Arc::new(
+            influxdb3_write::write_buffer::WriteBufferImpl::new(
+                Arc::clone(&persister),
+                None::<Arc<influxdb3_write::wal::WalImpl>>,
+                Arc::clone(&time_provider),
+                SegmentDuration::new_5m(),
+                Arc::clone(&exec),
+            )
+            .await
+            .unwrap(),
+        );
+        let query_executor = crate::query_executor::QueryExecutorImpl::new(
+            write_buffer.catalog(),
+            Arc::clone(&write_buffer),
+            Arc::clone(&exec),
+            Arc::clone(&metrics),
+            Arc::new(HashMap::new()),
+            10,
+        );
+
+        let server = ServerBuilder::new(common_state)
+            .write_buffer(Arc::clone(&write_buffer))
+            .query_executor(Arc::new(query_executor))
+            .persister(persister)
+            .authorizer(Arc::new(DefaultAuthorizer))
+            .time_provider(Arc::clone(&time_provider))
+            .build();
+        let frontend_shutdown = CancellationToken::new();
+        let shutdown = frontend_shutdown.clone();
+
+        tokio::spawn(async move { serve(server, frontend_shutdown).await });
+
+        let server = format!("http://{}", addr);
+        let resp = write_lp(
+            &server,
+            "foo",
+            "cpu,host=b val=5 1708473600",
+            None,
+            false,
+            "auto",
+        )
+        .await;
+        assert_eq!(resp.status(), StatusCode::OK);
+        let resp = write_lp(
+            &server,
+            "foo",
+            "cpu,host=b val=5 1708473601000",
+            None,
+            false,
+            "auto",
+        )
+        .await;
+        assert_eq!(resp.status(), StatusCode::OK);
+        let resp = write_lp(
+            &server,
+            "foo",
+            "cpu,host=b val=5 1708473602000000",
+            None,
+            false,
+            "auto",
+        )
+        .await;
+        assert_eq!(resp.status(), StatusCode::OK);
+        let resp = write_lp(
+            &server,
+            "foo",
+            "cpu,host=b val=5 1708473603000000000",
+            None,
+            false,
+            "auto",
+        )
+        .await;
+        assert_eq!(resp.status(), StatusCode::OK);
+        let resp = write_lp(
+            &server,
+            "foo",
+            "cpu,host=b val=6 1708473604",
+            None,
+            false,
+            "second",
+        )
+        .await;
+        assert_eq!(resp.status(), StatusCode::OK);
+        let resp = write_lp(
+            &server,
+            "foo",
+            "cpu,host=b val=6 1708473605000",
+            None,
+            false,
+            "millisecond",
+        )
+        .await;
+        assert_eq!(resp.status(), StatusCode::OK);
+        let resp = write_lp(
+            &server,
+            "foo",
+            "cpu,host=b val=6 1708473606000000",
+            None,
+            false,
+            "microsecond",
+        )
+        .await;
+        assert_eq!(resp.status(), StatusCode::OK);
+        let resp = write_lp(
+            &server,
+            "foo",
+            "cpu,host=b val=6 1708473607000000000",
+            None,
+            false,
+            "nanosecond",
+        )
+        .await;
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        let res = query(
+            &server,
+            "foo",
+            "select host, time, val from cpu",
+            "csv",
+            None,
+        )
+        .await;
+        let body = body::to_bytes(res.into_body()).await.unwrap();
+        // Since a query can come back with data in any order we need to sort it
+        // here before we do any assertions
+        let mut unsorted = String::from_utf8(body.as_bytes().to_vec())
+            .unwrap()
+            .lines()
+            .skip(1)
+            .map(|s| s.to_string())
+            .collect::<Vec<String>>();
+        unsorted.sort();
+        let actual = unsorted.join("\n");
+        let expected = "b,2024-02-21T00:00:00,5.0\n\
+                        b,2024-02-21T00:00:01,5.0\n\
+                        b,2024-02-21T00:00:02,5.0\n\
+                        b,2024-02-21T00:00:03,5.0\n\
+                        b,2024-02-21T00:00:04,6.0\n\
+                        b,2024-02-21T00:00:05,6.0\n\
+                        b,2024-02-21T00:00:06,6.0\n\
+                        b,2024-02-21T00:00:07,6.0";
+        assert_eq!(actual, expected);
+
+        shutdown.cancel();
+    }
+
+    pub(crate) async fn write_lp(
+        server: impl Into<String> + Send,
+        database: impl Into<String> + Send,
+        lp: impl Into<String> + Send,
+        authorization: Option<&str>,
+        accept_partial: bool,
+        precision: impl Into<String> + Send,
+    ) -> Response<Body> {
+        let server = server.into();
+        let client = Client::new();
+        let url = format!(
+            "{}/api/v3/write_lp?db={}&accept_partial={accept_partial}&precision={}",
+            server,
+            database.into(),
+            precision.into(),
+        );
+        println!("{}", url);
+
+        let mut builder = Request::builder().uri(url).method("POST");
+        if let Some(authorization) = authorization {
+            builder = builder.header(hyper::header::AUTHORIZATION, authorization);
+        };
+        let request = builder
+            .body(Body::from(lp.into()))
+            .expect("failed to construct HTTP request");
+
+        client
+            .request(request)
+            .await
+            .expect("http error sending write")
+    }
+
+    pub(crate) async fn query(
+        server: impl Into<String> + Send,
+        database: impl Into<String> + Send,
+        query: impl Into<String> + Send,
+        format: impl Into<String> + Send,
+        authorization: Option<&str>,
+    ) -> Response<Body> {
+        let client = Client::new();
+        // query escaped for uri
+        let query = urlencoding::encode(&query.into());
+        let url = format!(
+            "{}/api/v3/query_sql?db={}&q={}&format={}",
+            server.into(),
+            database.into(),
+            query,
+            format.into()
+        );
+
+        println!("query url: {}", url);
+        let mut builder = Request::builder().uri(url).method("GET");
+        if let Some(authorization) = authorization {
+            builder = builder.header(hyper::header::AUTHORIZATION, authorization);
+        };
+        let request = builder
+            .body(Body::empty())
+            .expect("failed to construct HTTP request");
+
+        client
+            .request(request)
+            .await
+            .expect("http error sending query")
+    }
+
+    pub(crate) fn get_free_port() -> SocketAddr {
+        let ip = std::net::Ipv4Addr::new(127, 0, 0, 1);
+
+        loop {
+            let port = NEXT_PORT.fetch_add(1, Ordering::SeqCst);
+            let addr = SocketAddrV4::new(ip, port);
+
+            if std::net::TcpListener::bind(addr).is_ok() {
+                return addr.into();
+            }
+        }
+    }
+}
diff --git a/influxdb3_server/src/query_executor.rs b/influxdb3_server/src/query_executor.rs
new file mode 100644
index 00000000000..d5a762d7277
--- /dev/null
+++ b/influxdb3_server/src/query_executor.rs
@@ -0,0 +1,497 @@
+//! module for query executor
+use crate::{QueryExecutor, QueryKind};
+use arrow::datatypes::SchemaRef;
+use arrow::record_batch::RecordBatch;
+use arrow_schema::ArrowError;
+use async_trait::async_trait;
+use data_types::NamespaceId;
+use datafusion::catalog::schema::SchemaProvider;
+use datafusion::catalog::CatalogProvider;
+use datafusion::common::arrow::array::StringArray;
+use datafusion::common::arrow::datatypes::{DataType, Field, Schema as DatafusionSchema};
+use datafusion::datasource::{TableProvider, TableType};
+use datafusion::error::DataFusionError;
+use datafusion::execution::context::SessionState;
+use datafusion::execution::SendableRecordBatchStream;
+use datafusion::physical_plan::ExecutionPlan;
+use datafusion::prelude::Expr;
+use datafusion_util::config::DEFAULT_SCHEMA;
+use datafusion_util::MemoryStream;
+use influxdb3_write::{
+    catalog::{Catalog, DatabaseSchema},
+    WriteBuffer,
+};
+use iox_query::exec::{Executor, IOxSessionContext, QueryConfig};
+use iox_query::frontend::sql::SqlQueryPlanner;
+use iox_query::provider::ProviderBuilder;
+use iox_query::query_log::QueryCompletedToken;
+use iox_query::query_log::QueryLog;
+use iox_query::query_log::QueryText;
+use iox_query::query_log::StateReceived;
+use iox_query::QueryNamespaceProvider;
+use iox_query::{QueryChunk, QueryNamespace};
+use iox_query_influxql::frontend::planner::InfluxQLQueryPlanner;
+use iox_query_params::StatementParams;
+use metric::Registry;
+use observability_deps::tracing::{debug, info, trace};
+use schema::Schema;
+use serde::{Deserialize, Serialize};
+use serde_arrow::schema::SchemaLike;
+use std::any::Any;
+use std::collections::HashMap;
+use std::fmt::Debug;
+use std::sync::Arc;
+use trace::ctx::SpanContext;
+use trace::span::{Span, SpanExt, SpanRecorder};
+use trace_http::ctx::RequestLogContext;
+use tracker::{
+    AsyncSemaphoreMetrics, InstrumentedAsyncOwnedSemaphorePermit, InstrumentedAsyncSemaphore,
+};
+
+#[derive(Debug)]
+pub struct QueryExecutorImpl<W> {
+    catalog: Arc<Catalog>,
+    write_buffer: Arc<W>,
+    exec: Arc<Executor>,
+    datafusion_config: Arc<HashMap<String, String>>,
+    query_execution_semaphore: Arc<InstrumentedAsyncSemaphore>,
+}
+
+impl<W: WriteBuffer> QueryExecutorImpl<W> {
+    pub fn new(
+        catalog: Arc<Catalog>,
+        write_buffer: Arc<W>,
+        exec: Arc<Executor>,
+        metrics: Arc<Registry>,
+        datafusion_config: Arc<HashMap<String, String>>,
+        concurrent_query_limit: usize,
+    ) -> Self {
+        let semaphore_metrics = Arc::new(AsyncSemaphoreMetrics::new(
+            &metrics,
+            &[("semaphore", "query_execution")],
+        ));
+        let query_execution_semaphore =
+            Arc::new(semaphore_metrics.new_semaphore(concurrent_query_limit));
+        Self {
+            catalog,
+            write_buffer,
+            exec,
+            datafusion_config,
+            query_execution_semaphore,
+        }
+    }
+}
+
+#[async_trait]
+impl<W: WriteBuffer> QueryExecutor for QueryExecutorImpl<W> {
+    type Error = Error;
+
+    async fn query(
+        &self,
+        database: &str,
+        q: &str,
+        params: Option<StatementParams>,
+        kind: QueryKind,
+        span_ctx: Option<SpanContext>,
+        external_span_ctx: Option<RequestLogContext>,
+    ) -> Result<SendableRecordBatchStream, Self::Error> {
+        info!("query in executor {}", database);
+        let db = self
+            .db(database, span_ctx.child_span("get database"), false)
+            .await
+            .map_err(|_| Error::DatabaseNotFound {
+                db_name: database.to_string(),
+            })?
+            .ok_or_else(|| Error::DatabaseNotFound {
+                db_name: database.to_string(),
+            })?;
+
+        // TODO - configure query here?
+        let ctx = db.new_query_context(span_ctx, Default::default());
+
+        let token = db.record_query(
+            external_span_ctx.as_ref().map(RequestLogContext::ctx),
+            "sql",
+            Box::new(q.to_string()),
+            // TODO - ignoring params for now:
+            StatementParams::default(),
+        );
+
+        info!("plan");
+        let params = params.unwrap_or_default();
+        let plan = match kind {
+            QueryKind::Sql => {
+                let planner = SqlQueryPlanner::new();
+                planner.query(q, params, &ctx).await
+            }
+            QueryKind::InfluxQl => {
+                let planner = InfluxQLQueryPlanner::new();
+                planner.query(q, params, &ctx).await
+            }
+        }
+        .map_err(Error::QueryPlanning)?;
+        let token = token.planned(&ctx, Arc::clone(&plan));
+
+        // TODO: Enforce concurrency limit here
+        let token = token.permit();
+
+        info!("execute_stream");
+        match ctx.execute_stream(Arc::clone(&plan)).await {
+            Ok(query_results) => {
+                token.success();
+                Ok(query_results)
+            }
+            Err(err) => {
+                token.fail();
+                Err(Error::ExecuteStream(err))
+            }
+        }
+    }
+
+    fn show_databases(&self) -> Result<SendableRecordBatchStream, Self::Error> {
+        let mut databases = self.catalog.list_databases();
+        // sort them to ensure consistent order:
+        databases.sort_unstable();
+        let databases = StringArray::from(databases);
+        let schema =
+            DatafusionSchema::new(vec![Field::new("iox::database", DataType::Utf8, false)]);
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(databases)])
+            .map_err(Error::DatabasesToRecordBatch)?;
+        Ok(Box::pin(MemoryStream::new(vec![batch])))
+    }
+
+    async fn show_retention_policies(
+        &self,
+        database: Option<&str>,
+        span_ctx: Option<SpanContext>,
+    ) -> Result<SendableRecordBatchStream, Self::Error> {
+        let mut databases = if let Some(db) = database {
+            vec![db.to_owned()]
+        } else {
+            self.catalog.list_databases()
+        };
+        // sort them to ensure consistent order:
+        databases.sort_unstable();
+
+        let mut records = Vec::with_capacity(databases.len());
+        for database in databases {
+            let db = self
+                .db(&database, span_ctx.child_span("get database"), false)
+                .await
+                .map_err(|_| Error::DatabaseNotFound {
+                    db_name: database.to_string(),
+                })?
+                .ok_or_else(|| Error::DatabaseNotFound {
+                    db_name: database.to_string(),
+                })?;
+            let duration = db.retention_time_ns();
+            let (db_name, rp_name) = split_database_name(&database);
+            records.push(RetentionPolicyRecord {
+                database: db_name,
+                name: rp_name,
+                duration,
+            });
+        }
+
+        let fields = Vec::<Field>::from_type::<RetentionPolicyRecord>(Default::default())?;
+        let arrays = serde_arrow::to_arrow(&fields, &records)?;
+        let schema = DatafusionSchema::new(fields);
+        let batch = RecordBatch::try_new(Arc::new(schema), arrays)
+            .map_err(Error::RetentionPoliciesToRecordBatch)?;
+        Ok(Box::pin(MemoryStream::new(vec![batch])))
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct RetentionPolicyRecord {
+    #[serde(rename = "iox::database")]
+    database: String,
+    name: String,
+    duration: Option<i64>,
+}
+
+const AUTOGEN_RETENTION_POLICY: &str = "autogen";
+
+fn split_database_name(db_name: &str) -> (String, String) {
+    let mut split = db_name.split('/');
+    (
+        split.next().unwrap().to_owned(),
+        split.next().unwrap_or(AUTOGEN_RETENTION_POLICY).to_owned(),
+    )
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("database not found: {db_name}")]
+    DatabaseNotFound { db_name: String },
+    #[error("error while planning query: {0}")]
+    QueryPlanning(#[source] DataFusionError),
+    #[error("error while executing plan: {0}")]
+    ExecuteStream(#[source] DataFusionError),
+    #[error("unable to compose record batches from databases: {0}")]
+    DatabasesToRecordBatch(#[source] ArrowError),
+    #[error("unable to compose record batches from retention policies: {0}")]
+    RetentionPoliciesToRecordBatch(#[source] ArrowError),
+    #[error("serde_arrow error: {0}")]
+    SerdeArrow(#[from] serde_arrow::Error),
+}
+
+// This implementation is for the Flight service
+#[async_trait]
+impl<W: WriteBuffer> QueryNamespaceProvider for QueryExecutorImpl<W> {
+    async fn db(
+        &self,
+        name: &str,
+        span: Option<Span>,
+        _include_debug_info_tables: bool,
+    ) -> Result<Option<Arc<dyn QueryNamespace>>, DataFusionError> {
+        let _span_recorder = SpanRecorder::new(span);
+
+        let db_schema = self.catalog.db_schema(name).ok_or_else(|| {
+            DataFusionError::External(Box::new(Error::DatabaseNotFound {
+                db_name: name.into(),
+            }))
+        })?;
+
+        Ok(Some(Arc::new(QueryDatabase::new(
+            db_schema,
+            Arc::clone(&self.write_buffer) as _,
+            Arc::clone(&self.exec),
+            Arc::clone(&self.datafusion_config),
+        ))))
+    }
+
+    async fn acquire_semaphore(&self, span: Option<Span>) -> InstrumentedAsyncOwnedSemaphorePermit {
+        Arc::clone(&self.query_execution_semaphore)
+            .acquire_owned(span)
+            .await
+            .expect("Semaphore should not be closed by anyone")
+    }
+}
+
+#[derive(Debug)]
+pub struct QueryDatabase<B> {
+    db_schema: Arc<DatabaseSchema>,
+    write_buffer: Arc<B>,
+    exec: Arc<Executor>,
+    datafusion_config: Arc<HashMap<String, String>>,
+    query_log: Arc<QueryLog>,
+}
+
+impl<B: WriteBuffer> QueryDatabase<B> {
+    pub fn new(
+        db_schema: Arc<DatabaseSchema>,
+        write_buffer: Arc<B>,
+        exec: Arc<Executor>,
+        datafusion_config: Arc<HashMap<String, String>>,
+    ) -> Self {
+        // TODO Fine tune this number
+        const QUERY_LOG_LIMIT: usize = 10;
+
+        let query_log = Arc::new(QueryLog::new(
+            QUERY_LOG_LIMIT,
+            Arc::new(iox_time::SystemProvider::new()),
+        ));
+        Self {
+            db_schema,
+            write_buffer,
+            exec,
+            datafusion_config,
+            query_log,
+        }
+    }
+
+    async fn query_table(&self, table_name: &str) -> Option<Arc<QueryTable<B>>> {
+        self.db_schema.get_table_schema(table_name).map(|schema| {
+            Arc::new(QueryTable {
+                db_schema: Arc::clone(&self.db_schema),
+                name: table_name.into(),
+                schema: schema.clone(),
+                write_buffer: Arc::clone(&self.write_buffer),
+            })
+        })
+    }
+}
+
+#[async_trait]
+impl<B: WriteBuffer> QueryNamespace for QueryDatabase<B> {
+    async fn chunks(
+        &self,
+        table_name: &str,
+        filters: &[Expr],
+        projection: Option<&Vec<usize>>,
+        ctx: IOxSessionContext,
+    ) -> Result<Vec<Arc<dyn QueryChunk>>, DataFusionError> {
+        let _span_recorder = SpanRecorder::new(ctx.child_span("QueryDatabase::chunks"));
+        debug!(%table_name, ?filters, "Finding chunks for table");
+
+        let Some(table) = self.query_table(table_name).await else {
+            trace!(%table_name, "No entry for table");
+            return Ok(vec![]);
+        };
+
+        table.chunks(&ctx.inner().state(), projection, filters, None)
+    }
+
+    fn retention_time_ns(&self) -> Option<i64> {
+        None
+    }
+
+    fn record_query(
+        &self,
+        span_ctx: Option<&SpanContext>,
+        query_type: &'static str,
+        query_text: QueryText,
+        query_params: StatementParams,
+    ) -> QueryCompletedToken<StateReceived> {
+        let trace_id = span_ctx.map(|ctx| ctx.trace_id);
+        let namespace_name: Arc<str> = Arc::from("influxdb3 edge");
+        self.query_log.push(
+            NamespaceId::new(0),
+            namespace_name,
+            query_type,
+            query_text,
+            query_params,
+            trace_id,
+        )
+    }
+
+    fn new_query_context(
+        &self,
+        span_ctx: Option<SpanContext>,
+        _config: Option<&QueryConfig>,
+    ) -> IOxSessionContext {
+        let qdb = Self::new(
+            Arc::clone(&self.db_schema),
+            Arc::clone(&self.write_buffer),
+            Arc::clone(&self.exec),
+            Arc::clone(&self.datafusion_config),
+        );
+
+        let mut cfg = self
+            .exec
+            .new_execution_config()
+            .with_default_catalog(Arc::new(qdb))
+            .with_span_context(span_ctx);
+
+        for (k, v) in self.datafusion_config.as_ref() {
+            cfg = cfg.with_config_option(k, v);
+        }
+
+        cfg.build()
+    }
+}
+
+impl<B: WriteBuffer> CatalogProvider for QueryDatabase<B> {
+    fn as_any(&self) -> &dyn Any {
+        self as &dyn Any
+    }
+
+    fn schema_names(&self) -> Vec<String> {
+        info!("CatalogProvider schema_names");
+        vec![DEFAULT_SCHEMA.to_string()]
+    }
+
+    fn schema(&self, name: &str) -> Option<Arc<dyn SchemaProvider>> {
+        info!("CatalogProvider schema {}", name);
+        let qdb = Self::new(
+            Arc::clone(&self.db_schema),
+            Arc::clone(&self.write_buffer),
+            Arc::clone(&self.exec),
+            Arc::clone(&self.datafusion_config),
+        );
+
+        match name {
+            DEFAULT_SCHEMA => Some(Arc::new(qdb)),
+            _ => None,
+        }
+    }
+}
+
+#[async_trait]
+impl<B: WriteBuffer> SchemaProvider for QueryDatabase<B> {
+    fn as_any(&self) -> &dyn Any {
+        self as &dyn Any
+    }
+
+    fn table_names(&self) -> Vec<String> {
+        self.db_schema.table_names()
+    }
+
+    async fn table(&self, name: &str) -> Result<Option<Arc<dyn TableProvider>>, DataFusionError> {
+        Ok(self.query_table(name).await.map(|qt| qt as _))
+    }
+
+    fn table_exist(&self, name: &str) -> bool {
+        self.db_schema.table_exists(name)
+    }
+}
+
+#[derive(Debug)]
+pub struct QueryTable<B> {
+    db_schema: Arc<DatabaseSchema>,
+    name: Arc<str>,
+    schema: Schema,
+    write_buffer: Arc<B>,
+}
+
+impl<B: WriteBuffer> QueryTable<B> {
+    fn chunks(
+        &self,
+        ctx: &SessionState,
+        projection: Option<&Vec<usize>>,
+        filters: &[Expr],
+        _limit: Option<usize>,
+    ) -> Result<Vec<Arc<dyn QueryChunk>>, DataFusionError> {
+        // TODO - this is only pulling from write buffer, and not parquet?
+        self.write_buffer.get_table_chunks(
+            &self.db_schema.name,
+            self.name.as_ref(),
+            filters,
+            projection,
+            ctx,
+        )
+    }
+}
+
+#[async_trait]
+impl<B: WriteBuffer> TableProvider for QueryTable<B> {
+    fn as_any(&self) -> &dyn Any {
+        self as &dyn Any
+    }
+
+    fn schema(&self) -> SchemaRef {
+        self.schema.as_arrow()
+    }
+
+    fn table_type(&self) -> TableType {
+        TableType::Base
+    }
+
+    async fn scan(
+        &self,
+        ctx: &SessionState,
+        projection: Option<&Vec<usize>>,
+        filters: &[Expr],
+        limit: Option<usize>,
+    ) -> datafusion::common::Result<Arc<dyn ExecutionPlan>> {
+        let filters = filters.to_vec();
+        info!(
+            "TableProvider scan {:?} {:?} {:?}",
+            projection, filters, limit
+        );
+        let mut builder = ProviderBuilder::new(Arc::clone(&self.name), self.schema.clone());
+
+        let chunks = self.chunks(ctx, projection, &filters, limit)?;
+        for chunk in chunks {
+            builder = builder.add_chunk(chunk);
+        }
+
+        let provider = match builder.build() {
+            Ok(provider) => provider,
+            Err(e) => panic!("unexpected error: {e:?}"),
+        };
+
+        provider.scan(ctx, projection, &filters, limit).await
+    }
+}
diff --git a/influxdb3_server/src/service.rs b/influxdb3_server/src/service.rs
new file mode 100644
index 00000000000..74d11522bdc
--- /dev/null
+++ b/influxdb3_server/src/service.rs
@@ -0,0 +1,245 @@
+//! Code for generating a hybrid REST/gRPC service
+//!
+//! This module houses the [`HybridService`] which is used to serve HTTP
+//! traffic, for both a REST API and a gRPC API on the same port.
+//!
+//! This is accomplished via the [`hybrid`] method, which accepts a REST
+//! service in the form of `hyper`'s [`MakeServiceFn`][make-svc-fn], as well
+//! as a gRPC service from `tonic`, and produces a [`HybridMakeService`] that
+//! can be served with `hyper`'s [`Server`][hyper-server].
+//!
+//! Recommended reading: [Combining Axum, Hyper, Tonic, and Tower for hybrid web/gRPC apps][article]
+//!
+//! [make-svc-fn]: https://docs.rs/hyper/0.14.28/src/hyper/service/make.rs.html#149-151
+//! [hyper-server]: https://docs.rs/hyper/0.14.28/hyper/server/struct.Server.html
+//! [article]: https://www.fpcomplete.com/blog/axum-hyper-tonic-tower-part1/
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use futures::Future;
+use hyper::HeaderMap;
+use hyper::{body::HttpBody, Body, Request, Response};
+use pin_project_lite::pin_project;
+use tower::Service;
+
+type BoxError = Box<dyn std::error::Error + Send + Sync + 'static>;
+
+/// Generate a [`HybridMakeService`]
+pub(crate) fn hybrid<MakeRest, Grpc>(
+    make_rest: MakeRest,
+    grpc: Grpc,
+) -> HybridMakeService<MakeRest, Grpc> {
+    HybridMakeService { make_rest, grpc }
+}
+
+/// A hybrid of a "make service", i.e., a service that accepts connection info and returns
+/// a service that will serve a request over that connection as its output, and a gRPC service
+///
+/// Can be used with `hyper`'s [`Server`][hyper-server] to serve both kinds of requests
+/// on a single port.
+///
+/// [hyper-server]: https://docs.rs/hyper/0.14.28/hyper/server/struct.Server.html
+pub struct HybridMakeService<MakeRest, Grpc> {
+    make_rest: MakeRest,
+    grpc: Grpc,
+}
+
+impl<ConnInfo, MakeRest, Grpc> Service<ConnInfo> for HybridMakeService<MakeRest, Grpc>
+where
+    MakeRest: Service<ConnInfo>,
+    Grpc: Clone,
+{
+    type Response = HybridService<MakeRest::Response, Grpc>;
+    type Error = MakeRest::Error;
+    type Future = HybridMakeServiceFuture<MakeRest::Future, Grpc>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.make_rest.poll_ready(cx)
+    }
+
+    fn call(&mut self, conn_info: ConnInfo) -> Self::Future {
+        HybridMakeServiceFuture {
+            rest_future: self.make_rest.call(conn_info),
+            grpc: Some(self.grpc.clone()),
+        }
+    }
+}
+
+pin_project! {
+    /// A future that builds a new `Service` for serving REST requests or gRPC requests
+    pub struct HybridMakeServiceFuture<RestFuture, Grpc> {
+        #[pin]
+        rest_future: RestFuture,
+        grpc: Option<Grpc>,
+    }
+}
+
+impl<RestFuture, Rest, RestError, Grpc> Future for HybridMakeServiceFuture<RestFuture, Grpc>
+where
+    RestFuture: Future<Output = Result<Rest, RestError>>,
+{
+    type Output = Result<HybridService<Rest, Grpc>, RestError>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+        match this.rest_future.poll(cx) {
+            Poll::Ready(Ok(rest)) => Poll::Ready(Ok(HybridService {
+                rest,
+                grpc: this.grpc.take().expect("future polled after execution"),
+            })),
+            Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
+            Poll::Pending => Poll::Pending,
+        }
+    }
+}
+
+/// The service that can serve both gRPC and REST HTTP Requests
+pub struct HybridService<Rest, Grpc> {
+    rest: Rest,
+    grpc: Grpc,
+}
+
+impl<Rest, Grpc, RestBody, GrpcBody> Service<Request<Body>> for HybridService<Rest, Grpc>
+where
+    Rest: Service<Request<Body>, Response = Response<RestBody>>,
+    Grpc: Service<Request<Body>, Response = Response<GrpcBody>>,
+    Rest::Error: Into<BoxError>,
+    Grpc::Error: Into<BoxError>,
+{
+    type Response = Response<HybridBody<RestBody, GrpcBody>>;
+    type Error = BoxError;
+    type Future = HybridFuture<Rest::Future, Grpc::Future>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        match self.rest.poll_ready(cx) {
+            Poll::Ready(Ok(())) => match self.grpc.poll_ready(cx) {
+                Poll::Ready(Ok(())) => Poll::Ready(Ok(())),
+                Poll::Ready(Err(e)) => Poll::Ready(Err(e.into())),
+                Poll::Pending => Poll::Pending,
+            },
+            Poll::Ready(Err(e)) => Poll::Ready(Err(e.into())),
+            Poll::Pending => Poll::Pending,
+        }
+    }
+
+    /// When calling the service, gRPC is served if the HTTP request version is HTTP/2
+    /// and if the Content-Type is "application/grpc"; otherwise, the request is served
+    /// as a REST request
+    fn call(&mut self, req: Request<Body>) -> Self::Future {
+        match (
+            req.version(),
+            req.headers().get(hyper::header::CONTENT_TYPE),
+        ) {
+            (hyper::Version::HTTP_2, Some(hv))
+                if hv.as_bytes().starts_with(b"application/grpc") =>
+            {
+                HybridFuture::Grpc {
+                    grpc_future: self.grpc.call(req),
+                }
+            }
+            _ => HybridFuture::Rest {
+                rest_future: self.rest.call(req),
+            },
+        }
+    }
+}
+
+pin_project! {
+    /// A hybrid HTTP body that will be used in the response type for the
+    /// [`HybridFuture`], i.e., the output of the [`HybridService`]
+    #[project = HybridBodyProj]
+    pub enum HybridBody<RestBody, GrpcBody> {
+        Rest {
+            #[pin]
+            rest_body: RestBody
+        },
+        Grpc {
+            #[pin]
+            grpc_body: GrpcBody
+        },
+    }
+}
+
+impl<RestBody, GrpcBody> HttpBody for HybridBody<RestBody, GrpcBody>
+where
+    RestBody: HttpBody + Send + Unpin,
+    GrpcBody: HttpBody<Data = RestBody::Data> + Send + Unpin,
+    RestBody::Error: Into<BoxError>,
+    GrpcBody::Error: Into<BoxError>,
+{
+    type Data = RestBody::Data;
+    type Error = BoxError;
+
+    fn is_end_stream(&self) -> bool {
+        match self {
+            Self::Rest { rest_body } => rest_body.is_end_stream(),
+            Self::Grpc { grpc_body } => grpc_body.is_end_stream(),
+        }
+    }
+
+    fn poll_data(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Self::Data, Self::Error>>> {
+        match self.project() {
+            HybridBodyProj::Rest { rest_body } => rest_body.poll_data(cx).map_err(Into::into),
+            HybridBodyProj::Grpc { grpc_body } => grpc_body.poll_data(cx).map_err(Into::into),
+        }
+    }
+
+    fn poll_trailers(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<Option<HeaderMap>, Self::Error>> {
+        match self.project() {
+            HybridBodyProj::Rest { rest_body } => rest_body.poll_trailers(cx).map_err(Into::into),
+            HybridBodyProj::Grpc { grpc_body } => grpc_body.poll_trailers(cx).map_err(Into::into),
+        }
+    }
+}
+
+pin_project! {
+    /// A future that accepts an HTTP request as input and returns an HTTP
+    /// response as output for the [`HybridService`]
+    #[project = HybridFutureProj]
+    pub enum HybridFuture<RestFuture, GrpcFuture> {
+        Rest {
+            #[pin]
+            rest_future: RestFuture,
+        },
+        Grpc {
+            #[pin]
+            grpc_future: GrpcFuture,
+        }
+    }
+}
+
+impl<RestFuture, GrpcFuture, RestBody, GrpcBody, RestError, GrpcError> Future
+    for HybridFuture<RestFuture, GrpcFuture>
+where
+    RestFuture: Future<Output = Result<Response<RestBody>, RestError>>,
+    GrpcFuture: Future<Output = Result<Response<GrpcBody>, GrpcError>>,
+    RestError: Into<BoxError>,
+    GrpcError: Into<BoxError>,
+{
+    type Output = Result<Response<HybridBody<RestBody, GrpcBody>>, BoxError>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        match self.project() {
+            HybridFutureProj::Rest { rest_future } => match rest_future.poll(cx) {
+                Poll::Ready(Ok(res)) => {
+                    Poll::Ready(Ok(res.map(|rest_body| HybridBody::Rest { rest_body })))
+                }
+                Poll::Ready(Err(err)) => Poll::Ready(Err(err.into())),
+                Poll::Pending => Poll::Pending,
+            },
+            HybridFutureProj::Grpc { grpc_future } => match grpc_future.poll(cx) {
+                Poll::Ready(Ok(res)) => {
+                    Poll::Ready(Ok(res.map(|grpc_body| HybridBody::Grpc { grpc_body })))
+                }
+                Poll::Ready(Err(err)) => Poll::Ready(Err(err.into())),
+                Poll::Pending => Poll::Pending,
+            },
+        }
+    }
+}
diff --git a/influxdb3_write/Cargo.toml b/influxdb3_write/Cargo.toml
new file mode 100644
index 00000000000..fe54ede39bd
--- /dev/null
+++ b/influxdb3_write/Cargo.toml
@@ -0,0 +1,49 @@
+[package]
+name = "influxdb3_write"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+# Core Crates
+data_types.workspace = true
+datafusion_util.workspace = true
+influxdb-line-protocol.workspace = true
+iox_catalog.workspace = true
+iox_http.workspace = true
+iox_query.workspace = true
+iox_time.workspace = true
+parquet_file.workspace = true
+observability_deps.workspace = true
+schema.workspace = true
+
+# crates.io dependencies
+arrow.workspace = true
+async-trait.workspace = true
+byteorder.workspace  = true
+bytes.workspace = true
+chrono.workspace  = true
+crc32fast.workspace  = true
+crossbeam-channel.workspace  = true
+datafusion.workspace = true
+futures-util.workspace = true
+hex.workspace = true
+object_store.workspace = true
+parking_lot.workspace = true
+parquet.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+sha2.workspace = true
+snap.workspace = true
+thiserror.workspace = true
+tokio.workspace = true
+url.workspace = true
+uuid.workspace = true
+
+[dev-dependencies]
+# Core Crates
+arrow_util.workspace = true
+metric.workspace = true
+pretty_assertions.workspace = true
+test_helpers.workspace = true
diff --git a/influxdb3_write/src/cache.rs b/influxdb3_write/src/cache.rs
new file mode 100644
index 00000000000..3202b9d1636
--- /dev/null
+++ b/influxdb3_write/src/cache.rs
@@ -0,0 +1,419 @@
+use crate::persister::serialize_to_parquet;
+use crate::persister::Error;
+use crate::ParquetFile;
+use bytes::Bytes;
+use datafusion::execution::memory_pool::MemoryPool;
+use datafusion::physical_plan::SendableRecordBatchStream;
+use object_store::memory::InMemory;
+use object_store::path::Path as ObjPath;
+use object_store::ObjectStore;
+use parking_lot::RwLock;
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::runtime::Handle;
+use tokio::task;
+
+type MetaData = RwLock<HashMap<String, HashMap<String, HashMap<String, ParquetFile>>>>;
+
+#[derive(Debug)]
+pub struct ParquetCache {
+    object_store: Arc<dyn ObjectStore>,
+    meta_data: MetaData,
+    mem_pool: Arc<dyn MemoryPool>,
+}
+
+impl ParquetCache {
+    /// Create a new `ParquetCache`
+    pub fn new(mem_pool: &Arc<dyn MemoryPool>) -> Self {
+        Self {
+            object_store: Arc::new(InMemory::new()),
+            meta_data: RwLock::new(HashMap::new()),
+            mem_pool: Arc::clone(mem_pool),
+        }
+    }
+
+    /// Get the parquet file metadata for a given database and table
+    pub fn get_parquet_files(&self, database_name: &str, table_name: &str) -> Vec<ParquetFile> {
+        self.meta_data
+            .read()
+            .get(database_name)
+            .and_then(|db| db.get(table_name))
+            .cloned()
+            .unwrap_or_default()
+            .into_values()
+            .collect()
+    }
+
+    /// Persist a new parquet file to the cache or pass an object store path to update a currently
+    /// existing file in the cache
+    // Note we want to hold across await points until everything is cleared
+    // before letting other tasks access the data
+    pub async fn persist_parquet_file(
+        &self,
+        db_name: &str,
+        table_name: &str,
+        min_time: i64,
+        max_time: i64,
+        record_batches: SendableRecordBatchStream,
+        path: Option<ObjPath>,
+    ) -> Result<(), Error> {
+        let parquet = serialize_to_parquet(Arc::clone(&self.mem_pool), record_batches).await?;
+        // Generate a path for this
+        let id = uuid::Uuid::new_v4();
+        let parquet_path =
+            path.unwrap_or_else(|| ObjPath::from(format!("{db_name}-{table_name}-{id}")));
+        let size_bytes = parquet.bytes.len() as u64;
+        let meta_data = parquet.meta_data;
+
+        // Lock the data structure until everything is written into the object
+        // store and metadata. We block on writing to the ObjectStore so that we
+        // don't yield the thread while maintaining the lock
+        let mut meta_data_lock = self.meta_data.write();
+        let path = parquet_path.to_string();
+        task::block_in_place(move || -> Result<_, Error> {
+            Handle::current()
+                .block_on(self.object_store.put(&parquet_path, parquet.bytes))
+                .map_err(Into::into)
+        })?;
+
+        meta_data_lock
+            .entry(db_name.into())
+            .and_modify(|db| {
+                db.entry(table_name.into())
+                    .and_modify(|files| {
+                        files.insert(
+                            path.clone(),
+                            ParquetFile {
+                                path: path.clone(),
+                                size_bytes,
+                                row_count: meta_data.num_rows as u64,
+                                min_time,
+                                max_time,
+                            },
+                        );
+                    })
+                    .or_insert_with(|| {
+                        HashMap::from([(
+                            path.clone(),
+                            ParquetFile {
+                                path: path.clone(),
+                                size_bytes,
+                                row_count: meta_data.num_rows as u64,
+                                min_time,
+                                max_time,
+                            },
+                        )])
+                    });
+            })
+            .or_insert_with(|| {
+                HashMap::from([(
+                    table_name.into(),
+                    HashMap::from([(
+                        path.clone(),
+                        ParquetFile {
+                            path: path.clone(),
+                            size_bytes,
+                            row_count: meta_data.num_rows as u64,
+                            min_time,
+                            max_time,
+                        },
+                    )]),
+                )])
+            });
+
+        Ok(())
+    }
+
+    /// Load the file from the cache
+    pub async fn load_parquet_file(&self, path: ObjPath) -> Result<Bytes, Error> {
+        Ok(self.object_store.get(&path).await?.bytes().await?)
+    }
+
+    /// Remove the file from the cache
+    pub async fn remove_parquet_file(&self, path: ObjPath) -> Result<(), Error> {
+        let closure_path = path.clone();
+        let mut split = path.as_ref().split('-');
+        let db = split
+            .next()
+            .expect("cache keys are in the form db-table-uuid");
+        let table = split
+            .next()
+            .expect("cache keys are in the form db-table-uuid");
+
+        // Lock the cache until this function is completed. We block on the
+        // delete so that we don't hold the lock across await points
+        let mut meta_data_lock = self.meta_data.write();
+        task::block_in_place(move || -> Result<_, Error> {
+            Handle::current()
+                .block_on(self.object_store.delete(&closure_path))
+                .map_err(Into::into)
+        })?;
+        meta_data_lock
+            .get_mut(db)
+            .and_then(|tables| tables.get_mut(table))
+            .expect("the file exists in the meta_data table as well")
+            .remove(path.as_ref());
+
+        Ok(())
+    }
+
+    /// Purge the whole cache
+    pub async fn purge_cache(&self) -> Result<(), Error> {
+        // Lock the metadata table and thus all writing to the cache
+        let mut meta_data_lock = self.meta_data.write();
+        // Remove every object from the object store
+        for db in meta_data_lock.values() {
+            for table in db.values() {
+                for file in table.values() {
+                    // Block on deletes so that we don't hold the lock across
+                    // the await point
+                    task::block_in_place(move || -> Result<_, Error> {
+                        Handle::current()
+                            .block_on(self.object_store.delete(&file.path.as_str().into()))
+                            .map_err(Into::into)
+                    })?;
+                }
+            }
+        }
+
+        // Reset the metadata table back to a new state
+        *meta_data_lock = HashMap::new();
+
+        Ok(())
+    }
+
+    // Get a reference to the ObjectStore backing the cache
+    pub fn object_store(&self) -> Arc<dyn ObjectStore> {
+        Arc::clone(&self.object_store)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Error;
+    use super::ParquetCache;
+    use arrow::array::TimestampNanosecondArray;
+    use arrow::datatypes::DataType;
+    use arrow::datatypes::Field;
+    use arrow::datatypes::Schema;
+    use arrow::datatypes::TimeUnit;
+    use arrow::record_batch::RecordBatch;
+    use datafusion::execution::memory_pool::MemoryPool;
+    use datafusion::physical_plan::stream::RecordBatchReceiverStreamBuilder;
+    use std::sync::Arc;
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+    async fn cache_persist() -> Result<(), Error> {
+        let cache = make_cache();
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "time",
+            DataType::Timestamp(TimeUnit::Nanosecond, None),
+            false,
+        )]));
+        let stream_builder = RecordBatchReceiverStreamBuilder::new(schema.clone(), 5);
+
+        let time_array = TimestampNanosecondArray::from(vec![1, 2, 3, 4, 5]);
+        let batch = RecordBatch::try_new(schema.clone(), vec![Arc::new(time_array)]).unwrap();
+
+        stream_builder.tx().send(Ok(batch)).await.unwrap();
+
+        let stream = stream_builder.build();
+
+        cache
+            .persist_parquet_file("test_db", "test_table", 1, 5, stream, None)
+            .await?;
+
+        let tables = cache.get_parquet_files("test_db", "test_table");
+        assert_eq!(tables.len(), 1);
+
+        let _bytes = cache
+            .load_parquet_file(tables[0].path.as_str().into())
+            .await?;
+
+        Ok(())
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+    async fn cache_update() -> Result<(), Error> {
+        let cache = make_cache();
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "time",
+            DataType::Timestamp(TimeUnit::Nanosecond, None),
+            false,
+        )]));
+        let stream_builder = RecordBatchReceiverStreamBuilder::new(schema.clone(), 5);
+
+        let time_array = TimestampNanosecondArray::from(vec![1, 2, 3, 4, 5]);
+        let batch = RecordBatch::try_new(schema.clone(), vec![Arc::new(time_array)]).unwrap();
+
+        stream_builder.tx().send(Ok(batch)).await.unwrap();
+
+        let stream = stream_builder.build();
+
+        cache
+            .persist_parquet_file("test_db", "test_table", 1, 5, stream, None)
+            .await?;
+
+        let tables = cache.get_parquet_files("test_db", "test_table");
+        assert_eq!(tables.len(), 1);
+
+        let path: object_store::path::Path = tables[0].path.as_str().into();
+        let orig_bytes = cache.load_parquet_file(path.clone()).await?;
+
+        let stream_builder = RecordBatchReceiverStreamBuilder::new(schema.clone(), 5);
+
+        let time_array = TimestampNanosecondArray::from(vec![6, 7, 8, 9, 10]);
+        let batch = RecordBatch::try_new(schema.clone(), vec![Arc::new(time_array)]).unwrap();
+
+        stream_builder.tx().send(Ok(batch)).await.unwrap();
+
+        let stream = stream_builder.build();
+
+        cache
+            .persist_parquet_file("test_db", "test_table", 6, 10, stream, Some(path.clone()))
+            .await?;
+
+        let new_bytes = cache.load_parquet_file(path).await?;
+
+        assert_ne!(orig_bytes, new_bytes);
+
+        Ok(())
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+    async fn multiple_parquet() -> Result<(), Error> {
+        let cache = make_cache();
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "time",
+            DataType::Timestamp(TimeUnit::Nanosecond, None),
+            false,
+        )]));
+        let stream_builder = RecordBatchReceiverStreamBuilder::new(schema.clone(), 5);
+
+        let time_array = TimestampNanosecondArray::from(vec![1, 2, 3, 4, 5]);
+        let batch = RecordBatch::try_new(schema.clone(), vec![Arc::new(time_array)]).unwrap();
+
+        stream_builder.tx().send(Ok(batch)).await.unwrap();
+
+        let stream = stream_builder.build();
+
+        cache
+            .persist_parquet_file("test_db", "test_table", 1, 5, stream, None)
+            .await?;
+
+        let tables = cache.get_parquet_files("test_db", "test_table");
+        assert_eq!(tables.len(), 1);
+
+        let path: object_store::path::Path = tables[0].path.as_str().into();
+        let _ = cache.load_parquet_file(path.clone()).await?;
+
+        let stream_builder = RecordBatchReceiverStreamBuilder::new(schema.clone(), 5);
+
+        let time_array = TimestampNanosecondArray::from(vec![6, 7, 8, 9, 10]);
+        let batch = RecordBatch::try_new(schema.clone(), vec![Arc::new(time_array)]).unwrap();
+
+        stream_builder.tx().send(Ok(batch)).await.unwrap();
+
+        let stream = stream_builder.build();
+
+        cache
+            .persist_parquet_file("test_db", "test_table", 6, 10, stream, None)
+            .await?;
+
+        let tables = cache.get_parquet_files("test_db", "test_table");
+        assert_eq!(tables.len(), 2);
+
+        Ok(())
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+    async fn purge_cache() -> Result<(), Error> {
+        let cache = make_cache();
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "time",
+            DataType::Timestamp(TimeUnit::Nanosecond, None),
+            false,
+        )]));
+
+        let time_array = TimestampNanosecondArray::from(vec![1, 2, 3, 4, 5]);
+        let batch = RecordBatch::try_new(schema.clone(), vec![Arc::new(time_array)]).unwrap();
+
+        let stream_builder = RecordBatchReceiverStreamBuilder::new(schema.clone(), 5);
+        stream_builder.tx().send(Ok(batch.clone())).await.unwrap();
+        let stream = stream_builder.build();
+        cache
+            .persist_parquet_file("test_db", "test_table", 1, 5, stream, None)
+            .await?;
+        let tables = cache.get_parquet_files("test_db", "test_table");
+        assert_eq!(tables.len(), 1);
+
+        let stream_builder = RecordBatchReceiverStreamBuilder::new(schema.clone(), 5);
+        stream_builder.tx().send(Ok(batch.clone())).await.unwrap();
+        let stream = stream_builder.build();
+        cache
+            .persist_parquet_file("test_db_2", "test_table", 1, 5, stream, None)
+            .await?;
+        let tables = cache.get_parquet_files("test_db_2", "test_table");
+        assert_eq!(tables.len(), 1);
+
+        let stream_builder = RecordBatchReceiverStreamBuilder::new(schema.clone(), 5);
+        stream_builder.tx().send(Ok(batch.clone())).await.unwrap();
+        let stream = stream_builder.build();
+        cache
+            .persist_parquet_file("test_db_3", "test_table", 1, 5, stream, None)
+            .await?;
+        let tables = cache.get_parquet_files("test_db_3", "test_table");
+        assert_eq!(tables.len(), 1);
+
+        let size = cache.object_store.list(None).size_hint().0;
+        assert_eq!(size, 3);
+
+        cache.purge_cache().await?;
+        let size = cache.object_store.list(None).size_hint().0;
+        assert_eq!(size, 0);
+        assert_eq!(cache.meta_data.read().len(), 0);
+
+        Ok(())
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+    async fn cache_remove_parquet() -> Result<(), Error> {
+        let cache = make_cache();
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "time",
+            DataType::Timestamp(TimeUnit::Nanosecond, None),
+            false,
+        )]));
+        let stream_builder = RecordBatchReceiverStreamBuilder::new(schema.clone(), 5);
+
+        let time_array = TimestampNanosecondArray::from(vec![1, 2, 3, 4, 5]);
+        let batch = RecordBatch::try_new(schema.clone(), vec![Arc::new(time_array)]).unwrap();
+
+        stream_builder.tx().send(Ok(batch)).await.unwrap();
+
+        let stream = stream_builder.build();
+
+        cache
+            .persist_parquet_file("test_db", "test_table", 1, 5, stream, None)
+            .await?;
+
+        let tables = cache.get_parquet_files("test_db", "test_table");
+        assert_eq!(tables.len(), 1);
+
+        let path = object_store::path::Path::from(tables[0].path.as_str());
+        let _bytes = cache.load_parquet_file(path.clone()).await?;
+
+        cache.remove_parquet_file(path.clone()).await?;
+        let tables = cache.get_parquet_files("test_db", "test_table");
+        assert_eq!(tables.len(), 0);
+        assert!(cache.load_parquet_file(path.clone()).await.is_err());
+
+        Ok(())
+    }
+
+    fn make_cache() -> ParquetCache {
+        let mem_pool: Arc<dyn MemoryPool> =
+            Arc::new(datafusion::execution::memory_pool::UnboundedMemoryPool::default());
+        ParquetCache::new(&mem_pool)
+    }
+}
diff --git a/influxdb3_write/src/catalog.rs b/influxdb3_write/src/catalog.rs
new file mode 100644
index 00000000000..594c7f69be3
--- /dev/null
+++ b/influxdb3_write/src/catalog.rs
@@ -0,0 +1,398 @@
+//! Implementation of the Catalog that sits entirely in memory.
+
+use crate::SequenceNumber;
+use data_types::ColumnType;
+use observability_deps::tracing::info;
+use parking_lot::RwLock;
+use schema::{InfluxColumnType, InfluxFieldType, Schema, SchemaBuilder};
+use serde::de::Visitor;
+use serde::{Deserialize, Deserializer, Serialize};
+use std::collections::{BTreeMap, HashMap};
+use std::fmt;
+use std::sync::Arc;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("catalog updated elsewhere")]
+    CatalogUpdatedElsewhere,
+
+    #[error(
+        "Update to schema would exceed number of columns per table limit of {} columns",
+        Catalog::NUM_COLUMNS_PER_TABLE_LIMIT - 1
+    )]
+    TooManyColumns,
+
+    #[error(
+        "Update to schema would exceed number of tables limit of {} tables",
+        Catalog::NUM_TABLES_LIMIT
+    )]
+    TooManyTables,
+
+    #[error(
+        "Adding a new database would exceed limit of {} databases",
+        Catalog::NUM_DBS_LIMIT
+    )]
+    TooManyDbs,
+}
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+pub const TIME_COLUMN_NAME: &str = "time";
+pub const SERIES_ID_COLUMN_NAME: &str = "_series_id";
+
+#[derive(Debug)]
+pub struct Catalog {
+    inner: RwLock<InnerCatalog>,
+}
+
+impl Default for Catalog {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Catalog {
+    /// Limit for the number of Databases that InfluxDB Edge can have
+    pub(crate) const NUM_DBS_LIMIT: usize = 5;
+    /// Limit for the number of columns per table that InfluxDB Edge can have
+    ///
+    /// The user-facing limit is 500, but we have it as 501 to account for the
+    /// generated _series_id column
+    pub(crate) const NUM_COLUMNS_PER_TABLE_LIMIT: usize = 501;
+    // Limit for the number of tables across all DBs that InfluxDB Edge can have
+    pub(crate) const NUM_TABLES_LIMIT: usize = 2000;
+
+    pub fn new() -> Self {
+        Self {
+            inner: RwLock::new(InnerCatalog::new()),
+        }
+    }
+
+    pub fn from_inner(inner: InnerCatalog) -> Self {
+        Self {
+            inner: RwLock::new(inner),
+        }
+    }
+
+    pub(crate) fn replace_database(
+        &self,
+        sequence: SequenceNumber,
+        db: Arc<DatabaseSchema>,
+    ) -> Result<()> {
+        let mut inner = self.inner.write();
+        if inner.sequence != sequence {
+            info!("catalog updated elsewhere");
+            return Err(Error::CatalogUpdatedElsewhere);
+        }
+
+        // Check we have not gone over the table limit with this updated DB
+        let mut num_tables = inner
+            .databases
+            .iter()
+            .filter(|(k, _)| *k != &db.name)
+            .map(|(_, v)| v)
+            .fold(0, |acc, db| acc + db.tables.len());
+
+        num_tables += db.tables.len();
+
+        if num_tables > Self::NUM_TABLES_LIMIT {
+            return Err(Error::TooManyTables);
+        }
+
+        for table in db.tables.values() {
+            if table.columns.len() > Self::NUM_COLUMNS_PER_TABLE_LIMIT {
+                return Err(Error::TooManyColumns);
+            }
+        }
+
+        info!("inserted/updated database in catalog: {}", db.name);
+        inner.sequence = inner.sequence.next();
+        inner.databases.insert(db.name.clone(), db);
+        Ok(())
+    }
+
+    pub(crate) fn db_or_create(
+        &self,
+        db_name: &str,
+    ) -> Result<(SequenceNumber, Arc<DatabaseSchema>)> {
+        let (sequence, db) = {
+            let inner = self.inner.read();
+            (inner.sequence, inner.databases.get(db_name).cloned())
+        };
+
+        let db = match db {
+            Some(db) => {
+                info!("return existing db {}", db_name);
+                db
+            }
+            None => {
+                info!("return new db {}", db_name);
+                let mut inner = self.inner.write();
+
+                if inner.databases.len() >= Self::NUM_DBS_LIMIT {
+                    return Err(Error::TooManyDbs);
+                }
+
+                let db = Arc::new(DatabaseSchema::new(db_name));
+                inner.databases.insert(db.name.clone(), Arc::clone(&db));
+                db
+            }
+        };
+
+        Ok((sequence, db))
+    }
+
+    pub fn db_schema(&self, name: &str) -> Option<Arc<DatabaseSchema>> {
+        info!("db_schema {}", name);
+        self.inner.read().databases.get(name).cloned()
+    }
+
+    pub fn into_inner(self) -> InnerCatalog {
+        self.inner.into_inner()
+    }
+
+    pub fn sequence_number(&self) -> SequenceNumber {
+        self.inner.read().sequence
+    }
+
+    pub fn clone_inner(&self) -> InnerCatalog {
+        self.inner.read().clone()
+    }
+
+    pub fn list_databases(&self) -> Vec<String> {
+        self.inner.read().databases.keys().cloned().collect()
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Clone, Default)]
+pub struct InnerCatalog {
+    /// The catalog is a map of databases with their table schemas
+    databases: HashMap<String, Arc<DatabaseSchema>>,
+    sequence: SequenceNumber,
+}
+
+impl InnerCatalog {
+    pub(crate) fn new() -> Self {
+        Self {
+            databases: HashMap::new(),
+            sequence: SequenceNumber::new(0),
+        }
+    }
+
+    pub fn sequence_number(&self) -> SequenceNumber {
+        self.sequence
+    }
+
+    #[cfg(test)]
+    pub fn db_exists(&self, db_name: &str) -> bool {
+        self.databases.get(db_name).is_some()
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Clone)]
+pub struct DatabaseSchema {
+    pub name: String,
+    /// The database is a map of tables
+    pub(crate) tables: BTreeMap<String, TableDefinition>,
+}
+
+impl DatabaseSchema {
+    pub fn new(name: impl Into<String>) -> Self {
+        Self {
+            name: name.into(),
+            tables: BTreeMap::new(),
+        }
+    }
+
+    pub fn get_table_schema(&self, table_name: &str) -> Option<&Schema> {
+        self.tables.get(table_name).map(|table| &table.schema)
+    }
+
+    pub fn get_table(&self, table_name: &str) -> Option<&TableDefinition> {
+        self.tables.get(table_name)
+    }
+
+    pub fn table_names(&self) -> Vec<String> {
+        self.tables.keys().cloned().collect()
+    }
+
+    pub fn table_exists(&self, table_name: &str) -> bool {
+        self.tables.contains_key(table_name)
+    }
+}
+
+#[derive(Debug, Serialize, Eq, PartialEq, Clone)]
+pub struct TableDefinition {
+    pub name: String,
+    #[serde(skip_serializing, skip_deserializing)]
+    pub schema: Schema,
+    columns: BTreeMap<String, i16>,
+}
+
+struct TableDefinitionVisitor;
+
+impl<'de> Visitor<'de> for TableDefinitionVisitor {
+    type Value = TableDefinition;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("struct TableDefinition")
+    }
+
+    fn visit_map<V>(self, mut map: V) -> Result<TableDefinition, V::Error>
+    where
+        V: serde::de::MapAccess<'de>,
+    {
+        let mut name = None;
+        let mut columns = None;
+        while let Some(key) = map.next_key::<String>()? {
+            match key.as_str() {
+                "name" => {
+                    if name.is_some() {
+                        return Err(serde::de::Error::duplicate_field("name"));
+                    }
+                    name = Some(map.next_value::<String>()?);
+                }
+                "columns" => {
+                    if columns.is_some() {
+                        return Err(serde::de::Error::duplicate_field("columns"));
+                    }
+                    columns = Some(map.next_value::<BTreeMap<String, i16>>()?);
+                }
+                _ => {
+                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                }
+            }
+        }
+        let name = name.ok_or_else(|| serde::de::Error::missing_field("name"))?;
+        let columns = columns.ok_or_else(|| serde::de::Error::missing_field("columns"))?;
+
+        Ok(TableDefinition::new(name, columns))
+    }
+}
+
+impl<'de> Deserialize<'de> for TableDefinition {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_map(TableDefinitionVisitor)
+    }
+}
+
+impl TableDefinition {
+    pub(crate) fn new(name: impl Into<String>, columns: BTreeMap<String, i16>) -> Self {
+        let mut schema_builder = SchemaBuilder::with_capacity(columns.len());
+        for (name, column_type) in &columns {
+            schema_builder.influx_column(
+                name,
+                column_type_to_influx_column_type(&ColumnType::try_from(*column_type).unwrap()),
+            );
+        }
+        let schema = schema_builder.build().unwrap();
+
+        Self {
+            name: name.into(),
+            schema,
+            columns,
+        }
+    }
+
+    pub(crate) fn column_exists(&self, column: &str) -> bool {
+        self.columns.contains_key(column)
+    }
+
+    pub(crate) fn add_columns(&mut self, columns: Vec<(String, i16)>) {
+        for (name, column_type) in columns.into_iter() {
+            self.columns.insert(name, column_type);
+        }
+
+        let mut schema_builder = SchemaBuilder::with_capacity(self.columns.len());
+        for (name, column_type) in &self.columns {
+            schema_builder.influx_column(
+                name,
+                column_type_to_influx_column_type(&ColumnType::try_from(*column_type).unwrap()),
+            );
+        }
+        let schema = schema_builder.build().unwrap();
+
+        self.schema = schema;
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn schema(&self) -> &Schema {
+        &self.schema
+    }
+
+    #[cfg(test)]
+    pub(crate) fn columns(&self) -> &BTreeMap<String, i16> {
+        &self.columns
+    }
+}
+
+fn column_type_to_influx_column_type(column_type: &ColumnType) -> InfluxColumnType {
+    match column_type {
+        ColumnType::I64 => InfluxColumnType::Field(InfluxFieldType::Integer),
+        ColumnType::U64 => InfluxColumnType::Field(InfluxFieldType::UInteger),
+        ColumnType::F64 => InfluxColumnType::Field(InfluxFieldType::Float),
+        ColumnType::Bool => InfluxColumnType::Field(InfluxFieldType::Boolean),
+        ColumnType::String => InfluxColumnType::Field(InfluxFieldType::String),
+        ColumnType::Time => InfluxColumnType::Timestamp,
+        ColumnType::Tag => InfluxColumnType::Tag,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn catalog_serialization() {
+        let catalog = Catalog::new();
+        let mut database = DatabaseSchema {
+            name: "test".to_string(),
+            tables: BTreeMap::new(),
+        };
+        database.tables.insert(
+            "test".into(),
+            TableDefinition::new(
+                "test",
+                BTreeMap::from([("test".to_string(), ColumnType::String as i16)]),
+            ),
+        );
+        let database = Arc::new(database);
+        catalog
+            .replace_database(SequenceNumber::new(0), database)
+            .unwrap();
+        let inner = catalog.inner.read();
+
+        let serialized = serde_json::to_string(&*inner).unwrap();
+        let deserialized: InnerCatalog = serde_json::from_str(&serialized).unwrap();
+
+        assert_eq!(*inner, deserialized);
+    }
+
+    #[test]
+    fn add_columns_updates_schema() {
+        let mut database = DatabaseSchema {
+            name: "test".to_string(),
+            tables: BTreeMap::new(),
+        };
+        database.tables.insert(
+            "test".into(),
+            TableDefinition::new(
+                "test",
+                BTreeMap::from([("test".to_string(), ColumnType::String as i16)]),
+            ),
+        );
+
+        let table = database.tables.get_mut("test").unwrap();
+        table.add_columns(vec![("test2".to_string(), ColumnType::Tag as i16)]);
+        let schema = table.schema();
+        assert_eq!(
+            schema.field(0).0,
+            InfluxColumnType::Field(InfluxFieldType::String)
+        );
+        assert_eq!(schema.field(1).0, InfluxColumnType::Tag);
+    }
+}
diff --git a/influxdb3_write/src/chunk.rs b/influxdb3_write/src/chunk.rs
new file mode 100644
index 00000000000..81696989ba3
--- /dev/null
+++ b/influxdb3_write/src/chunk.rs
@@ -0,0 +1,116 @@
+use arrow::array::RecordBatch;
+use data_types::{ChunkId, ChunkOrder, TransitionPartitionId};
+use datafusion::common::Statistics;
+use iox_query::chunk_statistics::ChunkStatistics;
+use iox_query::{QueryChunk, QueryChunkData};
+use parquet_file::storage::ParquetExecInput;
+use schema::sort::SortKey;
+use schema::Schema;
+use std::any::Any;
+use std::sync::Arc;
+
+#[derive(Debug)]
+pub struct BufferChunk {
+    pub(crate) batches: Vec<RecordBatch>,
+    pub(crate) schema: Schema,
+    pub(crate) stats: Arc<ChunkStatistics>,
+    pub(crate) partition_id: data_types::partition::TransitionPartitionId,
+    pub(crate) sort_key: Option<SortKey>,
+    pub(crate) id: data_types::ChunkId,
+    pub(crate) chunk_order: data_types::ChunkOrder,
+}
+
+impl QueryChunk for BufferChunk {
+    fn stats(&self) -> Arc<Statistics> {
+        Arc::clone(&self.stats.statistics())
+    }
+
+    fn schema(&self) -> &Schema {
+        &self.schema
+    }
+
+    fn partition_id(&self) -> &data_types::partition::TransitionPartitionId {
+        &self.partition_id
+    }
+
+    fn sort_key(&self) -> Option<&SortKey> {
+        self.sort_key.as_ref()
+    }
+
+    fn id(&self) -> data_types::ChunkId {
+        self.id
+    }
+
+    fn may_contain_pk_duplicates(&self) -> bool {
+        true
+    }
+
+    fn data(&self) -> QueryChunkData {
+        QueryChunkData::in_mem(self.batches.clone(), Arc::clone(self.schema.inner()))
+    }
+
+    fn chunk_type(&self) -> &str {
+        "BufferChunk"
+    }
+
+    fn order(&self) -> data_types::ChunkOrder {
+        self.chunk_order
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
+#[derive(Debug)]
+pub struct ParquetChunk {
+    pub(crate) schema: Schema,
+    pub(crate) stats: Arc<ChunkStatistics>,
+    pub(crate) partition_id: TransitionPartitionId,
+    pub(crate) sort_key: Option<SortKey>,
+    pub(crate) id: ChunkId,
+    pub(crate) chunk_order: ChunkOrder,
+    pub(crate) parquet_exec: ParquetExecInput,
+}
+
+impl QueryChunk for ParquetChunk {
+    fn stats(&self) -> Arc<Statistics> {
+        Arc::clone(&self.stats.statistics())
+    }
+
+    fn schema(&self) -> &Schema {
+        &self.schema
+    }
+
+    fn partition_id(&self) -> &TransitionPartitionId {
+        &self.partition_id
+    }
+
+    fn sort_key(&self) -> Option<&SortKey> {
+        self.sort_key.as_ref()
+    }
+
+    fn id(&self) -> ChunkId {
+        self.id
+    }
+
+    fn may_contain_pk_duplicates(&self) -> bool {
+        false
+    }
+
+    fn data(&self) -> QueryChunkData {
+        QueryChunkData::Parquet(self.parquet_exec.clone())
+    }
+
+    fn chunk_type(&self) -> &str {
+        "Parquet"
+    }
+
+    fn order(&self) -> ChunkOrder {
+        self.chunk_order
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
diff --git a/influxdb3_write/src/lib.rs b/influxdb3_write/src/lib.rs
new file mode 100644
index 00000000000..6d8b86d2f89
--- /dev/null
+++ b/influxdb3_write/src/lib.rs
@@ -0,0 +1,769 @@
+//! This package contains definitions for writing data into InfluxDB3. The logical data model is the standard
+//! InfluxDB model of Database > Table > Row. As the data arrives into the server it is written into the open
+//! segment in the buffer. If the buffer has a WAL configured, the data is written into the WAL before being
+//! buffered in memory.
+//!
+//! When the segment reaches a certain size, or a certain amount of time has passed, it will be closed and marked
+//! to be persisted. A new open segment will be created and new writes will be written to that segment.
+
+pub mod cache;
+pub mod catalog;
+mod chunk;
+pub mod paths;
+pub mod persister;
+pub mod wal;
+pub mod write_buffer;
+
+use crate::catalog::Catalog;
+use crate::paths::{ParquetFilePath, SegmentWalFilePath};
+use async_trait::async_trait;
+use bytes::Bytes;
+use data_types::{NamespaceName, TimestampMinMax};
+use datafusion::datasource::object_store::ObjectStoreUrl;
+use datafusion::error::DataFusionError;
+use datafusion::execution::context::SessionState;
+use datafusion::physical_plan::SendableRecordBatchStream;
+use datafusion::prelude::Expr;
+use iox_query::QueryChunk;
+use iox_time::Time;
+use parquet::format::FileMetaData;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::any::Any;
+use std::collections::HashMap;
+use std::fmt::Debug;
+use std::ops::Add;
+use std::path::PathBuf;
+use std::str::FromStr;
+use std::sync::Arc;
+use std::time::Duration;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("database not found {db_name}")]
+    DatabaseNotFound { db_name: String },
+
+    #[error("object store path error: {0}")]
+    ObjStorePath(#[from] object_store::path::Error),
+
+    #[error("write buffer error: {0}")]
+    WriteBuffer(#[from] write_buffer::Error),
+
+    #[error("persister error: {0}")]
+    Persister(#[from] persister::Error),
+
+    #[error("invalid segment duration {0}. Must be one of 1m, 5m, 10m, 15m, 30m, 1h, 2h, 4h")]
+    InvalidSegmentDuration(String),
+
+    #[error("wal error: {0}")]
+    Wal(#[from] wal::Error),
+}
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+pub trait WriteBuffer: Bufferer + ChunkContainer {}
+
+/// The buffer is for buffering data in memory before it is persisted to object storage. The buffer is queryable and
+/// aims to use as little memory as possible, converting data into in-memory Parquet data periodically as it arrives
+/// and is queried out. The buffer is responsible for keeping a consistent view of the catalog and  is also responsible
+/// for writing data into the WAL if it is configured.
+///
+/// Data in the buffer is organized into monotonically increasing segments, each associated with a single WAL file, if
+/// the WAL is configured. As a segment is closed, it is persisted and then freed from memory.
+#[async_trait]
+pub trait Bufferer: Debug + Send + Sync + 'static {
+    /// Validates the line protocol, writes it into the WAL if configured, writes it into the in memory buffer
+    /// and returns the result with any lines that had errors and summary statistics. This writes into the currently
+    /// open segment or it will open one. The open segment id and the memory usage of the currently open segment are
+    /// returned.
+    async fn write_lp(
+        &self,
+        database: NamespaceName<'static>,
+        lp: &str,
+        ingest_time: Time,
+        accept_partial: bool,
+        precision: Precision,
+    ) -> write_buffer::Result<BufferedWriteRequest>;
+
+    /// Closes the open segment and returns it so that it can be persisted or thrown away. A new segment will be opened
+    /// with the catalog rolling over.
+    async fn close_open_segment(&self) -> Result<Arc<dyn BufferSegment>>;
+
+    /// Once a process opens segments with the Persister, they'll know the last segment that was persisted.
+    /// This can be used with a `Bufferer` to pass into this method, which will look for any WAL segments with an
+    /// ID greater than the one passed in.
+    async fn load_segments_after(
+        &self,
+        segment_id: SegmentId,
+        catalog: Catalog,
+    ) -> Result<Vec<Arc<dyn BufferSegment>>>;
+
+    /// Returns the configured WAL, if there is one.
+    fn wal(&self) -> Option<Arc<impl Wal>>;
+
+    /// Returns the catalog
+    fn catalog(&self) -> Arc<catalog::Catalog>;
+}
+
+/// A segment in the buffer that corresponds to a single WAL segment file. It contains a catalog with any updates
+/// that have been made to it since the segment was opened. It can convert all buffered data to parquet data that
+/// can be persisted.
+#[async_trait]
+pub trait BufferSegment: Debug + Send + Sync + 'static {
+    fn id(&self) -> SegmentId;
+
+    fn catalog(&self) -> Arc<catalog::Catalog>;
+
+    /// If the catalog has been updated in this buffer segment, it is written using the passed in persister. Then it
+    /// writes all data in the buffered segment to parquet files using the passed persister. Finally, it writes
+    /// the segment file with all parquet file summaries to object storage using the passed persister.
+    async fn persist(&self, persister: Arc<dyn Persister<Error = persister::Error>>) -> Result<()>;
+}
+
+/// ChunkContainer is used by the query engine to get chunks for a given table. Chunks will generally be in the
+/// `Bufferer` for those in memory from buffered writes or the `Persister` for parquet files that have been persisted
+/// from previously buffered segments.
+pub trait ChunkContainer: Debug + Send + Sync + 'static {
+    fn get_table_chunks(
+        &self,
+        database_name: &str,
+        table_name: &str,
+        filters: &[Expr],
+        projection: Option<&Vec<usize>>,
+        ctx: &SessionState,
+    ) -> Result<Vec<Arc<dyn QueryChunk>>, DataFusionError>;
+}
+
+/// The segment identifier, which will be monotonically increasing.
+#[derive(
+    Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
+)]
+pub struct SegmentId(u32);
+
+const RANGE_KEY_TIME_FORMAT: &str = "%Y-%m-%dT%H-%M";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct SegmentRange {
+    /// inclusive of this start time
+    pub start_time: Time,
+    /// exclusive of this end time
+    pub end_time: Time,
+    /// data in segment is outside this range of time
+    pub contains_data_outside_range: bool,
+}
+
+/// The duration of a segment.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct SegmentDuration(Duration);
+
+impl SegmentDuration {
+    pub fn duration_seconds(&self) -> i64 {
+        self.0.as_secs() as i64
+    }
+
+    /// Given a time, returns the start time of the segment that contains the time.
+    pub fn start_time(&self, timestamp_seconds: i64) -> Time {
+        let duration_seconds = self.duration_seconds();
+        let rounded_seconds = (timestamp_seconds / duration_seconds) * duration_seconds;
+        Time::from_timestamp(rounded_seconds, 0).unwrap()
+    }
+
+    pub fn as_duration(&self) -> Duration {
+        self.0
+    }
+
+    /// Returns the segment duration from a given `SegmentRange`
+    pub fn from_range(segment_range: SegmentRange) -> Self {
+        let duration = segment_range.duration();
+        Self(duration)
+    }
+
+    pub fn new_5m() -> Self {
+        Self(Duration::from_secs(300))
+    }
+}
+
+impl FromStr for SegmentDuration {
+    type Err = Error;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        match s {
+            "1m" => Ok(Self(Duration::from_secs(60))),
+            "5m" => Ok(Self(Duration::from_secs(300))),
+            "10m" => Ok(Self(Duration::from_secs(600))),
+            "15m" => Ok(Self(Duration::from_secs(900))),
+            "30m" => Ok(Self(Duration::from_secs(1800))),
+            "1h" => Ok(Self(Duration::from_secs(3600))),
+            "2h" => Ok(Self(Duration::from_secs(7200))),
+            "4h" => Ok(Self(Duration::from_secs(14400))),
+            _ => Err(Error::InvalidSegmentDuration(s.to_string())),
+        }
+    }
+}
+
+impl SegmentRange {
+    /// Given the time will find the appropriate start and end time for the given duration.
+    pub fn from_time_and_duration(
+        clock_time: Time,
+        segment_duration: SegmentDuration,
+        data_outside: bool,
+    ) -> Self {
+        let start_time = segment_duration.start_time(clock_time.timestamp());
+
+        Self {
+            start_time,
+            end_time: start_time.add(segment_duration.as_duration()),
+            contains_data_outside_range: data_outside,
+        }
+    }
+
+    /// Returns the min/max timestamp of the segment range
+    pub fn timestamp_min_max(&self) -> TimestampMinMax {
+        TimestampMinMax {
+            min: self.start_time.timestamp_nanos(),
+            max: self.end_time.timestamp_nanos() - 1, // end time is exclusive in range, but not MinMax
+        }
+    }
+
+    /// Returns the string key for the segment range
+    pub fn key(&self) -> String {
+        format!(
+            "{}",
+            self.start_time.date_time().format(RANGE_KEY_TIME_FORMAT)
+        )
+    }
+
+    /// Returns a segment range for the next block of time based on the range of this segment.
+    pub fn next(&self) -> Self {
+        Self {
+            start_time: self.end_time,
+            end_time: self.end_time.add(self.duration()),
+            contains_data_outside_range: self.contains_data_outside_range,
+        }
+    }
+
+    pub fn duration(&self) -> Duration {
+        self.end_time
+            .checked_duration_since(self.start_time)
+            .unwrap()
+    }
+
+    #[cfg(test)]
+    pub fn test_range() -> Self {
+        Self {
+            start_time: Time::from_rfc3339("1970-01-01T00:00:00Z").unwrap(),
+            end_time: Time::from_rfc3339("1970-01-01T00:05:00Z").unwrap(),
+            contains_data_outside_range: false,
+        }
+    }
+}
+
+impl Serialize for SegmentRange {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let start_time = self.start_time.timestamp();
+        let end_time = self.end_time.timestamp();
+        let times = (start_time, end_time, self.contains_data_outside_range);
+        times.serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for SegmentRange {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let (start_time, end_time, contains_data_outside_range) =
+            <(i64, i64, bool)>::deserialize(deserializer)?;
+
+        let start_time = Time::from_timestamp(start_time, 0)
+            .ok_or_else(|| serde::de::Error::custom("start_time is not a valid timestamp"))?;
+        let end_time = Time::from_timestamp(end_time, 0)
+            .ok_or_else(|| serde::de::Error::custom("end_time is not a valid timestamp"))?;
+
+        Ok(SegmentRange {
+            start_time,
+            end_time,
+            contains_data_outside_range,
+        })
+    }
+}
+
+impl SegmentId {
+    pub fn new(id: u32) -> Self {
+        Self(id)
+    }
+
+    pub fn next(&self) -> Self {
+        Self(self.0 + 1)
+    }
+}
+
+/// The sequence number of a batch of WAL operations.
+#[derive(
+    Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
+)]
+pub struct SequenceNumber(u32);
+
+impl SequenceNumber {
+    pub fn new(id: u32) -> Self {
+        Self(id)
+    }
+
+    pub fn next(&self) -> Self {
+        Self(self.0 + 1)
+    }
+}
+
+pub const DEFAULT_OBJECT_STORE_URL: &str = "iox://influxdb3/";
+
+#[async_trait]
+pub trait Persister: Debug + Send + Sync + 'static {
+    type Error;
+
+    /// Loads the most recently persisted catalog from object storage.
+    async fn load_catalog(&self) -> Result<Option<PersistedCatalog>, Self::Error>;
+
+    /// Loads the most recently persisted N segment parquet file lists from object storage.
+    async fn load_segments(
+        &self,
+        most_recent_n: usize,
+    ) -> Result<Vec<PersistedSegment>, Self::Error>;
+
+    // Loads a Parquet file from ObjectStore
+    async fn load_parquet_file(&self, path: ParquetFilePath) -> Result<Bytes, Self::Error>;
+
+    /// Persists the catalog with the given segment ID. If this is the highest segment ID, it will
+    /// be the catalog that is returned the next time `load_catalog` is called.
+    async fn persist_catalog(
+        &self,
+        segment_id: SegmentId,
+        catalog: catalog::Catalog,
+    ) -> Result<(), Self::Error>;
+
+    /// Writes a single file to object storage that contains the information for the parquet files persisted
+    /// for this segment.
+    async fn persist_segment(
+        &self,
+        persisted_segment: &PersistedSegment,
+    ) -> Result<(), Self::Error>;
+
+    // Writes a SendableRecorgBatchStream to the Parquet format and persists it
+    // to Object Store at the given path. Returns the number of bytes written and the file metadata.
+    async fn persist_parquet_file(
+        &self,
+        path: ParquetFilePath,
+        record_batch: SendableRecordBatchStream,
+    ) -> Result<(u64, FileMetaData), Self::Error>;
+
+    /// Returns the configured `ObjectStore` that data is loaded from and persisted to.
+    fn object_store(&self) -> Arc<dyn object_store::ObjectStore>;
+
+    // This is used by the query engine to know where to read parquet files from. This assumes
+    // that there is a `ParquetStorage` with an id of `influxdb3` and that this url has been
+    // registered with the query execution context. Kind of ugly here, but not sure where else
+    // to keep this.
+    fn object_store_url(&self) -> ObjectStoreUrl {
+        ObjectStoreUrl::parse(DEFAULT_OBJECT_STORE_URL).unwrap()
+    }
+
+    fn as_any(&self) -> &dyn Any;
+}
+
+pub trait Wal: Debug + Send + Sync + 'static {
+    /// Opens a writer to a new segment with the given id, start time (inclusive), and end_time
+    /// (exclusive). data_outside_range specifies if data in the segment has data that is in the
+    /// provided range or outside it.
+    fn new_segment_writer(
+        &self,
+        segment_id: SegmentId,
+        range: SegmentRange,
+    ) -> wal::Result<Box<dyn WalSegmentWriter>>;
+
+    /// Opens a writer to an existing segment, reading its last sequence number and making it
+    /// ready to append new writes.
+    fn open_segment_writer(&self, segment_id: SegmentId) -> wal::Result<Box<dyn WalSegmentWriter>>;
+
+    /// Opens a reader to a segment file.
+    fn open_segment_reader(&self, segment_id: SegmentId) -> wal::Result<Box<dyn WalSegmentReader>>;
+
+    /// Checks the WAL directory for any segment files and returns them.
+    fn segment_files(&self) -> wal::Result<Vec<SegmentFile>>;
+
+    /// Deletes the WAL segment file from disk.
+    fn delete_wal_segment(&self, segment_id: SegmentId) -> wal::Result<()>;
+
+    fn as_any(&self) -> &dyn Any;
+}
+
+#[derive(Debug)]
+pub struct SegmentFile {
+    /// The path to the segment file
+    pub path: PathBuf,
+    /// The segment id parsed from the file name
+    pub segment_id: SegmentId,
+}
+
+pub trait WalSegmentWriter: Debug + Send + Sync + 'static {
+    fn id(&self) -> SegmentId;
+
+    fn bytes_written(&self) -> u64;
+
+    fn write_batch(&mut self, ops: Vec<WalOp>) -> wal::Result<()>;
+
+    fn last_sequence_number(&self) -> SequenceNumber;
+}
+
+pub trait WalSegmentReader: Debug + Send + Sync + 'static {
+    fn next_batch(&mut self) -> wal::Result<Option<WalOpBatch>>;
+
+    fn header(&self) -> &wal::SegmentHeader;
+
+    fn path(&self) -> &SegmentWalFilePath;
+}
+
+/// Individual WalOps get batched into the WAL asynchronously. The batch is then written to the segment file.
+#[derive(Debug, Serialize, Deserialize, Eq, PartialEq)]
+pub struct WalOpBatch {
+    pub sequence_number: SequenceNumber,
+    pub ops: Vec<WalOp>,
+}
+
+/// A WalOp can be write of line protocol, the creation of a database, or other kinds of state that eventually
+/// lands in object storage. Things in the WAL are buffered until they are persisted to object storage. The write
+/// is called an `LpWrite` because it is a write of line protocol and we intend to have a new write protocol for
+/// 3.0 that supports a different kind of schema.
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
+pub enum WalOp {
+    LpWrite(LpWriteOp),
+}
+
+/// A write of 1 or more lines of line protocol to a single database. The default time is set by the server at the
+/// time the write comes in.
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
+pub struct LpWriteOp {
+    pub db_name: String,
+    pub lp: String,
+    pub default_time: i64,
+}
+
+/// A single write request can have many lines in it. A writer can request to accept all lines that are valid, while
+/// returning an error for any invalid lines. This is the error information for a single invalid line.
+#[derive(Debug, Serialize)]
+pub struct WriteLineError {
+    pub original_line: String,
+    pub line_number: usize,
+    pub error_message: String,
+}
+
+/// A write that has been validated against the catalog schema, written to the WAL (if configured), and buffered in
+/// memory. This is the summary information for the write along with any errors that were encountered.
+#[derive(Debug)]
+pub struct BufferedWriteRequest {
+    pub db_name: NamespaceName<'static>,
+    pub invalid_lines: Vec<WriteLineError>,
+    pub line_count: usize,
+    pub field_count: usize,
+    pub tag_count: usize,
+}
+
+/// A persisted Catalog that contains the database, table, and column schemas.
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct PersistedCatalog {
+    /// The segment_id that this catalog was persisted with.
+    pub segment_id: SegmentId,
+    /// The catalog that was persisted.
+    pub catalog: catalog::InnerCatalog,
+}
+
+/// The collection of Parquet files that were persisted for a segment.
+#[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Clone)]
+pub struct PersistedSegment {
+    /// The segment_id that these parquet files were persisted with.
+    pub segment_id: SegmentId,
+    /// The size of the segment WAL in bytes.
+    pub segment_wal_size_bytes: u64,
+    /// The size of the segment parquet files in bytes.
+    pub segment_parquet_size_bytes: u64,
+    /// The number of rows across all parquet files in the segment.
+    pub segment_row_count: u64,
+    /// The min time from all parquet files in the segment.
+    pub segment_min_time: i64,
+    /// The max time from all parquet files in the segment.
+    pub segment_max_time: i64,
+    /// The collection of databases that had tables persisted in this segment. The tables will then have their
+    /// name and the parquet files.
+    pub databases: HashMap<String, DatabaseTables>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Eq, PartialEq, Clone)]
+pub struct DatabaseTables {
+    pub tables: HashMap<String, TableParquetFiles>,
+}
+
+/// A collection of parquet files persisted in a segment for a specific table.
+#[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Clone)]
+pub struct TableParquetFiles {
+    /// The table name.
+    pub table_name: String,
+    /// The parquet files persisted in this segment for this table.
+    pub parquet_files: Vec<ParquetFile>,
+    /// The sort key used for all parquet files in this segment.
+    pub sort_key: Vec<String>,
+}
+
+/// The summary data for a persisted parquet file in a segment.
+#[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Clone)]
+pub struct ParquetFile {
+    pub path: String,
+    pub size_bytes: u64,
+    pub row_count: u64,
+    pub min_time: i64,
+    pub max_time: i64,
+}
+
+impl ParquetFile {
+    pub fn timestamp_min_max(&self) -> TimestampMinMax {
+        TimestampMinMax {
+            min: self.min_time,
+            max: self.max_time,
+        }
+    }
+}
+
+/// The summary data for a persisted parquet file in a segment.
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Precision {
+    Auto,
+    Second,
+    Millisecond,
+    Microsecond,
+    Nanosecond,
+}
+
+impl Default for Precision {
+    fn default() -> Self {
+        Self::Auto
+    }
+}
+
+impl From<iox_http::write::Precision> for Precision {
+    fn from(legacy: iox_http::write::Precision) -> Self {
+        match legacy {
+            iox_http::write::Precision::Second => Precision::Second,
+            iox_http::write::Precision::Millisecond => Precision::Millisecond,
+            iox_http::write::Precision::Microsecond => Precision::Microsecond,
+            iox_http::write::Precision::Nanosecond => Precision::Nanosecond,
+        }
+    }
+}
+
+/// Guess precision based off of a given timestamp.
+// Note that this will fail in June 2128, but that's not our problem
+pub(crate) fn guess_precision(timestamp: i64) -> Precision {
+    const NANO_SECS_PER_SEC: i64 = 1_000_000_000;
+    // Get the absolute value of the timestamp so we can work with negative
+    // numbers
+    let val = timestamp.abs() / NANO_SECS_PER_SEC;
+
+    if val < 5 {
+        // If the time sent to us is in seconds then this will be a number less than
+        // 5 so for example if the time in seconds is 1_708_976_567 then it will be
+        // 1 (due to integer truncation) and be less than 5
+        Precision::Second
+    } else if val < 5_000 {
+        // If however the value is milliseconds and not seconds than the same number
+        // for time but now in milliseconds 1_708_976_567_000 when divided will now
+        // be 1708 which is bigger than the previous if statement but less than this
+        // one and so we return milliseconds
+        Precision::Millisecond
+    } else if val < 5_000_000 {
+        // If we do the same thing here by going up another order of magnitude then
+        // 1_708_976_567_000_000 when divided will be 1708976 which is large enough
+        // for this if statement
+        Precision::Microsecond
+    } else {
+        // Anything else we can assume is large enough of a number that it must
+        // be nanoseconds
+        Precision::Nanosecond
+    }
+}
+
+#[cfg(test)]
+mod test_helpers {
+    use crate::catalog::Catalog;
+    use crate::write_buffer::buffer_segment::WriteBatch;
+    use crate::write_buffer::{parse_validate_and_update_schema, TableBatch};
+    use crate::{Precision, SegmentDuration, SequenceNumber};
+    use data_types::NamespaceName;
+    use iox_time::Time;
+    use std::collections::HashMap;
+    use std::sync::Arc;
+
+    pub(crate) fn lp_to_write_batch(
+        catalog: &Catalog,
+        db_name: &'static str,
+        lp: &str,
+    ) -> WriteBatch {
+        let db_name = NamespaceName::new(db_name).unwrap();
+        let mut write_batch = WriteBatch::default();
+        let (seq, db) = catalog.db_or_create(db_name.as_str()).unwrap();
+        let mut result = parse_validate_and_update_schema(
+            lp,
+            &db,
+            db_name.clone(),
+            Time::from_timestamp_nanos(0),
+            SegmentDuration::new_5m(),
+            false,
+            Precision::Nanosecond,
+            seq,
+        )
+        .unwrap();
+        if let Some(db) = result.schema {
+            catalog.replace_database(seq, Arc::new(db)).unwrap();
+        }
+
+        write_batch.add_db_write(
+            db_name,
+            result.valid_segmented_data.pop().unwrap().table_batches,
+        );
+        write_batch
+    }
+
+    pub(crate) fn lp_to_table_batches(
+        catalog: &Catalog,
+        db_name: &str,
+        lp: &str,
+        default_time: i64,
+    ) -> HashMap<String, TableBatch> {
+        let (seq, db) = catalog.db_or_create(db_name).unwrap();
+        let db_name = NamespaceName::new(db_name.to_string()).unwrap();
+        let mut result = parse_validate_and_update_schema(
+            lp,
+            &db,
+            db_name,
+            Time::from_timestamp_nanos(default_time),
+            SegmentDuration::new_5m(),
+            false,
+            Precision::Nanosecond,
+            SequenceNumber::new(0),
+        )
+        .unwrap();
+
+        if let Some(db) = result.schema {
+            catalog.replace_database(seq, Arc::new(db)).unwrap();
+        }
+
+        result.valid_segmented_data.pop().unwrap().table_batches
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn segment_range_initialization() {
+        let t = Time::from_rfc3339("2024-03-01T13:46:00Z").unwrap();
+
+        let expected = SegmentRange {
+            start_time: Time::from_rfc3339("2024-03-01T13:45:00Z").unwrap(),
+            end_time: Time::from_rfc3339("2024-03-01T14:00:00Z").unwrap(),
+            contains_data_outside_range: false,
+        };
+        let actual = SegmentRange::from_time_and_duration(
+            t,
+            SegmentDuration::from_str("15m").unwrap(),
+            false,
+        );
+
+        assert_eq!(expected, actual);
+
+        let expected = SegmentRange {
+            start_time: Time::from_rfc3339("2024-03-01T13:00:00Z").unwrap(),
+            end_time: Time::from_rfc3339("2024-03-01T14:00:00Z").unwrap(),
+            contains_data_outside_range: false,
+        };
+        let actual = SegmentRange::from_time_and_duration(
+            t,
+            SegmentDuration::from_str("1h").unwrap(),
+            false,
+        );
+
+        assert_eq!(expected, actual);
+
+        let expected = SegmentRange {
+            start_time: Time::from_rfc3339("2024-03-01T14:00:00Z").unwrap(),
+            end_time: Time::from_rfc3339("2024-03-01T15:00:00Z").unwrap(),
+            contains_data_outside_range: false,
+        };
+
+        assert_eq!(expected, actual.next());
+
+        let expected = SegmentRange {
+            start_time: Time::from_rfc3339("2024-03-01T12:00:00Z").unwrap(),
+            end_time: Time::from_rfc3339("2024-03-01T14:00:00Z").unwrap(),
+            contains_data_outside_range: false,
+        };
+        let actual = SegmentRange::from_time_and_duration(
+            t,
+            SegmentDuration::from_str("2h").unwrap(),
+            false,
+        );
+
+        assert_eq!(expected, actual);
+
+        let expected = SegmentRange {
+            start_time: Time::from_rfc3339("2024-03-01T12:00:00Z").unwrap(),
+            end_time: Time::from_rfc3339("2024-03-01T16:00:00Z").unwrap(),
+            contains_data_outside_range: false,
+        };
+        let actual = SegmentRange::from_time_and_duration(
+            t,
+            SegmentDuration::from_str("4h").unwrap(),
+            false,
+        );
+
+        assert_eq!(expected, actual);
+    }
+}
+
+#[cfg(test)]
+pub(crate) mod test_help {
+    use iox_query::exec::Executor;
+    use iox_query::exec::ExecutorConfig;
+    use object_store::memory::InMemory;
+    use object_store::ObjectStore;
+    use parquet_file::storage::ParquetStorage;
+    use parquet_file::storage::StorageId;
+    use std::num::NonZeroUsize;
+    use std::sync::Arc;
+
+    pub(crate) fn make_exec() -> Arc<Executor> {
+        let metrics = Arc::new(metric::Registry::default());
+        let num_threads = NonZeroUsize::new(1).unwrap();
+        let object_store: Arc<dyn ObjectStore> = Arc::new(InMemory::new());
+
+        let parquet_store = ParquetStorage::new(
+            Arc::clone(&object_store),
+            StorageId::from("test_exec_storage"),
+        );
+        Arc::new(Executor::new_with_config(
+            "datafusion",
+            ExecutorConfig {
+                num_threads,
+                target_query_partitions: num_threads,
+                object_stores: [&parquet_store]
+                    .into_iter()
+                    .map(|store| (store.id(), Arc::clone(store.object_store())))
+                    .collect(),
+                metric_registry: Arc::clone(&metrics),
+                // Default to 1gb
+                mem_pool_size: 1024 * 1024 * 1024, // 1024 (b/kb) * 1024 (kb/mb) * 1024 (mb/gb)
+            },
+        ))
+    }
+}
diff --git a/influxdb3_write/src/paths.rs b/influxdb3_write/src/paths.rs
new file mode 100644
index 00000000000..b883f2ff60e
--- /dev/null
+++ b/influxdb3_write/src/paths.rs
@@ -0,0 +1,214 @@
+use crate::SegmentId;
+use chrono::prelude::*;
+use object_store::path::Path as ObjPath;
+use std::ops::Deref;
+use std::path::Path;
+use std::path::PathBuf;
+
+/// File extension for catalog files
+pub const CATALOG_FILE_EXTENSION: &str = "json";
+
+/// File extension for parquet files
+pub const PARQUET_FILE_EXTENSION: &str = "parquet";
+
+/// File extension for segment info files
+pub const SEGMENT_INFO_FILE_EXTENSION: &str = "info.json";
+
+/// File extension for segment wal files
+pub const SEGMENT_WAL_FILE_EXTENSION: &str = "wal";
+
+fn object_store_file_stem(n: u32) -> u32 {
+    u32::MAX - n
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CatalogFilePath(ObjPath);
+
+impl CatalogFilePath {
+    pub fn new(segment_id: SegmentId) -> Self {
+        let path = ObjPath::from(format!(
+            "catalogs/{:010}.{}",
+            object_store_file_stem(segment_id.0),
+            CATALOG_FILE_EXTENSION
+        ));
+        Self(path)
+    }
+
+    pub fn dir() -> Self {
+        Self(ObjPath::from("catalogs"))
+    }
+}
+
+impl Deref for CatalogFilePath {
+    type Target = ObjPath;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl AsRef<ObjPath> for CatalogFilePath {
+    fn as_ref(&self) -> &ObjPath {
+        &self.0
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ParquetFilePath(ObjPath);
+
+impl ParquetFilePath {
+    pub fn new(db_name: &str, table_name: &str, date: DateTime<Utc>, file_number: u32) -> Self {
+        let path = ObjPath::from(format!(
+            "dbs/{db_name}/{table_name}/{}/{:010}.{}",
+            date.format("%Y-%m-%d"),
+            object_store_file_stem(file_number),
+            PARQUET_FILE_EXTENSION
+        ));
+        Self(path)
+    }
+
+    pub fn new_with_partition_key(
+        db_name: &str,
+        table_name: &str,
+        partition_key: &str,
+        file_number: u32,
+    ) -> Self {
+        let path = ObjPath::from(format!(
+            "dbs/{db_name}/{table_name}/{}/{:010}.{}",
+            partition_key,
+            object_store_file_stem(file_number),
+            PARQUET_FILE_EXTENSION
+        ));
+        Self(path)
+    }
+}
+
+impl Deref for ParquetFilePath {
+    type Target = ObjPath;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl AsRef<ObjPath> for ParquetFilePath {
+    fn as_ref(&self) -> &ObjPath {
+        &self.0
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SegmentWalFilePath(PathBuf);
+
+impl SegmentWalFilePath {
+    pub fn new(dir: impl Into<PathBuf>, segment_id: SegmentId) -> Self {
+        let mut path = dir.into();
+        path.push(format!("{:010}", segment_id.0));
+        path.set_extension(SEGMENT_WAL_FILE_EXTENSION);
+        Self(path)
+    }
+}
+
+impl ToString for SegmentWalFilePath {
+    fn to_string(&self) -> String {
+        self.0.to_string_lossy().into_owned()
+    }
+}
+
+impl Deref for SegmentWalFilePath {
+    type Target = Path;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl AsRef<Path> for SegmentWalFilePath {
+    fn as_ref(&self) -> &Path {
+        &self.0
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SegmentInfoFilePath(ObjPath);
+
+impl SegmentInfoFilePath {
+    pub fn new(segment_id: SegmentId) -> Self {
+        let path = ObjPath::from(format!(
+            "segments/{:010}.{}",
+            object_store_file_stem(segment_id.0),
+            SEGMENT_INFO_FILE_EXTENSION
+        ));
+        Self(path)
+    }
+
+    pub fn dir() -> Self {
+        Self(ObjPath::from("segments"))
+    }
+}
+
+impl Deref for SegmentInfoFilePath {
+    type Target = ObjPath;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl AsRef<ObjPath> for SegmentInfoFilePath {
+    fn as_ref(&self) -> &ObjPath {
+        &self.0
+    }
+}
+
+#[test]
+fn catalog_file_path_new() {
+    assert_eq!(
+        *CatalogFilePath::new(SegmentId::new(0)),
+        ObjPath::from("catalogs/4294967295.json")
+    );
+}
+
+#[test]
+fn parquet_file_path_new() {
+    assert_eq!(
+        *ParquetFilePath::new(
+            "my_db",
+            "my_table",
+            Utc.with_ymd_and_hms(2038, 1, 19, 3, 14, 7).unwrap(),
+            0
+        ),
+        ObjPath::from("dbs/my_db/my_table/2038-01-19/4294967295.parquet")
+    );
+}
+
+#[test]
+fn parquet_file_percent_encoded() {
+    assert_eq!(
+        ParquetFilePath::new(
+            "..",
+            "..",
+            Utc.with_ymd_and_hms(2038, 1, 19, 3, 14, 7).unwrap(),
+            0
+        )
+        .as_ref()
+        .as_ref(),
+        "dbs/%2E%2E/%2E%2E/2038-01-19/4294967295.parquet"
+    );
+}
+
+#[test]
+fn segment_info_file_path_new() {
+    assert_eq!(
+        *SegmentInfoFilePath::new(SegmentId::new(0)),
+        ObjPath::from("segments/4294967295.info.json")
+    );
+}
+
+#[test]
+fn segment_wal_file_path_new() {
+    assert_eq!(
+        *SegmentWalFilePath::new("dir", SegmentId::new(0)),
+        PathBuf::from("dir/0000000000.wal").as_ref()
+    );
+}
diff --git a/influxdb3_write/src/persister.rs b/influxdb3_write/src/persister.rs
new file mode 100644
index 00000000000..d68602cda1d
--- /dev/null
+++ b/influxdb3_write/src/persister.rs
@@ -0,0 +1,560 @@
+//! This is the implementation of the `Persister` used to write data from the buffer to object
+//! storage.
+
+use crate::catalog::Catalog;
+use crate::catalog::InnerCatalog;
+use crate::paths::CatalogFilePath;
+use crate::paths::ParquetFilePath;
+use crate::paths::SegmentInfoFilePath;
+use crate::PersistedCatalog;
+use crate::PersistedSegment;
+use crate::Persister;
+use crate::SegmentId;
+use arrow::datatypes::SchemaRef;
+use arrow::record_batch::RecordBatch;
+use async_trait::async_trait;
+use bytes::Bytes;
+use datafusion::common::DataFusionError;
+use datafusion::execution::memory_pool::MemoryConsumer;
+use datafusion::execution::memory_pool::MemoryPool;
+use datafusion::execution::memory_pool::MemoryReservation;
+use datafusion::execution::memory_pool::UnboundedMemoryPool;
+use datafusion::physical_plan::SendableRecordBatchStream;
+use futures_util::pin_mut;
+use futures_util::stream::StreamExt;
+use futures_util::stream::TryStreamExt;
+use object_store::path::Path as ObjPath;
+use object_store::ObjectStore;
+use parquet::arrow::ArrowWriter;
+use parquet::basic::Compression;
+use parquet::file::properties::WriterProperties;
+use parquet::format::FileMetaData;
+use std::any::Any;
+use std::io::Write;
+use std::sync::Arc;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("datafusion error: {0}")]
+    DataFusion(#[from] DataFusionError),
+
+    #[error("serde_json error: {0}")]
+    SerdeJson(#[from] serde_json::Error),
+
+    #[error("object_store error: {0}")]
+    ObjectStore(#[from] object_store::Error),
+
+    #[error("parquet error: {0}")]
+    ParquetError(#[from] parquet::errors::ParquetError),
+
+    #[error("tried to serialize a parquet file with no rows")]
+    NoRows,
+
+    #[error("parse int error: {0}")]
+    ParseInt(#[from] std::num::ParseIntError),
+}
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+#[derive(Debug)]
+pub struct PersisterImpl {
+    object_store: Arc<dyn ObjectStore>,
+    pub(crate) mem_pool: Arc<dyn MemoryPool>,
+}
+
+impl PersisterImpl {
+    pub fn new(object_store: Arc<dyn ObjectStore>) -> Self {
+        Self {
+            object_store,
+            mem_pool: Arc::new(UnboundedMemoryPool::default()),
+        }
+    }
+
+    async fn serialize_to_parquet(
+        &self,
+        batches: SendableRecordBatchStream,
+    ) -> Result<ParquetBytes> {
+        serialize_to_parquet(Arc::clone(&self.mem_pool), batches).await
+    }
+}
+
+pub async fn serialize_to_parquet(
+    mem_pool: Arc<dyn MemoryPool>,
+    batches: SendableRecordBatchStream,
+) -> Result<ParquetBytes> {
+    // The ArrowWriter::write() call will return an error if any subsequent
+    // batch does not match this schema, enforcing schema uniformity.
+    let schema = batches.schema();
+
+    let stream = batches;
+    let mut bytes = Vec::new();
+    pin_mut!(stream);
+
+    // Construct the arrow serializer with the metadata as part of the parquet
+    // file properties.
+    let mut writer = TrackedMemoryArrowWriter::try_new(&mut bytes, Arc::clone(&schema), mem_pool)?;
+
+    while let Some(batch) = stream.try_next().await? {
+        writer.write(batch)?;
+    }
+
+    let writer_meta = writer.close()?;
+    if writer_meta.num_rows == 0 {
+        return Err(Error::NoRows);
+    }
+
+    Ok(ParquetBytes {
+        meta_data: writer_meta,
+        bytes: Bytes::from(bytes),
+    })
+}
+
+#[async_trait]
+impl Persister for PersisterImpl {
+    type Error = Error;
+
+    async fn load_catalog(&self) -> Result<Option<PersistedCatalog>> {
+        let mut list = self.object_store.list(Some(&CatalogFilePath::dir()));
+        let mut catalog_path: Option<ObjPath> = None;
+        while let Some(item) = list.next().await {
+            let item = item?;
+            catalog_path = match catalog_path {
+                Some(old_path) => {
+                    let Some(new_catalog_name) = item.location.filename() else {
+                        // Skip this iteration as this listed file has no
+                        // filename
+                        catalog_path = Some(old_path);
+                        continue;
+                    };
+                    let old_catalog_name = old_path
+                        .filename()
+                        // NOTE: this holds so long as CatalogFilePath is used
+                        // from crate::paths
+                        .expect("catalog file paths are guaranteed to have a filename");
+
+                    // We order catalogs by number starting with u32::MAX and
+                    // then decrease it, therefore if the new catalog file name
+                    // is less than the old one this is the path we want
+                    if new_catalog_name < old_catalog_name {
+                        Some(item.location)
+                    } else {
+                        Some(old_path)
+                    }
+                }
+                None => Some(item.location),
+            };
+        }
+
+        match catalog_path {
+            None => Ok(None),
+            Some(path) => {
+                let bytes = self.object_store.get(&path).await?.bytes().await?;
+                let catalog: InnerCatalog = serde_json::from_slice(&bytes)?;
+                let file_name = path
+                    .filename()
+                    // NOTE: this holds so long as CatalogFilePath is used
+                    // from crate::paths
+                    .expect("catalog file paths are guaranteed to have a filename");
+                let parsed_number = file_name
+                    .trim_end_matches(format!(".{}", crate::paths::CATALOG_FILE_EXTENSION).as_str())
+                    .parse::<u32>()?;
+                let segment_id = SegmentId::new(u32::MAX - parsed_number);
+                Ok(Some(PersistedCatalog {
+                    segment_id,
+                    catalog,
+                }))
+            }
+        }
+    }
+
+    async fn load_segments(&self, mut most_recent_n: usize) -> Result<Vec<PersistedSegment>> {
+        let mut output = Vec::new();
+        let mut offset: Option<ObjPath> = None;
+        while most_recent_n > 0 {
+            let count = if most_recent_n > 1000 {
+                most_recent_n -= 1000;
+                1000
+            } else {
+                let count = most_recent_n;
+                most_recent_n = 0;
+                count
+            };
+
+            let mut segment_list = if let Some(offset) = offset {
+                self.object_store
+                    .list_with_offset(Some(&SegmentInfoFilePath::dir()), &offset)
+            } else {
+                self.object_store.list(Some(&SegmentInfoFilePath::dir()))
+            };
+
+            // Why not collect into a Result<Vec<ObjectMeta>, object_store::Error>>
+            // like we could with Iterators? Well because it's a stream it ends up
+            // using different traits and can't really do that. So we need to loop
+            // through to return any errors that might have occurred, then do an
+            // unstable sort (which is faster and we know won't have any
+            // duplicates) since these can arrive out of order, and then issue gets
+            // on the n most recent segments that we want and is returned in order
+            // of the moste recent to least.
+            let mut list = Vec::new();
+            while let Some(item) = segment_list.next().await {
+                list.push(item?);
+            }
+
+            list.sort_unstable_by(|a, b| a.location.cmp(&b.location));
+
+            let len = list.len();
+            let end = if len <= count { len } else { count };
+
+            for item in &list[0..end] {
+                let bytes = self.object_store.get(&item.location).await?.bytes().await?;
+                output.push(serde_json::from_slice(&bytes)?);
+            }
+
+            if end == 0 {
+                break;
+            }
+
+            // Get the last path in the array to use as an offset. This assumes
+            // we sorted the list as we can't guarantee otherwise the order of
+            // the list call to the object store.
+            offset = Some(list[end - 1].location.clone());
+        }
+
+        Ok(output)
+    }
+
+    async fn load_parquet_file(&self, path: ParquetFilePath) -> Result<Bytes> {
+        Ok(self.object_store.get(&path).await?.bytes().await?)
+    }
+
+    async fn persist_catalog(&self, segment_id: SegmentId, catalog: Catalog) -> Result<()> {
+        let catalog_path = CatalogFilePath::new(segment_id);
+        let json = serde_json::to_vec_pretty(&catalog.into_inner())?;
+        self.object_store
+            .put(catalog_path.as_ref(), Bytes::from(json))
+            .await?;
+        Ok(())
+    }
+
+    async fn persist_segment(&self, persisted_segment: &PersistedSegment) -> Result<()> {
+        let segment_file_path = SegmentInfoFilePath::new(persisted_segment.segment_id);
+        let json = serde_json::to_vec_pretty(persisted_segment)?;
+        self.object_store
+            .put(segment_file_path.as_ref(), Bytes::from(json))
+            .await?;
+        Ok(())
+    }
+
+    async fn persist_parquet_file(
+        &self,
+        path: ParquetFilePath,
+        record_batch: SendableRecordBatchStream,
+    ) -> Result<(u64, FileMetaData)> {
+        let parquet = self.serialize_to_parquet(record_batch).await?;
+        let bytes_written = parquet.bytes.len() as u64;
+        self.object_store.put(path.as_ref(), parquet.bytes).await?;
+
+        Ok((bytes_written, parquet.meta_data))
+    }
+
+    fn object_store(&self) -> Arc<dyn ObjectStore> {
+        self.object_store.clone()
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self as &dyn Any
+    }
+}
+
+pub struct ParquetBytes {
+    pub bytes: Bytes,
+    pub meta_data: FileMetaData,
+}
+
+/// Wraps an [`ArrowWriter`] to track its buffered memory in a
+/// DataFusion [`MemoryPool`]
+#[derive(Debug)]
+pub struct TrackedMemoryArrowWriter<W: Write + Send> {
+    /// The inner ArrowWriter
+    inner: ArrowWriter<W>,
+    /// DataFusion memory reservation with
+    reservation: MemoryReservation,
+}
+
+/// Parquet row group write size
+pub const ROW_GROUP_WRITE_SIZE: usize = 1024 * 1024;
+
+impl<W: Write + Send> TrackedMemoryArrowWriter<W> {
+    /// create a new `TrackedMemoryArrowWriter<`
+    pub fn try_new(sink: W, schema: SchemaRef, mem_pool: Arc<dyn MemoryPool>) -> Result<Self> {
+        let props = WriterProperties::builder()
+            .set_compression(Compression::ZSTD(Default::default()))
+            .set_max_row_group_size(ROW_GROUP_WRITE_SIZE)
+            .build();
+        let inner = ArrowWriter::try_new(sink, schema, Some(props))?;
+        let consumer = MemoryConsumer::new("InfluxDB3 ParquetWriter (TrackedMemoryArrowWriter)");
+        let reservation = consumer.register(&mem_pool);
+
+        Ok(Self { inner, reservation })
+    }
+
+    /// Push a `RecordBatch` into the underlying writer, updating the
+    /// tracked allocation
+    pub fn write(&mut self, batch: RecordBatch) -> Result<()> {
+        // writer encodes the batch into its internal buffers
+        self.inner.write(&batch)?;
+
+        // In progress memory, in bytes
+        let in_progress_size = self.inner.in_progress_size();
+
+        // update the allocation with the pool.
+        self.reservation.try_resize(in_progress_size)?;
+
+        Ok(())
+    }
+
+    /// closes the writer, flushing any remaining data and returning
+    /// the written [`FileMetaData`]
+    ///
+    /// [`FileMetaData`]: parquet::format::FileMetaData
+    pub fn close(self) -> Result<parquet::format::FileMetaData> {
+        // reservation is returned on drop
+        Ok(self.inner.close()?)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use object_store::memory::InMemory;
+    use {
+        arrow::array::Int32Array, arrow::datatypes::DataType, arrow::datatypes::Field,
+        arrow::datatypes::Schema, chrono::Utc,
+        datafusion::physical_plan::stream::RecordBatchReceiverStreamBuilder,
+        object_store::local::LocalFileSystem, std::collections::HashMap,
+    };
+
+    #[tokio::test]
+    async fn persist_catalog() {
+        let local_disk =
+            LocalFileSystem::new_with_prefix(test_helpers::tmp_dir().unwrap()).unwrap();
+        let persister = PersisterImpl::new(Arc::new(local_disk));
+        let catalog = Catalog::new();
+        let _ = catalog.db_or_create("my_db");
+
+        persister
+            .persist_catalog(SegmentId::new(0), catalog)
+            .await
+            .unwrap();
+    }
+
+    #[tokio::test]
+    async fn persist_and_load_newest_catalog() {
+        let local_disk =
+            LocalFileSystem::new_with_prefix(test_helpers::tmp_dir().unwrap()).unwrap();
+        let persister = PersisterImpl::new(Arc::new(local_disk));
+        let catalog = Catalog::new();
+        let _ = catalog.db_or_create("my_db");
+
+        persister
+            .persist_catalog(SegmentId::new(0), catalog)
+            .await
+            .unwrap();
+
+        let catalog = Catalog::new();
+        let _ = catalog.db_or_create("my_second_db");
+
+        persister
+            .persist_catalog(SegmentId::new(1), catalog)
+            .await
+            .unwrap();
+
+        let catalog = persister
+            .load_catalog()
+            .await
+            .expect("loading the catalog did not cause an error")
+            .expect("there was a catalog to load");
+
+        assert_eq!(catalog.segment_id, SegmentId::new(1));
+        assert!(catalog.catalog.db_exists("my_second_db"));
+        assert!(!catalog.catalog.db_exists("my_db"));
+    }
+
+    #[tokio::test]
+    async fn persist_segment_info_file() {
+        let local_disk =
+            LocalFileSystem::new_with_prefix(test_helpers::tmp_dir().unwrap()).unwrap();
+        let persister = PersisterImpl::new(Arc::new(local_disk));
+        let info_file = PersistedSegment {
+            segment_id: SegmentId::new(0),
+            segment_wal_size_bytes: 0,
+            databases: HashMap::new(),
+            segment_min_time: 0,
+            segment_max_time: 1,
+            segment_row_count: 0,
+            segment_parquet_size_bytes: 0,
+        };
+
+        persister.persist_segment(&info_file).await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn persist_and_load_segment_info_files() {
+        let local_disk =
+            LocalFileSystem::new_with_prefix(test_helpers::tmp_dir().unwrap()).unwrap();
+        let persister = PersisterImpl::new(Arc::new(local_disk));
+        let info_file = PersistedSegment {
+            segment_id: SegmentId::new(0),
+            segment_wal_size_bytes: 0,
+            databases: HashMap::new(),
+            segment_min_time: 0,
+            segment_max_time: 1,
+            segment_row_count: 0,
+            segment_parquet_size_bytes: 0,
+        };
+        let info_file_2 = PersistedSegment {
+            segment_id: SegmentId::new(1),
+            segment_wal_size_bytes: 0,
+            databases: HashMap::new(),
+            segment_min_time: 0,
+            segment_max_time: 1,
+            segment_row_count: 0,
+            segment_parquet_size_bytes: 0,
+        };
+        let info_file_3 = PersistedSegment {
+            segment_id: SegmentId::new(2),
+            segment_wal_size_bytes: 0,
+            databases: HashMap::new(),
+            segment_min_time: 0,
+            segment_max_time: 1,
+            segment_row_count: 0,
+            segment_parquet_size_bytes: 0,
+        };
+
+        persister.persist_segment(&info_file).await.unwrap();
+        persister.persist_segment(&info_file_2).await.unwrap();
+        persister.persist_segment(&info_file_3).await.unwrap();
+
+        let segments = persister.load_segments(2).await.unwrap();
+        assert_eq!(segments.len(), 2);
+        // The most recent one is first
+        assert_eq!(segments[0].segment_id.0, 2);
+        assert_eq!(segments[1].segment_id.0, 1);
+    }
+
+    #[tokio::test]
+    async fn persist_and_load_segment_info_files_with_fewer_than_requested() {
+        let local_disk =
+            LocalFileSystem::new_with_prefix(test_helpers::tmp_dir().unwrap()).unwrap();
+        let persister = PersisterImpl::new(Arc::new(local_disk));
+        let info_file = PersistedSegment {
+            segment_id: SegmentId::new(0),
+            segment_wal_size_bytes: 0,
+            databases: HashMap::new(),
+            segment_min_time: 0,
+            segment_max_time: 1,
+            segment_row_count: 0,
+            segment_parquet_size_bytes: 0,
+        };
+        persister.persist_segment(&info_file).await.unwrap();
+        let segments = persister.load_segments(2).await.unwrap();
+        // We asked for the most recent 2 but there should only be 1
+        assert_eq!(segments.len(), 1);
+        assert_eq!(segments[0].segment_id.0, 0);
+    }
+
+    #[tokio::test]
+    /// This test makes sure that the logic for offset lists works
+    async fn persist_and_load_over_9000_segment_info_files() {
+        let local_disk =
+            LocalFileSystem::new_with_prefix(test_helpers::tmp_dir().unwrap()).unwrap();
+        let persister = PersisterImpl::new(Arc::new(local_disk));
+        for id in 0..9001 {
+            let info_file = PersistedSegment {
+                segment_id: SegmentId::new(id),
+                segment_wal_size_bytes: 0,
+                databases: HashMap::new(),
+                segment_min_time: 0,
+                segment_max_time: 1,
+                segment_row_count: 0,
+                segment_parquet_size_bytes: 0,
+            };
+            persister.persist_segment(&info_file).await.unwrap();
+        }
+        let segments = persister.load_segments(9500).await.unwrap();
+        // We asked for the most recent 9500 so there should be 9001 of them
+        assert_eq!(segments.len(), 9001);
+        assert_eq!(segments[0].segment_id.0, 9000);
+    }
+
+    #[tokio::test]
+    async fn load_segments_works_with_no_segments() {
+        let store = InMemory::new();
+        let persister = PersisterImpl::new(Arc::new(store));
+
+        let segments = persister.load_segments(100).await.unwrap();
+        assert!(segments.is_empty());
+    }
+
+    #[tokio::test]
+    async fn get_parquet_bytes() {
+        let local_disk =
+            LocalFileSystem::new_with_prefix(test_helpers::tmp_dir().unwrap()).unwrap();
+        let persister = PersisterImpl::new(Arc::new(local_disk));
+
+        let schema = Arc::new(Schema::new(vec![Field::new("id", DataType::Int32, false)]));
+        let stream_builder = RecordBatchReceiverStreamBuilder::new(schema.clone(), 5);
+
+        let id_array = Int32Array::from(vec![1, 2, 3, 4, 5]);
+        let batch1 = RecordBatch::try_new(schema.clone(), vec![Arc::new(id_array)]).unwrap();
+
+        let id_array = Int32Array::from(vec![6, 7, 8, 9, 10]);
+        let batch2 = RecordBatch::try_new(schema.clone(), vec![Arc::new(id_array)]).unwrap();
+
+        stream_builder.tx().send(Ok(batch1)).await.unwrap();
+        stream_builder.tx().send(Ok(batch2)).await.unwrap();
+
+        let parquet = persister
+            .serialize_to_parquet(stream_builder.build())
+            .await
+            .unwrap();
+
+        // Assert we've written all the expected rows
+        assert_eq!(parquet.meta_data.num_rows, 10);
+    }
+
+    #[tokio::test]
+    async fn persist_and_load_parquet_bytes() {
+        let local_disk =
+            LocalFileSystem::new_with_prefix(test_helpers::tmp_dir().unwrap()).unwrap();
+        let persister = PersisterImpl::new(Arc::new(local_disk));
+
+        let schema = Arc::new(Schema::new(vec![Field::new("id", DataType::Int32, false)]));
+        let stream_builder = RecordBatchReceiverStreamBuilder::new(schema.clone(), 5);
+
+        let id_array = Int32Array::from(vec![1, 2, 3, 4, 5]);
+        let batch1 = RecordBatch::try_new(schema.clone(), vec![Arc::new(id_array)]).unwrap();
+
+        let id_array = Int32Array::from(vec![6, 7, 8, 9, 10]);
+        let batch2 = RecordBatch::try_new(schema.clone(), vec![Arc::new(id_array)]).unwrap();
+
+        stream_builder.tx().send(Ok(batch1)).await.unwrap();
+        stream_builder.tx().send(Ok(batch2)).await.unwrap();
+
+        let path = ParquetFilePath::new("db_one", "table_one", Utc::now(), 1);
+        let (bytes_written, meta) = persister
+            .persist_parquet_file(path.clone(), stream_builder.build())
+            .await
+            .unwrap();
+
+        // Assert we've written all the expected rows
+        assert_eq!(meta.num_rows, 10);
+
+        let bytes = persister.load_parquet_file(path).await.unwrap();
+
+        // Assert that we have a file of bytes > 0
+        assert!(!bytes.is_empty());
+        assert_eq!(bytes.len() as u64, bytes_written);
+    }
+}
diff --git a/influxdb3_write/src/wal.rs b/influxdb3_write/src/wal.rs
new file mode 100644
index 00000000000..4faddb2f91c
--- /dev/null
+++ b/influxdb3_write/src/wal.rs
@@ -0,0 +1,755 @@
+//! This is the implementation of the `Wal` that the buffer uses to make buffered data durable
+//! on disk.
+
+use crate::paths::SegmentWalFilePath;
+use crate::{
+    SegmentFile, SegmentId, SegmentRange, SequenceNumber, Wal, WalOp, WalOpBatch, WalSegmentReader,
+    WalSegmentWriter,
+};
+use async_trait::async_trait;
+use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
+use crc32fast::Hasher;
+use datafusion::parquet::file::reader::Length;
+use iox_time::Time;
+use observability_deps::tracing::{info, warn};
+use serde::{Deserialize, Serialize};
+use snap::read::FrameDecoder;
+use std::any::Any;
+use std::fmt::Debug;
+use std::{
+    fs::{File, OpenOptions},
+    io::{self, BufReader, Cursor, Read, Write},
+    mem,
+    path::PathBuf,
+};
+use thiserror::Error;
+
+/// The first bytes written into a segment file to identify it and its version.
+type FileTypeIdentifier = [u8; 8];
+const FILE_TYPE_IDENTIFIER: &[u8] = b"idb3.001";
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("io error: {source}")]
+    Io {
+        #[from]
+        source: io::Error,
+    },
+
+    #[error("error converting wal batch to json: {source}")]
+    Json {
+        #[from]
+        source: serde_json::Error,
+    },
+
+    #[error("converting u64 to u32: {source}")]
+    TryFromU64 {
+        #[from]
+        source: std::num::TryFromIntError,
+    },
+    #[error("invalid segment file {path:?}: {reason}")]
+    InvalidSegmentFile { path: PathBuf, reason: String },
+
+    #[error("unable to read crc for segment {segment_id:?}")]
+    UnableToReadCrc { segment_id: SegmentId },
+
+    #[error("unable to read length for segment data {segment_id:?}")]
+    UnableToReadLength { segment_id: SegmentId },
+
+    #[error("length mismatch for segment {segment_id:?}: expected {expected}, got {actual}")]
+    LengthMismatch {
+        segment_id: SegmentId,
+        expected: u32,
+        actual: u32,
+    },
+
+    #[error("checksum mismatch for segment {segment_id:?}: expected {expected}, got {actual}")]
+    ChecksumMismatch {
+        segment_id: SegmentId,
+        expected: u32,
+        actual: u32,
+    },
+
+    #[error("invalid segment file name {0:?}")]
+    InvalidSegmentFileName(String),
+
+    #[error("unable to parse segment id from file: {source}")]
+    UnableToParseSegmentId {
+        file_name: String,
+        source: std::num::ParseIntError,
+    },
+
+    #[error("file exists: {0}")]
+    FileExists(PathBuf),
+
+    #[error("file doens't exist: {0}")]
+    FileDoesntExist(PathBuf),
+
+    #[error("segment start time not open: {0}")]
+    SegmentStartTimeNotOpen(Time),
+
+    #[error("open segment limit reached: {0}")]
+    OpenSegmentLimitReached(usize),
+}
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+#[derive(Debug)]
+pub struct WalImpl {
+    root: PathBuf,
+}
+
+impl WalImpl {
+    pub fn new(path: impl Into<PathBuf>) -> Result<Self> {
+        let root = path.into();
+        info!(wal_dir=?root, "Ensuring WAL directory exists");
+        std::fs::create_dir_all(&root)?;
+
+        // ensure the directory creation is actually fsync'd so that when we create files there
+        // we don't lose them (see: https://www.usenix.org/system/files/conference/osdi14/osdi14-paper-pillai.pdf)
+        File::open(&root)
+            .expect("should be able to open just-created directory")
+            .sync_all()
+            .expect("fsync failure");
+
+        Ok(Self { root })
+    }
+
+    fn open_segment_reader(&self, segment_id: SegmentId) -> Result<Box<dyn WalSegmentReader>> {
+        let reader = WalSegmentReaderImpl::new(self.root.clone(), segment_id)?;
+        Ok(Box::new(reader))
+    }
+
+    fn segment_files(&self) -> Result<Vec<SegmentFile>> {
+        let dir = std::fs::read_dir(&self.root)?;
+
+        let mut segment_files = Vec::new();
+
+        for child in dir.into_iter() {
+            let child = child?;
+            let meta = child.metadata()?;
+            if meta.is_file() {
+                let path = child.path();
+
+                if let Some(file_name) = path.file_stem() {
+                    match file_name.to_str() {
+                        Some(file_name) => {
+                            if let Ok(segment_id) = segment_id_from_file_name(file_name) {
+                                segment_files.push(SegmentFile { segment_id, path });
+                            } else {
+                                warn!(
+                                    file_name=?file_name,
+                                    "File in wal dir has an invalid file stem that doesn't parse to an integer segment id, ignoring"
+                                );
+                            }
+                        }
+                        None => {
+                            warn!(
+                                file_name=?file_name,
+                                "File in wal dir has an invalid file stem that isn't valid UTF-8, ignoring"
+                            );
+                        }
+                    }
+                } else {
+                    warn!(
+                        path=?path,
+                        "File in wal dir doesn't have a file stem, ignoring"
+                    );
+                }
+            }
+        }
+
+        segment_files.sort_by_key(|f| f.segment_id);
+
+        Ok(segment_files)
+    }
+
+    fn delete_wal_segment(&self, segment_id: SegmentId) -> Result<()> {
+        let path = SegmentWalFilePath::new(self.root.clone(), segment_id);
+        std::fs::remove_file(path)?;
+        Ok(())
+    }
+}
+
+impl Wal for WalImpl {
+    fn new_segment_writer(
+        &self,
+        segment_id: SegmentId,
+        range: SegmentRange,
+    ) -> Result<Box<dyn WalSegmentWriter>> {
+        let writer = WalSegmentWriterImpl::new(self.root.clone(), segment_id, range)?;
+        Ok(Box::new(writer))
+    }
+
+    fn open_segment_writer(&self, segment_id: SegmentId) -> Result<Box<dyn WalSegmentWriter>> {
+        let writer = WalSegmentWriterImpl::open(self.root.clone(), segment_id)?;
+        Ok(Box::new(writer))
+    }
+
+    fn open_segment_reader(&self, segment_id: SegmentId) -> Result<Box<dyn WalSegmentReader>> {
+        self.open_segment_reader(segment_id)
+    }
+
+    fn segment_files(&self) -> Result<Vec<SegmentFile>> {
+        self.segment_files()
+    }
+
+    fn delete_wal_segment(&self, _segment_id: SegmentId) -> Result<()> {
+        self.delete_wal_segment(_segment_id)
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self as &dyn Any
+    }
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct SegmentHeader {
+    pub id: SegmentId,
+    pub range: SegmentRange,
+}
+
+#[derive(Debug)]
+pub struct WalSegmentWriterImpl {
+    segment_id: SegmentId,
+    f: File,
+    bytes_written: usize,
+    sequence_number: SequenceNumber,
+
+    buffer: Vec<u8>,
+}
+
+impl WalSegmentWriterImpl {
+    pub fn new(root: PathBuf, segment_id: SegmentId, range: SegmentRange) -> Result<Self> {
+        let path = SegmentWalFilePath::new(root, segment_id);
+
+        // if there's already a file there, error out
+        if path.exists() {
+            return Err(Error::FileExists(path.to_path_buf()));
+        }
+
+        // it's a new file, initialize it with the header and get ready to start writing
+        let mut f = OpenOptions::new()
+            .write(true)
+            .create(true)
+            .truncate(true)
+            .open(&path)?;
+
+        f.write_all(FILE_TYPE_IDENTIFIER)?;
+        let file_type_bytes_written = FILE_TYPE_IDENTIFIER.len();
+
+        let header = SegmentHeader {
+            id: segment_id,
+            range,
+        };
+
+        let header_bytes = serde_json::to_vec(&header)?;
+        f.write_u16::<BigEndian>(
+            header_bytes
+                .len()
+                .try_into()
+                .expect("header byes longer than u16"),
+        )?;
+        f.write_all(&header_bytes)?;
+
+        f.sync_all().expect("fsync failure");
+
+        let bytes_written = file_type_bytes_written + header_bytes.len();
+
+        Ok(Self {
+            segment_id,
+            f,
+            bytes_written,
+            sequence_number: SequenceNumber::new(0),
+            buffer: Vec::with_capacity(8 * 1204), // 8kiB initial size
+        })
+    }
+    pub fn open(root: PathBuf, segment_id: SegmentId) -> Result<Self> {
+        let path = SegmentWalFilePath::new(root, segment_id);
+
+        if let Some(file_info) =
+            WalSegmentReaderImpl::read_segment_file_info_if_exists(path.clone())?
+        {
+            let f = OpenOptions::new().append(true).open(&path)?;
+
+            Ok(Self {
+                segment_id,
+                f,
+                bytes_written: file_info
+                    .bytes_written
+                    .try_into()
+                    .expect("file length must fit in usize"),
+                sequence_number: file_info.last_sequence_number,
+                buffer: Vec::with_capacity(8 * 1204), // 8kiB initial size
+            })
+        } else {
+            Err(Error::FileDoesntExist(path.to_path_buf()))
+        }
+    }
+
+    fn write_batch(&mut self, ops: Vec<WalOp>) -> Result<()> {
+        // Ensure the write buffer is always empty before using it.
+        self.buffer.clear();
+
+        let sequence_number = self.sequence_number.next();
+
+        let batch = WalOpBatch {
+            sequence_number,
+            ops,
+        };
+
+        let data = serde_json::to_vec(&batch)?;
+
+        let bytes_written = self.write_bytes(data)?;
+
+        self.bytes_written += bytes_written;
+        self.sequence_number = sequence_number;
+
+        Ok(())
+    }
+
+    fn write_bytes(&mut self, data: Vec<u8>) -> Result<usize> {
+        // Only designed to support chunks up to `u32::max` bytes long.
+        let uncompressed_len = data.len();
+        u32::try_from(uncompressed_len)?;
+
+        // The chunk header is two u32 values, so write a dummy u64 value and
+        // come back to fill them in later.
+        self.buffer
+            .write_u64::<BigEndian>(0)
+            .expect("cannot fail to write to buffer");
+
+        // Compress the payload into the reused buffer, recording the crc hash
+        // as it is written.
+        let mut encoder = snap::write::FrameEncoder::new(HasherWrapper::new(&mut self.buffer));
+        encoder.write_all(&data)?;
+        let (checksum, buf) = encoder
+            .into_inner()
+            .expect("cannot fail to flush to a Vec")
+            .finalize();
+
+        // Adjust the compressed length to take into account the u64 padding
+        // above.
+        let compressed_len = buf.len() - mem::size_of::<u64>();
+        let compressed_len = u32::try_from(compressed_len)?;
+
+        // Go back and write the chunk header values
+        let mut buf = Cursor::new(buf);
+        buf.set_position(0);
+
+        buf.write_u32::<BigEndian>(checksum)?;
+        buf.write_u32::<BigEndian>(compressed_len)?;
+
+        // Write the entire buffer to the file
+        let buf = buf.into_inner();
+        let bytes_written = buf.len();
+        self.f.write_all(buf)?;
+
+        // fsync the fd
+        self.f.sync_all().expect("fsync failure");
+
+        Ok(bytes_written)
+    }
+}
+
+#[async_trait]
+impl WalSegmentWriter for WalSegmentWriterImpl {
+    fn id(&self) -> SegmentId {
+        self.segment_id
+    }
+
+    fn bytes_written(&self) -> u64 {
+        self.bytes_written as u64
+    }
+
+    fn write_batch(&mut self, ops: Vec<WalOp>) -> Result<()> {
+        self.write_batch(ops)
+    }
+
+    fn last_sequence_number(&self) -> SequenceNumber {
+        self.sequence_number
+    }
+}
+
+#[derive(Debug)]
+pub struct WalSegmentWriterNoopImpl {
+    segment_id: SegmentId,
+    sequence_number: SequenceNumber,
+    wal_ops_written: usize,
+}
+
+impl WalSegmentWriterNoopImpl {
+    pub fn new(segment_id: SegmentId) -> Self {
+        Self {
+            segment_id,
+            sequence_number: SequenceNumber::new(0),
+            wal_ops_written: 0,
+        }
+    }
+}
+
+impl WalSegmentWriter for WalSegmentWriterNoopImpl {
+    fn id(&self) -> SegmentId {
+        self.segment_id
+    }
+
+    fn bytes_written(&self) -> u64 {
+        self.wal_ops_written as u64
+    }
+
+    fn write_batch(&mut self, ops: Vec<WalOp>) -> Result<()> {
+        let sequence_number = self.sequence_number.next();
+        self.sequence_number = sequence_number;
+        self.wal_ops_written += ops.len();
+        Ok(())
+    }
+
+    fn last_sequence_number(&self) -> SequenceNumber {
+        self.sequence_number
+    }
+}
+
+#[derive(Debug)]
+pub struct WalSegmentReaderImpl {
+    f: BufReader<File>,
+    path: SegmentWalFilePath,
+    segment_header: SegmentHeader,
+}
+
+impl WalSegmentReaderImpl {
+    pub fn new(root: impl Into<PathBuf>, segment_id: SegmentId) -> Result<Self> {
+        let path = SegmentWalFilePath::new(root, segment_id);
+        let mut f = BufReader::new(File::open(path.clone())?);
+
+        let segment_header = read_header(&path, &mut f)?;
+
+        if segment_id != segment_header.id {
+            return Err(Error::InvalidSegmentFile {
+                path: path.to_path_buf(),
+                reason: format!(
+                    "expected segment id {:?} in file, got {:?}",
+                    segment_id, segment_header.id,
+                ),
+            });
+        }
+
+        let reader = Self {
+            f,
+            path,
+            segment_header,
+        };
+
+        Ok(reader)
+    }
+
+    fn read_segment_file_info_if_exists(
+        path: SegmentWalFilePath,
+    ) -> Result<Option<ExistingSegmentFileInfo>> {
+        let f = match File::open(path.clone()) {
+            Ok(f) => f,
+            Err(ref e) if e.kind() == io::ErrorKind::NotFound => return Ok(None),
+            Err(e) => return Err(e.into()),
+        };
+
+        let bytes_written = f.len().try_into()?;
+
+        let mut f = BufReader::new(f);
+        let segment_header = read_header(&path, &mut f)?;
+
+        let mut reader = Self {
+            f,
+            path,
+            segment_header,
+        };
+
+        let mut last_block = None;
+
+        while let Some(block) = reader.next_segment_block()? {
+            last_block = Some(block);
+        }
+
+        if let Some(block) = last_block {
+            let batch: WalOpBatch = serde_json::from_slice(&block)?;
+
+            Ok(Some(ExistingSegmentFileInfo {
+                last_sequence_number: batch.sequence_number,
+                bytes_written,
+            }))
+        } else {
+            Ok(Some(ExistingSegmentFileInfo {
+                last_sequence_number: SequenceNumber::new(0),
+                bytes_written,
+            }))
+        }
+    }
+
+    pub fn next_batch(&mut self) -> Result<Option<WalOpBatch>> {
+        if let Some(data) = self.next_segment_block()? {
+            let batch: WalOpBatch = serde_json::from_slice(&data)?;
+
+            Ok(Some(batch))
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn next_segment_block(&mut self) -> Result<Option<Vec<u8>>> {
+        let expected_checksum = match self.f.read_u32::<BigEndian>() {
+            Err(ref e) if e.kind() == io::ErrorKind::UnexpectedEof => return Ok(None),
+            other => other?,
+        };
+
+        let expected_len: u32 = self.f.read_u32::<BigEndian>()?;
+
+        let compressed_read = self.f.by_ref().take(expected_len.into());
+        let hashing_read = CrcReader::new(compressed_read);
+        let mut decompressing_read = FrameDecoder::new(hashing_read);
+
+        let mut data = Vec::with_capacity(100);
+        decompressing_read.read_to_end(&mut data)?;
+
+        let (actual_compressed_len, actual_checksum) = decompressing_read.into_inner().checksum();
+        let actual_compressed_len = u32::try_from(actual_compressed_len)
+            .expect("segment blocks are only designed to support chunks up to u32::max bytes long");
+
+        if expected_len != actual_compressed_len {
+            return Err(Error::LengthMismatch {
+                segment_id: self.segment_header.id,
+                expected: expected_len,
+                actual: actual_compressed_len,
+            });
+        }
+
+        if expected_checksum != actual_checksum {
+            return Err(Error::ChecksumMismatch {
+                segment_id: self.segment_header.id,
+                expected: expected_checksum,
+                actual: actual_checksum,
+            });
+        }
+
+        Ok(Some(data))
+    }
+}
+
+fn read_header(path: &SegmentWalFilePath, f: &mut BufReader<File>) -> Result<SegmentHeader> {
+    let file_type: FileTypeIdentifier = read_array(f)?;
+
+    if file_type != FILE_TYPE_IDENTIFIER {
+        return Err(Error::InvalidSegmentFile {
+            path: path.to_path_buf(),
+            reason: format!(
+                "expected file type identifier {:?}, got {:?}",
+                FILE_TYPE_IDENTIFIER, file_type
+            ),
+        });
+    }
+
+    let len = f.read_u16::<BigEndian>()?;
+    let mut data = vec![0u8; len.into()];
+    f.read_exact(&mut data)?;
+    let header: SegmentHeader = serde_json::from_slice(&data)?;
+
+    Ok(header)
+}
+
+fn read_array<const N: usize>(f: &mut BufReader<File>) -> Result<[u8; N]> {
+    let mut data = [0u8; N];
+    f.read_exact(&mut data)?;
+    Ok(data)
+}
+
+struct ExistingSegmentFileInfo {
+    last_sequence_number: SequenceNumber,
+    bytes_written: u32,
+}
+
+impl WalSegmentReader for WalSegmentReaderImpl {
+    fn next_batch(&mut self) -> Result<Option<WalOpBatch>> {
+        self.next_batch()
+    }
+
+    fn header(&self) -> &SegmentHeader {
+        &self.segment_header
+    }
+
+    fn path(&self) -> &SegmentWalFilePath {
+        &self.path
+    }
+}
+
+struct CrcReader<R> {
+    inner: R,
+    hasher: Hasher,
+    bytes_seen: u64,
+}
+
+impl<R> CrcReader<R> {
+    fn new(inner: R) -> Self {
+        let hasher = Hasher::default();
+        Self {
+            inner,
+            hasher,
+            bytes_seen: 0,
+        }
+    }
+
+    fn checksum(self) -> (u64, u32) {
+        (self.bytes_seen, self.hasher.finalize())
+    }
+}
+
+impl<R> Read for CrcReader<R>
+where
+    R: Read,
+{
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let len = self.inner.read(buf)?;
+        let len_u64 = u64::try_from(len).expect("Only designed to run on 32-bit systems or higher");
+
+        self.bytes_seen += len_u64;
+        self.hasher.update(&buf[..len]);
+        Ok(len)
+    }
+}
+
+/// A [`HasherWrapper`] acts as a [`Write`] decorator, recording the crc
+/// checksum of the data wrote to the inner [`Write`] implementation.
+struct HasherWrapper<W> {
+    inner: W,
+    hasher: Hasher,
+}
+
+impl<W> HasherWrapper<W> {
+    fn new(inner: W) -> Self {
+        Self {
+            inner,
+            hasher: Hasher::default(),
+        }
+    }
+
+    fn finalize(self) -> (u32, W) {
+        (self.hasher.finalize(), self.inner)
+    }
+}
+
+impl<W> Write for HasherWrapper<W>
+where
+    W: Write,
+{
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.hasher.update(buf);
+        self.inner.write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.inner.flush()
+    }
+}
+
+fn segment_id_from_file_name(name: &str) -> Result<SegmentId> {
+    let id = name
+        .parse::<u32>()
+        .map_err(|source| Error::UnableToParseSegmentId {
+            file_name: name.to_string(),
+            source,
+        })?;
+    Ok(SegmentId::new(id))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::LpWriteOp;
+
+    #[test]
+    fn segment_writer_reader() {
+        let dir = test_helpers::tmp_dir().unwrap().into_path();
+
+        let mut writer =
+            WalSegmentWriterImpl::new(dir.clone(), SegmentId::new(0), SegmentRange::test_range())
+                .unwrap();
+        let wal_op = WalOp::LpWrite(LpWriteOp {
+            db_name: "foo".to_string(),
+            lp: "cpu host=a val=10i 10".to_string(),
+            default_time: 1,
+        });
+        writer.write_batch(vec![wal_op.clone()]).unwrap();
+
+        let mut reader = WalSegmentReaderImpl::new(dir, SegmentId::new(0)).unwrap();
+        let batch = reader.next_batch().unwrap().unwrap();
+
+        assert_eq!(batch.ops, vec![wal_op]);
+        assert_eq!(batch.sequence_number, SequenceNumber::new(1));
+    }
+
+    #[test]
+    fn segment_writer_can_open_previously_existing_segment() {
+        let dir = test_helpers::tmp_dir().unwrap().into_path();
+        let wal_op = WalOp::LpWrite(LpWriteOp {
+            db_name: "foo".to_string(),
+            lp: "cpu host=a val=10i 10".to_string(),
+            default_time: 1,
+        });
+
+        // open the file, write and close it
+        {
+            let mut writer = WalSegmentWriterImpl::new(
+                dir.clone(),
+                SegmentId::new(0),
+                SegmentRange::test_range(),
+            )
+            .unwrap();
+            writer.write_batch(vec![wal_op.clone()]).unwrap();
+        }
+
+        // open it again, send a new write in and close it
+        {
+            let mut writer = WalSegmentWriterImpl::open(dir.clone(), SegmentId::new(0)).unwrap();
+            writer.write_batch(vec![wal_op.clone()]).unwrap();
+        }
+
+        // ensure that we have two WalOpBatch in the file with the correct sequence numbers
+        let mut reader = WalSegmentReaderImpl::new(dir, SegmentId::new(0)).unwrap();
+        let batch = reader.next_batch().unwrap().unwrap();
+
+        assert_eq!(batch.ops, vec![wal_op.clone()]);
+        assert_eq!(batch.sequence_number, SequenceNumber::new(1));
+
+        let batch = reader.next_batch().unwrap().unwrap();
+
+        assert_eq!(batch.ops, vec![wal_op]);
+        assert_eq!(batch.sequence_number, SequenceNumber::new(2));
+    }
+
+    #[test]
+    fn wal_can_open_write_and_read_segments() {
+        let dir = test_helpers::tmp_dir().unwrap().into_path();
+        let wal_op = WalOp::LpWrite(LpWriteOp {
+            db_name: "foo".to_string(),
+            lp: "cpu host=a val=10i 10".to_string(),
+            default_time: 1,
+        });
+
+        let wal = WalImpl::new(dir.clone()).unwrap();
+        let mut writer = wal
+            .new_segment_writer(SegmentId::new(0), SegmentRange::test_range())
+            .unwrap();
+        writer.write_batch(vec![wal_op.clone()]).unwrap();
+
+        let mut writer2 = wal
+            .new_segment_writer(SegmentId::new(1), SegmentRange::test_range())
+            .unwrap();
+        writer2.write_batch(vec![wal_op.clone()]).unwrap();
+
+        let segments = wal.segment_files().unwrap();
+        assert_eq!(segments.len(), 2);
+        assert_eq!(segments[0].segment_id, SegmentId::new(0));
+        assert_eq!(segments[1].segment_id, SegmentId::new(1));
+
+        let mut reader = wal.open_segment_reader(SegmentId::new(0)).unwrap();
+        let batch = reader.next_batch().unwrap().unwrap();
+        assert_eq!(batch.ops, vec![wal_op.clone()]);
+        assert_eq!(batch.sequence_number, SequenceNumber::new(1));
+    }
+}
diff --git a/influxdb3_write/src/write_buffer/buffer_segment.rs b/influxdb3_write/src/write_buffer/buffer_segment.rs
new file mode 100644
index 00000000000..71a10a0183f
--- /dev/null
+++ b/influxdb3_write/src/write_buffer/buffer_segment.rs
@@ -0,0 +1,855 @@
+//! A single buffer segment used by the write buffer. This is all the data in memory for a
+//! single WAL segment. Only one segment should be open for writes in the write buffer at any
+//! given time.
+
+use crate::catalog::Catalog;
+use crate::chunk::BufferChunk;
+use crate::paths::ParquetFilePath;
+use crate::write_buffer::flusher::BufferedWriteResult;
+use crate::write_buffer::table_buffer::Builder;
+use crate::write_buffer::table_buffer::TableBuffer;
+use crate::write_buffer::{
+    parse_validate_and_update_catalog, Error, TableBatch, ValidSegmentedData,
+};
+use crate::{
+    wal, write_buffer, write_buffer::Result, DatabaseTables, ParquetFile, PersistedSegment,
+    Persister, Precision, SegmentDuration, SegmentId, SegmentRange, SequenceNumber,
+    TableParquetFiles, WalOp, WalSegmentReader, WalSegmentWriter,
+};
+use arrow::record_batch::RecordBatch;
+use data_types::ChunkId;
+use data_types::ChunkOrder;
+use data_types::TableId;
+use data_types::TransitionPartitionId;
+use data_types::{NamespaceName, PartitionKey};
+use datafusion_util::stream_from_batches;
+use iox_query::chunk_statistics::create_chunk_statistics;
+use iox_query::frontend::reorg::ReorgPlanner;
+use iox_query::QueryChunk;
+use iox_time::Time;
+use schema::sort::SortKey;
+use schema::Schema;
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::oneshot;
+
+#[derive(Debug)]
+pub struct OpenBufferSegment {
+    segment_writer: Box<dyn WalSegmentWriter>,
+    segment_id: SegmentId,
+    segment_range: SegmentRange,
+    segment_duration: SegmentDuration,
+    segment_key: PartitionKey,
+    buffered_data: BufferedData,
+    segment_open_time: Time,
+    #[allow(dead_code)]
+    starting_catalog_sequence_number: SequenceNumber,
+    // TODO: This is temporarily just the number of rows in the segment. When the buffer gets refactored to use
+    //       different structures, we want this to be a representation of approximate memory usage.
+    segment_size: usize,
+}
+
+impl OpenBufferSegment {
+    pub fn new(
+        segment_id: SegmentId,
+        segment_range: SegmentRange,
+        segment_open_time: Time,
+        starting_catalog_sequence_number: SequenceNumber,
+        segment_writer: Box<dyn WalSegmentWriter>,
+        buffered_data: Option<(BufferedData, usize)>,
+    ) -> Self {
+        let (buffered_data, segment_size) = buffered_data.unwrap_or_default();
+        let segment_key = PartitionKey::from(segment_range.key());
+        let segment_duration = SegmentDuration::from_range(segment_range);
+
+        Self {
+            segment_writer,
+            segment_id,
+            segment_range,
+            segment_duration,
+            segment_open_time,
+            segment_key,
+            starting_catalog_sequence_number,
+            segment_size,
+            buffered_data,
+        }
+    }
+
+    #[cfg(test)]
+    pub fn segment_id(&self) -> SegmentId {
+        self.segment_id
+    }
+
+    pub fn segment_range(&self) -> &SegmentRange {
+        &self.segment_range
+    }
+
+    pub fn segment_key(&self) -> &PartitionKey {
+        &self.segment_key
+    }
+
+    pub fn write_wal_ops(&mut self, write_batch: Vec<WalOp>) -> wal::Result<()> {
+        self.segment_writer.write_batch(write_batch)
+    }
+
+    #[cfg(test)]
+    pub fn starting_catalog_sequence_number(&self) -> SequenceNumber {
+        self.starting_catalog_sequence_number
+    }
+
+    /// Adds the batch into the in memory buffer.
+    pub(crate) fn buffer_writes(&mut self, write_batch: WriteBatch) -> Result<()> {
+        for (db_name, db_batch) in write_batch.database_batches {
+            let db_buffer = self
+                .buffered_data
+                .database_buffers
+                .entry(db_name.to_string())
+                .or_default();
+
+            for (table_name, table_batch) in db_batch.table_batches {
+                // TODO: for now we'll just have the number of rows represent the segment size. The entire
+                //       buffer is going to get refactored to use different structures, so this will change.
+                self.segment_size += table_batch.rows.len();
+
+                db_buffer.buffer_table_batch(table_name, &self.segment_key, table_batch);
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Returns the table data as record batches
+    pub(crate) fn table_record_batches(
+        &self,
+        db_name: &str,
+        table_name: &str,
+        schema: &Schema,
+    ) -> Option<Vec<RecordBatch>> {
+        self.buffered_data
+            .table_record_batches(db_name, table_name, schema)
+    }
+
+    /// Returns true if the segment should be persisted. A segment should be persisted if both of
+    /// the following are true:
+    /// 1. The segment has been open longer than half its duration
+    /// 2. The current time is past the end time of the segment + half its duration
+    pub fn should_persist(&self, current_time: Time) -> bool {
+        let half_duration_seconds = self.segment_duration.duration_seconds() / 2;
+        let open_duration_seconds = current_time
+            .checked_duration_since(self.segment_open_time)
+            .unwrap_or(Duration::from_secs(0))
+            .as_secs() as i64;
+
+        let segment_end_epoch = self.segment_range.end_time.timestamp();
+        let end_time_age_out_epoch = segment_end_epoch + half_duration_seconds;
+
+        open_duration_seconds > half_duration_seconds
+            && current_time.timestamp() > end_time_age_out_epoch
+    }
+
+    #[allow(dead_code)]
+    pub fn into_closed_segment(self, catalog: Arc<Catalog>) -> ClosedBufferSegment {
+        ClosedBufferSegment::new(
+            self.segment_id,
+            self.segment_range,
+            self.segment_key,
+            self.starting_catalog_sequence_number,
+            catalog.sequence_number(),
+            self.buffered_data,
+            self.segment_writer.bytes_written(),
+            catalog,
+        )
+    }
+}
+
+pub(crate) fn load_buffer_from_segment(
+    catalog: &Catalog,
+    mut segment_reader: Box<dyn WalSegmentReader>,
+) -> Result<(BufferedData, usize)> {
+    let mut segment_size = 0;
+    let mut buffered_data = BufferedData::default();
+    let segment_key = PartitionKey::from(segment_reader.header().range.key());
+    let segment_duration = SegmentDuration::from_range(segment_reader.header().range);
+
+    while let Some(batch) = segment_reader.next_batch()? {
+        for wal_op in batch.ops {
+            match wal_op {
+                WalOp::LpWrite(write) => {
+                    let mut validated_write = parse_validate_and_update_catalog(
+                        NamespaceName::new(write.db_name.clone())?,
+                        &write.lp,
+                        catalog,
+                        Time::from_timestamp_nanos(write.default_time),
+                        segment_duration,
+                        false,
+                        Precision::Nanosecond,
+                    )?;
+
+                    let db_buffer = buffered_data
+                        .database_buffers
+                        .entry(write.db_name)
+                        .or_default();
+
+                    // there should only ever be data for a single segment as this is all read
+                    // from one segment file
+                    if validated_write.valid_segmented_data.len() != 1 {
+                        return Err(Error::WalOpForMultipleSegments(
+                            segment_reader.path().to_string(),
+                        ));
+                    }
+                    let segment_data = validated_write.valid_segmented_data.pop().unwrap();
+
+                    for (table_name, table_batch) in segment_data.table_batches {
+                        // TODO: for now we'll just have the number of rows represent the segment size. The entire
+                        //       buffer is going to get refactored to use different structures, so this will change.
+                        segment_size += table_batch.rows.len();
+
+                        db_buffer.buffer_table_batch(table_name, &segment_key, table_batch);
+                    }
+                }
+            }
+        }
+    }
+
+    Ok((buffered_data, segment_size))
+}
+
+#[derive(Debug, Default)]
+pub(crate) struct WriteBatch {
+    database_batches: HashMap<NamespaceName<'static>, DatabaseBatch>,
+}
+
+impl WriteBatch {
+    pub(crate) fn add_db_write(
+        &mut self,
+        db_name: NamespaceName<'static>,
+        table_batches: HashMap<String, TableBatch>,
+    ) {
+        let db_batch = self.database_batches.entry(db_name).or_default();
+        db_batch.add_table_batches(table_batches);
+    }
+}
+
+#[derive(Debug, Default)]
+struct DatabaseBatch {
+    table_batches: HashMap<String, TableBatch>,
+}
+
+impl DatabaseBatch {
+    fn add_table_batches(&mut self, table_batches: HashMap<String, TableBatch>) {
+        for (table_name, table_batch) in table_batches {
+            let write_table_batch = self.table_batches.entry(table_name).or_default();
+            write_table_batch.rows.extend(table_batch.rows);
+        }
+    }
+}
+
+pub struct BufferedWrite {
+    pub segmented_data: Vec<ValidSegmentedData>,
+    pub response_tx: oneshot::Sender<BufferedWriteResult>,
+}
+
+#[derive(Debug, Default)]
+pub struct BufferedData {
+    database_buffers: HashMap<String, DatabaseBuffer>,
+}
+
+impl BufferedData {
+    /// Returns the table data as record batches
+    pub(crate) fn table_record_batches(
+        &self,
+        db_name: &str,
+        table_name: &str,
+        schema: &Schema,
+    ) -> Option<Vec<RecordBatch>> {
+        self.database_buffers
+            .get(db_name)
+            .and_then(|db_buffer| db_buffer.table_buffers.get(table_name))
+            .map(|table_buffer| table_buffer.record_batches(schema))
+    }
+
+    /// Verifies that the passed in buffer has the same data as this buffer
+    #[cfg(test)]
+    pub(crate) fn verify_matches(&self, other: &BufferedData, catalog: &Catalog) {
+        assert_eq!(self.database_buffers.len(), other.database_buffers.len());
+        for (db_name, db_buffer) in &self.database_buffers {
+            let other_db_buffer = other.database_buffers.get(db_name).unwrap();
+            let db_schema = catalog.db_schema(db_name).unwrap();
+
+            for table_name in db_buffer.table_buffers.keys() {
+                let table_buffer = db_buffer.table_buffers.get(table_name).unwrap();
+                let other_table_buffer = other_db_buffer.table_buffers.get(table_name).unwrap();
+                let schema = db_schema.get_table_schema(table_name).unwrap();
+
+                let table_data = table_buffer.record_batches(schema);
+                let other_table_data = other_table_buffer.record_batches(schema);
+
+                assert_eq!(table_data, other_table_data);
+            }
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+struct DatabaseBuffer {
+    table_buffers: HashMap<String, TableBuffer>,
+}
+
+impl DatabaseBuffer {
+    fn buffer_table_batch(
+        &mut self,
+        table_name: String,
+        segment_key: &PartitionKey,
+        table_batch: TableBatch,
+    ) {
+        let table_buffer = self
+            .table_buffers
+            .entry(table_name)
+            .or_insert_with(|| TableBuffer::new(segment_key.clone()));
+
+        table_buffer.add_rows(table_batch.rows);
+    }
+}
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct ClosedBufferSegment {
+    pub segment_id: SegmentId,
+    pub segment_range: SegmentRange,
+    pub segment_key: PartitionKey,
+    pub catalog_start_sequence_number: SequenceNumber,
+    pub catalog_end_sequence_number: SequenceNumber,
+    pub buffered_data: BufferedData,
+    pub segment_wal_bytes: u64,
+    catalog: Arc<Catalog>,
+}
+
+impl ClosedBufferSegment {
+    #[allow(dead_code)]
+    #[allow(clippy::too_many_arguments)]
+    fn new(
+        segment_id: SegmentId,
+        segment_range: SegmentRange,
+        segment_key: PartitionKey,
+        catalog_start_sequence_number: SequenceNumber,
+        catalog_end_sequence_number: SequenceNumber,
+        buffered_data: BufferedData,
+        segment_wal_bytes: u64,
+        catalog: Arc<Catalog>,
+    ) -> Self {
+        Self {
+            segment_id,
+            segment_range,
+            segment_key,
+            catalog_start_sequence_number,
+            catalog_end_sequence_number,
+            buffered_data,
+            segment_wal_bytes,
+            catalog,
+        }
+    }
+
+    pub(crate) async fn persist<P>(
+        &self,
+        persister: Arc<P>,
+        executor: Arc<iox_query::exec::Executor>,
+        sort_key: Option<SortKey>,
+    ) -> Result<PersistedSegment>
+    where
+        P: Persister,
+        write_buffer::Error: From<<P as Persister>::Error>,
+    {
+        if self.catalog_start_sequence_number != self.catalog_end_sequence_number {
+            let inner_catalog = self.catalog.clone_inner();
+
+            persister
+                .persist_catalog(self.segment_id, Catalog::from_inner(inner_catalog))
+                .await?;
+        }
+
+        let mut persisted_database_files = HashMap::new();
+        let mut segment_parquet_size_bytes = 0;
+        let mut segment_row_count = 0;
+        let mut segment_min_time = i64::MAX;
+        let mut segment_max_time = i64::MIN;
+
+        // persist every partition buffer
+        for (db_name, db_buffer) in &self.buffered_data.database_buffers {
+            let mut database_tables = DatabaseTables::default();
+
+            if let Some(db_schema) = self.catalog.db_schema(db_name) {
+                for (table_name, table_buffer) in &db_buffer.table_buffers {
+                    if let Some(table) = db_schema.get_table(table_name) {
+                        let mut table_parquet_files = TableParquetFiles {
+                            table_name: table_name.to_string(),
+                            parquet_files: vec![],
+                            sort_key: vec![],
+                        };
+
+                        // All of the record batches for this table that we will
+                        // want to dedupe
+                        let batches = table_buffer.record_batches(table.schema());
+                        let row_count = batches.iter().map(|b| b.num_rows()).sum();
+
+                        // Dedupe and sort using the COMPACT query built into
+                        // iox_query
+                        let mut chunks: Vec<Arc<dyn QueryChunk>> = vec![];
+                        let time_min_max = table_buffer.timestamp_min_max();
+                        let schema = table.schema();
+
+                        let chunk_stats = create_chunk_statistics(
+                            Some(row_count),
+                            schema,
+                            Some(time_min_max),
+                            None,
+                        );
+
+                        chunks.push(Arc::new(BufferChunk {
+                            batches,
+                            schema: schema.clone(),
+                            stats: Arc::new(chunk_stats),
+                            partition_id: TransitionPartitionId::new(
+                                TableId::new(0),
+                                &self.segment_key,
+                            ),
+                            sort_key: None,
+                            id: ChunkId::new(),
+                            chunk_order: ChunkOrder::new(
+                                chunks
+                                    .len()
+                                    .try_into()
+                                    .expect("should never have this many chunks"),
+                            ),
+                        }));
+
+                        let ctx = executor.new_context();
+
+                        let sort_key = match sort_key.as_ref() {
+                            Some(key) => key.clone(),
+                            // Default to using tags sorted in lexographical
+                            // order as the sort key
+                            None => {
+                                let mut tags = table_buffer
+                                    .data
+                                    .iter()
+                                    .filter(|(_, v)| matches!(v, Builder::Tag(_)))
+                                    .map(|(k, _)| k)
+                                    .cloned()
+                                    .collect::<Vec<String>>();
+                                tags.sort();
+                                SortKey::from(tags)
+                            }
+                        };
+
+                        let logical_plan = ReorgPlanner::new()
+                            .compact_plan(
+                                Arc::from(table_name.clone()),
+                                table.schema(),
+                                chunks,
+                                sort_key,
+                            )
+                            .unwrap();
+
+                        // Build physical plan
+                        let physical_plan = ctx.create_physical_plan(&logical_plan).await.unwrap();
+
+                        // Execute the plan and return compacted record batches
+                        let data = ctx.collect(physical_plan).await.unwrap();
+
+                        // Get the new row count before turning it into a
+                        // stream. We couldn't turn the data directly into a
+                        // stream since we needed the row count for
+                        // `ParquetFile` below
+                        let row_count = data.iter().map(|b| b.num_rows()).sum::<usize>();
+
+                        let batch_stream = stream_from_batches(table.schema().as_arrow(), data);
+                        let parquet_file_path = ParquetFilePath::new_with_partition_key(
+                            db_name,
+                            &table.name,
+                            &table_buffer.segment_key.to_string(),
+                            self.segment_id.0,
+                        );
+                        let path = parquet_file_path.to_string();
+                        let (size_bytes, meta) = persister
+                            .persist_parquet_file(parquet_file_path, batch_stream)
+                            .await?;
+
+                        let parquet_file = ParquetFile {
+                            path,
+                            size_bytes,
+                            row_count: row_count as u64,
+                            min_time: time_min_max.min,
+                            max_time: time_min_max.max,
+                        };
+                        table_parquet_files.parquet_files.push(parquet_file);
+
+                        segment_parquet_size_bytes += size_bytes;
+                        segment_row_count += meta.num_rows as u64;
+                        segment_max_time = segment_max_time.max(time_min_max.max);
+                        segment_min_time = segment_min_time.min(time_min_max.min);
+
+                        if !table_parquet_files.parquet_files.is_empty() {
+                            database_tables
+                                .tables
+                                .insert(table_name.to_string(), table_parquet_files);
+                        }
+                    }
+                }
+            }
+
+            if !database_tables.tables.is_empty() {
+                persisted_database_files.insert(db_name.to_string(), database_tables);
+            }
+        }
+
+        let persisted_segment = PersistedSegment {
+            segment_id: self.segment_id,
+            segment_wal_size_bytes: self.segment_wal_bytes,
+            segment_parquet_size_bytes,
+            segment_row_count,
+            segment_min_time,
+            segment_max_time,
+            databases: persisted_database_files,
+        };
+
+        persister.persist_segment(&persisted_segment).await?;
+
+        Ok(persisted_segment)
+    }
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use super::*;
+    use crate::test_helpers::{lp_to_table_batches, lp_to_write_batch};
+    use crate::wal::WalSegmentWriterNoopImpl;
+    use crate::{persister, LpWriteOp, PersistedCatalog};
+    use arrow_util::assert_batches_eq;
+    use bytes::Bytes;
+    use datafusion::execution::SendableRecordBatchStream;
+    use object_store::ObjectStore;
+    use parking_lot::Mutex;
+    use parquet::format::FileMetaData;
+    use std::any::Any;
+    use std::str::FromStr;
+
+    #[test]
+    fn buffers_rows() {
+        let mut open_segment = OpenBufferSegment::new(
+            SegmentId::new(0),
+            SegmentRange::test_range(),
+            Time::from_timestamp_nanos(0),
+            SequenceNumber::new(0),
+            Box::new(WalSegmentWriterNoopImpl::new(SegmentId::new(0))),
+            None,
+        );
+
+        let db_name: NamespaceName<'static> = NamespaceName::new("db1").unwrap();
+        let catalog = Catalog::new();
+
+        let batches = lp_to_table_batches(
+            &catalog,
+            "db1",
+            "cpu,tag1=cupcakes bar=1 10\nmem,tag2=snakes bar=2 20",
+            10,
+        );
+        let mut write_batch = WriteBatch::default();
+        write_batch.add_db_write(db_name.clone(), batches);
+        open_segment.buffer_writes(write_batch).unwrap();
+
+        let batches = lp_to_table_batches(&catalog, "db1", "cpu,tag1=cupcakes bar=2 30", 10);
+        let mut write_batch = WriteBatch::default();
+        write_batch.add_db_write(db_name.clone(), batches);
+        open_segment.buffer_writes(write_batch).unwrap();
+
+        let db_schema = catalog.db_schema("db1").unwrap();
+        let cpu_table = open_segment
+            .table_record_batches("db1", "cpu", db_schema.get_table_schema("cpu").unwrap())
+            .unwrap();
+        let expected_cpu_table = vec![
+            "+------------------------------------------------------------------+-----+----------+--------------------------------+",
+            "| _series_id                                                       | bar | tag1     | time                           |",
+            "+------------------------------------------------------------------+-----+----------+--------------------------------+",
+            "| 505f9f5fc3347ac9d6ba45f2b2c94ad53a313e456e86e61db85ba1935369b238 | 1.0 | cupcakes | 1970-01-01T00:00:00.000000010Z |",
+            "| 505f9f5fc3347ac9d6ba45f2b2c94ad53a313e456e86e61db85ba1935369b238 | 2.0 | cupcakes | 1970-01-01T00:00:00.000000030Z |",
+            "+------------------------------------------------------------------+-----+----------+--------------------------------+",
+        ];
+        assert_batches_eq!(&expected_cpu_table, &cpu_table);
+
+        let mem_table = open_segment
+            .table_record_batches("db1", "mem", db_schema.get_table_schema("mem").unwrap())
+            .unwrap();
+        let expected_mem_table = vec![
+            "+------------------------------------------------------------------+-----+--------+--------------------------------+",
+            "| _series_id                                                       | bar | tag2   | time                           |",
+            "+------------------------------------------------------------------+-----+--------+--------------------------------+",
+            "| 5ae2bb295e8b0dec713daf0da555ecd3f2899a8967f18db799e26557029198f3 | 2.0 | snakes | 1970-01-01T00:00:00.000000020Z |",
+            "+------------------------------------------------------------------+-----+--------+--------------------------------+",
+        ];
+        assert_batches_eq!(&expected_mem_table, &mem_table);
+    }
+
+    #[tokio::test]
+    async fn buffers_schema_update() {
+        let mut open_segment = OpenBufferSegment::new(
+            SegmentId::new(0),
+            SegmentRange::test_range(),
+            Time::from_timestamp_nanos(0),
+            SequenceNumber::new(0),
+            Box::new(WalSegmentWriterNoopImpl::new(SegmentId::new(0))),
+            None,
+        );
+
+        let db_name: NamespaceName<'static> = NamespaceName::new("db1").unwrap();
+        let catalog = Catalog::new();
+
+        let batches = lp_to_table_batches(&catalog, "db1", "cpu,tag1=cupcakes bar=1 10", 10);
+        let mut write_batch = WriteBatch::default();
+        write_batch.add_db_write(db_name.clone(), batches);
+        open_segment.buffer_writes(write_batch).unwrap();
+
+        let batches = lp_to_table_batches(&catalog, "db1", "cpu,tag2=asdf bar=2 30", 10);
+        let mut write_batch = WriteBatch::default();
+        write_batch.add_db_write(db_name.clone(), batches);
+        open_segment.buffer_writes(write_batch).unwrap();
+
+        let batches = lp_to_table_batches(&catalog, "db1", "cpu bar=2,ival=7i 30", 10);
+        let mut write_batch = WriteBatch::default();
+        write_batch.add_db_write(db_name.clone(), batches);
+        open_segment.buffer_writes(write_batch).unwrap();
+
+        let batches =
+            lp_to_table_batches(&catalog, "db1", "cpu bar=2,ival=9i 40\ncpu fval=2.1 40", 10);
+        let mut write_batch = WriteBatch::default();
+        write_batch.add_db_write(db_name.clone(), batches);
+        open_segment.buffer_writes(write_batch).unwrap();
+
+        let db_schema = catalog.db_schema("db1").unwrap();
+        println!("{:?}", db_schema);
+        let cpu_table = open_segment
+            .table_record_batches("db1", "cpu", db_schema.get_table_schema("cpu").unwrap())
+            .unwrap();
+        let expected_cpu_table = vec![
+            "+------------------------------------------------------------------+-----+------+------+----------+------+--------------------------------+",
+            "| _series_id                                                       | bar | fval | ival | tag1     | tag2 | time                           |",
+            "+------------------------------------------------------------------+-----+------+------+----------+------+--------------------------------+",
+            "| 505f9f5fc3347ac9d6ba45f2b2c94ad53a313e456e86e61db85ba1935369b238 | 1.0 |      |      | cupcakes |      | 1970-01-01T00:00:00.000000010Z |",
+            "| 251081631d40db93f2e58103d12f03216512601273b4de08bc50e1b399df3de8 | 2.0 |      |      |          | asdf | 1970-01-01T00:00:00.000000030Z |",
+            "| e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 | 2.0 |      | 7    |          |      | 1970-01-01T00:00:00.000000030Z |",
+            "| e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 | 2.0 |      | 9    |          |      | 1970-01-01T00:00:00.000000040Z |",
+            "| e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 |     | 2.1  |      |          |      | 1970-01-01T00:00:00.000000040Z |",
+            "+------------------------------------------------------------------+-----+------+------+----------+------+--------------------------------+",
+        ];
+        assert_batches_eq!(&expected_cpu_table, &cpu_table);
+    }
+
+    #[tokio::test]
+    async fn persist_closed_buffer() {
+        const SEGMENT_KEY: &str = "1970-01-01T00-00";
+
+        let segment_id = SegmentId::new(4);
+        let segment_writer = Box::new(WalSegmentWriterNoopImpl::new(segment_id));
+        let mut open_segment = OpenBufferSegment::new(
+            segment_id,
+            SegmentRange::test_range(),
+            Time::from_timestamp_nanos(0),
+            SequenceNumber::new(0),
+            segment_writer,
+            None,
+        );
+
+        let catalog = Catalog::new();
+
+        // When we persist the data all of these duplicates should be removed
+        let lp = "cpu,tag1=cupcakes bar=1 10\n\
+                  cpu,tag1=cupcakes bar=1 10\n\
+                  cpu,tag1=something bar=5 10\n\
+                  cpu,tag1=cupcakes bar=1 10\n\
+                  mem,tag2=turtles bar=3 15\n\
+                  cpu,tag1=cupcakes bar=1 10\n\
+                  cpu,tag1=cupcakes bar=1 10\n\
+                  mem,tag2=turtles bar=3 15\n\
+                  mem,tag2=turtles bar=3 15\n\
+                  mem,tag2=snakes bar=2 20\n\
+                  mem,tag2=turtles bar=3 15\n\
+                  mem,tag2=turtles bar=3 15";
+
+        let wal_op = WalOp::LpWrite(LpWriteOp {
+            db_name: "db1".to_string(),
+            lp: lp.to_string(),
+            default_time: 0,
+        });
+
+        let write_batch = lp_to_write_batch(&catalog, "db1", lp);
+
+        open_segment.write_wal_ops(vec![wal_op]).unwrap();
+        open_segment.buffer_writes(write_batch).unwrap();
+
+        let catalog = Arc::new(catalog);
+        let closed_buffer_segment = open_segment.into_closed_segment(Arc::clone(&catalog));
+
+        let persister = Arc::new(TestPersister::default());
+        closed_buffer_segment
+            .persist(Arc::clone(&persister), crate::test_help::make_exec(), None)
+            .await
+            .unwrap();
+
+        let persisted_state = persister
+            .as_any()
+            .downcast_ref::<TestPersister>()
+            .unwrap()
+            .state
+            .lock();
+        assert_eq!(
+            persisted_state.catalog.first().unwrap().clone_inner(),
+            catalog.clone_inner()
+        );
+        let segment_info = persisted_state.segments.first().unwrap();
+
+        assert_eq!(segment_info.segment_id, segment_id);
+        assert_eq!(segment_info.segment_min_time, 10);
+        assert_eq!(segment_info.segment_max_time, 20);
+        assert_eq!(segment_info.segment_row_count, 2);
+        // in the mock each parquet file is 1 byte, so should have 2
+        assert_eq!(segment_info.segment_parquet_size_bytes, 2);
+        // should have been one write into the wal
+        assert_eq!(segment_info.segment_wal_size_bytes, 1);
+        // one file for cpu, one for mem
+        assert_eq!(persisted_state.parquet_files.len(), 2);
+
+        println!("segment_info:\n{:#?}", segment_info);
+        let db = segment_info.databases.get("db1").unwrap();
+        let cpu = db.tables.get("cpu").unwrap();
+        let cpu_parqet = &cpu.parquet_files[0];
+
+        // file number of the path should match the segment id
+        assert_eq!(
+            cpu_parqet.path,
+            ParquetFilePath::new_with_partition_key("db1", "cpu", SEGMENT_KEY, 4).to_string()
+        );
+        assert_eq!(cpu_parqet.row_count, 2);
+        assert_eq!(cpu_parqet.min_time, 10);
+        assert_eq!(cpu_parqet.max_time, 10);
+
+        let mem = db.tables.get("mem").unwrap();
+        let mem_parqet = &mem.parquet_files[0];
+
+        // file number of the path should match the segment id
+        assert_eq!(
+            mem_parqet.path,
+            ParquetFilePath::new_with_partition_key("db1", "mem", SEGMENT_KEY, 4).to_string()
+        );
+        assert_eq!(mem_parqet.row_count, 2);
+        assert_eq!(mem_parqet.min_time, 15);
+        assert_eq!(mem_parqet.max_time, 20);
+    }
+
+    #[test]
+    fn should_persist() {
+        let segment = OpenBufferSegment::new(
+            SegmentId::new(0),
+            SegmentRange::from_time_and_duration(
+                Time::from_timestamp_nanos(0),
+                SegmentDuration::from_str("1m").unwrap(),
+                false,
+            ),
+            Time::from_timestamp_nanos(0),
+            SequenceNumber::new(0),
+            Box::new(WalSegmentWriterNoopImpl::new(SegmentId::new(0))),
+            None,
+        );
+
+        // time is in current segment
+        assert!(!segment.should_persist(Time::from_timestamp(30, 0).unwrap()));
+
+        // time is in next segment, but before half duration
+        assert!(!segment.should_persist(Time::from_timestamp(61, 0).unwrap()));
+
+        // time is in next segment, and after half duration
+        assert!(segment.should_persist(Time::from_timestamp(61 + 30, 0).unwrap()));
+
+        let segment = OpenBufferSegment::new(
+            SegmentId::new(0),
+            SegmentRange::from_time_and_duration(
+                Time::from_timestamp_nanos(0),
+                SegmentDuration::from_str("1m").unwrap(),
+                false,
+            ),
+            Time::from_timestamp(500, 0).unwrap(),
+            SequenceNumber::new(0),
+            Box::new(WalSegmentWriterNoopImpl::new(SegmentId::new(0))),
+            None,
+        );
+
+        // time has advanced from segment open time, but is still less than half duration away
+        assert!(!segment.should_persist(Time::from_timestamp(500 + 29, 0).unwrap()));
+
+        // time has advanced from segment open time, and is now half duration away
+        assert!(segment.should_persist(Time::from_timestamp(500 + 31, 0).unwrap()));
+    }
+
+    #[derive(Debug, Default)]
+    pub(crate) struct TestPersister {
+        pub(crate) state: Mutex<PersistedState>,
+    }
+
+    #[derive(Debug, Default)]
+    pub(crate) struct PersistedState {
+        pub(crate) catalog: Vec<Catalog>,
+        pub(crate) segments: Vec<PersistedSegment>,
+        pub(crate) parquet_files: Vec<ParquetFilePath>,
+    }
+
+    #[async_trait::async_trait]
+    impl Persister for TestPersister {
+        type Error = persister::Error;
+
+        async fn persist_catalog(
+            &self,
+            _segment_id: SegmentId,
+            catalog: Catalog,
+        ) -> persister::Result<()> {
+            self.state.lock().catalog.push(catalog);
+            Ok(())
+        }
+
+        async fn persist_parquet_file(
+            &self,
+            path: ParquetFilePath,
+            _data: SendableRecordBatchStream,
+        ) -> persister::Result<(u64, FileMetaData)> {
+            self.state.lock().parquet_files.push(path);
+            let meta = FileMetaData::new(1, vec![], 1, vec![], None, None, None, None, None);
+            Ok((1, meta))
+        }
+
+        async fn persist_segment(&self, segment: &PersistedSegment) -> persister::Result<()> {
+            self.state.lock().segments.push(segment.clone());
+            Ok(())
+        }
+
+        fn as_any(&self) -> &dyn Any {
+            self as &dyn Any
+        }
+
+        async fn load_catalog(&self) -> persister::Result<Option<PersistedCatalog>> {
+            todo!()
+        }
+
+        async fn load_segments(
+            &self,
+            _most_recent_n: usize,
+        ) -> persister::Result<Vec<PersistedSegment>> {
+            todo!()
+        }
+
+        async fn load_parquet_file(&self, _path: ParquetFilePath) -> persister::Result<Bytes> {
+            todo!()
+        }
+
+        fn object_store(&self) -> Arc<dyn ObjectStore> {
+            todo!()
+        }
+    }
+}
diff --git a/influxdb3_write/src/write_buffer/flusher.rs b/influxdb3_write/src/write_buffer/flusher.rs
new file mode 100644
index 00000000000..aca85e13104
--- /dev/null
+++ b/influxdb3_write/src/write_buffer/flusher.rs
@@ -0,0 +1,310 @@
+//! Buffers writes and flushes them to the configured wal
+
+use crate::write_buffer::buffer_segment::{BufferedWrite, WriteBatch};
+use crate::write_buffer::{Error, SegmentState, ValidSegmentedData};
+use crate::{wal, SequenceNumber, Wal, WalOp};
+use crossbeam_channel::{bounded, Receiver as CrossbeamReceiver, Sender as CrossbeamSender};
+use iox_time::{Time, TimeProvider};
+use observability_deps::tracing::debug;
+use parking_lot::{Mutex, RwLock};
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::select;
+use tokio::sync::{mpsc, oneshot, watch};
+use tokio::time::MissedTickBehavior;
+
+// Duration to buffer writes before flushing them to the wal
+const BUFFER_FLUSH_INTERVAL: Duration = Duration::from_millis(10);
+// The maximum number of buffered writes that can be queued up before backpressure is applied
+const BUFFER_CHANNEL_LIMIT: usize = 10_000;
+
+// buffered writes should only fail if the underlying WAL throws an error. They are validated before they
+// are buffered. If there is an error, it'll be here
+#[derive(Debug, Clone)]
+pub enum BufferedWriteResult {
+    Success(()),
+    Error(String),
+}
+
+type SegmentedWalOps = HashMap<Time, (SequenceNumber, Vec<WalOp>)>;
+type SegmentedWriteBatch = HashMap<Time, (SequenceNumber, WriteBatch)>;
+
+/// The WriteBufferFlusher buffers writes and flushes them to the configured wal. The wal IO is done in a native
+/// thread rather than a tokio task to avoid blocking the tokio runtime. As referenced in this post, continuous
+/// long-running IO threads should be off the tokio runtime: `<https://ryhl.io/blog/async-what-is-blocking/>`.
+#[derive(Debug)]
+pub struct WriteBufferFlusher {
+    join_handle: Mutex<Option<tokio::task::JoinHandle<()>>>,
+    wal_io_handle: Mutex<Option<std::thread::JoinHandle<()>>>,
+    #[allow(dead_code)]
+    shutdown_tx: watch::Sender<()>,
+    buffer_tx: mpsc::Sender<BufferedWrite>,
+}
+
+impl WriteBufferFlusher {
+    pub fn new<T: TimeProvider, W: Wal>(segment_state: Arc<RwLock<SegmentState<T, W>>>) -> Self {
+        let (shutdown_tx, shutdown_rx) = watch::channel(());
+        let (buffer_tx, buffer_rx) = mpsc::channel(BUFFER_CHANNEL_LIMIT);
+        let (io_flush_tx, io_flush_rx) = bounded(1);
+        let (io_flush_notify_tx, io_flush_notify_rx) = bounded(1);
+
+        let flusher = Self {
+            join_handle: Default::default(),
+            wal_io_handle: Default::default(),
+            shutdown_tx,
+            buffer_tx,
+        };
+
+        let wal_op_buffer_segment_state = Arc::clone(&segment_state);
+
+        *flusher.wal_io_handle.lock() = Some(
+            std::thread::Builder::new()
+                .name("write buffer io flusher".to_string())
+                .spawn(move || {
+                    run_io_flush(segment_state, io_flush_rx, io_flush_notify_tx);
+                })
+                .expect("failed to spawn write buffer io flusher thread"),
+        );
+
+        *flusher.join_handle.lock() = Some(tokio::task::spawn(async move {
+            run_wal_op_buffer(
+                wal_op_buffer_segment_state,
+                buffer_rx,
+                io_flush_tx,
+                io_flush_notify_rx,
+                shutdown_rx,
+            )
+            .await;
+        }));
+
+        flusher
+    }
+
+    pub async fn write_to_open_segment(
+        &self,
+        segmented_data: Vec<ValidSegmentedData>,
+    ) -> crate::write_buffer::Result<()> {
+        let (response_tx, response_rx) = oneshot::channel();
+
+        self.buffer_tx
+            .send(BufferedWrite {
+                segmented_data,
+                response_tx,
+            })
+            .await
+            .expect("wal op buffer thread is dead");
+
+        let summary = response_rx.await.expect("wal op buffer thread is dead");
+
+        match summary {
+            BufferedWriteResult::Success(_) => Ok(()),
+            BufferedWriteResult::Error(e) => Err(Error::BufferSegmentError(e)),
+        }
+    }
+}
+
+async fn run_wal_op_buffer<T: TimeProvider, W: Wal>(
+    segment_state: Arc<RwLock<SegmentState<T, W>>>,
+    mut buffer_rx: mpsc::Receiver<BufferedWrite>,
+    io_flush_tx: CrossbeamSender<SegmentedWalOps>,
+    io_flush_notify_rx: CrossbeamReceiver<wal::Result<()>>,
+    mut shutdown: watch::Receiver<()>,
+) {
+    let mut ops = SegmentedWalOps::new();
+    let mut write_batch = SegmentedWriteBatch::new();
+    let mut notifies = Vec::new();
+    let mut interval = tokio::time::interval(BUFFER_FLUSH_INTERVAL);
+    interval.set_missed_tick_behavior(MissedTickBehavior::Skip);
+
+    loop {
+        // select on either buffering an op, ticking the flush interval, or shutting down
+        select! {
+            Some(buffered_write) = buffer_rx.recv() => {
+                for segmented_data in buffered_write.segmented_data {
+                    let segment_ops = ops.entry(segmented_data.segment_start).or_insert_with(|| {
+                        (segmented_data.starting_catalog_sequence_number, Vec::new())
+                    });
+                    segment_ops.1.push(segmented_data.wal_op);
+
+                    let segment_write_batch = write_batch.entry(segmented_data.segment_start).or_insert_with(|| {
+                        (segmented_data.starting_catalog_sequence_number, WriteBatch::default())
+                    });
+                    segment_write_batch.1.add_db_write(segmented_data.database_name, segmented_data.table_batches);
+                }
+                notifies.push(buffered_write.response_tx);
+            },
+            _ = interval.tick() => {
+                if ops.is_empty() {
+                    continue;
+                }
+
+                // send ops into IO flush channel and wait for response
+                io_flush_tx.send(ops).expect("wal io thread is dead");
+
+                let res = match io_flush_notify_rx.recv().expect("wal io thread is dead") {
+                  Ok(()) => {
+                       let mut err = BufferedWriteResult::Success(());
+
+                        let mut segment_state = segment_state.write();
+
+                        for (time, (sequence_number, write_batch)) in write_batch {
+                            if let Err(e) = segment_state.write_batch_to_segment(time, write_batch, sequence_number) {
+                                err = BufferedWriteResult::Error(e.to_string());
+                                break;
+                            }
+                        }
+
+                        err
+                    },
+                    Err(e) => BufferedWriteResult::Error(e.to_string()),
+                };
+
+                // notify the watchers of the write response
+                for response_tx in notifies {
+                    let _ = response_tx.send(res.clone());
+                }
+
+                // reset the buffers
+                ops = SegmentedWalOps::new();
+                write_batch = SegmentedWriteBatch::new();
+                notifies = Vec::new();
+            },
+            _ = shutdown.changed() => {
+                // shutdown has been requested
+                debug!("stopping wal op buffer thread");
+                return;
+            }
+        }
+    }
+}
+
+fn run_io_flush<T: TimeProvider, W: Wal>(
+    segment_state: Arc<RwLock<SegmentState<T, W>>>,
+    buffer_rx: CrossbeamReceiver<SegmentedWalOps>,
+    buffer_notify: CrossbeamSender<wal::Result<()>>,
+) {
+    loop {
+        let segmented_wal_ops = match buffer_rx.recv() {
+            Ok(batch) => batch,
+            Err(_) => {
+                // the buffer channel has closed, it's shutdown
+                debug!("stopping wal io thread");
+                return;
+            }
+        };
+
+        let mut state = segment_state.write();
+
+        // write the ops to the segment files, or return on first error
+        for (time, (sequence_number, wal_ops)) in segmented_wal_ops {
+            let res = state.write_ops_to_segment(time, wal_ops, sequence_number);
+            if res.is_err() {
+                buffer_notify.send(res).expect("buffer flusher is dead");
+                continue;
+            }
+        }
+
+        buffer_notify.send(Ok(())).expect("buffer flusher is dead");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::catalog::Catalog;
+    use crate::wal::{WalImpl, WalSegmentWriterNoopImpl};
+    use crate::write_buffer::buffer_segment::OpenBufferSegment;
+    use crate::write_buffer::parse_validate_and_update_catalog;
+    use crate::{Precision, SegmentDuration, SegmentId, SegmentRange, SequenceNumber};
+    use data_types::NamespaceName;
+    use iox_time::MockProvider;
+
+    #[tokio::test]
+    async fn flushes_to_open_segment() {
+        let segment_id = SegmentId::new(3);
+        let open_segment = OpenBufferSegment::new(
+            segment_id,
+            SegmentRange::test_range(),
+            Time::from_timestamp_nanos(0),
+            SequenceNumber::new(0),
+            Box::new(WalSegmentWriterNoopImpl::new(segment_id)),
+            None,
+        );
+        let next_segment_id = segment_id.next();
+        let next_segment_range = SegmentRange::test_range().next();
+
+        let next_segment = OpenBufferSegment::new(
+            next_segment_id,
+            next_segment_range,
+            Time::from_timestamp_nanos(0),
+            SequenceNumber::new(0),
+            Box::new(WalSegmentWriterNoopImpl::new(next_segment_id)),
+            None,
+        );
+        let catalog = Arc::new(Catalog::new());
+        let segment_state = Arc::new(RwLock::new(SegmentState::<MockProvider, WalImpl>::new(
+            SegmentDuration::new_5m(),
+            next_segment_id,
+            Arc::clone(&catalog),
+            Arc::new(MockProvider::new(Time::from_timestamp_nanos(0))),
+            vec![open_segment, next_segment],
+            vec![],
+            vec![],
+            None,
+        )));
+        let flusher = WriteBufferFlusher::new(Arc::clone(&segment_state));
+
+        let db_name = NamespaceName::new("db1").unwrap();
+        let ingest_time = Time::from_timestamp_nanos(0);
+        let res = parse_validate_and_update_catalog(
+            db_name.clone(),
+            "cpu bar=1 10",
+            &catalog,
+            ingest_time,
+            SegmentDuration::new_5m(),
+            false,
+            Precision::Nanosecond,
+        )
+        .unwrap();
+
+        flusher
+            .write_to_open_segment(res.valid_segmented_data)
+            .await
+            .unwrap();
+
+        let res = parse_validate_and_update_catalog(
+            db_name.clone(),
+            "cpu bar=1 20",
+            &catalog,
+            ingest_time,
+            SegmentDuration::new_5m(),
+            false,
+            Precision::Nanosecond,
+        )
+        .unwrap();
+        flusher
+            .write_to_open_segment(res.valid_segmented_data)
+            .await
+            .unwrap();
+
+        let state = segment_state.read();
+        let segment = state.segment_for_time(ingest_time).unwrap();
+
+        assert_eq!(segment.segment_id(), segment_id);
+
+        let data = segment
+            .table_record_batches(
+                db_name.as_str(),
+                "cpu",
+                catalog
+                    .db_schema("db1")
+                    .unwrap()
+                    .get_table_schema("cpu")
+                    .unwrap(),
+            )
+            .unwrap();
+        let row_count = data.iter().map(|batch| batch.num_rows()).sum::<usize>();
+        assert_eq!(row_count, 2);
+    }
+}
diff --git a/influxdb3_write/src/write_buffer/loader.rs b/influxdb3_write/src/write_buffer/loader.rs
new file mode 100644
index 00000000000..d34bcb6d629
--- /dev/null
+++ b/influxdb3_write/src/write_buffer/loader.rs
@@ -0,0 +1,667 @@
+//! This module contains logic to load the initial server state from the persister and wal
+//! if configured.
+
+use crate::catalog::Catalog;
+use crate::wal::WalSegmentWriterNoopImpl;
+use crate::write_buffer::{
+    buffer_segment::{load_buffer_from_segment, ClosedBufferSegment, OpenBufferSegment},
+    Result,
+};
+use crate::{persister, write_buffer, PersistedCatalog, PersistedSegment, Persister, SegmentId};
+use crate::{SegmentDuration, SegmentRange, Wal};
+use iox_time::Time;
+use std::sync::Arc;
+
+const SEGMENTS_TO_LOAD: usize = 1000;
+
+/// The state loaded and initialized from the persister and wal.
+#[derive(Debug)]
+pub struct LoadedState {
+    pub catalog: Arc<Catalog>,
+    pub open_segments: Vec<OpenBufferSegment>,
+    pub persisting_buffer_segments: Vec<ClosedBufferSegment>,
+    pub persisted_segments: Vec<PersistedSegment>,
+    pub last_segment_id: SegmentId,
+}
+
+pub async fn load_starting_state<P, W>(
+    persister: Arc<P>,
+    wal: Option<Arc<W>>,
+    server_load_time: Time,
+    segment_duration: SegmentDuration,
+) -> Result<LoadedState>
+where
+    P: Persister,
+    persister::Error: From<<P as Persister>::Error>,
+    W: Wal,
+    write_buffer::Error: From<<P as Persister>::Error>,
+{
+    let PersistedCatalog { catalog, .. } = persister.load_catalog().await?.unwrap_or_default();
+    let catalog = Arc::new(Catalog::from_inner(catalog));
+
+    let persisted_segments = persister.load_segments(SEGMENTS_TO_LOAD).await?;
+
+    let last_persisted_segment_id = persisted_segments
+        .last()
+        .map(|s| s.segment_id)
+        .unwrap_or(SegmentId::new(0));
+    let mut persisting_buffer_segments = Vec::new();
+
+    let current_segment_range =
+        SegmentRange::from_time_and_duration(server_load_time, segment_duration, false);
+    let next_segment_range = current_segment_range.next();
+
+    let mut open_segments = Vec::new();
+    let mut max_segment_id = last_persisted_segment_id;
+
+    if let Some(wal) = wal {
+        // read any segments that don't show up in the list of persisted segments
+        let wal_segments = wal.segment_files()?;
+
+        for segment_file in wal_segments {
+            max_segment_id = max_segment_id.max(segment_file.segment_id);
+
+            // if persisted segments is empty, load all segments from the wal, otherwise
+            // only load segments that haven't been persisted yet
+            if segment_file.segment_id <= last_persisted_segment_id
+                && !persisted_segments.is_empty()
+            {
+                continue;
+            }
+
+            let starting_sequence_number = catalog.sequence_number();
+            let segment_reader = wal.open_segment_reader(segment_file.segment_id)?;
+            let segment_header = *segment_reader.header();
+            let buffer = load_buffer_from_segment(&catalog, segment_reader)?;
+
+            let segment = OpenBufferSegment::new(
+                segment_header.id,
+                segment_header.range,
+                server_load_time,
+                starting_sequence_number,
+                wal.open_segment_writer(segment_file.segment_id)?,
+                Some(buffer),
+            );
+
+            // if it's the current or next segment, we want to keep it open rather than move it to
+            // a persisting state
+            if segment_header.range == current_segment_range
+                || segment_header.range == next_segment_range
+            {
+                open_segments.push(segment);
+            } else {
+                persisting_buffer_segments.push(segment.into_closed_segment(Arc::clone(&catalog)));
+            }
+        }
+
+        if open_segments.is_empty() {
+            // ensure that we open up a segment for the "now" period of time
+            let current_segment_id = max_segment_id.next();
+            max_segment_id = current_segment_id;
+
+            let current_segment = OpenBufferSegment::new(
+                current_segment_id,
+                current_segment_range,
+                server_load_time,
+                catalog.sequence_number(),
+                wal.new_segment_writer(current_segment_id, current_segment_range)?,
+                None,
+            );
+
+            open_segments.push(current_segment);
+        }
+    } else {
+        // ensure that we open up a segment for the "now" period of time
+        let current_segment_id = last_persisted_segment_id.next();
+        max_segment_id = current_segment_id;
+
+        let current_segment = OpenBufferSegment::new(
+            current_segment_id,
+            current_segment_range,
+            server_load_time,
+            catalog.sequence_number(),
+            Box::new(WalSegmentWriterNoopImpl::new(current_segment_id)),
+            None,
+        );
+
+        open_segments.push(current_segment);
+    };
+
+    Ok(LoadedState {
+        catalog,
+        last_segment_id: max_segment_id,
+        open_segments,
+        persisting_buffer_segments,
+        persisted_segments,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::persister::PersisterImpl;
+    use crate::test_helpers::lp_to_write_batch;
+    use crate::wal::{WalImpl, WalSegmentWriterNoopImpl};
+    use crate::{
+        DatabaseTables, LpWriteOp, ParquetFile, SegmentRange, SequenceNumber, TableParquetFiles,
+        WalOp,
+    };
+    use arrow_util::assert_batches_eq;
+    use iox_time::Time;
+    use object_store::memory::InMemory;
+    use object_store::ObjectStore;
+    use pretty_assertions::assert_eq;
+    use std::collections::HashMap;
+
+    #[tokio::test]
+    async fn loads_without_wal() {
+        let object_store: Arc<dyn ObjectStore> = Arc::new(InMemory::new());
+        let persister = Arc::new(PersisterImpl::new(Arc::clone(&object_store)));
+
+        let segment_id = SegmentId::new(4);
+        let segment_writer = Box::new(WalSegmentWriterNoopImpl::new(segment_id));
+        let mut open_segment = OpenBufferSegment::new(
+            segment_id,
+            SegmentRange::test_range(),
+            Time::from_timestamp_nanos(0),
+            SequenceNumber::new(0),
+            segment_writer,
+            None,
+        );
+
+        let catalog = Catalog::new();
+
+        let lp = "cpu,tag1=cupcakes bar=1 10\nmem,tag2=turtles bar=3 15\nmem,tag2=snakes bar=2 20";
+
+        let wal_op = WalOp::LpWrite(LpWriteOp {
+            db_name: "db1".to_string(),
+            lp: lp.to_string(),
+            default_time: 0,
+        });
+
+        let write_batch = lp_to_write_batch(&catalog, "db1", lp);
+
+        open_segment.write_wal_ops(vec![wal_op]).unwrap();
+        open_segment.buffer_writes(write_batch).unwrap();
+
+        let catalog = Arc::new(catalog);
+        let closed_buffer_segment = open_segment.into_closed_segment(Arc::clone(&catalog));
+        closed_buffer_segment
+            .persist(Arc::clone(&persister), crate::test_help::make_exec(), None)
+            .await
+            .unwrap();
+
+        let loaded_state = load_starting_state(
+            persister,
+            None::<Arc<crate::wal::WalImpl>>,
+            Time::from_timestamp_nanos(0),
+            SegmentDuration::new_5m(),
+        )
+        .await
+        .unwrap();
+        let expected_catalog = catalog.clone_inner();
+        let loaded_catalog = loaded_state.catalog.clone_inner();
+
+        assert_eq!(expected_catalog, loaded_catalog);
+        // the open segment it creates should be the next value in line
+        assert_eq!(
+            loaded_state.open_segments[0].segment_id(),
+            SegmentId::new(5)
+        );
+        let persisted_segment = loaded_state.persisted_segments.first().unwrap();
+        assert_eq!(persisted_segment.segment_id, segment_id);
+        assert_eq!(persisted_segment.segment_row_count, 3);
+
+        let tables_persisted = persisted_segment.databases.get("db1").unwrap();
+        assert_eq!(
+            tables_persisted
+                .tables
+                .get("cpu")
+                .unwrap()
+                .parquet_files
+                .len(),
+            1
+        );
+        assert_eq!(
+            tables_persisted
+                .tables
+                .get("mem")
+                .unwrap()
+                .parquet_files
+                .len(),
+            1
+        );
+
+        assert_eq!(loaded_state.last_segment_id, SegmentId::new(5));
+    }
+
+    #[tokio::test]
+    async fn loads_with_no_persisted_segments_and_wal() {
+        let object_store: Arc<dyn ObjectStore> = Arc::new(InMemory::new());
+        let persister = Arc::new(PersisterImpl::new(Arc::clone(&object_store)));
+        let dir = test_helpers::tmp_dir().unwrap().into_path();
+        let wal = Arc::new(WalImpl::new(dir.clone()).unwrap());
+        let db_name = "db1";
+
+        let LoadedState {
+            catalog,
+            mut open_segments,
+            ..
+        } = load_starting_state(
+            Arc::clone(&persister),
+            Some(Arc::clone(&wal)),
+            Time::from_timestamp_nanos(0),
+            SegmentDuration::new_5m(),
+        )
+        .await
+        .unwrap();
+
+        let mut current_segment = open_segments.pop().unwrap();
+
+        let lp = "cpu,tag1=cupcakes bar=1 10\nmem,tag2=turtles bar=3 15\nmem,tag2=snakes bar=2 20";
+
+        let wal_op = WalOp::LpWrite(LpWriteOp {
+            db_name: db_name.to_string(),
+            lp: lp.to_string(),
+            default_time: 0,
+        });
+
+        let write_batch = lp_to_write_batch(&catalog, db_name, lp);
+
+        current_segment.write_wal_ops(vec![wal_op.clone()]).unwrap();
+        current_segment.buffer_writes(write_batch).unwrap();
+
+        let loaded_state = load_starting_state(
+            persister,
+            Some(wal),
+            Time::from_timestamp_nanos(0),
+            SegmentDuration::new_5m(),
+        )
+        .await
+        .unwrap();
+        let current_segment = loaded_state.open_segments.first().unwrap();
+
+        assert!(loaded_state.persisting_buffer_segments.is_empty());
+        assert!(loaded_state.persisted_segments.is_empty());
+        let db = loaded_state.catalog.db_schema(db_name).unwrap();
+        assert_eq!(db.tables.len(), 2);
+        assert!(db.tables.contains_key("cpu"));
+        assert!(db.tables.contains_key("mem"));
+
+        let cpu_table = db.get_table("cpu").unwrap();
+        let cpu_data = current_segment
+            .table_record_batches(db_name, "cpu", cpu_table.schema())
+            .unwrap();
+        let expected = [
+            "+------------------------------------------------------------------+-----+----------+--------------------------------+",
+            "| _series_id                                                       | bar | tag1     | time                           |",
+            "+------------------------------------------------------------------+-----+----------+--------------------------------+",
+            "| 505f9f5fc3347ac9d6ba45f2b2c94ad53a313e456e86e61db85ba1935369b238 | 1.0 | cupcakes | 1970-01-01T00:00:00.000000010Z |",
+            "+------------------------------------------------------------------+-----+----------+--------------------------------+",
+        ];
+        assert_batches_eq!(&expected, &cpu_data);
+
+        let mem_table = db.get_table("mem").unwrap();
+        let mem_data = current_segment
+            .table_record_batches(db_name, "mem", mem_table.schema())
+            .unwrap();
+        let expected = [
+            "+------------------------------------------------------------------+-----+---------+--------------------------------+",
+            "| _series_id                                                       | bar | tag2    | time                           |",
+            "+------------------------------------------------------------------+-----+---------+--------------------------------+",
+            "| 635ef196e32aca85c36626ce7cdd298ad84e78caec369f4f0fe75e509750c8f7 | 3.0 | turtles | 1970-01-01T00:00:00.000000015Z |",
+            "| 5ae2bb295e8b0dec713daf0da555ecd3f2899a8967f18db799e26557029198f3 | 2.0 | snakes  | 1970-01-01T00:00:00.000000020Z |",
+            "+------------------------------------------------------------------+-----+---------+--------------------------------+",
+        ];
+        assert_batches_eq!(&expected, &mem_data);
+
+        assert_eq!(loaded_state.last_segment_id, SegmentId::new(1));
+    }
+
+    #[tokio::test]
+    async fn loads_with_persisted_segments_and_wal() {
+        let object_store: Arc<dyn ObjectStore> = Arc::new(InMemory::new());
+        let persister = Arc::new(PersisterImpl::new(Arc::clone(&object_store)));
+        let dir = test_helpers::tmp_dir().unwrap().into_path();
+        let wal = Arc::new(WalImpl::new(dir.clone()).unwrap());
+        let db_name = "db1";
+
+        let LoadedState {
+            catalog,
+            mut open_segments,
+            ..
+        } = load_starting_state(
+            Arc::clone(&persister),
+            Some(Arc::clone(&wal)),
+            Time::from_timestamp_nanos(0),
+            SegmentDuration::new_5m(),
+        )
+        .await
+        .unwrap();
+
+        let mut current_segment = open_segments.pop().unwrap();
+
+        let lp = "cpu,tag1=cupcakes bar=1 10\nmem,tag2=turtles bar=3 15\nmem,tag2=snakes bar=2 20";
+
+        let wal_op = WalOp::LpWrite(LpWriteOp {
+            db_name: db_name.to_string(),
+            lp: lp.to_string(),
+            default_time: 0,
+        });
+
+        let write_batch = lp_to_write_batch(&catalog, db_name, lp);
+
+        current_segment.write_wal_ops(vec![wal_op]).unwrap();
+        current_segment.buffer_writes(write_batch).unwrap();
+
+        let segment_id = current_segment.segment_id();
+
+        let next_segment_id = segment_id.next();
+        let next_segment_range = current_segment.segment_range().next();
+
+        // close and persist the current segment
+        let closed_segment = Arc::new(current_segment.into_closed_segment(Arc::clone(&catalog)));
+
+        closed_segment
+            .persist(Arc::clone(&persister), crate::test_help::make_exec(), None)
+            .await
+            .unwrap();
+
+        // write data into the next segment
+        let lp = "cpu,tag1=cupcakes bar=3 20\nfoo val=1 123";
+
+        let wal_op = WalOp::LpWrite(LpWriteOp {
+            db_name: db_name.to_string(),
+            lp: lp.to_string(),
+            default_time: 0,
+        });
+
+        let write_batch = lp_to_write_batch(&catalog, db_name, lp);
+
+        let segment_writer = wal
+            .new_segment_writer(next_segment_id, next_segment_range)
+            .unwrap();
+        let mut next_segment = OpenBufferSegment::new(
+            SegmentId::new(2),
+            SegmentRange::test_range().next(),
+            Time::from_timestamp_nanos(0),
+            catalog.sequence_number(),
+            segment_writer,
+            None,
+        );
+
+        next_segment.write_wal_ops(vec![wal_op]).unwrap();
+        next_segment.buffer_writes(write_batch).unwrap();
+
+        // now load up with a start time that puts us in next segment period
+        let loaded_state = load_starting_state(
+            persister,
+            Some(wal),
+            Time::from_timestamp(6 * 60, 0).unwrap(),
+            SegmentDuration::new_5m(),
+        )
+        .await
+        .unwrap();
+
+        // verify that the persisted segment doesn't show up as one that should be persisting
+        assert!(loaded_state.persisting_buffer_segments.is_empty());
+
+        // verify the data was persisted
+        assert_eq!(
+            loaded_state.persisted_segments[0],
+            PersistedSegment {
+                segment_id,
+                segment_wal_size_bytes: 227,
+                segment_parquet_size_bytes: 5476,
+                segment_row_count: 3,
+                segment_min_time: 10,
+                segment_max_time: 20,
+                databases: HashMap::from([(
+                    "db1".to_string(),
+                    DatabaseTables {
+                        tables: HashMap::from([
+                            (
+                                "cpu".to_string(),
+                                TableParquetFiles {
+                                    table_name: "cpu".to_string(),
+                                    parquet_files: vec![ParquetFile {
+                                        path: "dbs/db1/cpu/1970-01-01T00-00/4294967294.parquet"
+                                            .to_string(),
+                                        size_bytes: 2712,
+                                        row_count: 1,
+                                        min_time: 10,
+                                        max_time: 10,
+                                    }],
+                                    sort_key: vec![],
+                                }
+                            ),
+                            (
+                                "mem".to_string(),
+                                TableParquetFiles {
+                                    table_name: "mem".to_string(),
+                                    parquet_files: vec![ParquetFile {
+                                        path: "dbs/db1/mem/1970-01-01T00-00/4294967294.parquet"
+                                            .to_string(),
+                                        size_bytes: 2764,
+                                        row_count: 2,
+                                        min_time: 15,
+                                        max_time: 20,
+                                    }],
+                                    sort_key: vec![],
+                                }
+                            )
+                        ])
+                    }
+                )])
+            }
+        );
+        let db = loaded_state.catalog.db_schema(db_name).unwrap();
+        assert_eq!(db.tables.len(), 3);
+        assert!(db.tables.contains_key("cpu"));
+        assert!(db.tables.contains_key("mem"));
+        assert!(db.tables.contains_key("foo"));
+
+        let cpu_table = db.get_table("cpu").unwrap();
+        let cpu_data = loaded_state.open_segments[0]
+            .table_record_batches(db_name, "cpu", cpu_table.schema())
+            .unwrap();
+        let expected = [
+            "+------------------------------------------------------------------+-----+----------+--------------------------------+",
+            "| _series_id                                                       | bar | tag1     | time                           |",
+            "+------------------------------------------------------------------+-----+----------+--------------------------------+",
+            "| 505f9f5fc3347ac9d6ba45f2b2c94ad53a313e456e86e61db85ba1935369b238 | 3.0 | cupcakes | 1970-01-01T00:00:00.000000020Z |",
+            "+------------------------------------------------------------------+-----+----------+--------------------------------+",
+        ];
+        assert_batches_eq!(&expected, &cpu_data);
+
+        let foo_table = db.get_table("foo").unwrap();
+        let foo_data = loaded_state.open_segments[0]
+            .table_record_batches(db_name, "foo", foo_table.schema())
+            .unwrap();
+        let expected = [
+            "+------------------------------------------------------------------+--------------------------------+-----+",
+            "| _series_id                                                       | time                           | val |",
+            "+------------------------------------------------------------------+--------------------------------+-----+",
+            "| e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 | 1970-01-01T00:00:00.000000123Z | 1.0 |",
+            "+------------------------------------------------------------------+--------------------------------+-----+",
+        ];
+        assert_batches_eq!(&expected, &foo_data);
+
+        assert_eq!(loaded_state.last_segment_id, SegmentId::new(2));
+    }
+
+    #[tokio::test]
+    async fn loads_with_persisting() {
+        let object_store: Arc<dyn ObjectStore> = Arc::new(InMemory::new());
+        let persister = Arc::new(PersisterImpl::new(Arc::clone(&object_store)));
+        let dir = test_helpers::tmp_dir().unwrap().into_path();
+        let wal = Arc::new(WalImpl::new(dir.clone()).unwrap());
+        let db_name = "db1";
+
+        let LoadedState {
+            catalog,
+            mut open_segments,
+            ..
+        } = load_starting_state(
+            Arc::clone(&persister),
+            Some(Arc::clone(&wal)),
+            Time::from_timestamp_nanos(0),
+            SegmentDuration::new_5m(),
+        )
+        .await
+        .unwrap();
+        let mut current_segment = open_segments.pop().unwrap();
+
+        let lp = "cpu,tag1=cupcakes bar=1 10\nmem,tag2=turtles bar=3 15\nmem,tag2=snakes bar=2 20";
+
+        let wal_op = WalOp::LpWrite(LpWriteOp {
+            db_name: db_name.to_string(),
+            lp: lp.to_string(),
+            default_time: 0,
+        });
+
+        let write_batch = lp_to_write_batch(&catalog, db_name, lp);
+
+        current_segment.write_wal_ops(vec![wal_op]).unwrap();
+        current_segment.buffer_writes(write_batch).unwrap();
+
+        let next_segment_id = current_segment.segment_id().next();
+        let next_segment_range = current_segment.segment_range().next();
+
+        // close the current segment
+        let closed_segment = current_segment.into_closed_segment(Arc::clone(&catalog));
+
+        // write data into the next segment
+        let lp = "cpu,tag1=apples bar=3 20\nfoo val=1 123";
+
+        let wal_op = WalOp::LpWrite(LpWriteOp {
+            db_name: db_name.to_string(),
+            lp: lp.to_string(),
+            default_time: 0,
+        });
+
+        let write_batch = lp_to_write_batch(&catalog, db_name, lp);
+
+        let segment_writer = wal
+            .new_segment_writer(next_segment_id, next_segment_range)
+            .unwrap();
+        let mut next_segment = OpenBufferSegment::new(
+            SegmentId::new(2),
+            SegmentRange::test_range().next(),
+            Time::from_timestamp_nanos(0),
+            catalog.sequence_number(),
+            segment_writer,
+            None,
+        );
+
+        next_segment.write_wal_ops(vec![wal_op]).unwrap();
+        next_segment.buffer_writes(write_batch).unwrap();
+
+        // now load up with a start time that puts us in next segment period. we should now
+        // have the previous current_segment in persisting, the previous next_segment as the
+        // new current_segment, and a brand new next_segment
+        let loaded_state = load_starting_state(
+            persister,
+            Some(wal),
+            Time::from_timestamp(6 * 60, 0).unwrap(),
+            SegmentDuration::new_5m(),
+        )
+        .await
+        .unwrap();
+
+        assert_eq!(loaded_state.persisting_buffer_segments.len(), 1);
+        let loaded_closed_segment = &loaded_state.persisting_buffer_segments[0];
+        assert_eq!(loaded_closed_segment.segment_id, closed_segment.segment_id);
+        assert_eq!(
+            loaded_closed_segment.catalog_end_sequence_number,
+            closed_segment.catalog_end_sequence_number
+        );
+        assert_eq!(
+            loaded_closed_segment.catalog_start_sequence_number,
+            closed_segment.catalog_start_sequence_number
+        );
+
+        loaded_closed_segment
+            .buffered_data
+            .verify_matches(&closed_segment.buffered_data, &catalog);
+
+        let db = loaded_state.catalog.db_schema(db_name).unwrap();
+        assert_eq!(db.tables.len(), 3);
+        assert!(db.tables.contains_key("cpu"));
+        assert!(db.tables.contains_key("mem"));
+        assert!(db.tables.contains_key("foo"));
+
+        let cpu_table = db.get_table("cpu").unwrap();
+        let cpu_data = loaded_state.open_segments[0]
+            .table_record_batches(db_name, "cpu", cpu_table.schema())
+            .unwrap();
+        let expected = [
+            "+------------------------------------------------------------------+-----+--------+--------------------------------+",
+            "| _series_id                                                       | bar | tag1   | time                           |",
+            "+------------------------------------------------------------------+-----+--------+--------------------------------+",
+            "| 82a59579ecb9ae1adf113fe3a09a2ebd61aa15f92c570d26278d3f1dfe8bcbd8 | 3.0 | apples | 1970-01-01T00:00:00.000000020Z |",
+            "+------------------------------------------------------------------+-----+--------+--------------------------------+",
+        ];
+        assert_batches_eq!(&expected, &cpu_data);
+
+        let foo_table = db.get_table("foo").unwrap();
+        let foo_data = loaded_state.open_segments[0]
+            .table_record_batches(db_name, "foo", foo_table.schema())
+            .unwrap();
+        let expected = [
+            "+------------------------------------------------------------------+--------------------------------+-----+",
+            "| _series_id                                                       | time                           | val |",
+            "+------------------------------------------------------------------+--------------------------------+-----+",
+            "| e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 | 1970-01-01T00:00:00.000000123Z | 1.0 |",
+            "+------------------------------------------------------------------+--------------------------------+-----+",
+        ];
+        assert_batches_eq!(&expected, &foo_data);
+
+        assert_eq!(loaded_state.last_segment_id, SegmentId::new(2));
+    }
+
+    #[tokio::test]
+    async fn loads_with_persisting_wal_file_and_no_open_segment() {
+        let object_store: Arc<dyn ObjectStore> = Arc::new(InMemory::new());
+        let persister = Arc::new(PersisterImpl::new(Arc::clone(&object_store)));
+        let dir = test_helpers::tmp_dir().unwrap().into_path();
+        let wal = Arc::new(WalImpl::new(dir.clone()).unwrap());
+
+        let LoadedState {
+            mut open_segments, ..
+        } = load_starting_state(
+            Arc::clone(&persister),
+            Some(Arc::clone(&wal)),
+            Time::from_timestamp_nanos(0),
+            SegmentDuration::new_5m(),
+        )
+        .await
+        .unwrap();
+
+        let current_segment = open_segments.pop().unwrap();
+        let segment_id = current_segment.segment_id();
+        let next_segment_id = segment_id.next();
+
+        let mut loaded_state = load_starting_state(
+            persister,
+            Some(wal),
+            Time::from_timestamp(360, 0).unwrap(),
+            SegmentDuration::new_5m(),
+        )
+        .await
+        .unwrap();
+
+        assert_eq!(
+            loaded_state
+                .persisting_buffer_segments
+                .pop()
+                .unwrap()
+                .segment_id,
+            segment_id
+        );
+        assert_eq!(
+            loaded_state.open_segments.pop().unwrap().segment_id(),
+            next_segment_id
+        );
+    }
+}
diff --git a/influxdb3_write/src/write_buffer/mod.rs b/influxdb3_write/src/write_buffer/mod.rs
new file mode 100644
index 00000000000..f44ed01a3bb
--- /dev/null
+++ b/influxdb3_write/src/write_buffer/mod.rs
@@ -0,0 +1,1263 @@
+//! Implementation of an in-memory buffer for writes that persists data into a wal if it is configured.
+
+pub(crate) mod buffer_segment;
+mod flusher;
+mod loader;
+mod segment_state;
+mod table_buffer;
+
+use crate::cache::ParquetCache;
+use crate::catalog::{
+    Catalog, DatabaseSchema, TableDefinition, SERIES_ID_COLUMN_NAME, TIME_COLUMN_NAME,
+};
+use crate::chunk::ParquetChunk;
+use crate::persister::PersisterImpl;
+use crate::write_buffer::flusher::WriteBufferFlusher;
+use crate::write_buffer::loader::load_starting_state;
+use crate::write_buffer::segment_state::{run_buffer_segment_persist_and_cleanup, SegmentState};
+use crate::{
+    BufferSegment, BufferedWriteRequest, Bufferer, ChunkContainer, LpWriteOp, Persister, Precision,
+    SegmentDuration, SegmentId, SequenceNumber, Wal, WalOp, WriteBuffer, WriteLineError,
+};
+use async_trait::async_trait;
+use data_types::{
+    column_type_from_field, ChunkId, ChunkOrder, ColumnType, NamespaceName, NamespaceNameError,
+};
+use datafusion::common::DataFusionError;
+use datafusion::execution::context::SessionState;
+use datafusion::logical_expr::Expr;
+use datafusion::physical_plan::SendableRecordBatchStream;
+use influxdb_line_protocol::{parse_lines, FieldValue, ParsedLine, Series, TagSet};
+use iox_query::chunk_statistics::create_chunk_statistics;
+use iox_query::QueryChunk;
+use iox_time::{Time, TimeProvider};
+use object_store::path::Path as ObjPath;
+use object_store::ObjectMeta;
+use observability_deps::tracing::{debug, error};
+use parking_lot::{Mutex, RwLock};
+use parquet_file::storage::ParquetExecInput;
+use sha2::Digest;
+use sha2::Sha256;
+use std::borrow::Cow;
+use std::collections::{BTreeMap, HashMap};
+use std::i64;
+use std::sync::{Arc, OnceLock};
+use thiserror::Error;
+use tokio::sync::watch;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("parsing for line protocol failed")]
+    ParseError(WriteLineError),
+
+    #[error("column type mismatch for column {name}: existing: {existing:?}, new: {new:?}")]
+    ColumnTypeMismatch {
+        name: String,
+        existing: ColumnType,
+        new: ColumnType,
+    },
+
+    #[error("catalog update erorr {0}")]
+    CatalogUpdateError(#[from] crate::catalog::Error),
+
+    #[error("error from wal: {0}")]
+    WalError(#[from] crate::wal::Error),
+
+    #[error("error from buffer segment: {0}")]
+    BufferSegmentError(String),
+
+    #[error("error from persister: {0}")]
+    PersisterError(#[from] crate::persister::Error),
+
+    #[error("corrupt load state: {0}")]
+    CorruptLoadState(String),
+
+    #[error("database name error: {0}")]
+    DatabaseNameError(#[from] NamespaceNameError),
+
+    #[error("walop in file {0} contained data for more than one segment, which is invalid")]
+    WalOpForMultipleSegments(String),
+}
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+#[derive(Debug)]
+pub struct WriteRequest<'a> {
+    pub db_name: NamespaceName<'static>,
+    pub line_protocol: &'a str,
+    pub default_time: u64,
+}
+
+#[derive(Debug)]
+pub struct WriteBufferImpl<W, T> {
+    catalog: Arc<Catalog>,
+    persister: Arc<PersisterImpl>,
+    parquet_cache: Arc<ParquetCache>,
+    segment_state: Arc<RwLock<SegmentState<T, W>>>,
+    wal: Option<Arc<W>>,
+    write_buffer_flusher: WriteBufferFlusher,
+    segment_duration: SegmentDuration,
+    #[allow(dead_code)]
+    time_provider: Arc<T>,
+    #[allow(dead_code)]
+    segment_persist_handle: Mutex<tokio::task::JoinHandle<()>>,
+    #[allow(dead_code)]
+    shutdown_segment_persist_tx: watch::Sender<()>,
+}
+
+impl<W: Wal, T: TimeProvider> WriteBufferImpl<W, T> {
+    pub async fn new(
+        persister: Arc<PersisterImpl>,
+        wal: Option<Arc<W>>,
+        time_provider: Arc<T>,
+        segment_duration: SegmentDuration,
+        executor: Arc<iox_query::exec::Executor>,
+    ) -> Result<Self> {
+        let now = time_provider.now();
+        let loaded_state =
+            load_starting_state(Arc::clone(&persister), wal.clone(), now, segment_duration).await?;
+
+        let segment_state = Arc::new(RwLock::new(SegmentState::new(
+            segment_duration,
+            loaded_state.last_segment_id,
+            Arc::clone(&loaded_state.catalog),
+            Arc::clone(&time_provider),
+            loaded_state.open_segments,
+            loaded_state.persisting_buffer_segments,
+            loaded_state.persisted_segments,
+            wal.clone(),
+        )));
+
+        let write_buffer_flusher = WriteBufferFlusher::new(Arc::clone(&segment_state));
+
+        let segment_state_persister = Arc::clone(&segment_state);
+        let time_provider_persister = Arc::clone(&time_provider);
+        let wal_perister = wal.clone();
+        let cloned_persister = Arc::clone(&persister);
+
+        let (shutdown_segment_persist_tx, shutdown_rx) = watch::channel(());
+        let segment_persist_handle = tokio::task::spawn(async move {
+            run_buffer_segment_persist_and_cleanup(
+                cloned_persister,
+                segment_state_persister,
+                shutdown_rx,
+                time_provider_persister,
+                wal_perister,
+                executor,
+            )
+            .await;
+        });
+
+        Ok(Self {
+            catalog: loaded_state.catalog,
+            segment_state,
+            parquet_cache: Arc::new(ParquetCache::new(&persister.mem_pool)),
+            persister,
+            wal,
+            write_buffer_flusher,
+            time_provider,
+            segment_duration,
+            segment_persist_handle: Mutex::new(segment_persist_handle),
+            shutdown_segment_persist_tx,
+        })
+    }
+
+    pub fn catalog(&self) -> Arc<Catalog> {
+        Arc::clone(&self.catalog)
+    }
+
+    async fn write_lp(
+        &self,
+        db_name: NamespaceName<'static>,
+        lp: &str,
+        ingest_time: Time,
+        accept_partial: bool,
+        precision: Precision,
+    ) -> Result<BufferedWriteRequest> {
+        debug!("write_lp to {} in writebuffer", db_name);
+
+        let result = parse_validate_and_update_catalog(
+            db_name.clone(),
+            lp,
+            &self.catalog,
+            ingest_time,
+            self.segment_duration,
+            accept_partial,
+            precision,
+        )?;
+
+        self.write_buffer_flusher
+            .write_to_open_segment(result.valid_segmented_data)
+            .await?;
+
+        Ok(BufferedWriteRequest {
+            db_name,
+            invalid_lines: result.errors,
+            line_count: result.line_count,
+            field_count: result.field_count,
+            tag_count: result.tag_count,
+        })
+    }
+
+    fn get_table_chunks(
+        &self,
+        database_name: &str,
+        table_name: &str,
+        filters: &[Expr],
+        projection: Option<&Vec<usize>>,
+        ctx: &SessionState,
+    ) -> Result<Vec<Arc<dyn QueryChunk>>, DataFusionError> {
+        let db_schema = self
+            .catalog
+            .db_schema(database_name)
+            .ok_or_else(|| DataFusionError::Execution(format!("db {} not found", database_name)))?;
+
+        let table_schema = {
+            let table = db_schema.tables.get(table_name).ok_or_else(|| {
+                DataFusionError::Execution(format!(
+                    "table {} not found in db {}",
+                    table_name, database_name
+                ))
+            })?;
+
+            table.schema.clone()
+        };
+
+        let segment_state = self.segment_state.read();
+        let mut chunks =
+            segment_state.get_table_chunks(db_schema, table_name, filters, projection, ctx)?;
+        let parquet_files = segment_state.get_parquet_files(database_name, table_name);
+
+        let mut chunk_order = chunks.len() as i64;
+        let object_store_url = self.persister.object_store_url();
+
+        for parquet_file in parquet_files {
+            // TODO: update persisted segments to serialize their key to use here
+            let partition_key = data_types::PartitionKey::from(parquet_file.path.clone());
+            let partition_id = data_types::partition::TransitionPartitionId::new(
+                data_types::TableId::new(0),
+                &partition_key,
+            );
+
+            let chunk_stats = create_chunk_statistics(
+                Some(parquet_file.row_count as usize),
+                &table_schema,
+                Some(parquet_file.timestamp_min_max()),
+                None,
+            );
+
+            let location = ObjPath::from(parquet_file.path.clone());
+
+            let parquet_exec = ParquetExecInput {
+                object_store_url: object_store_url.clone(),
+                object_meta: ObjectMeta {
+                    location,
+                    last_modified: Default::default(),
+                    size: parquet_file.size_bytes as usize,
+                    e_tag: None,
+                    version: None,
+                },
+                object_store: self.persister.object_store(),
+            };
+
+            let parquet_chunk = ParquetChunk {
+                schema: table_schema.clone(),
+                stats: Arc::new(chunk_stats),
+                partition_id,
+                sort_key: None,
+                id: ChunkId::new(),
+                chunk_order: ChunkOrder::new(chunk_order),
+                parquet_exec,
+            };
+
+            chunk_order += 1;
+
+            chunks.push(Arc::new(parquet_chunk));
+        }
+
+        // Get any cached files and add them to the query
+        // This is mostly the same as above, but we change the object store to
+        // point to the in memory cache
+        for parquet_file in self
+            .parquet_cache
+            .get_parquet_files(database_name, table_name)
+        {
+            let partition_key = data_types::PartitionKey::from(parquet_file.path.clone());
+            let partition_id = data_types::partition::TransitionPartitionId::new(
+                data_types::TableId::new(0),
+                &partition_key,
+            );
+
+            let chunk_stats = create_chunk_statistics(
+                Some(parquet_file.row_count as usize),
+                &table_schema,
+                Some(parquet_file.timestamp_min_max()),
+                None,
+            );
+
+            let location = ObjPath::from(parquet_file.path.clone());
+
+            let parquet_exec = ParquetExecInput {
+                object_store_url: object_store_url.clone(),
+                object_meta: ObjectMeta {
+                    location,
+                    last_modified: Default::default(),
+                    size: parquet_file.size_bytes as usize,
+                    e_tag: None,
+                    version: None,
+                },
+                object_store: Arc::clone(&self.parquet_cache.object_store()),
+            };
+
+            let parquet_chunk = ParquetChunk {
+                schema: table_schema.clone(),
+                stats: Arc::new(chunk_stats),
+                partition_id,
+                sort_key: None,
+                id: ChunkId::new(),
+                chunk_order: ChunkOrder::new(chunk_order),
+                parquet_exec,
+            };
+
+            chunk_order += 1;
+
+            chunks.push(Arc::new(parquet_chunk));
+        }
+
+        Ok(chunks)
+    }
+
+    pub async fn cache_parquet(
+        &self,
+        db_name: &str,
+        table_name: &str,
+        min_time: i64,
+        max_time: i64,
+        records: SendableRecordBatchStream,
+    ) -> Result<(), Error> {
+        Ok(self
+            .parquet_cache
+            .persist_parquet_file(db_name, table_name, min_time, max_time, records, None)
+            .await?)
+    }
+
+    pub async fn update_parquet(
+        &self,
+        db_name: &str,
+        table_name: &str,
+        min_time: i64,
+        max_time: i64,
+        path: ObjPath,
+        records: SendableRecordBatchStream,
+    ) -> Result<(), Error> {
+        Ok(self
+            .parquet_cache
+            .persist_parquet_file(db_name, table_name, min_time, max_time, records, Some(path))
+            .await?)
+    }
+
+    pub async fn remove_parquet(&self, path: ObjPath) -> Result<(), Error> {
+        Ok(self.parquet_cache.remove_parquet_file(path).await?)
+    }
+
+    pub async fn purge_cache(&self) -> Result<(), Error> {
+        Ok(self.parquet_cache.purge_cache().await?)
+    }
+
+    #[cfg(test)]
+    fn get_table_record_batches(
+        &self,
+        datbase_name: &str,
+        table_name: &str,
+    ) -> Vec<arrow::record_batch::RecordBatch> {
+        let db_schema = self.catalog.db_schema(datbase_name).unwrap();
+        let table = db_schema.tables.get(table_name).unwrap();
+        let schema = table.schema.clone();
+
+        let segment_state = self.segment_state.read();
+        segment_state.open_segments_table_record_batches(datbase_name, table_name, &schema)
+    }
+}
+
+#[async_trait]
+impl<W: Wal, T: TimeProvider> Bufferer for WriteBufferImpl<W, T> {
+    async fn write_lp(
+        &self,
+        database: NamespaceName<'static>,
+        lp: &str,
+        ingest_time: Time,
+        accept_partial: bool,
+        precision: Precision,
+    ) -> Result<BufferedWriteRequest> {
+        self.write_lp(database, lp, ingest_time, accept_partial, precision)
+            .await
+    }
+
+    async fn close_open_segment(&self) -> crate::Result<Arc<dyn BufferSegment>> {
+        todo!()
+    }
+
+    async fn load_segments_after(
+        &self,
+        _segment_id: SegmentId,
+        _catalog: Catalog,
+    ) -> crate::Result<Vec<Arc<dyn BufferSegment>>> {
+        todo!()
+    }
+
+    fn wal(&self) -> Option<Arc<impl Wal>> {
+        self.wal.clone()
+    }
+
+    fn catalog(&self) -> Arc<Catalog> {
+        self.catalog()
+    }
+}
+
+impl<W: Wal, T: TimeProvider> ChunkContainer for WriteBufferImpl<W, T> {
+    fn get_table_chunks(
+        &self,
+        database_name: &str,
+        table_name: &str,
+        filters: &[Expr],
+        projection: Option<&Vec<usize>>,
+        ctx: &SessionState,
+    ) -> crate::Result<Vec<Arc<dyn QueryChunk>>, DataFusionError> {
+        self.get_table_chunks(database_name, table_name, filters, projection, ctx)
+    }
+}
+
+impl<W: Wal, T: TimeProvider> WriteBuffer for WriteBufferImpl<W, T> {}
+
+/// Returns a validated result and the sequence number of the catalog before any updates were
+/// applied.
+pub(crate) fn parse_validate_and_update_catalog(
+    db_name: NamespaceName<'static>,
+    lp: &str,
+    catalog: &Catalog,
+    ingest_time: Time,
+    segment_duration: SegmentDuration,
+    accept_partial: bool,
+    precision: Precision,
+) -> Result<ValidationResult> {
+    let (sequence, db) = catalog.db_or_create(db_name.as_str())?;
+    let mut result = parse_validate_and_update_schema(
+        lp,
+        &db,
+        db_name,
+        ingest_time,
+        segment_duration,
+        accept_partial,
+        precision,
+        sequence,
+    )?;
+
+    if let Some(schema) = result.schema.take() {
+        debug!("replacing schema for {:?}", schema);
+
+        catalog.replace_database(sequence, Arc::new(schema))?;
+    }
+
+    Ok(result)
+}
+
+/// Takes &str of line protocol, parses lines, validates the schema, and inserts new columns
+/// if present. Assigns the default time to any lines that do not include a time
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn parse_validate_and_update_schema(
+    lp: &str,
+    schema: &DatabaseSchema,
+    db_name: NamespaceName<'static>,
+    ingest_time: Time,
+    segment_duration: SegmentDuration,
+    accept_partial: bool,
+    precision: Precision,
+    starting_catalog_sequence_number: SequenceNumber,
+) -> Result<ValidationResult> {
+    let mut errors = vec![];
+    let mut lp_lines = lp.lines();
+
+    let mut valid_parsed_and_raw_lines: Vec<(ParsedLine, &str)> = vec![];
+
+    for (line_idx, maybe_line) in parse_lines(lp).enumerate() {
+        let line = match maybe_line {
+            Ok(line) => line,
+            Err(e) => {
+                if !accept_partial {
+                    return Err(Error::ParseError(WriteLineError {
+                        // This unwrap is fine because we're moving line by line
+                        // alongside the output from parse_lines
+                        original_line: lp_lines.next().unwrap().to_string(),
+                        line_number: line_idx + 1,
+                        error_message: e.to_string(),
+                    }));
+                } else {
+                    errors.push(WriteLineError {
+                        original_line: lp_lines.next().unwrap().to_string(),
+                        // This unwrap is fine because we're moving line by line
+                        // alongside the output from parse_lines
+                        line_number: line_idx + 1,
+                        error_message: e.to_string(),
+                    });
+                }
+                continue;
+            }
+        };
+        // This unwrap is fine because we're moving line by line
+        // alongside the output from parse_lines
+        valid_parsed_and_raw_lines.push((line, lp_lines.next().unwrap()));
+    }
+
+    validate_or_insert_schema_and_partitions(
+        valid_parsed_and_raw_lines,
+        schema,
+        db_name,
+        ingest_time,
+        segment_duration,
+        precision,
+        starting_catalog_sequence_number,
+    )
+    .map(move |mut result| {
+        result.errors = errors;
+        result
+    })
+}
+
+/// Takes parsed lines, validates their schema. If new tables or columns are defined, they
+/// are passed back as a new DatabaseSchema as part of the ValidationResult. Lines are split
+/// into partitions and the validation result contains the data that can then be serialized
+/// into the WAL.
+pub(crate) fn validate_or_insert_schema_and_partitions(
+    lines: Vec<(ParsedLine<'_>, &str)>,
+    schema: &DatabaseSchema,
+    db_name: NamespaceName<'static>,
+    ingest_time: Time,
+    segment_duration: SegmentDuration,
+    precision: Precision,
+    starting_catalog_sequence_number: SequenceNumber,
+) -> Result<ValidationResult> {
+    // The (potentially updated) DatabaseSchema to return to the caller.
+    let mut schema = Cow::Borrowed(schema);
+
+    // The parsed and validated table_batches
+    let mut segment_table_batches: HashMap<Time, TableBatchMap> = HashMap::new();
+
+    let line_count = lines.len();
+    let mut field_count = 0;
+    let mut tag_count = 0;
+
+    for (line, raw_line) in lines.into_iter() {
+        field_count += line.field_set.len();
+        tag_count += line.series.tag_set.as_ref().map(|t| t.len()).unwrap_or(0);
+
+        validate_and_convert_parsed_line(
+            line,
+            raw_line,
+            &mut segment_table_batches,
+            &mut schema,
+            ingest_time,
+            segment_duration,
+            precision,
+        )?;
+    }
+
+    let schema = match schema {
+        Cow::Owned(s) => Some(s),
+        Cow::Borrowed(_) => None,
+    };
+
+    let valid_segmented_data = segment_table_batches
+        .into_iter()
+        .map(|(segment_start, table_batches)| ValidSegmentedData {
+            database_name: db_name.clone(),
+            segment_start,
+            table_batches: table_batches.table_batches,
+            wal_op: WalOp::LpWrite(LpWriteOp {
+                db_name: db_name.to_string(),
+                lp: table_batches.lines.join("\n"),
+                default_time: ingest_time.timestamp_nanos(),
+            }),
+            starting_catalog_sequence_number,
+        })
+        .collect();
+
+    Ok(ValidationResult {
+        schema,
+        line_count,
+        field_count,
+        tag_count,
+        errors: vec![],
+        valid_segmented_data,
+    })
+}
+
+/// Check if the table exists in the schema and update the schema if it does not
+// Because the entry API requires &mut it is not used to avoid a premature
+// clone of the Cow.
+fn validate_and_update_schema(line: &ParsedLine<'_>, schema: &mut Cow<'_, DatabaseSchema>) {
+    let table_name = line.series.measurement.as_str();
+    match schema.tables.get(table_name) {
+        Some(t) => {
+            // Collect new column definitions
+            let mut new_cols = Vec::with_capacity(line.column_count() + 1);
+            if let Some(tagset) = &line.series.tag_set {
+                for (tag_key, _) in tagset {
+                    if !t.column_exists(tag_key.as_str()) {
+                        new_cols.push((tag_key.to_string(), ColumnType::Tag as i16));
+                    }
+                }
+            }
+            for (field_name, value) in &line.field_set {
+                if !t.column_exists(field_name.as_str()) {
+                    new_cols.push((field_name.to_string(), column_type_from_field(value) as i16));
+                }
+            }
+
+            if !new_cols.is_empty() {
+                let t = schema.to_mut().tables.get_mut(table_name).unwrap();
+                t.add_columns(new_cols);
+            }
+        }
+        None => {
+            let mut columns = BTreeMap::new();
+            if let Some(tag_set) = &line.series.tag_set {
+                for (tag_key, _) in tag_set {
+                    columns.insert(tag_key.to_string(), ColumnType::Tag as i16);
+                }
+            }
+            for (field_name, value) in &line.field_set {
+                columns.insert(field_name.to_string(), column_type_from_field(value) as i16);
+            }
+
+            columns.insert(TIME_COLUMN_NAME.to_string(), ColumnType::Time as i16);
+            columns.insert(SERIES_ID_COLUMN_NAME.to_string(), ColumnType::String as i16);
+
+            let table = TableDefinition::new(table_name, columns);
+
+            assert!(schema
+                .to_mut()
+                .tables
+                .insert(table_name.to_string(), table)
+                .is_none());
+        }
+    };
+}
+
+fn validate_and_convert_parsed_line<'a>(
+    mut line: ParsedLine<'_>,
+    raw_line: &'a str,
+    segment_table_batches: &mut HashMap<Time, TableBatchMap<'a>>,
+    schema: &mut Cow<'_, DatabaseSchema>,
+    ingest_time: Time,
+    segment_duration: SegmentDuration,
+    precision: Precision,
+) -> Result<()> {
+    validate_and_update_schema(&line, schema);
+
+    // now that we've ensured all columns exist in the schema, construct the actual row and values
+    // while validating the column types match.
+    let mut values = Vec::with_capacity(line.column_count() + 1);
+
+    // generate _series_id from tag set
+    let series_id = hash_series_id(raw_line, &mut line.series);
+    let value = Field {
+        name: SERIES_ID_COLUMN_NAME.to_string(),
+        value: FieldData::String(series_id.to_string()),
+    };
+    values.push(value);
+
+    // validate tags, collecting any new ones that must be inserted, or adding the values
+    if let Some(tag_set) = line.series.tag_set {
+        for (tag_key, value) in tag_set {
+            let value = Field {
+                name: tag_key.to_string(),
+                value: FieldData::Tag(value.to_string()),
+            };
+            values.push(value);
+        }
+    }
+
+    // validate fields, collecting any new ones that must be inserted, or adding values
+    for (field_name, value) in line.field_set {
+        let field_data = match value {
+            FieldValue::I64(v) => FieldData::Integer(v),
+            FieldValue::F64(v) => FieldData::Float(v),
+            FieldValue::U64(v) => FieldData::UInteger(v),
+            FieldValue::Boolean(v) => FieldData::Boolean(v),
+            FieldValue::String(v) => FieldData::String(v.to_string()),
+        };
+        let value = Field {
+            name: field_name.to_string(),
+            value: field_data,
+        };
+        values.push(value);
+    }
+
+    // set the time value
+    let time_value_nanos = line
+        .timestamp
+        .map(|ts| {
+            let multiplier = match precision {
+                Precision::Auto => match crate::guess_precision(ts) {
+                    Precision::Second => 1_000_000_000,
+                    Precision::Millisecond => 1_000_000,
+                    Precision::Microsecond => 1_000,
+                    Precision::Nanosecond => 1,
+
+                    Precision::Auto => unreachable!(),
+                },
+                Precision::Second => 1_000_000_000,
+                Precision::Millisecond => 1_000_000,
+                Precision::Microsecond => 1_000,
+                Precision::Nanosecond => 1,
+            };
+
+            ts * multiplier
+        })
+        .unwrap_or(ingest_time.timestamp_nanos());
+
+    let segment_start = segment_duration.start_time(time_value_nanos / 1_000_000_000);
+
+    values.push(Field {
+        name: TIME_COLUMN_NAME.to_string(),
+        value: FieldData::Timestamp(time_value_nanos),
+    });
+
+    let table_batch_map = segment_table_batches.entry(segment_start).or_default();
+
+    let table_batch = table_batch_map
+        .table_batches
+        .entry(line.series.measurement.to_string())
+        .or_default();
+    table_batch.rows.push(Row {
+        time: time_value_nanos,
+        fields: values,
+    });
+
+    table_batch_map.lines.push(raw_line);
+
+    Ok(())
+}
+
+#[derive(Debug, Default)]
+pub(crate) struct TableBatch {
+    #[allow(dead_code)]
+    pub(crate) name: String,
+    pub(crate) rows: Vec<Row>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct Row {
+    pub(crate) time: i64,
+    pub(crate) fields: Vec<Field>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct Field {
+    pub(crate) name: String,
+    pub(crate) value: FieldData,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) enum FieldData {
+    Timestamp(i64),
+    Tag(String),
+    String(String),
+    Integer(i64),
+    UInteger(u64),
+    Float(f64),
+    Boolean(bool),
+}
+
+impl PartialEq for FieldData {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (FieldData::Timestamp(a), FieldData::Timestamp(b)) => a == b,
+            (FieldData::Tag(a), FieldData::Tag(b)) => a == b,
+            (FieldData::String(a), FieldData::String(b)) => a == b,
+            (FieldData::Integer(a), FieldData::Integer(b)) => a == b,
+            (FieldData::UInteger(a), FieldData::UInteger(b)) => a == b,
+            (FieldData::Float(a), FieldData::Float(b)) => a == b,
+            (FieldData::Boolean(a), FieldData::Boolean(b)) => a == b,
+            _ => false,
+        }
+    }
+}
+
+impl Eq for FieldData {}
+
+/// Result of the validation. If the NamespaceSchema or PartitionMap were updated, they will be
+/// in the result.
+#[derive(Debug, Default)]
+#[allow(dead_code)]
+pub(crate) struct ValidationResult {
+    /// If the namespace schema is updated with new tables or columns it will be here, which
+    /// can be used to update the cache.
+    pub(crate) schema: Option<DatabaseSchema>,
+    /// Number of lines passed in
+    pub(crate) line_count: usize,
+    /// Number of fields passed in
+    pub(crate) field_count: usize,
+    /// Number of tags passed in
+    pub(crate) tag_count: usize,
+    /// Any errors that occurred while parsing the lines
+    pub(crate) errors: Vec<crate::WriteLineError>,
+    /// Only valid lines from what was passed in to validate, segmented based on the
+    /// timestamps of the data.
+    pub(crate) valid_segmented_data: Vec<ValidSegmentedData>,
+}
+
+#[derive(Debug)]
+pub(crate) struct ValidSegmentedData {
+    pub(crate) database_name: NamespaceName<'static>,
+    pub(crate) segment_start: Time,
+    pub(crate) table_batches: HashMap<String, TableBatch>,
+    pub(crate) wal_op: WalOp,
+    /// The sequence number of the catalog before any updates were applied based on this write.
+    pub(crate) starting_catalog_sequence_number: SequenceNumber,
+}
+
+#[derive(Debug, Default)]
+pub(crate) struct TableBatchMap<'a> {
+    pub(crate) lines: Vec<&'a str>,
+    pub(crate) table_batches: HashMap<String, TableBatch>,
+}
+
+/// The 32 byte SHA256 digest of the full tag set for a line of measurement data
+#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]
+pub struct SeriesId([u8; 32]);
+
+impl std::fmt::Display for SeriesId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", hex::encode(self.0))
+    }
+}
+
+fn default_series_sha() -> &'static [u8; 32] {
+    static DEFAULT_SERIES_ID_SHA: OnceLock<[u8; 32]> = OnceLock::new();
+    // the unwrap is safe here because the Sha256 digest will always be 32 bytes:
+    DEFAULT_SERIES_ID_SHA.get_or_init(|| Sha256::digest("")[..].try_into().unwrap())
+}
+
+impl Default for SeriesId {
+    fn default() -> Self {
+        Self(default_series_sha().to_owned())
+    }
+}
+
+/// Produce a [`SeriesId`] from a raw line of line protocol / parsed [`Series`]
+///
+/// If the tag set is sorted, we parse out the original tags from the raw line
+/// protocol, instead of formatting a new string.
+///
+/// If the tags are not sorted, then we need to sort them, and allocate a new
+/// string to format them in the original 'key=val,key=val` form.
+///
+/// Generally, InfluxDB clients should be sending tags sorted.
+fn hash_series_id(raw_line: &str, series: &mut Series) -> SeriesId {
+    if let Some(tag_set) = &mut series.tag_set {
+        let bytes = if is_sorted(tag_set) {
+            // extract the raw string; if we are here, then the following `expect`s should
+            // never panic, there should be a tag set in the raw line protocol
+            let tag_set_str = raw_line
+                .split_once(',')
+                .expect("raw line protocol contains comma separating measurement from tag set")
+                .1
+                .split_once(' ')
+                .expect("raw line protocol contains tag set followed by space")
+                .0;
+            Sha256::digest(tag_set_str)
+        } else {
+            // sort the tag set and format as string, unstable sorting is fine because
+            // there should never be two tag keys of the same value
+            tag_set.sort_unstable_by(|(a, _), (b, _)| a.cmp(b));
+            let tag_set_str = tag_set
+                .iter()
+                .map(|(k, v)| format!("{k}={v}"))
+                .collect::<Vec<String>>()
+                .join(",");
+            Sha256::digest(tag_set_str)
+        };
+        // The Sha256 digests will produce 32 byte arrays, so the unwrap here is safe
+        SeriesId(bytes[..].try_into().unwrap())
+    } else {
+        // for an empty tag set, we still need a series ID:
+        SeriesId::default()
+    }
+}
+
+/// Check that a [`TagSet`], as a slice, is sorted
+fn is_sorted(tag_set: &TagSet) -> bool {
+    tag_set.windows(2).all(|w| w[0].0 <= w[1].0)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::persister::PersisterImpl;
+    use crate::wal::WalImpl;
+    use crate::{SequenceNumber, WalOpBatch};
+    use arrow::record_batch::RecordBatch;
+    use arrow_util::assert_batches_eq;
+    use datafusion_util::config::register_iox_object_store;
+    use iox_query::exec::IOxSessionContext;
+    use iox_time::{MockProvider, Time};
+    use object_store::memory::InMemory;
+    use object_store::ObjectStore;
+
+    #[test]
+    fn parse_lp_into_buffer() {
+        let db = Arc::new(DatabaseSchema::new("foo"));
+        let db_name = NamespaceName::new("foo").unwrap();
+        let lp = "cpu,region=west user=23.2 100\nfoo f1=1i";
+        let result = parse_validate_and_update_schema(
+            lp,
+            &db,
+            db_name,
+            Time::from_timestamp_nanos(0),
+            SegmentDuration::new_5m(),
+            false,
+            Precision::Nanosecond,
+            SequenceNumber::new(0),
+        )
+        .unwrap();
+
+        let db = result.schema.unwrap();
+
+        assert_eq!(db.tables.len(), 2);
+        assert_eq!(db.tables.get("cpu").unwrap().columns().len(), 4);
+        assert_eq!(db.tables.get("foo").unwrap().columns().len(), 3);
+    }
+
+    #[tokio::test]
+    async fn buffers_and_persists_to_wal() {
+        let dir = test_helpers::tmp_dir().unwrap().into_path();
+        let wal = WalImpl::new(dir.clone()).unwrap();
+        let object_store: Arc<dyn ObjectStore> = Arc::new(InMemory::new());
+        let persister = Arc::new(PersisterImpl::new(Arc::clone(&object_store)));
+        let time_provider = Arc::new(MockProvider::new(Time::from_timestamp_nanos(0)));
+        let segment_duration = SegmentDuration::new_5m();
+        let write_buffer = WriteBufferImpl::new(
+            Arc::clone(&persister),
+            Some(Arc::new(wal)),
+            Arc::clone(&time_provider),
+            segment_duration,
+            crate::test_help::make_exec(),
+        )
+        .await
+        .unwrap();
+
+        let summary = write_buffer
+            .write_lp(
+                NamespaceName::new("foo").unwrap(),
+                "cpu bar=1 10",
+                Time::from_timestamp_nanos(123),
+                false,
+                Precision::Nanosecond,
+            )
+            .await
+            .unwrap();
+        assert_eq!(summary.line_count, 1);
+        assert_eq!(summary.field_count, 1);
+        assert_eq!(summary.tag_count, 0);
+
+        // ensure the data is in the buffer
+        let actual = write_buffer.get_table_record_batches("foo", "cpu");
+        let expected = [
+            "+------------------------------------------------------------------+-----+--------------------------------+",
+            "| _series_id                                                       | bar | time                           |",
+            "+------------------------------------------------------------------+-----+--------------------------------+",
+            "| e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 | 1.0 | 1970-01-01T00:00:00.000000010Z |",
+            "+------------------------------------------------------------------+-----+--------------------------------+",
+        ];
+        assert_batches_eq!(&expected, &actual);
+
+        // ensure the data is in the wal
+        let wal = WalImpl::new(dir).unwrap();
+        let mut reader = wal.open_segment_reader(SegmentId::new(1)).unwrap();
+        let batch = reader.next_batch().unwrap().unwrap();
+        let expected_batch = WalOpBatch {
+            sequence_number: SequenceNumber::new(1),
+            ops: vec![WalOp::LpWrite(LpWriteOp {
+                db_name: "foo".to_string(),
+                lp: "cpu bar=1 10".to_string(),
+                default_time: 123,
+            })],
+        };
+        assert_eq!(batch, expected_batch);
+
+        // ensure we load state from the persister
+        let write_buffer = WriteBufferImpl::new(
+            persister,
+            Some(Arc::new(wal)),
+            time_provider,
+            segment_duration,
+            crate::test_help::make_exec(),
+        )
+        .await
+        .unwrap();
+        let actual = write_buffer.get_table_record_batches("foo", "cpu");
+        assert_batches_eq!(&expected, &actual);
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn returns_chunks_across_buffered_persisted_and_persisting_data() {
+        let dir = test_helpers::tmp_dir().unwrap().into_path();
+        let wal = Some(Arc::new(WalImpl::new(dir.clone()).unwrap()));
+        let object_store: Arc<dyn ObjectStore> = Arc::new(InMemory::new());
+        let persister = Arc::new(PersisterImpl::new(Arc::clone(&object_store)));
+        let time_provider = Arc::new(MockProvider::new(Time::from_timestamp_nanos(0)));
+        let segment_duration = SegmentDuration::new_5m();
+        let write_buffer = WriteBufferImpl::new(
+            Arc::clone(&persister),
+            wal.clone(),
+            Arc::clone(&time_provider),
+            segment_duration,
+            crate::test_help::make_exec(),
+        )
+        .await
+        .unwrap();
+        let session_context = IOxSessionContext::with_testing();
+        let runtime_env = session_context.inner().runtime_env();
+        register_iox_object_store(runtime_env, "influxdb3", Arc::clone(&object_store));
+
+        let _ = write_buffer
+            .write_lp(
+                NamespaceName::new("foo").unwrap(),
+                "cpu bar=1 10",
+                Time::from_timestamp_nanos(123),
+                false,
+                Precision::Nanosecond,
+            )
+            .await
+            .unwrap();
+
+        let expected = [
+            "+------------------------------------------------------------------+-----+--------------------------------+",
+            "| _series_id                                                       | bar | time                           |",
+            "+------------------------------------------------------------------+-----+--------------------------------+",
+            "| e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 | 1.0 | 1970-01-01T00:00:00.000000010Z |",
+            "+------------------------------------------------------------------+-----+--------------------------------+",
+        ];
+        let actual = get_table_batches(&write_buffer, "foo", "cpu", &session_context).await;
+        assert_batches_eq!(&expected, &actual);
+
+        // advance the time and wait for it to persist
+        time_provider.set(Time::from_timestamp(800, 0).unwrap());
+        loop {
+            let segment_state = write_buffer.segment_state.read();
+            if !segment_state.persisted_segments().is_empty() {
+                break;
+            }
+        }
+
+        // nothing should be open at this point
+        assert!(write_buffer
+            .segment_state
+            .read()
+            .open_segment_times()
+            .is_empty());
+
+        // verify we get the persisted data
+        let actual = get_table_batches(&write_buffer, "foo", "cpu", &session_context).await;
+        assert_batches_eq!(&expected, &actual);
+
+        // now write some into the next segment we're in and verify we get both buffer and persisted
+        let _ = write_buffer
+            .write_lp(
+                NamespaceName::new("foo").unwrap(),
+                "cpu bar=2",
+                Time::from_timestamp(900, 0).unwrap(),
+                false,
+                Precision::Nanosecond,
+            )
+            .await
+            .unwrap();
+        let expected = [
+            "+------------------------------------------------------------------+-----+--------------------------------+",
+            "| _series_id                                                       | bar | time                           |",
+            "+------------------------------------------------------------------+-----+--------------------------------+",
+            "| e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 | 2.0 | 1970-01-01T00:15:00Z           |",
+            "| e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 | 1.0 | 1970-01-01T00:00:00.000000010Z |",
+            "+------------------------------------------------------------------+-----+--------------------------------+",
+        ];
+        let actual = get_table_batches(&write_buffer, "foo", "cpu", &session_context).await;
+        assert_batches_eq!(&expected, &actual);
+
+        // and now reload the buffer and verify that we get persisted and the buffer again
+        let write_buffer = WriteBufferImpl::new(
+            Arc::clone(&persister),
+            wal,
+            Arc::clone(&time_provider),
+            segment_duration,
+            crate::test_help::make_exec(),
+        )
+        .await
+        .unwrap();
+        let actual = get_table_batches(&write_buffer, "foo", "cpu", &session_context).await;
+        assert_batches_eq!(&expected, &actual);
+
+        // and now add to the buffer and verify that we still only get two chunks
+        let _ = write_buffer
+            .write_lp(
+                NamespaceName::new("foo").unwrap(),
+                "cpu bar=3",
+                Time::from_timestamp(950, 0).unwrap(),
+                false,
+                Precision::Nanosecond,
+            )
+            .await
+            .unwrap();
+        let expected = [
+            "+------------------------------------------------------------------+-----+--------------------------------+",
+            "| _series_id                                                       | bar | time                           |",
+            "+------------------------------------------------------------------+-----+--------------------------------+",
+            "| e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 | 2.0 | 1970-01-01T00:15:00Z           |",
+            "| e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 | 3.0 | 1970-01-01T00:15:50Z           |",
+            "| e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 | 1.0 | 1970-01-01T00:00:00.000000010Z |",
+            "+------------------------------------------------------------------+-----+--------------------------------+",
+        ];
+        let actual = get_table_batches(&write_buffer, "foo", "cpu", &session_context).await;
+        assert_batches_eq!(&expected, &actual);
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn sets_starting_catalog_number_on_new_segment() {
+        let dir = test_helpers::tmp_dir().unwrap().into_path();
+        let wal = Some(Arc::new(WalImpl::new(dir.clone()).unwrap()));
+        let object_store: Arc<dyn ObjectStore> = Arc::new(InMemory::new());
+        let persister = Arc::new(PersisterImpl::new(Arc::clone(&object_store)));
+        let time_provider = Arc::new(MockProvider::new(Time::from_timestamp_nanos(0)));
+        let segment_duration = SegmentDuration::new_5m();
+        let write_buffer = WriteBufferImpl::new(
+            Arc::clone(&persister),
+            wal.clone(),
+            Arc::clone(&time_provider),
+            segment_duration,
+            crate::test_help::make_exec(),
+        )
+        .await
+        .unwrap();
+        let starting_catalog_sequence_number = write_buffer.catalog().sequence_number();
+
+        let session_context = IOxSessionContext::with_testing();
+        let runtime_env = session_context.inner().runtime_env();
+        register_iox_object_store(runtime_env, "influxdb3", Arc::clone(&object_store));
+
+        // write data into the buffer that will go into a new segment
+        let new_segment_time = Time::from_timestamp(360, 0).unwrap();
+        let _ = write_buffer
+            .write_lp(
+                NamespaceName::new("foo").unwrap(),
+                "cpu bar=1",
+                new_segment_time,
+                false,
+                Precision::Nanosecond,
+            )
+            .await
+            .unwrap();
+
+        let expected = [
+            "+------------------------------------------------------------------+-----+----------------------+",
+            "| _series_id                                                       | bar | time                 |",
+            "+------------------------------------------------------------------+-----+----------------------+",
+            "| e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 | 1.0 | 1970-01-01T00:06:00Z |",
+            "+------------------------------------------------------------------+-----+----------------------+",
+        ];
+        let actual = get_table_batches(&write_buffer, "foo", "cpu", &session_context).await;
+        assert_batches_eq!(&expected, &actual);
+
+        // get the segment for the new_segment_time and validate that it has the correct starting catalog sequence number
+        let state = write_buffer.segment_state.read();
+        let segment_start_time = SegmentDuration::new_5m().start_time(new_segment_time.timestamp());
+        let segment = state.segment_for_time(segment_start_time).unwrap();
+        assert_eq!(
+            segment.starting_catalog_sequence_number(),
+            starting_catalog_sequence_number
+        );
+    }
+
+    async fn get_table_batches(
+        write_buffer: &WriteBufferImpl<WalImpl, MockProvider>,
+        database_name: &str,
+        table_name: &str,
+        ctx: &IOxSessionContext,
+    ) -> Vec<RecordBatch> {
+        let chunks = write_buffer
+            .get_table_chunks(database_name, table_name, &[], None, &ctx.inner().state())
+            .unwrap();
+        let mut batches = vec![];
+        for chunk in chunks {
+            let chunk = chunk
+                .data()
+                .read_to_batches(chunk.schema(), ctx.inner())
+                .await;
+            batches.extend(chunk);
+        }
+        batches
+    }
+
+    /// Parse the series from a line of line protocol
+    macro_rules! parse_series {
+        ($line:expr) => {
+            parse_lines($line)
+                .collect::<Result<Vec<ParsedLine<'_>>, _>>()
+                .expect("parse lines")
+                .pop()
+                .expect("there is at least one line")
+                .series
+        };
+    }
+
+    /// Parse the tag set from a line of line protocol
+    macro_rules! parse_tag_set {
+        ($line:expr) => {
+            parse_series!($line).tag_set.expect("has a tag set")
+        };
+    }
+
+    #[test]
+    fn tag_set_is_sorted() {
+        assert!(is_sorted(&parse_tag_set!("cpu,a=_ foo=1")));
+        assert!(is_sorted(&parse_tag_set!("cpu,a=_,b=_ foo=1")));
+        assert!(!is_sorted(&parse_tag_set!("cpu,b=_,a=_ foo=1")));
+        assert!(is_sorted(&parse_tag_set!("cpu,a=_,b=_,c=_ foo=1")));
+        assert!(!is_sorted(&parse_tag_set!("cpu,a=_,c=_,b=_ foo=1")));
+        assert!(!is_sorted(&parse_tag_set!("cpu,b=_,a=_,c=_ foo=1")));
+        assert!(!is_sorted(&parse_tag_set!("cpu,c=_,b=_,a=_ foo=1")));
+    }
+
+    #[test]
+    fn series_ids() {
+        let raw_line_1 = "cpu,a=1,b=2 foo=1";
+        let mut series_1 = parse_series!(raw_line_1);
+        let series_id_1 = hash_series_id(raw_line_1, &mut series_1);
+        // check that we have a hash:
+        assert_eq!(
+            "06beefe2b477ff1d0fe92dfa45128217630672abff564dc7746f106833d3fc7a",
+            series_id_1.to_string()
+        );
+        // create another line that has the same tag values, but they are not
+        // in the same order:
+        let raw_line_2 = "cpu,b=2,a=1 foo=1";
+        let mut series_2 = parse_series!(raw_line_2);
+        let series_id_2 = hash_series_id(raw_line_2, &mut series_2);
+        // this and the previous series IDs should be equal:
+        assert_eq!(series_id_1, series_id_2);
+        // create a third with different tag values:
+        let raw_line_3 = "cpu,a=2,b=1 foo=1";
+        let mut series_3 = parse_series!(raw_line_3);
+        let series_id_3 = hash_series_id(raw_line_3, &mut series_3);
+        // the third should not be equal with either of the first two:
+        assert_ne!(series_id_1, series_id_3);
+        assert_ne!(series_id_2, series_id_3);
+        // produce series ID for empty tag set:
+        let raw_line_4 = "cpu foo=1";
+        let mut series_4 = parse_series!(raw_line_4);
+        let series_id_4 = hash_series_id(raw_line_4, &mut series_4);
+        assert_eq!(
+            "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+            series_id_4.to_string()
+        );
+    }
+}
diff --git a/influxdb3_write/src/write_buffer/segment_state.rs b/influxdb3_write/src/write_buffer/segment_state.rs
new file mode 100644
index 00000000000..d783c00b796
--- /dev/null
+++ b/influxdb3_write/src/write_buffer/segment_state.rs
@@ -0,0 +1,671 @@
+//! State for the write buffer segments.
+
+use crate::catalog::{Catalog, DatabaseSchema};
+use crate::chunk::BufferChunk;
+use crate::wal::WalSegmentWriterNoopImpl;
+use crate::write_buffer::buffer_segment::{ClosedBufferSegment, OpenBufferSegment, WriteBatch};
+use crate::{
+    persister, wal, write_buffer, ParquetFile, PersistedSegment, Persister, SegmentDuration,
+    SegmentId, SegmentRange, SequenceNumber, Wal, WalOp,
+};
+#[cfg(test)]
+use arrow::record_batch::RecordBatch;
+use data_types::{ChunkId, ChunkOrder, TableId, TransitionPartitionId};
+use datafusion::common::DataFusionError;
+use datafusion::execution::context::SessionState;
+use datafusion::logical_expr::Expr;
+use iox_query::chunk_statistics::create_chunk_statistics;
+use iox_query::QueryChunk;
+use iox_time::{Time, TimeProvider};
+use observability_deps::tracing::error;
+use parking_lot::RwLock;
+#[cfg(test)]
+use schema::Schema;
+use std::collections::BTreeMap;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::watch;
+
+// The maximum number of open segments that can be open at any one time. Each one of these will
+// have an open wal file and a buffer segment in memory.
+const OPEN_SEGMENT_LIMIT: usize = 100;
+
+#[derive(Debug)]
+pub(crate) struct SegmentState<T, W> {
+    segment_duration: SegmentDuration,
+    last_segment_id: SegmentId,
+    catalog: Arc<Catalog>,
+    wal: Option<Arc<W>>,
+    time_provider: Arc<T>,
+    // Map of segment start times to open segments. Should always have a segment open for the
+    // start time that time.now falls into.
+    segments: BTreeMap<Time, OpenBufferSegment>,
+    persisting_segments: BTreeMap<Time, Arc<ClosedBufferSegment>>,
+    persisted_segments: BTreeMap<Time, Arc<PersistedSegment>>,
+}
+
+impl<T: TimeProvider, W: Wal> SegmentState<T, W> {
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn new(
+        segment_duration: SegmentDuration,
+        last_segment_id: SegmentId,
+        catalog: Arc<Catalog>,
+        time_provider: Arc<T>,
+        open_segments: Vec<OpenBufferSegment>,
+        persisting_segments: Vec<ClosedBufferSegment>,
+        persisted_segments: Vec<PersistedSegment>,
+        wal: Option<Arc<W>>,
+    ) -> Self {
+        let mut segments = BTreeMap::new();
+        for segment in open_segments {
+            segments.insert(segment.segment_range().start_time, segment);
+        }
+
+        let mut persisting_segments_map = BTreeMap::new();
+        for segment in persisting_segments {
+            persisting_segments_map.insert(segment.segment_range.start_time, Arc::new(segment));
+        }
+
+        let mut persisted_segments_map = BTreeMap::new();
+        for segment in persisted_segments {
+            persisted_segments_map.insert(
+                Time::from_timestamp_nanos(segment.segment_min_time),
+                Arc::new(segment),
+            );
+        }
+
+        Self {
+            segment_duration,
+            last_segment_id,
+            catalog,
+            time_provider,
+            wal,
+            segments,
+            persisting_segments: persisting_segments_map,
+            persisted_segments: persisted_segments_map,
+        }
+    }
+
+    pub(crate) fn write_ops_to_segment(
+        &mut self,
+        segment_start: Time,
+        ops: Vec<WalOp>,
+        starting_catalog_sequence_number: SequenceNumber,
+    ) -> wal::Result<()> {
+        let segment =
+            self.get_or_create_segment_for_time(segment_start, starting_catalog_sequence_number)?;
+        segment.write_wal_ops(ops)
+    }
+
+    pub(crate) fn write_batch_to_segment(
+        &mut self,
+        segment_start: Time,
+        write_batch: WriteBatch,
+        starting_catalog_sequence_number: SequenceNumber,
+    ) -> crate::write_buffer::Result<()> {
+        let segment =
+            self.get_or_create_segment_for_time(segment_start, starting_catalog_sequence_number)?;
+        segment.buffer_writes(write_batch)
+    }
+
+    pub(crate) fn get_table_chunks(
+        &self,
+        db_schema: Arc<DatabaseSchema>,
+        table_name: &str,
+        _filters: &[Expr],
+        _projection: Option<&Vec<usize>>,
+        _ctx: &SessionState,
+    ) -> Result<Vec<Arc<dyn QueryChunk>>, DataFusionError> {
+        let table = db_schema
+            .tables
+            .get(table_name)
+            .ok_or_else(|| DataFusionError::Execution(format!("table {} not found", table_name)))?;
+        let schema = table.schema.clone();
+
+        let mut chunks: Vec<Arc<dyn QueryChunk>> = vec![];
+
+        for segment in self.segments.values() {
+            if let Some(batches) =
+                segment.table_record_batches(&db_schema.name, table_name, &schema)
+            {
+                let row_count = batches.iter().map(|b| b.num_rows()).sum();
+
+                let chunk_stats = create_chunk_statistics(
+                    Some(row_count),
+                    &schema,
+                    Some(segment.segment_range().timestamp_min_max()),
+                    None,
+                );
+
+                chunks.push(Arc::new(BufferChunk {
+                    batches,
+                    schema: schema.clone(),
+                    stats: Arc::new(chunk_stats),
+                    partition_id: TransitionPartitionId::new(
+                        TableId::new(0),
+                        segment.segment_key(),
+                    ),
+                    sort_key: None,
+                    id: ChunkId::new(),
+                    chunk_order: ChunkOrder::new(
+                        chunks
+                            .len()
+                            .try_into()
+                            .expect("should never have this many chunks"),
+                    ),
+                }));
+            }
+        }
+
+        for persisting_segment in self.persisting_segments.values() {
+            if let Some(batches) = persisting_segment.buffered_data.table_record_batches(
+                &db_schema.name,
+                table_name,
+                &schema,
+            ) {
+                let row_count = batches.iter().map(|b| b.num_rows()).sum();
+
+                let chunk_stats = create_chunk_statistics(
+                    Some(row_count),
+                    &schema,
+                    Some(persisting_segment.segment_range.timestamp_min_max()),
+                    None,
+                );
+
+                chunks.push(Arc::new(BufferChunk {
+                    batches,
+                    schema: schema.clone(),
+                    stats: Arc::new(chunk_stats),
+                    partition_id: TransitionPartitionId::new(
+                        TableId::new(0),
+                        &persisting_segment.segment_key,
+                    ),
+                    sort_key: None,
+                    id: ChunkId::new(),
+                    chunk_order: ChunkOrder::new(
+                        chunks
+                            .len()
+                            .try_into()
+                            .expect("should never have this many chunks"),
+                    ),
+                }));
+            }
+        }
+
+        Ok(chunks)
+    }
+
+    pub(crate) fn get_parquet_files(
+        &self,
+        database_name: &str,
+        table_name: &str,
+    ) -> Vec<ParquetFile> {
+        let mut parquet_files = vec![];
+
+        for segment in self.persisted_segments.values() {
+            segment.databases.get(database_name).map(|db| {
+                db.tables.get(table_name).map(|table| {
+                    parquet_files.extend(table.parquet_files.clone());
+                })
+            });
+        }
+
+        parquet_files
+    }
+
+    #[cfg(test)]
+    pub(crate) fn persisted_segments(&self) -> Vec<Arc<PersistedSegment>> {
+        self.persisted_segments.values().cloned().collect()
+    }
+
+    #[cfg(test)]
+    pub(crate) fn open_segment_times(&self) -> Vec<Time> {
+        self.segments.keys().cloned().collect()
+    }
+
+    #[cfg(test)]
+    pub(crate) fn open_segments_table_record_batches(
+        &self,
+        db_name: &str,
+        table_name: &str,
+        schema: &Schema,
+    ) -> Vec<RecordBatch> {
+        self.segments
+            .values()
+            .filter_map(|segment| segment.table_record_batches(db_name, table_name, schema))
+            .flatten()
+            .collect()
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn segment_for_time(&self, time: Time) -> Option<&OpenBufferSegment> {
+        self.segments.get(&time)
+    }
+
+    // Looks at the open buffer segments and returns the start `Time` of any that meet the following
+    // criteria (in time ascending order):
+    // 1. The segment is not in the current time or next time
+    // 2. The segment has been open for longer than half the segment duration
+    fn segments_to_persist(&self, current_time: Time) -> Vec<Time> {
+        let mut segments_to_persist = vec![];
+
+        for (start_time, segment) in &self.segments {
+            if segment.should_persist(current_time) {
+                segments_to_persist.push(*start_time);
+            }
+        }
+
+        segments_to_persist.sort();
+        segments_to_persist
+    }
+
+    fn close_segment(&mut self, segment_start: Time) -> Option<Arc<ClosedBufferSegment>> {
+        self.segments.remove(&segment_start).map(|segment| {
+            let closed_segment = Arc::new(segment.into_closed_segment(Arc::clone(&self.catalog)));
+
+            self.persisting_segments
+                .insert(segment_start, Arc::clone(&closed_segment));
+
+            closed_segment
+        })
+    }
+
+    // return the segment with this start time or open up a new one if it isn't currently open.
+    fn get_or_create_segment_for_time(
+        &mut self,
+        time: Time,
+        starting_catalog_sequence_number: SequenceNumber,
+    ) -> wal::Result<&mut OpenBufferSegment> {
+        if !self.segments.contains_key(&time) {
+            if self.segments.len() >= OPEN_SEGMENT_LIMIT {
+                return Err(wal::Error::OpenSegmentLimitReached(OPEN_SEGMENT_LIMIT));
+            }
+
+            self.last_segment_id = self.last_segment_id.next();
+            let segment_id = self.last_segment_id;
+            let segment_range =
+                SegmentRange::from_time_and_duration(time, self.segment_duration, false);
+
+            let segment_writer = match &self.wal {
+                Some(wal) => wal.new_segment_writer(segment_id, segment_range)?,
+                None => Box::new(WalSegmentWriterNoopImpl::new(segment_id)),
+            };
+
+            let segment = OpenBufferSegment::new(
+                segment_id,
+                segment_range,
+                self.time_provider.now(),
+                starting_catalog_sequence_number,
+                segment_writer,
+                None,
+            );
+            self.segments.insert(time, segment);
+        }
+
+        Ok(self.segments.get_mut(&time).unwrap())
+    }
+}
+
+#[cfg(test)]
+const PERSISTER_CHECK_INTERVAL: Duration = Duration::from_millis(10);
+
+#[cfg(not(test))]
+const PERSISTER_CHECK_INTERVAL: Duration = Duration::from_secs(1);
+
+pub(crate) async fn run_buffer_segment_persist_and_cleanup<P, T, W>(
+    persister: Arc<P>,
+    segment_state: Arc<RwLock<SegmentState<T, W>>>,
+    mut shutdown_rx: watch::Receiver<()>,
+    time_provider: Arc<T>,
+    wal: Option<Arc<W>>,
+    executor: Arc<iox_query::exec::Executor>,
+) where
+    P: Persister,
+    persister::Error: From<<P as Persister>::Error>,
+    T: TimeProvider,
+    W: Wal,
+    write_buffer::Error: From<<P as Persister>::Error>,
+{
+    loop {
+        tokio::select! {
+            _ = shutdown_rx.changed() => {
+                break;
+            }
+            _ = tokio::time::sleep(PERSISTER_CHECK_INTERVAL) => {
+                if let Err(e) = persist_and_cleanup_ready_segments(Arc::clone(&persister), Arc::clone(&segment_state), Arc::clone(&time_provider), wal.clone(), Arc::clone(&executor)).await {
+                    error!("Error persisting and cleaning up segments: {}", e);
+                }
+            }
+        }
+    }
+}
+
+async fn persist_and_cleanup_ready_segments<P, T, W>(
+    persister: Arc<P>,
+    segment_state: Arc<RwLock<SegmentState<T, W>>>,
+    time_provider: Arc<T>,
+    wal: Option<Arc<W>>,
+    executor: Arc<iox_query::exec::Executor>,
+) -> Result<(), crate::Error>
+where
+    P: Persister,
+    persister::Error: From<<P as Persister>::Error>,
+    T: TimeProvider,
+    W: Wal,
+    write_buffer::Error: From<<P as Persister>::Error>,
+{
+    // this loop is where persistence happens so if anything is in persisting,
+    // it's either been dropped or remaining from a restart, so clear those out first.
+    let persisting_segments = {
+        let segment_state = segment_state.read();
+        segment_state
+            .persisting_segments
+            .values()
+            .cloned()
+            .collect::<Vec<_>>()
+    };
+
+    for segment in persisting_segments {
+        persist_closed_segment_and_cleanup(
+            segment,
+            Arc::clone(&persister),
+            Arc::clone(&segment_state),
+            wal.clone(),
+            Arc::clone(&executor),
+        )
+        .await
+        .unwrap()
+    }
+
+    // check for open segments to persist
+    let current_time = time_provider.now();
+    let segments_to_persist = {
+        let segment_state = segment_state.read();
+        segment_state.segments_to_persist(current_time)
+    };
+
+    // close and persist each one in turn
+    for segment_start in segments_to_persist {
+        let closed_segment = {
+            let mut segment_state = segment_state.write();
+            segment_state.close_segment(segment_start)
+        };
+
+        if let Some(closed_segment) = closed_segment {
+            persist_closed_segment_and_cleanup(
+                closed_segment,
+                Arc::clone(&persister),
+                Arc::clone(&segment_state),
+                wal.clone(),
+                Arc::clone(&executor),
+            )
+            .await
+            .unwrap()
+        }
+    }
+
+    Ok(())
+}
+
+// Performs the following:
+// 1. persist the segment to the object store
+// 2. remove the segment from the persisting_segments map and add it to the persisted_segments map
+// 3. remove the wal segment file
+async fn persist_closed_segment_and_cleanup<P, T, W>(
+    closed_segment: Arc<ClosedBufferSegment>,
+    persister: Arc<P>,
+    segment_state: Arc<RwLock<SegmentState<T, W>>>,
+    wal: Option<Arc<W>>,
+    executor: Arc<iox_query::exec::Executor>,
+) -> Result<(), crate::Error>
+where
+    P: Persister,
+    persister::Error: From<<P as Persister>::Error>,
+    T: TimeProvider,
+    W: Wal,
+    write_buffer::Error: From<<P as Persister>::Error>,
+{
+    let closed_segment_start_time = closed_segment.segment_range.start_time;
+    let closed_segment_id = closed_segment.segment_id;
+    let persisted_segment = closed_segment.persist(persister, executor, None).await?;
+
+    {
+        let mut segment_state = segment_state.write();
+        segment_state
+            .persisting_segments
+            .remove(&closed_segment_start_time);
+        segment_state
+            .persisted_segments
+            .insert(closed_segment_start_time, Arc::new(persisted_segment));
+    }
+
+    if let Some(wal) = wal {
+        wal.delete_wal_segment(closed_segment_id)?;
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_helpers::lp_to_write_batch;
+    use crate::wal::WalImpl;
+    use crate::{SegmentFile, WalSegmentReader, WalSegmentWriter};
+    use iox_time::MockProvider;
+    use parking_lot::Mutex;
+    use std::any::Any;
+    use std::fmt::Debug;
+    use write_buffer::buffer_segment::tests::TestPersister;
+
+    #[test]
+    fn segments_to_persist_sorts_oldest_first() {
+        let catalog = Arc::new(Catalog::new());
+        let time_provider = Arc::new(MockProvider::new(Time::from_timestamp_nanos(0)));
+        let segment_duration = SegmentDuration::new_5m();
+        let first_segment_range = SegmentRange::from_time_and_duration(
+            Time::from_timestamp_nanos(0),
+            segment_duration,
+            false,
+        );
+
+        let open_segment1 = OpenBufferSegment::new(
+            SegmentId::new(1),
+            first_segment_range,
+            time_provider.now(),
+            catalog.sequence_number(),
+            Box::new(WalSegmentWriterNoopImpl::new(SegmentId::new(1))),
+            None,
+        );
+
+        let open_segment2 = OpenBufferSegment::new(
+            SegmentId::new(2),
+            SegmentRange::from_time_and_duration(
+                Time::from_timestamp(300, 0).unwrap(),
+                segment_duration,
+                false,
+            ),
+            time_provider.now(),
+            catalog.sequence_number(),
+            Box::new(WalSegmentWriterNoopImpl::new(SegmentId::new(2))),
+            None,
+        );
+
+        let open_segment3 = OpenBufferSegment::new(
+            SegmentId::new(3),
+            SegmentRange::from_time_and_duration(
+                Time::from_timestamp(600, 0).unwrap(),
+                segment_duration,
+                false,
+            ),
+            time_provider.now(),
+            catalog.sequence_number(),
+            Box::new(WalSegmentWriterNoopImpl::new(SegmentId::new(3))),
+            None,
+        );
+
+        let segment_state: SegmentState<MockProvider, WalImpl> = SegmentState::new(
+            SegmentDuration::new_5m(),
+            SegmentId::new(4),
+            Arc::clone(&catalog),
+            Arc::clone(&time_provider),
+            vec![open_segment1, open_segment2, open_segment3],
+            vec![],
+            vec![],
+            None,
+        );
+
+        let segments_to_persist =
+            segment_state.segments_to_persist(Time::from_timestamp(800, 0).unwrap());
+
+        assert_eq!(
+            segments_to_persist,
+            vec![
+                Time::from_timestamp_nanos(0),
+                Time::from_timestamp(300, 0).unwrap()
+            ]
+        );
+    }
+
+    #[tokio::test]
+    async fn persist_and_cleanup_ready_segments_handles_persisting_and_rotates_old() {
+        let catalog = Arc::new(Catalog::new());
+        let time_provider = Arc::new(MockProvider::new(Time::from_timestamp_nanos(0)));
+        let segment_duration = SegmentDuration::new_5m();
+        let first_segment_range = SegmentRange::from_time_and_duration(
+            Time::from_timestamp_nanos(0),
+            segment_duration,
+            false,
+        );
+
+        let mut open_segment1 = OpenBufferSegment::new(
+            SegmentId::new(1),
+            first_segment_range,
+            time_provider.now(),
+            catalog.sequence_number(),
+            Box::new(WalSegmentWriterNoopImpl::new(SegmentId::new(1))),
+            None,
+        );
+        open_segment1
+            .buffer_writes(lp_to_write_batch(&catalog, "foo", "cpu bar=1 10"))
+            .unwrap();
+
+        let mut open_segment2 = OpenBufferSegment::new(
+            SegmentId::new(2),
+            SegmentRange::from_time_and_duration(
+                Time::from_timestamp(300, 0).unwrap(),
+                segment_duration,
+                false,
+            ),
+            time_provider.now(),
+            catalog.sequence_number(),
+            Box::new(WalSegmentWriterNoopImpl::new(SegmentId::new(2))),
+            None,
+        );
+        open_segment2
+            .buffer_writes(lp_to_write_batch(&catalog, "foo", "cpu bar=2 300000000000"))
+            .unwrap();
+
+        let mut open_segment3 = OpenBufferSegment::new(
+            SegmentId::new(3),
+            SegmentRange::from_time_and_duration(
+                Time::from_timestamp(600, 0).unwrap(),
+                segment_duration,
+                false,
+            ),
+            time_provider.now(),
+            catalog.sequence_number(),
+            Box::new(WalSegmentWriterNoopImpl::new(SegmentId::new(3))),
+            None,
+        );
+        open_segment3
+            .buffer_writes(lp_to_write_batch(&catalog, "foo", "cpu bar=3 700000000000"))
+            .unwrap();
+
+        let wal = Arc::new(TestWal::default());
+
+        let segment_state: SegmentState<MockProvider, TestWal> = SegmentState::new(
+            SegmentDuration::new_5m(),
+            SegmentId::new(4),
+            Arc::clone(&catalog),
+            Arc::clone(&time_provider),
+            vec![open_segment2, open_segment3],
+            vec![open_segment1.into_closed_segment(Arc::clone(&catalog))],
+            vec![],
+            Some(Arc::clone(&wal)),
+        );
+        let segment_state = Arc::new(RwLock::new(segment_state));
+
+        let persister = Arc::new(TestPersister::default());
+
+        time_provider.set(Time::from_timestamp(900, 0).unwrap());
+
+        persist_and_cleanup_ready_segments(
+            Arc::clone(&persister),
+            Arc::clone(&segment_state),
+            Arc::clone(&time_provider),
+            Some(Arc::clone(&wal)),
+            crate::test_help::make_exec(),
+        )
+        .await
+        .unwrap();
+
+        let persisted_state = persister
+            .as_any()
+            .downcast_ref::<TestPersister>()
+            .unwrap()
+            .state
+            .lock();
+
+        assert_eq!(persisted_state.catalog.len(), 1);
+        assert_eq!(persisted_state.segments.len(), 2);
+        assert_eq!(persisted_state.parquet_files.len(), 2);
+
+        let wal_state = wal.as_any().downcast_ref::<TestWal>().unwrap();
+        let deleted_segments = wal_state.deleted_wal_segments.lock().clone();
+
+        assert_eq!(deleted_segments, vec![SegmentId::new(1), SegmentId::new(2)]);
+    }
+
+    #[derive(Debug, Default)]
+    struct TestWal {
+        deleted_wal_segments: Mutex<Vec<SegmentId>>,
+    }
+
+    impl Wal for TestWal {
+        fn new_segment_writer(
+            &self,
+            _segment_id: SegmentId,
+            _range: SegmentRange,
+        ) -> wal::Result<Box<dyn WalSegmentWriter>> {
+            todo!()
+        }
+
+        fn open_segment_writer(
+            &self,
+            _segment_id: SegmentId,
+        ) -> wal::Result<Box<dyn WalSegmentWriter>> {
+            todo!()
+        }
+
+        fn open_segment_reader(
+            &self,
+            _segment_id: SegmentId,
+        ) -> wal::Result<Box<dyn WalSegmentReader>> {
+            todo!()
+        }
+
+        fn segment_files(&self) -> wal::Result<Vec<SegmentFile>> {
+            todo!()
+        }
+
+        fn delete_wal_segment(&self, segment_id: SegmentId) -> wal::Result<()> {
+            self.deleted_wal_segments.lock().push(segment_id);
+            Ok(())
+        }
+
+        fn as_any(&self) -> &dyn Any {
+            self as &dyn Any
+        }
+    }
+}
diff --git a/influxdb3_write/src/write_buffer/table_buffer.rs b/influxdb3_write/src/write_buffer/table_buffer.rs
new file mode 100644
index 00000000000..2e1761ba112
--- /dev/null
+++ b/influxdb3_write/src/write_buffer/table_buffer.rs
@@ -0,0 +1,237 @@
+//! The in memory bufffer of a table that can be quickly added to and queried
+
+use crate::write_buffer::{FieldData, Row};
+use arrow::array::{
+    ArrayRef, BooleanBuilder, Float64Builder, Int64Builder, StringBuilder, StringDictionaryBuilder,
+    TimestampNanosecondBuilder, UInt64Builder,
+};
+use arrow::datatypes::Int32Type;
+use arrow::record_batch::RecordBatch;
+use data_types::{PartitionKey, TimestampMinMax};
+use observability_deps::tracing::debug;
+use schema::Schema;
+use std::collections::{BTreeMap, HashSet};
+use std::sync::Arc;
+use std::vec;
+
+pub struct TableBuffer {
+    pub segment_key: PartitionKey,
+    timestamp_min: i64,
+    timestamp_max: i64,
+    pub(crate) data: BTreeMap<String, Builder>,
+    row_count: usize,
+}
+
+impl TableBuffer {
+    pub fn new(segment_key: PartitionKey) -> Self {
+        Self {
+            segment_key,
+            timestamp_min: i64::MAX,
+            timestamp_max: i64::MIN,
+            data: Default::default(),
+            row_count: 0,
+        }
+    }
+
+    pub fn add_rows(&mut self, rows: Vec<Row>) {
+        let new_row_count = rows.len();
+
+        for (row_index, r) in rows.into_iter().enumerate() {
+            let mut value_added = HashSet::with_capacity(r.fields.len());
+
+            for f in r.fields {
+                value_added.insert(f.name.clone());
+
+                match f.value {
+                    FieldData::Timestamp(v) => {
+                        self.timestamp_min = self.timestamp_min.min(v);
+                        self.timestamp_max = self.timestamp_max.max(v);
+
+                        let b = self.data.entry(f.name).or_insert_with(|| {
+                            debug!("Creating new timestamp builder");
+                            let mut time_builder = TimestampNanosecondBuilder::new();
+                            // append nulls for all previous rows
+                            for _ in 0..(row_index + self.row_count) {
+                                debug!("Appending null for timestamp");
+                                time_builder.append_null();
+                            }
+                            Builder::Time(time_builder)
+                        });
+                        if let Builder::Time(b) = b {
+                            b.append_value(v);
+                        } else {
+                            panic!("unexpected field type");
+                        }
+                    }
+                    FieldData::Tag(v) => {
+                        let b = self.data.entry(f.name).or_insert_with(|| {
+                            let mut tag_builder = StringDictionaryBuilder::new();
+                            // append nulls for all previous rows
+                            for _ in 0..(row_index + self.row_count) {
+                                tag_builder.append_null();
+                            }
+                            Builder::Tag(tag_builder)
+                        });
+                        if let Builder::Tag(b) = b {
+                            b.append(v).unwrap(); // we won't overflow the 32-bit integer for this dictionary
+                        } else {
+                            panic!("unexpected field type");
+                        }
+                    }
+                    FieldData::String(v) => {
+                        let b = self.data.entry(f.name).or_insert_with(|| {
+                            let mut string_builder = StringBuilder::new();
+                            // append nulls for all previous rows
+                            for _ in 0..(row_index + self.row_count) {
+                                string_builder.append_null();
+                            }
+                            Builder::String(string_builder)
+                        });
+                        if let Builder::String(b) = b {
+                            b.append_value(v);
+                        } else {
+                            panic!("unexpected field type");
+                        }
+                    }
+                    FieldData::Integer(v) => {
+                        let b = self.data.entry(f.name).or_insert_with(|| {
+                            let mut int_builder = Int64Builder::new();
+                            // append nulls for all previous rows
+                            for _ in 0..(row_index + self.row_count) {
+                                int_builder.append_null();
+                            }
+                            Builder::I64(int_builder)
+                        });
+                        if let Builder::I64(b) = b {
+                            b.append_value(v);
+                        } else {
+                            panic!("unexpected field type");
+                        }
+                    }
+                    FieldData::UInteger(v) => {
+                        let b = self.data.entry(f.name).or_insert_with(|| {
+                            let mut uint_builder = UInt64Builder::new();
+                            // append nulls for all previous rows
+                            for _ in 0..(row_index + self.row_count) {
+                                uint_builder.append_null();
+                            }
+                            Builder::U64(uint_builder)
+                        });
+                        if let Builder::U64(b) = b {
+                            b.append_value(v);
+                        } else {
+                            panic!("unexpected field type");
+                        }
+                    }
+                    FieldData::Float(v) => {
+                        let b = self.data.entry(f.name).or_insert_with(|| {
+                            let mut float_builder = Float64Builder::new();
+                            // append nulls for all previous rows
+                            for _ in 0..(row_index + self.row_count) {
+                                float_builder.append_null();
+                            }
+                            Builder::F64(float_builder)
+                        });
+                        if let Builder::F64(b) = b {
+                            b.append_value(v);
+                        } else {
+                            panic!("unexpected field type");
+                        }
+                    }
+                    FieldData::Boolean(v) => {
+                        let b = self.data.entry(f.name).or_insert_with(|| {
+                            let mut bool_builder = BooleanBuilder::new();
+                            // append nulls for all previous rows
+                            for _ in 0..(row_index + self.row_count) {
+                                bool_builder.append_null();
+                            }
+                            Builder::Bool(bool_builder)
+                        });
+                        if let Builder::Bool(b) = b {
+                            b.append_value(v);
+                        } else {
+                            panic!("unexpected field type");
+                        }
+                    }
+                }
+            }
+
+            // add nulls for any columns not present
+            for (name, builder) in &mut self.data {
+                if !value_added.contains(name) {
+                    debug!("Adding null for column {}", name);
+                    match builder {
+                        Builder::Bool(b) => b.append_null(),
+                        Builder::F64(b) => b.append_null(),
+                        Builder::I64(b) => b.append_null(),
+                        Builder::U64(b) => b.append_null(),
+                        Builder::String(b) => b.append_null(),
+                        Builder::Tag(b) => b.append_null(),
+                        Builder::Time(b) => b.append_null(),
+                    }
+                }
+            }
+        }
+
+        self.row_count += new_row_count;
+    }
+
+    pub fn timestamp_min_max(&self) -> TimestampMinMax {
+        TimestampMinMax {
+            min: self.timestamp_min,
+            max: self.timestamp_max,
+        }
+    }
+
+    pub fn record_batches(&self, schema: &Schema) -> Vec<RecordBatch> {
+        // ensure the order of the columns matches their order in the Arrow schema definition
+        let mut cols = Vec::with_capacity(self.data.len());
+        let schema = schema.as_arrow();
+        for f in &schema.fields {
+            cols.push(
+                self.data
+                    .get(f.name())
+                    .unwrap_or_else(|| panic!("missing field in table buffer: {}", f.name()))
+                    .as_arrow(),
+            );
+        }
+
+        vec![RecordBatch::try_new(schema, cols).unwrap()]
+    }
+}
+
+// Debug implementation for TableBuffer
+impl std::fmt::Debug for TableBuffer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("TableBuffer")
+            .field("segment_key", &self.segment_key)
+            .field("timestamp_min", &self.timestamp_min)
+            .field("timestamp_max", &self.timestamp_max)
+            .field("row_count", &self.row_count)
+            .finish()
+    }
+}
+
+pub enum Builder {
+    Bool(BooleanBuilder),
+    I64(Int64Builder),
+    F64(Float64Builder),
+    U64(UInt64Builder),
+    String(StringBuilder),
+    Tag(StringDictionaryBuilder<Int32Type>),
+    Time(TimestampNanosecondBuilder),
+}
+
+impl Builder {
+    fn as_arrow(&self) -> ArrayRef {
+        match self {
+            Self::Bool(b) => Arc::new(b.finish_cloned()),
+            Self::I64(b) => Arc::new(b.finish_cloned()),
+            Self::F64(b) => Arc::new(b.finish_cloned()),
+            Self::U64(b) => Arc::new(b.finish_cloned()),
+            Self::String(b) => Arc::new(b.finish_cloned()),
+            Self::Tag(b) => Arc::new(b.finish_cloned()),
+            Self::Time(b) => Arc::new(b.finish_cloned()),
+        }
+    }
+}
diff --git a/iox_query_influxql_rewrite/Cargo.toml b/iox_query_influxql_rewrite/Cargo.toml
new file mode 100644
index 00000000000..810515d6873
--- /dev/null
+++ b/iox_query_influxql_rewrite/Cargo.toml
@@ -0,0 +1,18 @@
+[package]
+name = "iox_query_influxql_rewrite"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+# workspace dependencies:
+influxdb_influxql_parser.workspace = true
+
+# crates.io dependencies:
+thiserror.workspace = true
+
+[lints]
+workspace = true
diff --git a/iox_query_influxql_rewrite/src/lib.rs b/iox_query_influxql_rewrite/src/lib.rs
new file mode 100644
index 00000000000..9ea2ab6b2da
--- /dev/null
+++ b/iox_query_influxql_rewrite/src/lib.rs
@@ -0,0 +1,555 @@
+use std::collections::HashSet;
+
+use influxdb_influxql_parser::{
+    common::ParseError,
+    explain::ExplainStatement,
+    identifier::Identifier,
+    parse_statements as parse_internal,
+    select::{MeasurementSelection, SelectStatement},
+    show_measurements::ExtendedOnClause,
+    statement::Statement,
+};
+
+#[derive(Debug)]
+pub struct Rewritten<S> {
+    database: Option<Identifier>,
+    retention_policy: Option<Identifier>,
+    statement: S,
+}
+
+impl<S> Rewritten<S> {
+    fn new(statement: S) -> Self {
+        Self {
+            database: None,
+            retention_policy: None,
+            statement,
+        }
+    }
+
+    fn with_database(mut self, db: Option<Identifier>) -> Self {
+        self.database = db;
+        self
+    }
+
+    fn with_retention_policy(mut self, rp: Option<Identifier>) -> Self {
+        self.retention_policy = rp;
+        self
+    }
+
+    pub fn database(&self) -> Option<&Identifier> {
+        self.database.as_ref()
+    }
+
+    pub fn retention_policy(&self) -> Option<&Identifier> {
+        self.retention_policy.as_ref()
+    }
+
+    pub fn statement(&self) -> &S {
+        &self.statement
+    }
+
+    pub fn to_statement(self) -> S {
+        self.statement
+    }
+
+    pub fn resolve_dbrp(&self) -> Option<String> {
+        match (&self.database, &self.retention_policy) {
+            (None, None) | (None, Some(_)) => None,
+            (Some(db), None) => Some(db.to_string()),
+            (Some(db), Some(rp)) => {
+                if rp.as_str() != "autogen" && rp.as_str() != "default" {
+                    Some(format!("{db}/{rp}"))
+                } else {
+                    Some(db.to_string())
+                }
+            }
+        }
+    }
+}
+
+impl From<Rewritten<Statement>> for Statement {
+    fn from(r: Rewritten<Statement>) -> Self {
+        r.to_statement()
+    }
+}
+
+impl TryFrom<Statement> for Rewritten<Statement> {
+    type Error = Error;
+
+    fn try_from(statement: Statement) -> Result<Self, Self::Error> {
+        match statement {
+            Statement::ShowMeasurements(mut s) => {
+                if let Some(on) = s.on.take() {
+                    let (db, rp) = match on {
+                        ExtendedOnClause::Database(db) => (Some(db), None),
+                        ExtendedOnClause::DatabaseRetentionPolicy(db, rp) => (Some(db), Some(rp)),
+                        ExtendedOnClause::AllDatabases
+                        | ExtendedOnClause::AllDatabasesAndRetentionPolicies => {
+                            return Err(Error::MultiDatabase)
+                        }
+                    };
+                    Ok(Self::new(Statement::ShowMeasurements(s))
+                        .with_database(db)
+                        .with_retention_policy(rp))
+                } else {
+                    Ok(Self::new(Statement::ShowMeasurements(s)))
+                }
+            }
+            Statement::ShowRetentionPolicies(mut s) => {
+                let identifier = s.database.take().map(Into::into);
+                Ok(Self::new(Statement::ShowRetentionPolicies(s)).with_database(identifier))
+            }
+            Statement::ShowTagKeys(mut s) => {
+                let identifier = s.database.take().map(Into::into);
+                Ok(Self::new(Statement::ShowTagKeys(s)).with_database(identifier))
+            }
+            Statement::ShowTagValues(mut s) => {
+                let identifier = s.database.take().map(Into::into);
+                Ok(Self::new(Statement::ShowTagValues(s)).with_database(identifier))
+            }
+            Statement::ShowFieldKeys(mut s) => {
+                let identifier = s.database.take().map(Into::into);
+                Ok(Self::new(Statement::ShowFieldKeys(s)).with_database(identifier))
+            }
+            Statement::Select(s) => {
+                let ss = Rewritten::<SelectStatement>::try_from(*s)?;
+                let db = ss.database.to_owned();
+                let rp = ss.retention_policy.to_owned();
+                Ok(Self::new(Statement::Select(Box::new(ss.to_statement())))
+                    .with_database(db)
+                    .with_retention_policy(rp))
+            }
+            Statement::Explain(mut s) => {
+                let options = s.options.take();
+                let s = Self::try_from(*s.statement)?;
+                let db = s.database.to_owned();
+                let rp = s.retention_policy.to_owned();
+                Ok(Self::new(Statement::Explain(Box::new(ExplainStatement {
+                    options,
+                    statement: Box::new(s.to_statement()),
+                })))
+                .with_database(db)
+                .with_retention_policy(rp))
+            }
+            // For all other statements, we just pass them through. Explicitly
+            // do not use a catch-all match arm here in the event that new variants
+            // are added to the Statement enum, we want the compiler to direct us
+            // here to handle, if relevant.
+            Statement::CreateDatabase(_)
+            | Statement::Delete(_)
+            | Statement::DropMeasurement(_)
+            | Statement::ShowDatabases(_) => Ok(Self::new(statement)),
+        }
+    }
+}
+
+impl TryFrom<SelectStatement> for Rewritten<SelectStatement> {
+    type Error = Error;
+
+    fn try_from(mut select_statement: SelectStatement) -> Result<Self, Self::Error> {
+        let mut db_rp_set = HashSet::new();
+        let from_clause = select_statement
+            .from
+            .take()
+            .into_iter()
+            .map(|ms| {
+                let (db, rp, ms) = match ms {
+                    MeasurementSelection::Name(mut qn) => {
+                        let db = qn.database.take();
+                        let rp = qn.retention_policy.take();
+                        (db, rp, MeasurementSelection::Name(qn))
+                    }
+                    // Recursively call try_from on nested sub-queries, and compare their
+                    // resulting db/rp to the same at this level. Sub-queries that have
+                    // multiple db/rp in them will throw the MultiDatabase error.
+                    MeasurementSelection::Subquery(s) => {
+                        let ss = Self::try_from(*s)?;
+                        (
+                            ss.database.to_owned(),
+                            ss.retention_policy.to_owned(),
+                            MeasurementSelection::Subquery(Box::new(ss.to_statement())),
+                        )
+                    }
+                };
+                if db_rp_set.insert((db, rp)) && db_rp_set.len() > 1 {
+                    Err(Error::MultiDatabase)
+                } else {
+                    Ok(ms)
+                }
+            })
+            .collect::<Result<Vec<MeasurementSelection>, Error>>()?;
+        select_statement.from.replace(from_clause);
+        let mut result = Self::new(select_statement);
+        if let Some((db, rp)) = db_rp_set.into_iter().next() {
+            result = result.with_database(db).with_retention_policy(rp);
+        }
+        Ok(result)
+    }
+}
+
+#[derive(Debug, thiserror::Error, Clone, PartialEq, Eq)]
+pub enum Error {
+    #[error("can only perform queries on a single database")]
+    MultiDatabase,
+    #[error("parsing error: {0}")]
+    Parse(ParseError),
+}
+
+pub fn parse_statements(input: &str) -> Result<Vec<Rewritten<Statement>>, Error> {
+    parse_internal(input)
+        .map_err(Error::Parse)?
+        .into_iter()
+        .map(Rewritten::<Statement>::try_from)
+        .collect::<Result<Vec<Rewritten<Statement>>, Error>>()
+}
+
+#[cfg(test)]
+mod tests {
+    use influxdb_influxql_parser::statement::Statement;
+
+    use crate::{parse_statements, Error, Rewritten};
+
+    fn parse_single(input: &str) -> Rewritten<Statement> {
+        parse_statements(input).unwrap().pop().unwrap()
+    }
+
+    fn parse_single_failure(input: &str) -> Error {
+        parse_statements(input).unwrap_err()
+    }
+
+    struct TestCase {
+        input: &'static str,
+        expected: &'static str,
+        db: Option<&'static str>,
+        rp: Option<&'static str>,
+    }
+
+    impl TestCase {
+        fn assert(&self) {
+            let s = parse_single(self.input);
+            assert_eq!(s.database().map(|db| db.as_str()), self.db);
+            assert_eq!(s.retention_policy().map(|rp| rp.as_str()), self.rp);
+            assert_eq!(self.expected, s.to_statement().to_string());
+        }
+    }
+
+    struct TestFailure {
+        input: &'static str,
+        expected: Error,
+    }
+
+    impl TestFailure {
+        fn assert(&self) {
+            let e = parse_single_failure(self.input);
+            assert_eq!(self.expected, e, "input: {}", self.input);
+        }
+    }
+
+    #[test]
+    fn show_measurements() {
+        TestCase {
+            input: "SHOW MEASUREMENTS",
+            expected: "SHOW MEASUREMENTS",
+            db: None,
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "SHOW MEASUREMENTS ON foo",
+            expected: "SHOW MEASUREMENTS",
+            db: Some("foo"),
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "SHOW MEASUREMENTS ON foo.bar",
+            expected: "SHOW MEASUREMENTS",
+            db: Some("foo"),
+            rp: Some("bar"),
+        }
+        .assert();
+    }
+
+    #[test]
+    fn show_measurements_failure_modes() {
+        TestFailure {
+            input: "SHOW MEASUREMENTS ON *.*",
+            expected: Error::MultiDatabase,
+        }
+        .assert();
+        TestFailure {
+            input: r#"SHOW MEASUREMENTS ON *"#,
+            expected: Error::MultiDatabase,
+        }
+        .assert();
+    }
+
+    #[test]
+    fn show_retention_policies() {
+        TestCase {
+            input: "SHOW RETENTION POLICIES",
+            expected: "SHOW RETENTION POLICIES",
+            db: None,
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "SHOW RETENTION POLICIES ON foo",
+            expected: "SHOW RETENTION POLICIES",
+            db: Some("foo"),
+            rp: None,
+        }
+        .assert();
+    }
+
+    #[test]
+    fn show_tag_keys() {
+        TestCase {
+            input: "SHOW TAG KEYS",
+            expected: "SHOW TAG KEYS",
+            db: None,
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "SHOW TAG KEYS FROM cpu",
+            expected: "SHOW TAG KEYS FROM cpu",
+            db: None,
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "SHOW TAG KEYS ON foo",
+            expected: "SHOW TAG KEYS",
+            db: Some("foo"),
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "SHOW TAG KEYS ON foo FROM cpu",
+            expected: "SHOW TAG KEYS FROM cpu",
+            db: Some("foo"),
+            rp: None,
+        }
+        .assert();
+    }
+
+    #[test]
+    fn show_tag_values() {
+        TestCase {
+            input: "SHOW TAG VALUES WITH KEY = host",
+            expected: "SHOW TAG VALUES WITH KEY = host",
+            db: None,
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "SHOW TAG VALUES FROM cpu WITH KEY = host",
+            expected: "SHOW TAG VALUES FROM cpu WITH KEY = host",
+            db: None,
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "SHOW TAG VALUES ON foo WITH KEY = host",
+            expected: "SHOW TAG VALUES WITH KEY = host",
+            db: Some("foo"),
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "SHOW TAG VALUES ON foo FROM cpu WITH KEY = host",
+            expected: "SHOW TAG VALUES FROM cpu WITH KEY = host",
+            db: Some("foo"),
+            rp: None,
+        }
+        .assert();
+    }
+
+    #[test]
+    fn show_field_keys() {
+        TestCase {
+            input: "SHOW FIELD KEYS",
+            expected: "SHOW FIELD KEYS",
+            db: None,
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "SHOW FIELD KEYS FROM cpu",
+            expected: "SHOW FIELD KEYS FROM cpu",
+            db: None,
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "SHOW FIELD KEYS ON foo",
+            expected: "SHOW FIELD KEYS",
+            db: Some("foo"),
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "SHOW FIELD KEYS ON foo FROM cpu",
+            expected: "SHOW FIELD KEYS FROM cpu",
+            db: Some("foo"),
+            rp: None,
+        }
+        .assert();
+    }
+
+    #[test]
+    fn select() {
+        TestCase {
+            input: "SELECT * FROM cpu",
+            expected: "SELECT * FROM cpu",
+            db: None,
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "SELECT * FROM bar.cpu",
+            expected: "SELECT * FROM cpu",
+            db: None,
+            rp: Some("bar"),
+        }
+        .assert();
+        TestCase {
+            input: "SELECT * FROM foo.bar.cpu",
+            expected: "SELECT * FROM cpu",
+            db: Some("foo"),
+            rp: Some("bar"),
+        }
+        .assert();
+        TestCase {
+            input: r#"SELECT * FROM (SELECT * FROM cpu)"#,
+            expected: r#"SELECT * FROM (SELECT * FROM cpu)"#,
+            db: None,
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: r#"SELECT * FROM (SELECT * FROM bar.cpu), bar.mem"#,
+            expected: r#"SELECT * FROM (SELECT * FROM cpu), mem"#,
+            db: None,
+            rp: Some("bar"),
+        }
+        .assert();
+        TestCase {
+            input: r#"SELECT * FROM (SELECT * FROM foo.bar.cpu), foo.bar.mem"#,
+            expected: r#"SELECT * FROM (SELECT * FROM cpu), mem"#,
+            db: Some("foo"),
+            rp: Some("bar"),
+        }
+        .assert();
+    }
+
+    #[test]
+    fn select_failure_modes() {
+        TestFailure {
+            input: r#"SELECT * FROM foo.bar.cpu, baz.bop.cpu"#,
+            expected: Error::MultiDatabase,
+        }
+        .assert();
+        TestFailure {
+            input: r#"SELECT * FROM cpu, baz.bop.cpu"#,
+            expected: Error::MultiDatabase,
+        }
+        .assert();
+        TestFailure {
+            input: r#"SELECT * FROM bar.cpu, baz.bop.cpu"#,
+            expected: Error::MultiDatabase,
+        }
+        .assert();
+        TestFailure {
+            input: r#"SELECT * FROM foo.bar.cpu, (SELECT * FROM mem)"#,
+            expected: Error::MultiDatabase,
+        }
+        .assert();
+    }
+
+    #[test]
+    fn explain() {
+        TestCase {
+            input: "EXPLAIN SELECT * FROM cpu",
+            expected: "EXPLAIN SELECT * FROM cpu",
+            db: None,
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "EXPLAIN SELECT * FROM bar.cpu",
+            expected: "EXPLAIN SELECT * FROM cpu",
+            db: None,
+            rp: Some("bar"),
+        }
+        .assert();
+        TestCase {
+            input: "EXPLAIN SELECT * FROM foo.bar.cpu",
+            expected: "EXPLAIN SELECT * FROM cpu",
+            db: Some("foo"),
+            rp: Some("bar"),
+        }
+        .assert();
+        TestCase {
+            input: r#"EXPLAIN SELECT * FROM (SELECT * FROM cpu)"#,
+            expected: r#"EXPLAIN SELECT * FROM (SELECT * FROM cpu)"#,
+            db: None,
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: r#"EXPLAIN SELECT * FROM (SELECT * FROM bar.cpu), bar.mem"#,
+            expected: r#"EXPLAIN SELECT * FROM (SELECT * FROM cpu), mem"#,
+            db: None,
+            rp: Some("bar"),
+        }
+        .assert();
+        TestCase {
+            input: r#"EXPLAIN SELECT * FROM (SELECT * FROM foo.bar.cpu), foo.bar.mem"#,
+            expected: r#"EXPLAIN SELECT * FROM (SELECT * FROM cpu), mem"#,
+            db: Some("foo"),
+            rp: Some("bar"),
+        }
+        .assert();
+    }
+
+    #[test]
+    fn noop_rewrites() {
+        TestCase {
+            input: "CREATE DATABASE foo",
+            expected: "CREATE DATABASE foo",
+            db: None,
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "DELETE FROM cpu",
+            expected: "DELETE FROM cpu",
+            db: None,
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "DROP MEASUREMENT cpu",
+            expected: "DROP MEASUREMENT cpu",
+            db: None,
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "EXPLAIN SELECT * FROM cpu",
+            expected: "EXPLAIN SELECT * FROM cpu",
+            db: None,
+            rp: None,
+        }
+        .assert();
+        TestCase {
+            input: "SHOW DATABASES",
+            expected: "SHOW DATABASES",
+            db: None,
+            rp: None,
+        }
+        .assert();
+    }
+}
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
new file mode 100644
index 00000000000..7aac9b8f1b3
--- /dev/null
+++ b/rust-toolchain.toml
@@ -0,0 +1,3 @@
+[toolchain]
+channel = "1.77.0"
+components = ["rustfmt", "clippy", "rust-analyzer"]
diff --git a/rustfmt.toml b/rustfmt.toml
new file mode 100644
index 00000000000..7b060483bec
--- /dev/null
+++ b/rustfmt.toml
@@ -0,0 +1,6 @@
+edition = "2021"
+
+# Unstable features not yet supported on stable Rust
+#wrap_comments = true
+#imports_granularity = "Crate"
+#group_imports = "StdExternalCrate"