#orm #query #parser #compile-time


Query parser for the ORM for Scylla, fully compatible with Apache Cassandra™

19 releases

0.1.20 Oct 26, 2023
0.1.17 Sep 7, 2023
0.1.14 Jul 9, 2023
0.1.12 Jan 31, 2023
0.1.0 Jan 20, 2022

#134 in Procedural macros

Download history 21/week @ 2023-08-08 27/week @ 2023-08-15 19/week @ 2023-08-22 19/week @ 2023-08-29 142/week @ 2023-09-05 11/week @ 2023-09-12 10/week @ 2023-09-19 10/week @ 2023-09-26 20/week @ 2023-10-03 76/week @ 2023-10-10 30/week @ 2023-10-17 105/week @ 2023-10-24 83/week @ 2023-10-31 87/week @ 2023-11-07 133/week @ 2023-11-14 84/week @ 2023-11-21

389 downloads per month
Used in catalytic_macro

MIT license


Catalytic: ScyllaDB and Cassandra Object-Relation Mapper

Latest Version Build Status

This library contains several crates with the following features:
  • Automatic map tables to Rust structs: catalytic_table_to_struct. See Usage. See the generated dir for the generated code.
  • Compile time checked queries: catalytic_macro (catalytic_macro::query). See Usage.
  • Plugin derive macro to generate business logic: catalytic_macro (catalytic_macro::mirror)
  • Automatic JSON mapping. When there is a column with type text, you can implement the Transformer trait and map it to a type that implements serde::Serialize and serde::Deserialize
  • All queries are executed as a prepared statement
  • Support for Materialized Views (and mapping between the base table if the columns are the same)

Not all types are supported yet due to https://github.com/scylladb/scylla-rust-driver/issues/104

Query types

Depending on a query, a certain query type can be derived. These can be found here. These are the commonly used query types:

  • SelectMultiple: Can be used as an iterator to iterate over the rows
  • SelectUnique: Selects an optional unique row by full primary key
  • SelectUniqueExpect: Same as SelectUnique, but fails if the row doesn't exist
  • SelectUniqueExpect with Count as entity type: has the special select_count method for queries like "select count(*) from ..."

There are also structs for CRUD operations.


Automatic map tables to Rust

You can see an example on how to generate Rust structs in the example dir.

  • In the build.rs file the Transformer trait is implemented and used for json mapping
  • In the generated dir you can see the generated structs

How to implement it yourself (step-by-step guide how to mimic the example crate):

  • Add a build-dependency: catalytic_table_to_struct = "0.1"
  • Create a build.rs file
  • Optionally implement the Tranformer trait (or use DefaultTransformer)
  • Call catalytic_table_to_struct::generate
  • Build the project

An example of the structure of the generated code for table 'child' is:

  • Child: a struct with owned values. Can be converted to ChildRef, PrimaryKey and PrimaryKeyRef
  • ChildRef: a struct where the values are all borrowed. This struct can perform insertions. Can be converted to Child, PrimaryKey and PrimaryKeyRef
  • PrimaryKey: a struct which holds the owned values of the primary key fields of Child. Can be converted to PrimaryKeyRef.
  • PrimaryKeyRef: a struct where the values are all borrowed. This struct can perform updates, deletions and selects. Can be converted to PrimaryKey
  • UpdatableColumn: an enum which holds the enum variants with owned values of columns that can be updated. Can be converted to UpdatableColumnRef.
  • UpdatableColumnRef: an enum where the values are all borrowed. This is used by PrimaryKeyRef for updates. Can be converted to UpdatableColumn.


Crate catalytic_macro holds several macros that can be used to ensure compile/type checked queries. Examples on how this can be used can be found in lib.rs, method qmd.

How to implement it yourself:

  • Add dependency: catalytic_macro = "0.1"
  • The query macro returns the correct query type for the given query
  • The query_base_table macro transforms a select query to the materialized view table, to a select query of the base table
  • mirror and primary_key can be used for other derive macros


~310K SLoC