Format protocol preparation sources and reject empty formatter checks

Author: rustyconover

example-worker/catalog_def.cpp

@@ -565,7 +565,9 @@ void declare_catalog(vgi::Worker& worker) {
     // In `main`, not `data`: a view is looked up by the schema the user names,
     // and the suite names `main` for these two.
     auto& main = worker.catalog().schema("main");
-    main.tables.push_back(backed_by("projection_rows", "projection_sequence", arrow::schema({arrow::field("n", arrow::int32(), true)}), "Finite optional scalar projection example"));
+    main.tables.push_back(backed_by("projection_rows", "projection_sequence",
+                                    arrow::schema({arrow::field("n", arrow::int32(), true)}),
+                                    "Finite optional scalar projection example"));
     main.comment = "Example functions for testing VGI";
     main.tables.push_back(backed_by("test_same_name_table", "test_same_name_table_scan",
                                     columns({{"tag", arrow::utf8()}}),
@@ -632,7 +634,8 @@ void declare_catalog(vgi::Worker& worker) {
                       "Department reference table");
         departments.cardinality = 3;
         departments.constraints = constraint_fixtures::records("departments");
-        departments.columns = constraint_fixtures::required_schema(departments.columns, "departments");
+        departments.columns =
+            constraint_fixtures::required_schema(departments.columns, "departments");
         // Bounds wider than the three rows on purpose: they describe the table
         // the fixture stands in for, and `column_statistics.test` folds
         // `id > 100` to EMPTY_RESULT against them, not against the data.
@@ -746,10 +749,16 @@ void declare_catalog(vgi::Worker& worker) {
         // computes the other two.
         auto generated = backed_by(
             "generated_sequence", "sequence",
-            arrow::schema({arrow::field("n", arrow::int64(), /*nullable=*/true),
-                           tagged("doubled", arrow::int64(), {"vgi.column.generated.v1", "vgi.column.generation.v1"}, {vgi::generated_expression_metadata("n * 2", {"data"}), "virtual"}),
-                           tagged("label", arrow::utf8(), {"vgi.column.generated.v1", "vgi.column.generation.v1"},
-                                  {vgi::generated_expression_metadata("'item_' || CAST(n AS VARCHAR)", {"data"}), "virtual"})}),
+            arrow::schema(
+                {arrow::field("n", arrow::int64(), /*nullable=*/true),
+                 tagged("doubled", arrow::int64(),
+                        {"vgi.column.generated.v1", "vgi.column.generation.v1"},
+                        {vgi::generated_expression_metadata("n * 2", {"data"}), "virtual"}),
+                 tagged(
+                     "label", arrow::utf8(),
+                     {"vgi.column.generated.v1", "vgi.column.generation.v1"},
+                     {vgi::generated_expression_metadata("'item_' || CAST(n AS VARCHAR)", {"data"}),
+                      "virtual"})}),
             "Table with generated columns backed by sequence(10)");
         generated.scan_arguments = vgi::serialize_scan_arguments({int64_arg(10)});
         generated.cardinality = 10;
@@ -904,7 +913,8 @@ void declare_catalog(vgi::Worker& worker) {
             vgi::TimeTravelVersion entry;
             entry.version = version;
             entry.columns = constraint_fixtures::required_schema(
-                columns(per_version[static_cast<size_t>(version) - 1]), "versioned_constraints", version);
+                columns(per_version[static_cast<size_t>(version) - 1]), "versioned_constraints",
+                version);
             entry.scan_function = "versioned_constraints_scan";
             entry.scan_arguments = vgi::serialize_scan_arguments({int64_arg(version)});
             entry.timestamp_year = constraint_years[version - 1];

example-worker/constraint_fixtures.h

@@ -137,9 +137,12 @@ inline std::vector<std::string> definitions(const std::string& table, int64_t ve
             constraint(table, "fixture:versioned_constraints:nn:id", "NOT_NULL", {{"id"}}),
         };
         if (version >= 2) {
-            result.push_back(constraint(table, "fixture:versioned_constraints:nn:name", "NOT_NULL", {{"name"}}));
-            result.push_back(constraint(table, "fixture:versioned_constraints:primary", "PRIMARY_KEY", {{"id"}}));
-            result.push_back(constraint(table, "fixture:versioned_constraints:unique:email", "UNIQUE", {{"email"}}));
+            result.push_back(
+                constraint(table, "fixture:versioned_constraints:nn:name", "NOT_NULL", {{"name"}}));
+            result.push_back(constraint(table, "fixture:versioned_constraints:primary",
+                                        "PRIMARY_KEY", {{"id"}}));
+            result.push_back(constraint(table, "fixture:versioned_constraints:unique:email",
+                                        "UNIQUE", {{"email"}}));
         }
         if (version >= 3)
             result.push_back(constraint(table, "fixture:versioned_constraints:fk:department",

example-worker/table/rff.cpp

@@ -266,7 +266,8 @@ void register_rff(vgi::Worker& worker) {
 // The `rff_*` tables, declared by the catalog.
 std::vector<vgi::CatalogTable> rff_tables() {
     const auto table = [](std::string name, std::shared_ptr<arrow::Schema> columns,
-                          std::string scan, std::vector<std::vector<std::vector<std::string>>> required) {
+                          std::string scan,
+                          std::vector<std::vector<std::vector<std::string>>> required) {
         vgi::CatalogTable entry;
         entry.name = std::move(name);
         entry.columns = std::move(columns);

example-worker/table/sequence.cpp

@@ -147,7 +147,9 @@ class Sequence : public vgi::TableFunction {
 };
 
 class ProjectionRows : public vgi::TableProducer {
-    vgi::ProcessParams params_; bool done_ = false;
+    vgi::ProcessParams params_;
+    bool done_ = false;
+
 public:
     explicit ProjectionRows(vgi::ProcessParams params) : params_(std::move(params)) {}
     std::shared_ptr<arrow::RecordBatch> next_batch() override {
@@ -156,8 +158,17 @@ class ProjectionRows : public vgi::TableProducer {
         arrow::ArrayVector arrays;
         for (const auto& field : params_.output_schema->fields()) {
             std::shared_ptr<arrow::Array> array;
-            if (field->name() == "n") { arrow::Int32Builder b; for (int n = 0; n < 10; ++n) (void)b.Append(n); (void)b.Finish(&array); }
-            else { if (params_.bind_opaque_data.empty()) throw std::invalid_argument("projection state missing"); arrow::Int64Builder b; for (int64_t n = 0; n < 10; ++n) (void)b.Append(n); (void)b.Finish(&array); }
+            if (field->name() == "n") {
+                arrow::Int32Builder b;
+                for (int n = 0; n < 10; ++n) (void)b.Append(n);
+                (void)b.Finish(&array);
+            } else {
+                if (params_.bind_opaque_data.empty())
+                    throw std::invalid_argument("projection state missing");
+                arrow::Int64Builder b;
+                for (int64_t n = 0; n < 10; ++n) (void)b.Append(n);
+                (void)b.Finish(&array);
+            }
             arrays.push_back(array);
         }
         return arrow::RecordBatch::Make(params_.output_schema, 10, arrays);
@@ -166,24 +177,49 @@ class ProjectionRows : public vgi::TableProducer {
 class ProjectionSequence : public vgi::TableFunction {
 public:
     std::string name() const override { return "projection_sequence"; }
-    vgi::FunctionMetadata metadata() const override { vgi::FunctionMetadata md; md.projection_pushdown = true; return md; }
+    vgi::FunctionMetadata metadata() const override {
+        vgi::FunctionMetadata md;
+        md.projection_pushdown = true;
+        return md;
+    }
     std::vector<vgi::ArgSpec> argument_specs() const override { return {}; }
-    std::shared_ptr<arrow::Schema> bind(const vgi::BindParams&) const override { return arrow::schema({arrow::field("n", arrow::int32(), true)}); }
-    std::vector<std::string> projection_expression_profiles(const vgi::BindParams&) const override { return {vgi::SCALAR_PROJECTION_PROFILE}; }
-    vgi::BindRepeatability repeatability(const vgi::BindParams&) const override { return vgi::BindRepeatability::StableWithinQuery; }
-    vgi::ProjectionAcceptance projection(const vgi::BindParams&, const vgi::ProjectionProposal& p) const override {
-        vgi::ProjectionAcceptance result; auto fields = p.source_schema->fields();
+    std::shared_ptr<arrow::Schema> bind(const vgi::BindParams&) const override {
+        return arrow::schema({arrow::field("n", arrow::int32(), true)});
+    }
+    std::vector<std::string> projection_expression_profiles(const vgi::BindParams&) const override {
+        return {vgi::SCALAR_PROJECTION_PROFILE};
+    }
+    vgi::BindRepeatability repeatability(const vgi::BindParams&) const override {
+        return vgi::BindRepeatability::StableWithinQuery;
+    }
+    vgi::ProjectionAcceptance projection(const vgi::BindParams&,
+                                         const vgi::ProjectionProposal& p) const override {
+        vgi::ProjectionAcceptance result;
+        auto fields = p.source_schema->fields();
         for (size_t i = 0; i < p.expressions.size(); ++i) {
             const auto& row = p.expressions[i];
             auto sql = std::static_pointer_cast<arrow::StringArray>(row->column(0))->GetString(0);
             auto c = std::static_pointer_cast<arrow::StructArray>(row->column(3));
-            const auto str = [&](int n) { return std::static_pointer_cast<arrow::StringArray>(c->field(n))->GetString(0); };
-            if (sql == "CAST(\"n\" AS BIGINT)" && str(0) == "UTC" && str(1) == "binary" && str(2) == "asc" && str(3) == "nulls_last" && std::static_pointer_cast<arrow::BooleanArray>(c->field(4))->Value(0) && p.result_schema->field(static_cast<int>(i))->type()->id() == arrow::Type::INT64) { result.accepted_indices.push_back(static_cast<int64_t>(i)); fields.push_back(p.result_schema->field(static_cast<int>(i))); }
+            const auto str = [&](int n) {
+                return std::static_pointer_cast<arrow::StringArray>(c->field(n))->GetString(0);
+            };
+            if (sql == "CAST(\"n\" AS BIGINT)" && str(0) == "UTC" && str(1) == "binary" &&
+                str(2) == "asc" && str(3) == "nulls_last" &&
+                std::static_pointer_cast<arrow::BooleanArray>(c->field(4))->Value(0) &&
+                p.result_schema->field(static_cast<int>(i))->type()->id() == arrow::Type::INT64) {
+                result.accepted_indices.push_back(static_cast<int64_t>(i));
+                fields.push_back(p.result_schema->field(static_cast<int>(i)));
+            }
+        }
+        if (!result.accepted_indices.empty()) {
+            result.output_schema = arrow::schema(fields, p.source_schema->metadata());
+            result.opaque_data = std::to_string(result.accepted_indices.size());
         }
-        if (!result.accepted_indices.empty()) { result.output_schema = arrow::schema(fields, p.source_schema->metadata()); result.opaque_data = std::to_string(result.accepted_indices.size()); }
         return result;
     }
-    std::unique_ptr<vgi::TableProducer> init(const vgi::ProcessParams& p) const override { return std::make_unique<ProjectionRows>(p); }
+    std::unique_ptr<vgi::TableProducer> init(const vgi::ProcessParams& p) const override {
+        return std::make_unique<ProjectionRows>(p);
+    }
 };
 }  // namespace
 

example-worker/table/static_scan.cpp

@@ -364,8 +364,8 @@ class VersionedConstraintsScan : public vgi::TableFunction {
 
     std::shared_ptr<arrow::Schema> bind(const vgi::BindParams& params) const override {
         const auto version = params.arguments.const_int64(0).value_or(3);
-        return constraint_fixtures::required_schema(
-            columns_schema(constraints_version(version)), "versioned_constraints", version);
+        return constraint_fixtures::required_schema(columns_schema(constraints_version(version)),
+                                                    "versioned_constraints", version);
     }
 
     vgi::TableCardinality cardinality(const vgi::ProcessParams& params) const override {
@@ -690,8 +690,8 @@ void register_static_scans(vgi::Worker& worker) {
     // Catalog facts and scans share these immutable arrays. Validate before
     // registration, so an invalid fixture cannot publish trusted constraints.
     for (const std::string table : {"departments", "products", "employees", "projects"}) {
-        worker.register_table(std::make_shared<StaticScan>(
-            table + "_scan", constraint_fixtures::rows(table), table));
+        worker.register_table(
+            std::make_shared<StaticScan>(table + "_scan", constraint_fixtures::rows(table), table));
     }
     // Ordered by id, not by the ENUM ordinal the statistics are derived from:
     // the two disagreeing is exactly what `column_statistics.test` checks.

include/vgi/table_function.h

@@ -174,11 +174,17 @@ class TableFunction {
 
     virtual std::unique_ptr<TableProducer> init(const ProcessParams& params) const = 0;
     // Explicit per-bind offer. Ordinary column selection never enables this hook.
-    virtual std::vector<std::string> projection_expression_profiles(const BindParams&) const { return {}; }
+    virtual std::vector<std::string> projection_expression_profiles(const BindParams&) const {
+        return {};
+    }
     // Opt in only when the bound source/transaction fixes the logical rows.
-    virtual BindRepeatability repeatability(const BindParams&) const { return BindRepeatability::Unknown; }
+    virtual BindRepeatability repeatability(const BindParams&) const {
+        return BindRepeatability::Unknown;
+    }
     // Pure planning: no resources allocated, rows consumed, or effects produced.
-    virtual ProjectionAcceptance projection(const BindParams&, const ProjectionProposal&) const { return {}; }
+    virtual ProjectionAcceptance projection(const BindParams&, const ProjectionProposal&) const {
+        return {};
+    }
 
     // The planner's estimate. The default declines to guess, which is what
     // most generators should do.

scripts/format.sh

@@ -37,8 +37,16 @@ CF="$(find_clang_format)" || {
 # Generated sources are excluded: they are rewritten from the protocol
 # definition, and formatting them only guarantees the next regeneration
 # produces a diff.
+if ! git -C "$ROOT" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  echo "format.sh requires a Git checkout to enumerate source files." >&2
+  exit 2
+fi
 mapfile -t FILES < <(cd "$ROOT" && git ls-files '*.cpp' '*.h' '*.hpp' \
   | grep -v '^include/vgi/generated/' | grep -v '^src/generated/' | grep -v '^vcpkg/')
+if [[ ${#FILES[@]} == 0 ]]; then
+  echo "format.sh found no tracked C++ sources." >&2
+  exit 2
+fi
 
 if [[ "${1:-}" == "--check" ]]; then
   failed=0