Struct Parser 

pub struct Parser<'a> { /* private fields */ }

SQL Parser.

The parser converts SQL text into an Abstract Syntax Tree (AST).

Implementations

impl<'a> Parser<'a>

pub fn parse_expression(&mut self) -> Result<Box<Expr>>

Parse an expression.

pub fn parse_data_type(&mut self) -> Result<DataTypeSpec>

Parse a data type specification.

impl<'a> Parser<'a>

pub fn parse_query(&mut self) -> Result<Query>

Parse a complete query (WITH clause, SELECT, set operations, ORDER BY, LIMIT).

impl<'a> Parser<'a>

pub fn parse_insert(&mut self) -> Result<StatementKind>

Parse INSERT statement.

pub fn parse_update(&mut self) -> Result<StatementKind>

Parse UPDATE statement.

pub fn parse_delete(&mut self) -> Result<StatementKind>

Parse DELETE statement.

pub fn parse_merge(&mut self) -> Result<StatementKind>

Parse MERGE statement.

pub fn parse_create(&mut self) -> Result<StatementKind>

Parse CREATE statement.

pub fn parse_alter(&mut self) -> Result<StatementKind>

Parse ALTER statement.

pub fn parse_drop(&mut self) -> Result<StatementKind>

Parse DROP statement.

pub fn parse_truncate(&mut self) -> Result<StatementKind>

Parse TRUNCATE statement.

pub fn parse_begin(&mut self) -> Result<StatementKind>

Parse BEGIN statement.

pub fn parse_rollback(&mut self) -> Result<StatementKind>

Parse ROLLBACK statement.

pub fn parse_explain(&mut self) -> Result<StatementKind>

Parse EXPLAIN statement.

pub fn parse_describe(&mut self) -> Result<StatementKind>

Parse DESCRIBE statement.

pub fn parse_show(&mut self) -> Result<StatementKind>

Parse SHOW statement.

pub fn parse_set(&mut self) -> Result<StatementKind>

Parse SET statement.

impl<'a> Parser<'a>

pub fn new(input: &'a str) -> Self

Create a new parser for the given input.

Examples found in repository

examples/csv_database/database.rs (line 174)

    pub fn execute(&mut self, sql: &str) -> Result<QueryResult, String> {
        let mut parser = Parser::new(sql);
        let statements = parser.parse().map_err(|e| format!("Parse error: {}", e))?;

        if statements.is_empty() {
            return Err("No statements to execute".to_string());
        }

        let stmt = &statements[0];

        match &stmt.kind {
            StatementKind::Query(query) => self.execute_query(query),
            StatementKind::Insert(insert) => {
                let table_name = insert
                    .table
                    .parts
                    .last()
                    .map(|i| i.value.clone())
                    .unwrap_or_default();

                if let vibesql::InsertSource::Values(rows) = &insert.source {
                    for row in rows {
                        let values: Vec<String> =
                            row.iter().map(|expr| self.eval_literal(expr)).collect();

                        if let Some(table_data) = self.tables.get_mut(&table_name) {
                            table_data.push(values.clone());
                        }
                    }
                    self.save_table(&table_name)?;
                    Ok(QueryResult::new(
                        vec!["result".to_string()],
                        vec![vec!["Inserted".to_string()]],
                    ))
                } else {
                    Err("Only INSERT VALUES is supported".to_string())
                }
            }
            StatementKind::CreateTable(create) => {
                let table_name = create
                    .name
                    .parts
                    .last()
                    .map(|i| i.value.clone())
                    .unwrap_or_default();

                let mut builder = TableSchemaBuilder::new(&table_name);
                for col in &create.columns {
                    builder = builder.column(ColumnSchema::new(&col.name.value, SqlType::Varchar));
                }
                let schema = builder.build();
                self.catalog.add_table(schema);

                self.tables.insert(table_name.clone(), Vec::new());
                self.save_table(&table_name)?;

                Ok(QueryResult::new(
                    vec!["result".to_string()],
                    vec![vec![format!("Created table {}", table_name)]],
                ))
            }
            _ => Err("Unsupported statement type".to_string()),
        }
    }

pub fn parse(&mut self) -> Result<Vec<Statement>>

Parse all statements from the input.

Examples found in repository

examples/csv_database/database.rs (line 175)

    pub fn execute(&mut self, sql: &str) -> Result<QueryResult, String> {
        let mut parser = Parser::new(sql);
        let statements = parser.parse().map_err(|e| format!("Parse error: {}", e))?;

        if statements.is_empty() {
            return Err("No statements to execute".to_string());
        }

        let stmt = &statements[0];

        match &stmt.kind {
            StatementKind::Query(query) => self.execute_query(query),
            StatementKind::Insert(insert) => {
                let table_name = insert
                    .table
                    .parts
                    .last()
                    .map(|i| i.value.clone())
                    .unwrap_or_default();

                if let vibesql::InsertSource::Values(rows) = &insert.source {
                    for row in rows {
                        let values: Vec<String> =
                            row.iter().map(|expr| self.eval_literal(expr)).collect();

                        if let Some(table_data) = self.tables.get_mut(&table_name) {
                            table_data.push(values.clone());
                        }
                    }
                    self.save_table(&table_name)?;
                    Ok(QueryResult::new(
                        vec!["result".to_string()],
                        vec![vec!["Inserted".to_string()]],
                    ))
                } else {
                    Err("Only INSERT VALUES is supported".to_string())
                }
            }
            StatementKind::CreateTable(create) => {
                let table_name = create
                    .name
                    .parts
                    .last()
                    .map(|i| i.value.clone())
                    .unwrap_or_default();

                let mut builder = TableSchemaBuilder::new(&table_name);
                for col in &create.columns {
                    builder = builder.column(ColumnSchema::new(&col.name.value, SqlType::Varchar));
                }
                let schema = builder.build();
                self.catalog.add_table(schema);

                self.tables.insert(table_name.clone(), Vec::new());
                self.save_table(&table_name)?;

                Ok(QueryResult::new(
                    vec!["result".to_string()],
                    vec![vec![format!("Created table {}", table_name)]],
                ))
            }
            _ => Err("Unsupported statement type".to_string()),
        }
    }

pub fn parse_statement(&mut self) -> Result<Statement>

Parse a single statement.