Updates for documentation

Author: JasonAtClockwork

docs/docs/00200-core-concepts/00100-databases/00500-cheat-sheet.md

@@ -720,6 +720,14 @@ SPACETIMEDB_VIEW(std::vector<Player>, top_players, Public, ViewContext ctx) {
     return ctx.db[player_score].filter(range_from(int32_t(1000))).collect();
 }
 
+// Perform a generic filter using the query builder.
+// Equivalent to `SELECT * FROM player WHERE score < 1000`.
+SPACETIMEDB_VIEW(Query<Player>, bottom_players, Public, ViewContext ctx) {
+    return ctx.from[player].where([](const auto& p) {
+        return p.score.lt(uint64_t(1000));
+    });
+}
+
 struct PlayerCount {
     uint64_t count;
 };

docs/docs/00200-core-concepts/00200-functions/00500-views.md

@@ -285,7 +285,7 @@ SPACETIMEDB_VIEW(std::vector<PlayerAndLevel>, players_for_level, Public, Anonymo
 }
 ```
 
-Views can return either `std::optional<T>` for at-most-one row or `std::vector<T>` for multiple rows, where `T` can be a table type or any product type.
+Views can return `std::optional<T>` for at-most-one row, `std::vector<T>` for multiple rows, or a query-builder type, where `T` can be a table type or any product type.
 
 </TabItem>
 </Tabs>
@@ -895,6 +895,21 @@ fn high_scorers(ctx: &AnonymousViewContext) -> impl Query<Player> {
 }
 ```
 
+</TabItem>
+<TabItem value="cpp" label="C++">
+
+```cpp
+SPACETIMEDB_VIEW(Query<Player>, high_scorers, Public, AnonymousViewContext ctx) {
+    return ctx.from[player]
+        .where([](const auto& p) {
+            return p.score.gte(uint64_t(1000));
+        })
+        .where([](const auto& p) {
+            return p.name.ne("BOT");
+        });
+}
+```
+
 </TabItem>
 </Tabs>
 
@@ -1000,6 +1015,34 @@ fn high_scoring_moderators_declarative(ctx: &AnonymousViewContext) -> impl Query
 }
 ```
 
+</TabItem>
+<TabItem value="cpp" label="C++">
+
+```cpp
+// Procedural: row-by-row join in module code.
+SPACETIMEDB_VIEW(std::vector<Player>, high_scoring_moderators_procedural, Public, AnonymousViewContext ctx) {
+    std::vector<Player> results;
+    for (const auto& p : ctx.db[player_score].filter(range_from(uint64_t(100)))) {
+        if (!ctx.db[moderator_player_id].filter(p.id).empty()) {
+            results.push_back(p);
+        }
+    }
+    return results;
+}
+
+// Query builder: equivalent logic pushed to the query engine.
+// The engine can reorder this join if it decides the smaller side is a better starting point.
+SPACETIMEDB_VIEW(Query<Player>, high_scoring_moderators_declarative, Public, AnonymousViewContext ctx) {
+    return ctx.from[player]
+        .where([](const auto& p) {
+            return p.score.gte(uint64_t(100));
+        })
+        .left_semijoin(ctx.from[moderator], [](const auto& p, const auto& m) {
+            return p.id.eq(m.player_id);
+        });
+}
+```
+
 </TabItem>
 </Tabs>
 
@@ -1123,6 +1166,38 @@ fn all_player_levels(ctx: &AnonymousViewContext) -> impl Query<PlayerLevel> {
 }
 ```
 
+</TabItem>
+<TabItem value="cpp" label="C++">
+
+```cpp
+struct Player {
+    uint64_t id;
+    std::string name;
+    uint64_t score;
+};
+SPACETIMEDB_STRUCT(Player, id, name, score)
+SPACETIMEDB_TABLE(Player, player, Public)
+FIELD_PrimaryKey(player, id)
+FIELD_Index(player, score)
+
+struct PlayerLevel {
+    uint64_t player_id;
+    uint64_t level;
+};
+SPACETIMEDB_STRUCT(PlayerLevel, player_id, level)
+SPACETIMEDB_TABLE(PlayerLevel, player_level, Public)
+FIELD_Unique(player_level, player_id)
+FIELD_Index(player_level, level)
+
+SPACETIMEDB_VIEW(Query<Player>, all_players, Public, AnonymousViewContext ctx) {
+    return ctx.from[player];
+}
+
+SPACETIMEDB_VIEW(Query<PlayerLevel>, all_player_levels, Public, AnonymousViewContext ctx) {
+    return ctx.from[player_level];
+}
+```
+
 </TabItem>
 </Tabs>
 
@@ -1184,6 +1259,21 @@ fn high_scorers(ctx: &AnonymousViewContext) -> impl Query<Player> {
 }
 ```
 
+</TabItem>
+<TabItem value="cpp" label="C++">
+
+```cpp
+SPACETIMEDB_VIEW(Query<Player>, high_scorers, Public, AnonymousViewContext ctx) {
+    return ctx.from[player]
+        .where([](const auto& p) {
+            return p.score.gte(uint64_t(1000));
+        })
+        .filter([](const auto& p) {
+            return p.name.ne("BOT");
+        });
+}
+```
+
 </TabItem>
 </Tabs>
 
@@ -1218,6 +1308,15 @@ ctx.from.player().r#where(|p| p.name.eq("ADMIN").or(p.name.eq("BOT")));
 ctx.from.player().r#where(|p| p.name.eq("BOT").not());
 ```
 
+</TabItem>
+<TabItem value="cpp" label="C++">
+
+```cpp
+ctx.from[player].where([](const auto& p) { return p.score.gte(uint64_t(1000)).and_(p.score.lt(uint64_t(5000))); });
+ctx.from[player].where([](const auto& p) { return p.name.eq("ADMIN").or_(p.name.eq("BOT")); });
+ctx.from[player].where([](const auto& p) { return p.name.eq("BOT").not_(); });
+```
+
 </TabItem>
 </Tabs>
 
@@ -1302,6 +1401,31 @@ fn levels_for_high_scorers(ctx: &AnonymousViewContext) -> impl Query<PlayerLevel
 }
 ```
 
+</TabItem>
+<TabItem value="cpp" label="C++">
+
+```cpp
+SPACETIMEDB_VIEW(Query<Player>, players_with_levels, Public, AnonymousViewContext ctx) {
+    return ctx.from[player]
+        .left_semijoin(ctx.from[player_level], [](const auto& p, const auto& pl) {
+            return p.id.eq(pl.player_id);
+        });
+}
+
+SPACETIMEDB_VIEW(Query<PlayerLevel>, levels_for_high_scorers, Public, AnonymousViewContext ctx) {
+    return ctx.from[player]
+        .where([](const auto& p) {
+            return p.score.gte(uint64_t(1000));
+        })
+        .right_semijoin(ctx.from[player_level], [](const auto& p, const auto& pl) {
+            return p.id.eq(pl.player_id);
+        })
+        .where([](const auto& pl) {
+            return pl.level.gte(uint64_t(10));
+        });
+}
+```
+
 </TabItem>
 </Tabs>