sql_create_parser is both an executable binary that can be run, and a library that can be used in Rust programs.

Installing the command-line executable

Assuming you have Rust/Cargo installed, run this command in a terminal:

cargo install sql_create_parser

It will make the sql_create_parser command available in your PATH if you've allowed the PATH to be modified when installing Rust. cargo uninstall sql_create_parser uninstalls.

Adding `sql_create_parser` library as a dependency

Run this command in a terminal, in your project's directory:

cargo add sql_create_parser

To add it manually, edit your project's Cargo.toml file and add to the [dependencies] section:

sql_create_parser = "0.1.3"

The sql_create_parser library will be automatically available globally. Read the sql_create_parser library documentation.

Back to the crate overview.

Readme

sql_create_parser

Overview

A command-line tool designed to parse and analyze SQL CREATE TABLE queries. Developed in Rust, it uses the pest parser generator to produce a well-structured Abstract Syntax Tree (AST) that represents the input query.

Technical Description

This tool parses CREATE TABLE statements. The parser identifies the table name and a list of column definitions. Each column definition consists of a column name and its corresponding data type.

Supported data types:

INT
TEXT
BOOLEAN
DATE
VARCHAR(n) (where 'n' is a number)
NOT NULL constraint

The parsing process uses a pest grammar to generate a parse tree, which is then traversed to build a strongly-typed AST (CreateTableQuery). This AST can be used for schema validation, code generation, or database migration analysis.

Features

Parse SQL CREATE TABLE Queries (including NOT NULL).
Abstract Syntax Tree (AST) Generation.
Simple Command-Line Interface.
Detailed error handling with thiserror.
Includes Makefile for easy building, testing, and linting.

AST (Data Structures)

CreateTableQuery:
- table_name: The name of the table.
- columns: A Vec<ColumnDef> of column definitions.
ColumnDef:
- name: The name of the column.
- data_type: A DataType enum.
- not_null: A bool indicating if the NOT NULL constraint is present.
DataType (enum):
- Simple(String): e.g., INT, TEXT.
- Varchar(u64): e.g., VARCHAR(255).

Links

Crate on crates.io
Documentation on docs.rs

Installation

Clone the repository:

git clone https://github.com/prymochenkovictoria/sql_create_parser
cd sql_create_parser

Example

We have an example file:

CREATE TABLE users (
    user_id INT,
    username VARCHAR(100) NOT NULL,
    email TEXT,
    is_active BOOLEAN,
    created_at DATE
);

It will be parsed like this:

Parsed Query:
CreateTableQuery {
    table_name: "users",
    columns: [
        ColumnDef {
            name: "user_id",
            data_type: Simple(
                "INT",
            ),
            not_null: false,
        },
        ColumnDef {
            name: "username",
            data_type: Varchar(
                100,
            ),
            not_null: true,
        },
        ColumnDef {
            name: "email",
            data_type: Simple(
                "TEXT",
            ),
            not_null: false,
        },
        ColumnDef {
            name: "is_active",
            data_type: Simple(
                "BOOLEAN",
            ),
            not_null: false,
        },
        ColumnDef {
            name: "created_at",
            data_type: Simple(
                "DATE",
            ),
            not_null: false,
        },
    ],
}

Grammar

WHITESPACE = _{" " | "\t" | "\r" | "\n"}

CREATE = {"CREATE" | "create"}
TABLE = {"TABLE" | "table"}

NOT = {"NOT" | "not"}
NULL = {"NULL" | "null"}

identifier = @{(ASCII_ALPHA | "_") ~ (ASCII_ALPHANUMERIC | "_")*}

number = @{ASCII_DIGIT+}

simple_type = @{"INT" | "int" | "TEXT" | "text" | "BOOLEAN" | "boolean" | "DATE" | "date"}

varchar_type = {("VARCHAR" | "varchar") ~ "(" ~ number ~ ")"}

data_type = {simple_type | varchar_type}

not_null_constraint = {(NOT ~ NULL)}

column_definition = {identifier ~ data_type ~ not_null_constraint?}

column_list = {column_definition ~ ("," ~ column_definition)*}

create_query = {SOI ~ CREATE ~ TABLE ~ identifier ~ "(" ~ column_list ~ ")" ~ (";")? ~ EOI}

Installing the command-line executable

Adding sql_create_parser library as a dependency

Adding `sql_create_parser` library as a dependency