Expand description

Crate for typing SQL statements.

use sql_type::{schema::parse_schemas, type_statement, TypeOptions,
    SQLDialect, SQLArguments, StatementType};
let schemas = "
    CREATE TABLE `events` (
      `id` bigint(20) NOT NULL,
      `user` int(11) NOT NULL,
      `message` text NOT NULL
    );";

let mut issues = Vec::new();

// Compute terse representation of the schemas
let schemas = parse_schemas(schemas,
    &mut issues,
    &TypeOptions::new().dialect(SQLDialect::MariaDB));
assert!(issues.is_empty());

let sql = "SELECT `id`, `user`, `message` FROM `events` WHERE `id` = ?";
let stmt = type_statement(&schemas, sql, &mut issues,
    &TypeOptions::new().dialect(SQLDialect::MariaDB).arguments(SQLArguments::QuestionMark));
assert!(issues.is_empty());

let stmt = match stmt {
    StatementType::Select{columns, arguments} => {
        assert_eq!(columns.len(), 3);
        assert_eq!(arguments.len(), 1);
    }
    _ => panic!("Expected select statement")
};

Modules

Facility for parsing SQL schemas into a terse format that can be used for typing statements.

Structs

Represent a type with not_null information

An issue encountered during parsing, or later stages

A column in select

Options used when typing sql or parsing a schema

Enums

Key of argument

Does the insert yield an auto increment id

Canonical base type of a type

Level of an issues

Represent a reference to T or a direct T

What kinds or arguments

What sql diarect to parse as

Type information of typed statement

Represent the type of a value

Functions

Type an sql statement with respect to a given schema