Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

feat(cognitarium)!: add query expression filters #616

Merged
merged 15 commits into from
Aug 23, 2024

Conversation

amimart
Copy link
Member

@amimart amimart commented Aug 12, 2024

Closes #614

Description

Here is an API evolution to integrate expression filtering capabilities in the cognitarium querying mechanism. The changes are breaking.

The idea is to enhance the WhereClause type by renaming the old Simple by Bgp for basic graph patterns and adding a new Filter clause allowing to filter another clause based on expressions, this would allow to filter with specific variable values.

Here is an example using this to filter on a range of a height value:

{
    "filter": {
        "expr": {
            "and": [
                {
                    "greater_or_equal": [
                        {"variable": "height"},
                        {"literal": "1000"}
                    ]
                },
                {
                    "less_or_equal": [
                        {"variable": "height"},
                        {"literal": "2000"}
                    ]
                }
            ]
        },
        "inner": {
            "bgp": [
                {
                    "subject": {"variable": "subject"},
                    "predicate": {"named": {"full": "height"}},
                    "object": {"variable": "height"}
                }
            ]
        }
    }
}

In this example the BGP will provide the resolution of the height variable and the filter will then limit the possibilities for those between 1000 and 2000.

@ccamel @bdeneux I'd appreciate your insights on this design before going further in the implementation :)

Details

The WhereClause::Filter takes an inner clause and filtering matching the provided Expression. An expression internally resolves as a term, which can currently be either a String or a bool. A term can be built from a variable so it can be constructed from object literals for example, the construction of the resulting string is opinionated and impact the behaviour of comparison operators, so I'll let you juge the proposed implementation.

This implementation is very simplistic, it'd make sense in the future to provide more types of Term for a fine grained control on expression operators...

Misc

A WhereClause::LateralJoin clause has also been added to allow to join two clauses as a for loop, this was needed to make the Describe message to work with the refactoring.

The namespace resolution mechanism has been reworked by providing trait abstraction to ease tests and integration with the new filtering capabilities, it brings a lot of additional changes sorry for that..

Summary by CodeRabbit

  • New Features

    • Enhanced query flexibility by allowing optional WhereClause in query operations.
    • Introduced a new Expression type for complex logical operations in queries.
    • Added Filter variant in query plans to enable conditional filtering of results.
  • Bug Fixes

    • Improved error handling when no valid WhereClause is provided.
  • Documentation

    • Updated documentation to reflect changes in query structures, including WhereClause, Bgp, and Expression.
    • Clarified the usage of deletion conditions and query parameters.
  • Chores

    • Refactored internal logic for namespace resolution and query engine operations for better clarity and efficiency.

@amimart amimart self-assigned this Aug 12, 2024
@amimart amimart requested review from ccamel and bdeneux August 12, 2024 09:38
Copy link

coderabbitai bot commented Aug 12, 2024

Walkthrough

The changes introduce a more flexible and robust query handling system by modifying how WhereClause is utilized across various modules. The execute function now accepts an optional WhereClause, enabling queries without explicit conditions. Additionally, the Expression and Term structures enhance the logical evaluation of expressions in queries, expanding the capabilities of the query engine. Overall, the codebase has been refactored for improved clarity and efficiency in query construction and execution.

Changes

Files Change Summary
contracts/axone-cognitarium/src/contract.rs
contracts/axone-cognitarium/src/msg.rs
contracts/axone-cognitarium/src/querier/engine.rs
contracts/axone-cognitarium/src/querier/expression.rs
contracts/axone-cognitarium/src/querier/mapper.rs
contracts/axone-cognitarium/src/querier/mod.rs
contracts/axone-cognitarium/src/querier/plan.rs
contracts/axone-cognitarium/src/querier/plan_builder.rs
contracts/axone-cognitarium/src/querier/variable.rs
contracts/axone-cognitarium/src/state/mod.rs
contracts/axone-cognitarium/src/state/namespaces.rs
contracts/axone-cognitarium/src/state/test_util.rs
contracts/axone-cognitarium/src/state/triples.rs
contracts/axone-cognitarium/src/storer/engine.rs
Major refactor of query handling, introducing optional WhereClause, enhancing expression evaluation capabilities, and modifying namespace handling and resolution methods. This includes the addition of new structures like Expression and InMemoryNamespaceSolver.
contracts/axone-dataverse/src/contract.rs
contracts/axone-dataverse/src/registrar/registry.rs
Updated query conditions to use the new WhereClause structure, replacing older formats for improved query construction.
docs/axone-cognitarium.md Documentation updates to reflect changes in query parameters and the introduction of new expression types.

Sequence Diagram(s)

sequenceDiagram
    participant User
    participant QueryEngine
    participant PlanBuilder
    participant ExpressionEvaluator

    User->>QueryEngine: Execute Query with Optional WhereClause
    QueryEngine->>PlanBuilder: Build Query Plan
    PlanBuilder->>ExpressionEvaluator: Evaluate Expressions
    ExpressionEvaluator-->>PlanBuilder: Return Results
    PlanBuilder-->>QueryEngine: Return Query Plan
    QueryEngine-->>User: Return Query Results
Loading

Assessment against linked issues

Objective Addressed Explanation
Extend querying capabilities by evaluating expressions against resolved variables (614)

Poem

🐇 In fields of code, where queries play,
New clauses hop and dance today.
With expressions bright, they twist and twirl,
In logic’s embrace, new patterns unfurl.
For every byte and every line,
A rabbit’s joy—this code is divine! 🐇✨


Thank you for using CodeRabbit. We offer it for free to the OSS community and would appreciate your support in helping us grow. If you find it useful, would you consider giving us a shout-out on your favorite social media?

Share
Tips

Chat

There are 3 ways to chat with CodeRabbit:

  • Review comments: Directly reply to a review comment made by CodeRabbit. Example:
    • I pushed a fix in commit <commit_id>.
    • Generate unit testing code for this file.
    • Open a follow-up GitHub issue for this discussion.
  • Files and specific lines of code (under the "Files changed" tab): Tag @coderabbitai in a new review comment at the desired location with your query. Examples:
    • @coderabbitai generate unit testing code for this file.
    • @coderabbitai modularize this function.
  • PR comments: Tag @coderabbitai in a new PR comment to ask questions about the PR branch. For the best results, please provide a very specific query, as very limited context is provided in this mode. Examples:
    • @coderabbitai generate interesting stats about this repository and render them as a table.
    • @coderabbitai show all the console.log statements in this repository.
    • @coderabbitai read src/utils.ts and generate unit testing code.
    • @coderabbitai read the files in the src/scheduler package and generate a class diagram using mermaid and a README in the markdown format.
    • @coderabbitai help me debug CodeRabbit configuration file.

Note: Be mindful of the bot's finite context window. It's strongly recommended to break down tasks such as reading entire modules into smaller chunks. For a focused discussion, use review comments to chat about specific files and their changes, instead of using the PR comments.

CodeRabbit Commands (invoked as PR comments)

  • @coderabbitai pause to pause the reviews on a PR.
  • @coderabbitai resume to resume the paused reviews.
  • @coderabbitai review to trigger an incremental review. This is useful when automatic reviews are disabled for the repository.
  • @coderabbitai full review to do a full review from scratch and review all the files again.
  • @coderabbitai summary to regenerate the summary of the PR.
  • @coderabbitai resolve resolve all the CodeRabbit review comments.
  • @coderabbitai configuration to show the current CodeRabbit configuration for the repository.
  • @coderabbitai help to get help.

Additionally, you can add @coderabbitai ignore anywhere in the PR description to prevent this PR from being reviewed.

CodeRabbit Configuration File (.coderabbit.yaml)

  • You can programmatically configure CodeRabbit by adding a .coderabbit.yaml file to the root of your repository.
  • Please see the configuration documentation for more information.
  • If your editor has YAML language server enabled, you can add the path at the top of this file to enable auto-completion and validation: # yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json

Documentation and Community

  • Visit our Documentation for detailed information on how to use CodeRabbit.
  • Join our Discord Community to get help, request features, and share feedback.
  • Follow us on X/Twitter for updates and announcements.

@ccamel
Copy link
Member

ccamel commented Aug 14, 2024

Sounds good 👍

adopt a more specific naming for the type of clauses and allow to
combine multiple ones, simplifying the addition of new ones
@amimart amimart force-pushed the feat/cognitarium-expr-eval branch 2 times, most recently from 2c882ca to 87b53fa Compare August 21, 2024 20:17
@amimart amimart force-pushed the feat/cognitarium-expr-eval branch from 87b53fa to e179988 Compare August 22, 2024 08:41
@amimart amimart force-pushed the feat/cognitarium-expr-eval branch from a374a14 to 73df19c Compare August 22, 2024 11:28
@bot-anik
Copy link
Member

size-limit report 📦

Path Size
target/wasm32-unknown-unknown/release/axone_objectarium.wasm 458.07 KB (0%)
target/wasm32-unknown-unknown/release/axone_law_stone.wasm 648.51 KB (0%)
target/wasm32-unknown-unknown/release/axone_cognitarium.wasm 877.09 KB (+5.51% 🔺)
target/wasm32-unknown-unknown/release/axone_dataverse.wasm 678.36 KB (+1.19% 🔺)

@amimart amimart marked this pull request as ready for review August 22, 2024 13:47
Copy link

@coderabbitai coderabbitai bot left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Actionable comments posted: 3

Outside diff range, codebase verification and nitpick comments (3)
contracts/axone-cognitarium/src/querier/mod.rs (1)

2-2: Consider documenting the new expression module.

The addition of the expression module suggests new functionality. Consider adding documentation to clarify its purpose and usage.

contracts/axone-cognitarium/src/state/test_util.rs (1)

1-3: Consider adding documentation for InMemoryNamespaceSolver.

Adding documentation will help clarify the purpose and usage of this in-memory solver for future developers.

contracts/axone-cognitarium/src/msg.rs (1)

469-482: Enhance documentation for WhereClause.

The WhereClause enum now supports Bgp, LateralJoin, and Filter. Ensure that the documentation clearly explains each variant's purpose and usage, especially the new Filter variant.

Consider adding examples to illustrate how each variant can be used in queries.

Review details

Configuration used: CodeRabbit UI
Review profile: CHILL

Commits

Files that changed from the base of the PR and between 63b8573 and dcc7155.

Files selected for processing (17)
  • contracts/axone-cognitarium/src/contract.rs (45 hunks)
  • contracts/axone-cognitarium/src/msg.rs (4 hunks)
  • contracts/axone-cognitarium/src/querier/engine.rs (23 hunks)
  • contracts/axone-cognitarium/src/querier/expression.rs (1 hunks)
  • contracts/axone-cognitarium/src/querier/mapper.rs (3 hunks)
  • contracts/axone-cognitarium/src/querier/mod.rs (1 hunks)
  • contracts/axone-cognitarium/src/querier/plan.rs (6 hunks)
  • contracts/axone-cognitarium/src/querier/plan_builder.rs (12 hunks)
  • contracts/axone-cognitarium/src/querier/variable.rs (7 hunks)
  • contracts/axone-cognitarium/src/state/mod.rs (1 hunks)
  • contracts/axone-cognitarium/src/state/namespaces.rs (5 hunks)
  • contracts/axone-cognitarium/src/state/test_util.rs (1 hunks)
  • contracts/axone-cognitarium/src/state/triples.rs (2 hunks)
  • contracts/axone-cognitarium/src/storer/engine.rs (2 hunks)
  • contracts/axone-dataverse/src/contract.rs (2 hunks)
  • contracts/axone-dataverse/src/registrar/registry.rs (2 hunks)
  • docs/axone-cognitarium.md (8 hunks)
Additional context used
GitHub Check: codecov/patch
contracts/axone-cognitarium/src/state/test_util.rs

[warning] 35-40: contracts/axone-cognitarium/src/state/test_util.rs#L35-L40
Added lines #L35 - L40 were not covered by tests

contracts/axone-cognitarium/src/querier/plan.rs

[warning] 115-118: contracts/axone-cognitarium/src/querier/plan.rs#L115-L118
Added lines #L115 - L118 were not covered by tests

contracts/axone-cognitarium/src/state/namespaces.rs

[warning] 220-222: contracts/axone-cognitarium/src/state/namespaces.rs#L220-L222
Added lines #L220 - L222 were not covered by tests

contracts/axone-cognitarium/src/querier/engine.rs

[warning] 163-172: contracts/axone-cognitarium/src/querier/engine.rs#L163-L172
Added lines #L163 - L172 were not covered by tests


[warning] 223-223: contracts/axone-cognitarium/src/querier/engine.rs#L223
Added line #L223 was not covered by tests


[warning] 773-773: contracts/axone-cognitarium/src/querier/engine.rs#L773
Added line #L773 was not covered by tests

contracts/axone-cognitarium/src/contract.rs

[warning] 106-106: contracts/axone-cognitarium/src/contract.rs#L106
Added line #L106 was not covered by tests


[warning] 230-232: contracts/axone-cognitarium/src/contract.rs#L230-L232
Added lines #L230 - L232 were not covered by tests


[warning] 291-291: contracts/axone-cognitarium/src/contract.rs#L291
Added line #L291 was not covered by tests

Markdownlint
docs/axone-cognitarium.md

420-420: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


421-421: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


422-422: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


525-525: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


526-526: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


550-550: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


551-551: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


552-552: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


571-571: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


572-572: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


599-599: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


600-600: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


601-601: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


644-644: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


645-645: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


646-646: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


741-741: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


924-924: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)

Additional comments not posted (40)
contracts/axone-cognitarium/src/querier/mod.rs (1)

9-9: Ensure the plan module export is necessary.

The plan module is now publicly exported. Verify that this export is required and aligns with the intended architecture.

contracts/axone-cognitarium/src/state/mod.rs (1)

11-14: Good practice: Conditional compilation for testing utilities.

The use of #[cfg(test)] for the test_util module is a good practice, ensuring it only compiles during testing.

contracts/axone-cognitarium/src/querier/mapper.rs (3)

Line range hint 9-20: Simplification and renaming approved.

The changes to literal_as_object simplify the function by removing the storage dependency and align with the new NamespaceSolver naming convention.


Line range hint 26-39: Simplification and renaming approved.

The changes to iri_as_node simplify the function by removing the storage dependency and align with the new NamespaceSolver naming convention.


43-48: New function addition approved.

The iri_as_string function provides a useful utility for converting IRI types into strings. The implementation is straightforward and aligns with existing patterns.

contracts/axone-dataverse/src/registrar/registry.rs (1)

39-47: Enhanced query flexibility approved.

The use of WhereClause::Bgp allows for more complex graph patterns, aligning with the PR objectives of enhancing querying capabilities. The changes maintain the intended functionality.

contracts/axone-cognitarium/src/querier/plan.rs (4)

24-29: New method addition approved.

The empty_plan method provides a straightforward way to create an empty QueryPlan, enhancing usability. The implementation is simple and aligns with the intended functionality.


77-78: New variant addition approved.

The Filter variant in QueryNode enhances query capabilities by allowing filtering based on an Expression. This aligns with the PR objectives of improving query precision.


88-91: New method addition approved.

The noop method provides a way to create a no-operation node, improving the flexibility of constructing query nodes. The implementation is straightforward and aligns with the intended functionality.


115-118: Modification for Filter variant approved.

The changes to lookup_bound_variables ensure that the Filter variant is correctly handled, maintaining the integrity of variable management. The implementation is consistent with existing patterns.

Tools
GitHub Check: codecov/patch

[warning] 115-118: contracts/axone-cognitarium/src/querier/plan.rs#L115-L118
Added lines #L115 - L118 were not covered by tests

contracts/axone-cognitarium/src/state/triples.rs (1)

154-155: LGTM! Verify NamespaceSolver implementation.

The change to use NamespaceSolver enhances type safety and clarity. Ensure that the NamespaceSolver trait is correctly implemented for all necessary structures.

Run the following script to verify the NamespaceSolver trait implementation:

contracts/axone-cognitarium/src/storer/engine.rs (1)

283-286: LGTM!

The refactoring of the node_size function improves readability and reduces code complexity while maintaining functionality.

contracts/axone-cognitarium/src/state/namespaces.rs (1)

44-47: LGTM!

The renaming of NamespaceResolver to NamespaceQuerier and the introduction of NamespaceSolver enhance modularity and clarity in namespace management.

contracts/axone-cognitarium/src/querier/variable.rs (3)

Line range hint 54-99: LGTM! The as_value method changes enhance flexibility.

The update to accept a mutable reference to a NamespaceSolver trait object improves the method's extensibility.


101-124: LGTM! The as_term method is well-implemented.

The method effectively converts ResolvedVariable instances into Term objects using the NamespaceSolver.


177-187: LGTM! The HasBoundVariables trait adds useful abstraction.

The trait provides a structured approach for handling variable lookups, enhancing the module's functionality.

contracts/axone-dataverse/src/contract.rs (2)

145-146: LGTM! The import for WhereClause is necessary.

The addition of the WhereClause import reflects its new usage in query construction.


306-314: LGTM! The test case update improves clarity.

The use of WhereClause::Bgp allows for more structured query conditions in the test.

contracts/axone-cognitarium/src/querier/expression.rs (3)

10-70: LGTM! The Expression enum and evaluate method are well-implemented.

The enum provides a comprehensive set of logical operations, and the evaluate method effectively handles different expression types.


100-153: LGTM! The Term enum and its methods are well-designed.

The enum provides necessary conversions and comparisons, and the methods are implemented correctly.


155-512: LGTM! The test cases are comprehensive and thorough.

The tests cover various scenarios, ensuring the correctness of the Expression and Term implementations.

contracts/axone-cognitarium/src/msg.rs (2)

76-76: Ensure backward compatibility with optional WhereClause.

The r#where field in both DeleteData and DescribeQuery has been changed to Option<WhereClause>. Ensure that any existing code handling these structures can accommodate the possibility of a None value.

Consider adding tests to verify the behavior when r#where is None.

Also applies to: 428-428


485-514: Verify logical operations in Expression.

The Expression enum supports various logical operations. Ensure that these operations are correctly implemented and tested, especially complex combinations of And, Or, and Not.

Consider adding tests to cover edge cases and complex logical expressions.

contracts/axone-cognitarium/src/querier/plan_builder.rs (2)

14-14: Initialize ns_resolver correctly in PlanBuilder.

The ns_resolver field is initialized using NamespaceResolver::new. Ensure that the initialization correctly handles the provided storage and ns_cache.

Consider adding tests to verify the behavior of PlanBuilder with different namespace configurations.


68-87: Ensure comprehensive testing of build_node.

The build_node method handles different WhereClause variants. Ensure that each variant is correctly processed and that error handling, especially for unbound variables, is robust.

Consider adding tests to cover each WhereClause variant and potential error scenarios.

contracts/axone-cognitarium/src/querier/engine.rs (3)

22-22: Ensure ns_cache is correctly utilized in QueryEngine.

The ns_cache field is introduced to manage namespaces. Ensure that it is correctly initialized and used throughout the QueryEngine.

Consider adding tests to verify the behavior of QueryEngine with different namespace configurations.


163-172: Add test coverage for FilterIterator.

The FilterIterator is a new addition that implements filtering logic. Ensure that it is thoroughly tested, especially for edge cases and complex expressions.

Consider adding tests to cover the filtering logic and potential error scenarios.

Tools
GitHub Check: codecov/patch

[warning] 163-172: contracts/axone-cognitarium/src/querier/engine.rs#L163-L172
Added lines #L163 - L172 were not covered by tests


773-773: Add test coverage for literal_as_object.

The literal_as_object function is used in build_object_template. Ensure that it is correctly implemented and tested, especially for different literal types.

Consider adding tests to cover various literal conversions and potential error scenarios.

Tools
GitHub Check: codecov/patch

[warning] 773-773: contracts/axone-cognitarium/src/querier/engine.rs#L773
Added line #L773 was not covered by tests

docs/axone-cognitarium.md (6)

423-423: Verify the delete_data.where parameter description.

Ensure that the WhereClause type and its usage are accurately described in the documentation.


552-552: Verify the where parameter in construct query description.

Ensure that the WhereClause type and its usage in the construct query are accurately described in the documentation.

Tools
Markdownlint

552-552: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


573-573: Verify the where parameter in describe query description.

Ensure that the WhereClause type and its usage in the describe query are accurately described in the documentation.


910-910: Verify consistency of WhereCondition to WhereClause renaming.

Ensure that the renaming is consistently applied throughout the documentation.


519-527: Verify the new Bgp section description.

Ensure that the Bgp construct and its usage are accurately described in the new section.

Tools
Markdownlint

525-525: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


526-526: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


Line range hint 575-647: Verify the new sections for Expression, Filter, and LateralJoin.

Ensure that the constructs and their usage are accurately described in the new sections.

Tools
Markdownlint

571-571: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


572-572: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


599-599: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


600-600: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)


601-601: null
Spaces inside emphasis markers

(MD037, no-space-in-emphasis)

contracts/axone-cognitarium/src/contract.rs (6)

96-107: Verify the correctness of the execute function changes.

Ensure that the changes to handle an optional WhereClause are correctly implemented and consistent with the PR objectives.

Tools
GitHub Check: codecov/patch

[warning] 106-106: contracts/axone-cognitarium/src/contract.rs#L106
Added line #L106 was not covered by tests


101-107: Verify the logic of the delete function.

Ensure that the logic for handling the delete vector and r#where parameter is correctly implemented.

Tools
GitHub Check: codecov/patch

[warning] 106-106: contracts/axone-cognitarium/src/contract.rs#L106
Added line #L106 was not covered by tests


223-233: Verify the correctness of the describe function changes.

Ensure that the usage of WhereClause for query construction is correctly implemented.

Tools
GitHub Check: codecov/patch

[warning] 230-232: contracts/axone-cognitarium/src/contract.rs#L230-L232
Added lines #L230 - L232 were not covered by tests


282-292: Verify the correctness of the construct function changes.

Ensure that the usage of WhereClause for query construction is correctly implemented.

Tools
GitHub Check: codecov/patch

[warning] 291-291: contracts/axone-cognitarium/src/contract.rs#L291
Added line #L291 was not covered by tests


203-203: Verify the correctness of the select function changes.

Ensure that the usage of WhereClause for query construction is correctly implemented.


Line range hint 354-363: Verify the correctness of the map_select_solutions function.

Ensure that the function correctly maps query solutions to the expected response format.

Copy link
Contributor

@bdeneux bdeneux left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Seems very good ! Great job ! 👏

Copy link
Member

@ccamel ccamel left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

That's good 👍

@amimart amimart merged commit 844a8b9 into main Aug 23, 2024
17 checks passed
@amimart amimart deleted the feat/cognitarium-expr-eval branch September 4, 2024 14:29
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

Successfully merging this pull request may close these issues.

🤯 Filter query with expressions
4 participants