SQLite: parse the full PRAGMA value grammar

Author: LucaCappelletti94

src/ast/mod.rs

@@ -4783,8 +4783,8 @@ pub enum Statement {
     Pragma {
         /// Pragma name (possibly qualified).
         name: ObjectName,
-        /// Optional pragma value.
-        value: Option<ValueWithSpan>,
+        /// Optional pragma value (`signed-number`, `name`, or `signed-literal`).
+        value: Option<Expr>,
         /// Whether the pragma used `=`.
         is_eq: bool,
     },

src/parser/mod.rs

@@ -20166,44 +20166,40 @@ impl<'a> Parser<'a> {
         })
     }
 
-    fn parse_pragma_value(&mut self) -> Result<ValueWithSpan, ParserError> {
-        let v = self.parse_value()?;
-        match &v.value {
-            Value::SingleQuotedString(_) => Ok(v),
-            Value::DoubleQuotedString(_) => Ok(v),
-            Value::Number(_, _) => Ok(v),
-            Value::Placeholder(_) => Ok(v),
-            _ => {
-                self.prev_token();
-                self.expected_ref("number or string or ? placeholder", self.peek_token_ref())
-            }
+    /// Parse a SQLite `pragma-value`: `signed-number | name | signed-literal`
+    /// (<https://www.sqlite.org/pragma.html>). SQLite performs no per-pragma type
+    /// validation at parse time, so a bare `name` such as `WAL` is kept as an
+    /// identifier and left for the caller to interpret.
+    fn parse_pragma_value(&mut self) -> Result<Expr, ParserError> {
+        if matches!(self.peek_token_ref().token, Token::Plus | Token::Minus) {
+            let op = match self.next_token().token {
+                Token::Plus => UnaryOperator::Plus,
+                _ => UnaryOperator::Minus,
+            };
+            return Ok(Expr::UnaryOp {
+                op,
+                expr: Box::new(Expr::Value(self.parse_value()?)),
+            });
+        }
+        match self.maybe_parse(|parser| parser.parse_value())? {
+            Some(value) => Ok(Expr::Value(value)),
+            None => Ok(Expr::Identifier(self.parse_identifier()?)),
         }
     }
 
     /// PRAGMA [schema-name '.'] pragma-name [('=' pragma-value) | '(' pragma-value ')']
     pub fn parse_pragma(&mut self) -> Result<Statement, ParserError> {
         let name = self.parse_object_name(false)?;
-        if self.consume_token(&Token::LParen) {
+        let (value, is_eq) = if self.consume_token(&Token::LParen) {
             let value = self.parse_pragma_value()?;
             self.expect_token(&Token::RParen)?;
-            Ok(Statement::Pragma {
-                name,
-                value: Some(value),
-                is_eq: false,
-            })
+            (Some(value), false)
         } else if self.consume_token(&Token::Eq) {
-            Ok(Statement::Pragma {
-                name,
-                value: Some(self.parse_pragma_value()?),
-                is_eq: true,
-            })
+            (Some(self.parse_pragma_value()?), true)
         } else {
-            Ok(Statement::Pragma {
-                name,
-                value: None,
-                is_eq: false,
-            })
-        }
+            (None, false)
+        };
+        Ok(Statement::Pragma { name, value, is_eq })
     }
 
     /// `INSTALL [extension_name]`

tests/sqlparser_sqlite.rs

@@ -30,8 +30,8 @@ use sqlparser::ast::SelectItem::UnnamedExpr;
 use sqlparser::ast::Value::Placeholder;
 use sqlparser::ast::*;
 use sqlparser::dialect::{GenericDialect, SQLiteDialect};
-use sqlparser::parser::{ParserError, ParserOptions};
-use sqlparser::tokenizer::Token;
+use sqlparser::parser::{Parser, ParserError, ParserOptions};
+use sqlparser::tokenizer::{Span, Token};
 
 #[test]
 fn pragma_no_value() {
@@ -971,3 +971,82 @@ fn sqlite_and_generic() -> TestedDialects {
         Box::new(GenericDialect {}),
     ])
 }
+
+#[test]
+fn pragma_values() {
+    // `signed-literal`: boolean and numeric literals keep their `Value`.
+    let statement = sqlite_and_generic().verified_stmt("PRAGMA case_sensitive_like = true");
+    assert!(matches!(
+        statement,
+        Statement::Pragma {
+            value: Some(Expr::Value(ValueWithSpan {
+                value: Value::Boolean(true),
+                ..
+            })),
+            is_eq: true,
+            ..
+        }
+    ));
+
+    // `name`: bare keywords are kept verbatim as identifiers. SQLite assigns
+    // their meaning at execution time, so the parser does not interpret them.
+    for spelling in [
+        "ON", "OFF", "YES", "NO", "WAL", "DELETE", "NORMAL", "FULL", "MEMORY",
+    ] {
+        let sql = format!("PRAGMA case_sensitive_like = {spelling}");
+        let Statement::Pragma {
+            value: Some(Expr::Identifier(ident)),
+            is_eq: true,
+            ..
+        } = sqlite_and_generic().verified_stmt(&sql)
+        else {
+            panic!("expected identifier pragma value for {spelling}");
+        };
+        assert_eq!(spelling, ident.value);
+        assert_eq!(None, ident.quote_style);
+    }
+
+    // The identifier value keeps its source span.
+    let statements =
+        Parser::parse_sql(&SQLiteDialect {}, "PRAGMA case_sensitive_like = oN").unwrap();
+    let [Statement::Pragma {
+        value: Some(Expr::Identifier(ident)),
+        is_eq: true,
+        ..
+    }] = statements.as_slice()
+    else {
+        panic!("Expected equality-form PRAGMA")
+    };
+    assert_eq!("oN", ident.value);
+    assert_eq!(Span::new((1, 30).into(), (1, 32).into()), ident.span);
+
+    // `signed-number`: a leading sign becomes a unary operation.
+    let statement = sqlite_and_generic().verified_stmt("PRAGMA cache_size = -2000");
+    assert!(matches!(
+        statement,
+        Statement::Pragma {
+            value: Some(Expr::UnaryOp {
+                op: UnaryOperator::Minus,
+                ..
+            }),
+            is_eq: true,
+            ..
+        }
+    ));
+    sqlite_and_generic().verified_stmt("PRAGMA cache_size = +2000");
+
+    // Hex integer literals tokenize to a hex string literal.
+    sqlite_and_generic()
+        .one_statement_parses_to("PRAGMA optimize = 0x10002", "PRAGMA optimize = X'10002'");
+
+    // The function-call form accepts a `name` argument too.
+    let statement = sqlite_and_generic().verified_stmt("PRAGMA wal_checkpoint(TRUNCATE)");
+    assert!(matches!(
+        statement,
+        Statement::Pragma {
+            value: Some(Expr::Identifier(_)),
+            is_eq: false,
+            ..
+        }
+    ));
+}