🥮 mooncakes.io

sqlparser

Extensible SQL Lexer and Parser in MoonBit

sql
parser
lexer
moon add Milky2018/sqlparser@0.5.0
Download zip
Author
Version
0.5.0
License
Apache-2.0
Repository
Last updated
8 months ago
Downloads
31

Dependencies

README

#Extensible SQL Lexer and Parser for MoonBit

A comprehensive SQL parser library for MoonBit that supports multiple SQL dialects and all major SQL language categories.

#Example Usage

// Parse a simple SELECT statement
let sql = "SELECT name, age FROM users WHERE age > 18"
let statements = parse_sql(sql)
let pretty_output = statements.stmts[0] |> pretty_print
println(pretty_output)

// Parse complex queries with CTEs
let complex_sql = """
WITH sales AS (
  SELECT user_id, SUM(amount) as total
  FROM orders 
  WHERE date > '2023-01-01'
  GROUP BY user_id
)
SELECT u.name, s.total
FROM users u
JOIN sales s ON u.id = s.user_id
ORDER BY s.total DESC
LIMIT 10
"""
let result = parse_sql(complex_sql)

// Parse transaction control statements
let tcl_sql = "BEGIN TRANSACTION; INSERT INTO users VALUES ('Alice'); COMMIT;"
let tcl_statements = parse_sql(tcl_sql)

// Parse data control statements
let dcl_sql = "GRANT SELECT, INSERT ON users TO alice WITH GRANT OPTION"
let dcl_result = parse_sql(dcl_sql)

// Dialect-specific parsing
let mysql_sql = "SHOW TABLES LIKE 'user%'"
let mysql_result = parse_sql(dialect=MySQL::{}, mysql_sql)

#Architecture

The parser follows a modular design:

  • Lexer (lexer.mbt): Tokenizes SQL input with dialect-aware keyword recognition
  • Parser (parser.mbt): Main parsing logic with statement dispatching
  • AST (ast.mbt): Complete Abstract Syntax Tree definitions with pretty printing
  • Dialect Modules: Separate modules for each SQL dialect (mysql.mbt, postgres.mbt, etc.)
  • Language Modules:
    • dml.mbt: Data Manipulation Language parsing
    • ddl.mbt: Data Definition Language parsing
    • tcl.mbt: Transaction Control Language parsing
    • dcl.mbt: Data Control Language parsing

#Testing

The library includes comprehensive test coverage with 284+ tests covering:

  • All SQL statement types across all language categories
  • Dialect-specific features and syntax variations
  • Complex expressions and nested queries
  • Edge cases and error handling
  • Pretty printing accuracy

Run tests with:
moon test

#Contributing

The parser is designed for extensibility. To add new SQL features:

  1. Add keywords to keyword.mbt and lexer.mbt
  2. Define AST structures in ast.mbt
  3. Implement parsing logic in appropriate language module
  4. Add statement cases to parser.mbt

#Contributing

The parser is designed for extensibility. To add new SQL features:

  1. Add keywords to keyword.mbt and lexer.mbt
  2. Define AST structures in ast.mbt
  3. Implement parsing logic in appropriate language module
  4. Add statement cases to parser.mbt
  5. Write comprehensive tests

See ROADMAP.md for planned features and implementation priorities.

#License

This project is licensed under the Apache 2.0 License.

#
Dialect

source
pub trait Dialect {
  supports_string_literal_backslash_escape(Self) -> Bool
  supports_boolean_literals(Self) -> Bool
  supports_filter_during_aggregation(Self) -> Bool
  supports_within_after_array_aggregation(Self) -> Bool
  requires_column_types_in_create_table(Self) -> Bool
  supports_if_not_exists(Self) -> Bool
  supports_double_quoted_identifiers(Self) -> Bool
  supports_array_syntax(Self) -> Bool
  supports_named_parameters(Self) -> Bool
  parse_expr(Self, tokens : ArrayView[Token]) -> (Expr, ArrayView[Token])? raise ParserError
  parse_statement(Self, parser : Parser, tokens : ArrayView[Token]) -> (Statement, ArrayView[Token])? raise ParserError
  read_keyword(Self, word : String) -> Keyword?
}

#
LexerError

source
type LexerError

impl Show for LexerError

#
ParserError

source
type ParserError

impl Show for ParserError

#
SqlParserError

source
pub suberror SqlParserError {
  LexerError(LexerError)
  ParserError(ParserError)
}

#
ANSI

source
pub(all) struct ANSI {
}

ANSI SQL dialect - adheres to ANSI SQL standards
impl Dialect for ANSI

#
AccessExpr

source
pub(all) enum AccessExpr {
  Dot(Expr)
  Subscript(Subscript)
}

Access expression for array indexing, slicing, and field access
impl Eq for AccessExpr
impl Show for AccessExpr

#
AlterIndexOperation

source
pub(all) enum AlterIndexOperation {
  RenameTo(String)
  SetTablespace(String)
  Reset(Array[String])
  Set(Array[IndexParameter])
}

ALTER INDEX operations

#
AlterIndexStmt

source
pub(all) struct AlterIndexStmt {
  name : String
  if_exists : Bool
  operation : AlterIndexOperation
}

ALTER INDEX statement

#
AlterTableOperation

source
pub(all) enum AlterTableOperation {
  DropColumn(String, Bool)
}

#
AlterTableStmt

source
pub(all) struct AlterTableStmt {
  table_name : ObjectName
  if_exists : Bool
  operation : AlterTableOperation
}

#
ArrayExpr

source
pub(all) struct ArrayExpr {
  elem : Array[Expr]
  named : Bool
}

PostgreSQL array expression
impl Pretty for ArrayExpr
impl Eq for ArrayExpr
impl Show for ArrayExpr

#
Assignment

source
pub(all) struct Assignment {
  column : String
  value : Expr
}

impl Eq for Assignment
impl Show for Assignment

#
BeginStmt

source
pub(all) struct BeginStmt {
  work : Bool
  transaction : Bool
}

impl Pretty for BeginStmt
impl Eq for BeginStmt
impl Show for BeginStmt

#
BigQuery

source
pub(all) struct BigQuery {
}

BigQuery dialect - supports Google BigQuery specific syntax
impl Dialect for BigQuery

#
BinaryOperator

source
pub(all) enum BinaryOperator {
  Eq
  Neq
  Lt
  Gt
  LtEq
  GtEq
  Spaceship
  Plus
  Minus
  Mul
  Div
  IntegerDiv
  Mod
  And
  Or
  JsonExtract
  JsonExtractText
  JsonExtractPath
  JsonExtractPathText
  JsonContains
  JsonContainedIn
}

#
BinaryOperator::get_precedence

source
fn BinaryOperator::get_precedence(self : BinaryOperator) -> Precedence

#
CaseExpr

source
pub(all) struct CaseExpr {
  operand : Expr?
  when_then_clauses : Array[(Expr, Expr)]
  else_expr : Expr?
}

CASE [operand] WHEN THEN [...] [ELSE ] END
impl Pretty for CaseExpr
impl Eq for CaseExpr
impl Show for CaseExpr

#
ClickHouse

source
pub(all) struct ClickHouse {
}

ClickHouse dialect - supports ClickHouse specific syntax

#
ColumnDef

source
pub(all) struct ColumnDef {
  name : String
  data_type : DataType
  options : Array[ColumnDefOption]
}

impl Pretty for ColumnDef
impl Eq for ColumnDef
impl Show for ColumnDef

#
ColumnDefOption

source
pub(all) enum ColumnDefOption {
  NotNull
  Unique
  Default(Expr)
  PrimaryKey
}

#
CommitStmt

source
pub(all) struct CommitStmt {
  work : Bool
  transaction : Bool
}

impl Eq for CommitStmt
impl Show for CommitStmt

#
ConflictAction

source
pub(all) enum ConflictAction {
  DoNothing
  DoUpdate(Array[Assignment], Expr?)
}

Action to take when conflict occurs

#
ConflictTarget

source
pub(all) enum ConflictTarget {
  Columns(Array[String])
  OnConstraint(String)
  OnExpression(Expr, Expr?)
}

Conflict target specification

#
CopyDirection

source
pub(all) enum CopyDirection {
  To
  From
}

Direction of COPY operation
impl Eq for CopyDirection

#
CopyForceQuote

source
pub(all) enum CopyForceQuote {
  All
  Columns(Array[String])
}

FORCE_QUOTE specification

#
CopyFormat

source
pub(all) enum CopyFormat {
  Csv
  Text
  Binary
}

COPY format specification
impl Eq for CopyFormat
impl Show for CopyFormat

#
CopyOption

source
pub(all) enum CopyOption {
  Format(CopyFormat)
  Delimiter(String)
  Null(String)
  Header(Bool?)
  Quote(String)
  Escape(String)
  ForceQuote(CopyForceQuote)
  ForceNotNull(Array[String])
  ForceNull(Array[String])
  Encoding(String)
}

COPY statement options
impl Eq for CopyOption
impl Show for CopyOption

#
CopySource

source
pub(all) enum CopySource {
  Table(ObjectName, Array[String]?)
  Query(QueryStmt)
}

Source specification for COPY statement
impl Eq for CopySource
impl Show for CopySource

#
CopyStmt

source
pub(all) struct CopyStmt {
  source : CopySource
  direction : CopyDirection
  target : CopyTarget
  format_options : Array[CopyOption]
}

COPY statement for bulk data import/export operations
impl Pretty for CopyStmt
impl Eq for CopyStmt
impl Show for CopyStmt

#
CopyTarget

source
pub(all) enum CopyTarget {
  File(String)
  Stdin
  Stdout
  Program(String)
}

Target specification for COPY statement
impl Eq for CopyTarget
impl Show for CopyTarget

#
CreateDatabaseStmt

source
pub(all) struct CreateDatabaseStmt {
  name : String
  if_not_exists : Bool
  character_set : String?
  collate : String?
}

CREATE DATABASE statement

#
CreateFunctionStmt

source
pub(all) struct CreateFunctionStmt {
  name : String
  parameters : Array[FunctionParameter]
  return_type : DataType?
  language : String?
  body : String?
  deterministic : Bool
  if_not_exists : Bool
}

CREATE FUNCTION statement

#
CreateIndexStmt

source
pub(all) struct CreateIndexStmt {
  unique : Bool
  concurrently : Bool
  if_not_exists : Bool
  name : String
  table_name : ObjectName
  index_method : IndexMethod?
  columns : Array[IndexColumn]
  where_clause : Expr?
}

CREATE INDEX statement

#
CreateProcedureStmt

source
pub(all) struct CreateProcedureStmt {
  name : String
  parameters : Array[FunctionParameter]
  language : String?
  body : String?
  if_not_exists : Bool
}

CREATE PROCEDURE statement

#
CreateSchemaStmt

source
pub(all) struct CreateSchemaStmt {
  name : String
  if_not_exists : Bool
  authorization : String?
}

CREATE SCHEMA statement (synonym for CREATE DATABASE in many dialects)

#
CreateSequenceStmt

source
pub(all) struct CreateSequenceStmt {
  name : String
  if_not_exists : Bool
  temporary : Bool
  increment : Int?
  minvalue : SequenceLimit?
  maxvalue : SequenceLimit?
  start_with : Int?
  cache : Int?
  cycle : Bool?
  owned_by : SequenceOwnedBy?
}

CREATE SEQUENCE statement

#
CreateTableDefinition

source
pub(all) enum CreateTableDefinition {
  Columns(Array[ColumnDef], Array[TableConstraint])
  AsQuery(QueryStmt)
}

#
CreateTableStmt

source
pub(all) struct CreateTableStmt {
  name : String
  if_not_exists : Bool
  definition : CreateTableDefinition
}

#
CreateViewStmt

source
type CreateViewStmt

#
Cte

source
pub(all) struct Cte {
  name : String
  query : QueryStmt
  columns : Array[String]?
}

Common Table Expression (CTE) for WITH clauses
impl Pretty for Cte
impl Eq for Cte
impl Show for Cte

#
DataType

source
pub(all) enum DataType {
  Integer
  Smallint
  Bigint
  Float(Int?)
  Real
  Double
  Char(Int)
  Varchar(Int)
  Text
  Boolean
  Timestamp
  Blob
}

impl Pretty for DataType
impl Eq for DataType
impl Show for DataType

#
DatetimeUnit

source
pub(all) enum DatetimeUnit {
  Year
  Month
  Day
  Hour
  Minute
  Second
}

impl Eq for DatetimeUnit

#
DeallocateStmt

source
pub(all) struct DeallocateStmt {
  name : String
  prepare : Bool
}

DEALLOCATE statement Syntax: DEALLOCATE [PREPARE] name

#
DeleteStmt

source
pub(all) struct DeleteStmt {
  table_name : ObjectName
  where_clause : Expr?
}

impl Eq for DeleteStmt
impl Show for DeleteStmt

#
DropIndexStmt

source
pub(all) struct DropIndexStmt {
  name : String
  if_exists : Bool
  concurrently : Bool
  table_name : ObjectName?
}

impl Eq for DropIndexStmt

#
DropTableStmt

source
pub(all) struct DropTableStmt {
  table_name : ObjectName
  if_exists : Bool
}

impl Eq for DropTableStmt

#
DropViewStmt

source
pub(all) struct DropViewStmt {
  name : String
}

impl Eq for DropViewStmt

#
DuckDB

source
pub(all) struct DuckDB {
}

DuckDB dialect - supports DuckDB specific syntax
impl Dialect for DuckDB

#
DuplicateTreatment

source
pub(all) enum DuplicateTreatment {
  Distinct
  All
}

#
ExecuteStmt

source
pub(all) struct ExecuteStmt {
  name : ObjectName?
  parameters : Array[Expr]
  has_parentheses : Bool
  into : Array[String]
  using_exprs : Array[Expr]
}

EXECUTE statement Syntax: EXECUTE name [(param [, ...])] EXECUTE name USING expr [, ...] EXECUTE IMMEDIATE 'sql_string' [INTO var [, ...]] [USING expr [, ...]]
impl Eq for ExecuteStmt
impl Show for ExecuteStmt

#
Expr

source
pub(all) enum Expr {
  Identifier(String)
  CompoundIdentifier(Array[String])
  Literal(Literal)
  BinaryOperation(Expr, BinaryOperator, Expr)
  UnaryOperation(UnaryOperator, Expr)
  FunctionCall(String, DuplicateTreatment?, Array[Expr], Expr?)
  Wildcard
  Datetime(String)
  Interval(String, IntervalQualifier)
  Like(Bool, Expr, Expr)
  ILike(Bool, Expr, Expr)
  SubQuery(QueryStmt)
  Exists(Bool, QueryStmt)
  Between(Bool, Expr, Expr, Expr)
  Extract(PrimaryDatetimeField, Expr)
  Case(CaseExpr)
  InList(Bool, Expr, Array[Expr])
  InSubQuery(Bool, Expr, QueryStmt)
  Substring(Expr, Expr?, Expr?)
  Placeholder(String)
  Array(ArrayExpr)
  CompoundFieldAccess(Expr, Array[AccessExpr])
  WindowFunction(String, DuplicateTreatment?, Array[Expr], WindowSpec)
}

impl Pretty for Expr
impl Eq for Expr
impl Show for Expr

#
FunctionParameter

source
pub(all) struct FunctionParameter {
  name : String
  param_type : DataType
  mode : ParameterMode?
}

Function parameter definition

#
Generic

source
pub(all) struct Generic {
}

Generic SQL dialect that supports the union of all other dialects This is the most permissive dialect, useful for parsing various SQL statements from different sources without strict dialect requirements
impl Dialect for Generic

#
GrantStmt

source
pub(all) struct GrantStmt {
  privileges : Array[Privilege]
  objects : Array[ObjectName]
  grantees : Array[String]
  with_grant_option : Bool
}

impl Pretty for GrantStmt
impl Eq for GrantStmt
impl Show for GrantStmt

#
IndexColumn

source
pub(all) struct IndexColumn {
  name : Expr
  asc : Bool?
  nulls_first : Bool?
}

Index column specification
impl Eq for IndexColumn
impl Show for IndexColumn

#
IndexMethod

source
pub(all) enum IndexMethod {
  Btree
  Hash
  Gin
  Gist
  Spgist
  Brin
}

Index creation method
impl Eq for IndexMethod
impl Show for IndexMethod

#
IndexParameter

source
pub(all) struct IndexParameter {
  name : String
  value : String
}

Index parameter for SET operations

#
InsertSource

source
pub(all) enum InsertSource {
  Values(Array[Array[Expr]])
  Query(QueryStmt)
}

impl Eq for InsertSource

#
InsertStmt

source
pub(all) struct InsertStmt {
  table_name : ObjectName
  columns : Array[String]
  source : InsertSource
  or : SqliteOnConflict?
  on : OnInsert?
}

impl Eq for InsertStmt
impl Show for InsertStmt

#
IntervalQualifier

source
pub(all) enum IntervalQualifier {
  Single(PrimaryDatetimeField)
  Range(PrimaryDatetimeField, PrimaryDatetimeField)
}

#
Join

source
pub(all) struct Join {
  table_ref : TableRef
  join_operator : JoinOperator
}

impl Pretty for Join
impl Eq for Join
impl Show for Join

#
JoinConstraint

source
pub(all) enum JoinConstraint {
  On(Expr)
  Using(Array[String])
  Non
}

#
JoinOperator

source
pub(all) enum JoinOperator {
  Join(JoinConstraint)
  Left(JoinConstraint)
  LeftOuter(JoinConstraint)
  Right(JoinConstraint)
  RightOuter(JoinConstraint)
  Full(JoinConstraint)
  FullOuter(JoinConstraint)
  Inner(JoinConstraint)
  Cross
}

impl Eq for JoinOperator

#
Keyword

source
pub(all) enum Keyword {
  Select
  From
  Where
  As
  Group
  Order
  By
  Asc
  Desc
  Nulls
  First
  Last
  Year
  Month
  Day
  Hour
  Minute
  Second
  Date
  Interval
  To
  Like
  Not
  ILike
  Exists
  Between
  And
  Or
  Extract
  Filter
  Case
  When
  Matched
  Target
  Then
  Else
  Having
  End
  In
  Join
  Left
  Right
  Full
  Outer
  Inner
  Cross
  On
  Using
  Limit
  Offset
  Create
  Table
  Integer
  Int
  Smallint
  Bigint
  Real
  Double
  Precision
  Char
  Character
  Collate
  Authorization
  Varchar
  Varing
  Text
  Time
  Boolean
  Float
  Timestamp
  Blob
  Null
  Default
  Unique
  View
  Drop
  Distinct
  All
  Substring
  For
  Primary
  Key
  Foreign
  References
  Check
  Union
  Intersect
  Except
  Top
  Insert
  Into
  Values
  Merge
  If
  Delete
  Update
  Set
  Replace
  Rollback
  Abort
  Fail
  Ignore
  Truncate
  Alter
  Column
  Show
  Tables
  Columns
  Status
  Databases
  Database
  Div
  Lock
  Unlock
  Listen
  Notify
  Schemas
  Schema
  Variables
  Processlist
  Grants
  Functions
  Function
  Extended
  Global
  Session
  Procedure
  Returns
  Language
  Deterministic
  Event
  Trigger
  Duplicate
  Conflict
  Do
  Nothing
  Constraint
  Array
  With
  Begin
  Start
  Transaction
  Commit
  Savepoint
  Release
  Work
  Grant
  Revoke
  Privileges
  Usage
  Use
  Execute
  Prepare
  Deallocate
  Immediate
  Connect
  Temporary
  Temp
  Option
  Restrict
  Cascade
  Index
  Copy
  Format
  Stdin
  Stdout
  Program
  Header
  ForceQuote
  ForceNotNull
  ForceNull
  Encoding
  Load
  Data
  Local
  Infile
  Fields
  Lines
  Terminated
  Enclosed
  Escaped
  Starting
  Optionally
  Rename
  Tablespace
  Reset
  Btree
  Hash
  Gin
  Gist
  Spgist
  Brin
  Concurrently
  Over
  Window
  Partition
  Rows
  Range
  Preceding
  Following
  Current
  Unbounded
  Row
  Out
  InOut
  Sequence
  Increment
  Minvalue
  Maxvalue
  Cache
  Cycle
  Owned
  No
}

impl Eq for Keyword
impl Show for Keyword

#
Literal

source
pub(all) enum Literal {
  Integer(Int)
  Double(Double)
  String(String)
  Boolean(Bool)
  Null
}

impl Pretty for Literal
impl Eq for Literal
impl Show for Literal

#
LoadDataDuplicateHandling

source
pub(all) enum LoadDataDuplicateHandling {
  Replace
  Ignore
}

Duplicate handling for LOAD DATA

#
LoadDataFieldsOptions

source
pub(all) struct LoadDataFieldsOptions {
  terminated_by : String?
  enclosed_by : String?
  optionally_enclosed : Bool
  escaped_by : String?
}

FIELDS options for LOAD DATA

#
LoadDataLinesOptions

source
pub(all) struct LoadDataLinesOptions {
  starting_by : String?
  terminated_by : String?
}

LINES options for LOAD DATA

#
LoadDataStmt

source
pub(all) struct LoadDataStmt {
  is_local : Bool
  filename : String
  duplicate_handling : LoadDataDuplicateHandling?
  table_name : ObjectName
  character_set : String?
  fields_options : LoadDataFieldsOptions?
  lines_options : LoadDataLinesOptions?
  ignore_lines : Int?
  columns : Array[String]?
  set_assignments : Array[Assignment]?
}

LOAD DATA statement for MySQL-style bulk data loading
impl Eq for LoadDataStmt

#
MergeAction

source
pub(all) enum MergeAction {
  Insert(Array[String], Array[Expr])
  Update(Array[Assignment])
  Delete
}

Actions that can be performed in MERGE
impl Eq for MergeAction
impl Show for MergeAction

#
MergeMatchType

source
pub(all) enum MergeMatchType {
  Matched
  NotMatched
}

Match type for WHEN clause

#
MergeSource

source
pub(all) enum MergeSource {
  Table(ObjectName)
  Query(QueryStmt)
}

Source for MERGE statement
impl Eq for MergeSource
impl Show for MergeSource

#
MergeStmt

source
pub(all) struct MergeStmt {
  target_table : ObjectName
  target_alias : String?
  source : MergeSource
  source_alias : String?
  join_condition : Expr
  when_clauses : Array[MergeWhenClause]
}

MERGE statement for conditional INSERT/UPDATE/DELETE operations
impl Pretty for MergeStmt
impl Eq for MergeStmt
impl Show for MergeStmt

#
MergeWhenClause

source
pub(all) struct MergeWhenClause {
  match_type : MergeMatchType
  condition : Expr?
  action : MergeAction
}

WHEN clause in MERGE statement

#
MySQL

source
pub(all) struct MySQL {
}

impl Dialect for MySQL

#
ObjectName

source
pub(all) struct ObjectName {
  parts : Array[String]
}

impl Eq for ObjectName
impl Show for ObjectName

#
OnConflictClause

source
pub(all) struct OnConflictClause {
  conflict_target : ConflictTarget?
  conflict_action : ConflictAction
}

PostgreSQL ON CONFLICT clause for advanced conflict resolution Syntax: ON CONFLICT [ conflict_target ] conflict_action

#
OnInsert

source
pub(all) enum OnInsert {
  DuplicateKeyUpdate(Array[Assignment])
  OnConflict(OnConflictClause)
}

MySQL ON DUPLICATE KEY UPDATE or PostgreSQL ON CONFLICT
impl Pretty for OnInsert
impl Eq for OnInsert
impl Show for OnInsert

#
OrderByExpr

source
pub(all) struct OrderByExpr {
  expr : Expr
  asc : Bool?
  nulls_first : Bool?
}

impl Eq for OrderByExpr
impl Show for OrderByExpr

#
ParameterMode

source
pub(all) enum ParameterMode {
  In
  Out
  InOut
}

Parameter mode for functions/procedures
impl Eq for ParameterMode

#
Parser

source
pub struct Parser {
  dialect : &Dialect
}

#
Postgres

source
pub(all) struct Postgres {
}

impl Dialect for Postgres

#
Precedence

source
pub(all) enum Precedence {
  PlusMinus
  MulDivMod
  Eq
  Like
  And
  Or
  Between
  UnaryNot
  JsonOperator
}

#
Precedence::value

source
fn Precedence::value(self : Precedence) -> Int

#
PrepareStmt

source
pub(all) struct PrepareStmt {
  name : String
  data_types : Array[DataType]
  statement : Statement
}

PREPARE statement Syntax: PREPARE name [(data_type [, ...])] AS statement
impl Eq for PrepareStmt
impl Show for PrepareStmt

#
PrimaryDatetimeField

source
type PrimaryDatetimeField

#
Privilege

source
pub(all) enum Privilege {
  Select(Array[String]?)
  Insert(Array[String]?)
  Update(Array[String]?)
  Delete
  References(Array[String]?)
  Create
  Drop
  Alter
  Index
  All
  Usage
  Execute
  Connect
  Temporary
}

impl Pretty for Privilege
impl Eq for Privilege
impl Show for Privilege

#
Projection

source
pub(all) enum Projection {
  Wildcard
  UnamedExpr(Expr)
  AliasedExpr(Expr, String)
}

impl Eq for Projection
impl Show for Projection

#
QueryStmt

source
pub(all) struct QueryStmt {
  with_clause : Array[Cte]?
  body : SetExpr
  order_by : Array[OrderByExpr]
  limit : Expr?
  offset : Expr?
}

impl Pretty for QueryStmt
impl Eq for QueryStmt
impl Show for QueryStmt

#
Redshift

source
pub(all) struct Redshift {
}

Redshift dialect - supports Amazon Redshift specific syntax
impl Dialect for Redshift

#
ReleaseSavepointStmt

source
pub(all) struct ReleaseSavepointStmt {
  savepoint_keyword : Bool
  name : String
}

#
RevokeOption

source
pub(all) enum RevokeOption {
  Restrict
  Cascade
}

impl Eq for RevokeOption

#
RevokeStmt

source
pub(all) struct RevokeStmt {
  grant_option_for : Bool
  privileges : Array[Privilege]
  objects : Array[ObjectName]
  grantees : Array[String]
  cascade : RevokeOption?
}

impl Eq for RevokeStmt
impl Show for RevokeStmt

#
RollbackStmt

source
pub(all) struct RollbackStmt {
  work : Bool
  transaction : Bool
  savepoint : String?
}

impl Eq for RollbackStmt

#
SQLite

source
pub(all) struct SQLite {
}

impl Dialect for SQLite

#
SavepointStmt

source
pub(all) struct SavepointStmt {
  name : String
}

impl Eq for SavepointStmt

#
SelectStmt

source
type SelectStmt

impl Eq for SelectStmt
impl Show for SelectStmt

#
SequenceLimit

source
pub(all) enum SequenceLimit {
  Value(Int)
  NoLimit
}

Sequence limit specification
impl Eq for SequenceLimit

#
SequenceOwnedBy

source
pub(all) enum SequenceOwnedBy {
  Column(ObjectName, String)
  ByNone
}

OWNED BY specification for sequences

#
SetAssignment

source
pub(all) struct SetAssignment {
  variable : String
  value : Expr
}

impl Eq for SetAssignment

#
SetExpr

source
type SetExpr

impl Eq for SetExpr
impl Show for SetExpr

#
SetOperator

source
type SetOperator

impl Eq for SetOperator
impl Show for SetOperator

#
SetScope

source
pub(all) enum SetScope {
  Global
  Session
  UserVar
  Local
}

impl Eq for SetScope
impl Show for SetScope

#
SetStmt

source
pub(all) struct SetStmt {
  scope : SetScope
  assignments : Array[SetAssignment]
}

impl Pretty for SetStmt
impl Eq for SetStmt
impl Show for SetStmt

#
ShowFilter

source
pub(all) enum ShowFilter {
  Like(String)
  Where(Expr)
}

impl Eq for ShowFilter
impl Show for ShowFilter

#
ShowStmt

source
pub(all) struct ShowStmt {
  show_type : ShowType
  object : ObjectName?
  filter : ShowFilter?
  extended : Bool
  full : Bool
  global_scope : Bool
}

MySQL SHOW statement
impl Pretty for ShowStmt
impl Eq for ShowStmt
impl Show for ShowStmt

#
ShowType

source
pub(all) enum ShowType {
  Tables
  Columns
  Status
  Databases
  Schemas
  Variables
  Processlist
  Grants
  Functions
  CreateTable
  CreateView
  CreateFunction
  CreateProcedure
  CreateEvent
  CreateTrigger
}

impl Pretty for ShowType
impl Eq for ShowType
impl Show for ShowType

#
Snowflake

source
pub(all) struct Snowflake {
}

Snowflake dialect - supports Snowflake specific syntax

#
SqliteOnConflict

source
pub(all) enum SqliteOnConflict {
  Rollback
  Abort
  Fail
  Ignore
  Replace
}

SQLite-style conflict resolution for INSERT statements See: https://sqlite.org/lang_conflict.html

#
Statement

source
pub(all) enum Statement {
  Query(QueryStmt)
  CreateTable(CreateTableStmt)
  CreateView(CreateViewStmt)
  CreateIndex(CreateIndexStmt)
  CreateDatabase(CreateDatabaseStmt)
  CreateSchema(CreateSchemaStmt)
  CreateFunction(CreateFunctionStmt)
  CreateProcedure(CreateProcedureStmt)
  CreateSequence(CreateSequenceStmt)
  DropView(DropViewStmt)
  DropTable(DropTableStmt)
  DropIndex(DropIndexStmt)
  Insert(InsertStmt)
  Delete(DeleteStmt)
  Update(UpdateStmt)
  Merge(MergeStmt)
  Truncate(TruncateStmt)
  AlterTable(AlterTableStmt)
  AlterIndex(AlterIndexStmt)
  Show(ShowStmt)
  Set(SetStmt)
  Use(UseStmt)
  Copy(CopyStmt)
  LoadData(LoadDataStmt)
  Prepare(PrepareStmt)
  Execute(ExecuteStmt)
  Deallocate(DeallocateStmt)
  LockTables(Array[ObjectName])
  UnlockTables
  Listen(String)
  Notify(String, String?)
  Begin(BeginStmt)
  Commit(CommitStmt)
  Rollback(RollbackStmt)
  Savepoint(SavepointStmt)
  ReleaseSavepoint(ReleaseSavepointStmt)
  Grant(GrantStmt)
  Revoke(RevokeStmt)
}

impl Pretty for Statement
impl Eq for Statement
impl Show for Statement

#
Statements

source
pub(all) struct Statements {
  stmts : Array[Statement]
}

impl Eq for Statements
impl Show for Statements

#
Statements::op_get

source
fn Statements::op_get(self : Statements, index : Int) -> Statement

#
Subscript

source
pub(all) enum Subscript {
  Index(Expr)
  Slice(Expr?, Expr?, Expr?)
}

Subscript expression for array indexing and slicing
impl Pretty for Subscript
impl Eq for Subscript
impl Show for Subscript

#
TableAlias

source
pub(all) struct TableAlias {
  name : String
  columns : Array[String]
}

impl Eq for TableAlias
impl Show for TableAlias

#
TableConstraint

source
pub(all) enum TableConstraint {
  Unique(Array[OrderByExpr])
  PrimaryKey(Array[OrderByExpr])
  ForeignKey(Array[OrderByExpr], ObjectName, Array[String])
  Check(Expr)
}

#
TableFactor

source
pub(all) enum TableFactor {
  Column(ObjectName, TableAlias?)
  SubQuery(QueryStmt, TableAlias?)
}

impl Eq for TableFactor
impl Show for TableFactor

#
TableRef

source
pub(all) struct TableRef {
  factor : TableFactor
  joins : Array[Join]
}

impl Pretty for TableRef
impl Eq for TableRef
impl Show for TableRef

#
Token

source
pub(all) enum Token {
  Keyword(Keyword)
  Identifier(String)
  Number(String)
  StringLiteral(String)
  Boolean(Bool)
  Comma
  Semicolon
  Colon
  Eq
  DoubleEq
  Neq
  Lt
  Gt
  LtEq
  GtEq
  Spaceship
  Plus
  Minus
  Mul
  Div
  Mod
  LBracket
  RBracket
  LBrace
  RBrace
  LParen
  RParen
  Period
  Placeholder(String)
  JsonExtract
  JsonExtractText
  JsonExtractPath
  JsonExtractPathText
  JsonContains
  JsonContainedIn
  Unknown(Char)
  Eof
}

impl Eq for Token
impl Show for Token

#
Top

source
pub(all) enum Top {
  Constant(Int)
  Expr(Expr)
}

impl Pretty for Top
impl Eq for Top
impl Show for Top

#
TruncateStmt

source
pub(all) struct TruncateStmt {
  table_name : ObjectName
}

impl Eq for TruncateStmt

#
UnaryOperator

source
pub(all) enum UnaryOperator {
  Plus
  Minus
  Not
}

impl Eq for UnaryOperator

#
UpdateStmt

source
pub(all) struct UpdateStmt {
  table_name : ObjectName
  assignments : Array[Assignment]
  where_clause : Expr?
}

impl Eq for UpdateStmt
impl Show for UpdateStmt

#
UseStmt

source
pub(all) struct UseStmt {
  database_name : ObjectName
}

USE database statement for database switching
impl Pretty for UseStmt
impl Eq for UseStmt
impl Show for UseStmt

#
ViewColumnDef

source
pub(all) struct ViewColumnDef {
  name : String
}

impl Eq for ViewColumnDef

#
WindowFrameBound

source
pub(all) enum WindowFrameBound {
  UnboundedPreceding
  UnboundedFollowing
  CurrentRow
  Preceding(Expr)
  Following(Expr)
}

Window frame bound

#
WindowFrameClause

source
pub(all) struct WindowFrameClause {
  frame_units : WindowFrameUnits
  frame_start : WindowFrameBound
  frame_end : WindowFrameBound?
}

Window frame clause

#
WindowFrameUnits

source
pub(all) enum WindowFrameUnits {
  Rows
  Range
}

Window frame units

#
WindowSpec

source
pub(all) struct WindowSpec {
  partition_by : Array[Expr]
  order_by : Array[OrderByExpr]
  frame_clause : WindowFrameClause?
}

Window function specification: OVER ([PARTITION BY ...] [ORDER BY ...] [frame_clause])
impl Eq for WindowSpec
impl Show for WindowSpec

#
parse

source
fn parse(tokens : ArrayView[Token], dialect? : &Dialect) -> Array[Statement] raise ParserError

#
parse_sql

source
fn parse_sql(dialect? : &Dialect, input : String) -> Statements raise SqlParserError

#
pretty_print

source
fn[T : 
Pretty] pretty_print(obj : T) -> String

#
structural_print

source
fn[T : Show] structural_print(obj : T) -> String

#
tokenize

source
fn tokenize(dialect? : &Dialect, input : String) -> Array[Token] raise LexerError

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io