Struct QueryFile 

pub struct QueryFile {
    pub queries: Vec<QueryDef>,
}

Collection of named queries from a queries.qail file

Fields

queries: Vec<QueryDef>

Implementations

impl QueryFile

pub fn parse(input: &str) -> Result<Self, String>

Parse a query file from .qail format string

Examples found in repository

examples/test_query_parse.rs (line 26)

fn main() {
    let queries_content = r#"
-- User queries
query find_user(id: Uuid) -> User:
  get users where id = :id

query list_users() -> Vec<User>:
  get users order by created_at desc

query find_by_email(email: String) -> Option<User>:
  get users where email = :email limit 1

execute create_user(email: String, name: String):
  add::users : email, name [ :email, :name ]

execute delete_user(id: Uuid):
  del::users where id = :id
"#;

    println!("Testing query file parsing...\n");

    match QueryFile::parse(queries_content) {
        Ok(qf) => {
            println!("✓ Parsed {} queries\n", qf.queries.len());

            for q in &qf.queries {
                let kind = if q.is_execute { "execute" } else { "query" };
                let params: Vec<_> = q
                    .params
                    .iter()
                    .map(|p| format!("{}: {}", p.name, p.typ))
                    .collect();

                let return_type = match &q.return_type {
                    Some(qail_core::parser::query_file::ReturnType::Single(t)) => {
                        format!("-> {}", t)
                    }
                    Some(qail_core::parser::query_file::ReturnType::Vec(t)) => {
                        format!("-> Vec<{}>", t)
                    }
                    Some(qail_core::parser::query_file::ReturnType::Option(t)) => {
                        format!("-> Option<{}>", t)
                    }
                    None => String::new(),
                };

                println!("{} {}({}) {}", kind, q.name, params.join(", "), return_type);
                println!("  body: {}", q.body.lines().next().unwrap_or(""));
                println!();
            }

            println!("✓ All query parsing tests passed!");
        }
        Err(e) => {
            eprintln!("✗ Parse error: {}", e);
            std::process::exit(1);
        }
    }
}

pub fn find_query(&self, name: &str) -> Option<&QueryDef>

Find a query by name

pub fn to_json(&self) -> Result<String, String>

Export to JSON

pub fn from_json(json: &str) -> Result<Self, String>

Import from JSON

Trait Implementations

impl Clone for QueryFile

fn clone(&self) -> QueryFile

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QueryFile

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for QueryFile

fn default() -> QueryFile

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for QueryFile

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for QueryFile

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.