inquerest

Inquerest can parse complex url query into a SQL abstract syntax tree.

Example this url:

 /person?age=lt.42&(student=eq.true|gender=eq.'M')&group_by=sum(age),grade,gender&having=min(age)=gt.42&order_by=age.desc,height.asc&page=20&page_size=100

will be parsed into:

Select {
        from_table: FromTable {
            from: Table {
                name: "person",
            },
            join: None,
        },
        filter: Some(
            BinaryOperation(
                BinaryOperation {
                    left: BinaryOperation(
                        BinaryOperation {
                            left: Column(
                                Column {
                                    name: "age",
                                },
                            ),
                            operator: Lt,
                            right: Value(
                                Number(
                                    42.0,
                                ),
                            ),
                        },
                    ),
                    operator: And,
                    right: Nested(
                        BinaryOperation(
                            BinaryOperation {
                                left: BinaryOperation(
                                    BinaryOperation {
                                        left: Column(
                                            Column {
                                                name: "student",
                                            },
                                        ),
                                        operator: Eq,
                                        right: Value(
                                            Bool(
                                                true,
                                            ),
                                        ),
                                    },
                                ),
                                operator: Or,
                                right: BinaryOperation(
                                    BinaryOperation {
                                        left: Column(
                                            Column {
                                                name: "gender",
                                            },
                                        ),
                                        operator: Eq,
                                        right: Value(
                                            String(
                                                "M",
                                            ),
                                        ),
                                    },
                                ),
                            },
                        ),
                    ),
                },
            ),
        ),
        group_by: Some(
            [
                Function(
                    Function {
                        name: "sum",
                        params: [
                            Column(
                                Column {
                                    name: "age",
                                },
                            ),
                        ],
                    },
                ),
                Column(
                    Column {
                        name: "grade",
                    },
                ),
                Column(
                    Column {
                        name: "gender",
                    },
                ),
            ],
        ),
        having: Some(
            BinaryOperation(
                BinaryOperation {
                    left: Function(
                        Function {
                            name: "min",
                            params: [
                                Column(
                                    Column {
                                        name: "age",
                                    },
                                ),
                            ],
                        },
                    ),
                    operator: Gt,
                    right: Value(
                        Number(
                            42.0,
                        ),
                    ),
                },
            ),
        ),
        projection: None,
        order_by: Some(
            [
                Order {
                    expr: Column(
                        Column {
                            name: "age",
                        },
                    ),
                    direction: Some(
                        Desc,
                    ),
                },
                Order {
                    expr: Column(
                        Column {
                            name: "height",
                        },
                    ),
                    direction: Some(
                        Asc,
                    ),
                },
            ],
        ),
        range: Some(
            Page(
                Page {
                    page: 20,
                    page_size: 100,
                },
            ),
        ),
    }

Which translate to the sql statement:

SELECT * FROM person WHERE age < 42 AND (student = true OR gender = 'M') GROUP BY sum(age), grade, gender HAVING min(age) > 42 ORDER BY age DESC, height ASC LIMIT 100 OFFSET 1900 ROWS

Note: However, you don't want to convert to the sql statement directly to avoid sql injection attack. You need to validate the tables and columns if it is allowed to be accessed by the user. You also need to extract the values yourself and supply it as a parameterized value into your ORM.

Please support this project:

License: MIT

A fast, extensible, command-line arguments parser

parkour A fast, extensible, command-line arguments parser. Introduction 📚 The most popular argument parser, clap, allows you list all the possible ar

18 Apr 19, 2021

Soon to be AsciiDoc parser implemented in rust!

pagliascii "But ASCII Doc, I am Pagliascii" Soon to be AsciiDoc parser implemented in rust! This project is the current implementation of the requeste

49 Dec 11, 2022

An LR parser generator, implemented as a proc macro

parsegen parsegen is an LR parser generator, similar to happy, ocamlyacc, and lalrpop. It currently generates canonical LR(1) parsers, but LALR(1) and

5 Feb 28, 2022

A rusty, dual-wielding Quake and Half-Life texture WAD parser.

Ogre A rusty, dual-wielding Quake and Half-Life texture WAD parser ogre is a rust representation and nom parser for Quake and Half-Life WAD files. I

16 Dec 5, 2022

A modern dialogue executor and tree parser using YAML.

A modern dialogue executor and tree parser using YAML. This crate is for building(ex), importing/exporting(ex), and walking(ex) dialogue trees. convo

27 Aug 3, 2022

A friendly parser combinator crate

Chumsky A friendly parser combinator crate that makes writing LL-1 parsers with error recovery easy. Example Here follows a Brainfuck parser. See exam

2.4k Jan 8, 2023

Minimalist pedantic command line parser

Lexopt Lexopt is an argument parser for Rust. It tries to have the simplest possible design that's still correct. It's so simple that it's a bit tedio

155 Dec 28, 2022

Universal configuration library parser

LIBUCL Table of Contents generated with DocToc Introduction Basic structure Improvements to the json notation General syntax sugar Automatic arrays cr

1.5k Jan 7, 2023

PEG parser for YAML written in Rust 🦀

yaml-peg PEG parser (pest) for YAML written in Rust 🦀 Quick Start ⚡️ # Run cargo run -- --file example_files/test.yaml # Output { "xmas": "true",

4 Sep 17, 2022

Comments

PostgREST

This is an interesting project; have you come across PostgREST?

Looks like theremight be some similarity in the param syntax

(feel free to close this after reading by the way, it's not really an issue)

opened by cpursley 1
convert doc comment to regular comment

rust-lang/rust#57882 is modifying the unused_doc_comments lint to fire on mistakenly documented macro expansions. A crater run detected that this crate will break due to this change, likely because of the use of deny(unused_doc_comments) or deny(warnings).

While this kind of breakage is allowed under Rust's stability guarantees, I am opening PRs to affected crates to reduce the impact.

This PR protects your crate from future breakage by converting the offending doc comment to a regular comment.

This change is

opened by euclio 0