OracleDialect: Initial draft

Author: xitep

examples/cli.rs

@@ -58,6 +58,7 @@ $ cargo run --example cli - [--dialectname]
         "--clickhouse" => Box::new(ClickHouseDialect {}),
         "--duckdb" => Box::new(DuckDbDialect {}),
         "--sqlite" => Box::new(SQLiteDialect {}),
+        "--oracle" => Box::new(OracleDialect {}),
         "--generic" | "" => Box::new(GenericDialect {}),
         s => panic!("Unexpected parameter: {s}"),
     };

src/ast/query.rs

@@ -174,6 +174,15 @@ impl SetExpr {
             None
         }
     }
+
+    /// If this `SetExpr` is a `SELECT`, returns a mutable [`Select`].
+    pub fn as_select_mut(&mut self) -> Option<&mut Select> {
+        if let Self::Select(select) = self {
+            Some(&mut **select)
+        } else {
+            None
+        }
+    }
 }
 
 impl fmt::Display for SetExpr {

src/dialect/mod.rs

@@ -24,6 +24,7 @@ mod generic;
 mod hive;
 mod mssql;
 mod mysql;
+mod oracle;
 mod postgresql;
 mod redshift;
 mod snowflake;
@@ -45,6 +46,7 @@ pub use self::generic::GenericDialect;
 pub use self::hive::HiveDialect;
 pub use self::mssql::MsSqlDialect;
 pub use self::mysql::MySqlDialect;
+pub use self::oracle::OracleDialect;
 pub use self::postgresql::PostgreSqlDialect;
 pub use self::redshift::RedshiftSqlDialect;
 pub use self::snowflake::SnowflakeDialect;
@@ -84,6 +86,26 @@ macro_rules! dialect_is {
     }
 }
 
+const DEFAULT_PREC_VALUE_PERIOD: u8 = 100;
+const DEFAULT_PREC_VALUE_DOUBLE_COLON: u8 = 50;
+const DEFAULT_PREC_VALUE_AT_TZ: u8 = 41;
+const DEFAULT_PREC_VALUE_MUL_DIV_MOD_OP: u8 = 40;
+const DEFAULT_PREC_VALUE_PLUS_MINUS: u8 = 30;
+const DEFAULT_PREC_VALUE_XOR: u8 = 24;
+const DEFAULT_PREC_VALUE_AMPERSAND: u8 = 23;
+const DEFAULT_PREC_VALUE_CARET: u8 = 22;
+const DEFAULT_PREC_VALUE_PIPE: u8 = 21;
+const DEFAULT_PREC_VALUE_BETWEEN: u8 = 20;
+const DEFAULT_PREC_VALUE_EQ: u8 = 20;
+const DEFAULT_PREC_VALUE_LIKE: u8 = 19;
+const DEFAULT_PREC_VALUE_IS: u8 = 17;
+const DEFAULT_PREC_VALUE_PG_OTHER: u8 = 16;
+const DEFAULT_PREC_VALUE_UNARY_NOT: u8 = 15;
+const DEFAULT_PREC_VALUE_AND: u8 = 10;
+const DEFAULT_PREC_VALUE_OR: u8 = 5;
+
+const DEFAULT_PREC_VALUE_UNKNOWN: u8 = 0;
+
 /// Encapsulates the differences between SQL implementations.
 ///
 /// # SQL Dialects
@@ -773,6 +795,36 @@ pub trait Dialect: Debug + Any {
         }
     }
 
+    /// Decide the lexical Precedence of operators.
+    ///
+    /// Uses (APPROXIMATELY) <https://www.postgresql.org/docs/7.0/operators.htm#AEN2026> as a reference
+    fn prec_value(&self, prec: Precedence) -> u8 {
+        match prec {
+            Precedence::Period => DEFAULT_PREC_VALUE_PERIOD,
+            Precedence::DoubleColon => DEFAULT_PREC_VALUE_DOUBLE_COLON,
+            Precedence::AtTz => DEFAULT_PREC_VALUE_AT_TZ,
+            Precedence::MulDivModOp => DEFAULT_PREC_VALUE_MUL_DIV_MOD_OP,
+            Precedence::PlusMinus => DEFAULT_PREC_VALUE_PLUS_MINUS,
+            Precedence::Xor => DEFAULT_PREC_VALUE_XOR,
+            Precedence::Ampersand => DEFAULT_PREC_VALUE_AMPERSAND,
+            Precedence::Caret => DEFAULT_PREC_VALUE_CARET,
+            Precedence::Pipe => DEFAULT_PREC_VALUE_PIPE,
+            Precedence::Between => DEFAULT_PREC_VALUE_BETWEEN,
+            Precedence::Eq => DEFAULT_PREC_VALUE_EQ,
+            Precedence::Like => DEFAULT_PREC_VALUE_LIKE,
+            Precedence::Is => DEFAULT_PREC_VALUE_IS,
+            Precedence::PgOther => DEFAULT_PREC_VALUE_PG_OTHER,
+            Precedence::UnaryNot => DEFAULT_PREC_VALUE_UNARY_NOT,
+            Precedence::And => DEFAULT_PREC_VALUE_AND,
+            Precedence::Or => DEFAULT_PREC_VALUE_OR,
+        }
+    }
+
+    /// Returns the precedence when the precedence is otherwise unknown
+    fn prec_unknown(&self) -> u8 {
+        DEFAULT_PREC_VALUE_UNKNOWN
+    }
+
     /// Dialect-specific statement parser override
     ///
     /// This method is called to parse the next statement.
@@ -796,36 +848,6 @@ pub trait Dialect: Debug + Any {
         Ok(None)
     }
 
-    /// Decide the lexical Precedence of operators.
-    ///
-    /// Uses (APPROXIMATELY) <https://www.postgresql.org/docs/7.0/operators.htm#AEN2026> as a reference
-    fn prec_value(&self, prec: Precedence) -> u8 {
-        match prec {
-            Precedence::Period => 100,
-            Precedence::DoubleColon => 50,
-            Precedence::AtTz => 41,
-            Precedence::MulDivModOp => 40,
-            Precedence::PlusMinus => 30,
-            Precedence::Xor => 24,
-            Precedence::Ampersand => 23,
-            Precedence::Caret => 22,
-            Precedence::Pipe => 21,
-            Precedence::Between => 20,
-            Precedence::Eq => 20,
-            Precedence::Like => 19,
-            Precedence::Is => 17,
-            Precedence::PgOther => 16,
-            Precedence::UnaryNot => 15,
-            Precedence::And => 10,
-            Precedence::Or => 5,
-        }
-    }
-
-    /// Returns the precedence when the precedence is otherwise unknown
-    fn prec_unknown(&self) -> u8 {
-        0
-    }
-
     /// Returns true if this dialect requires the `TABLE` keyword after `DESCRIBE`
     ///
     /// Defaults to false.
@@ -1260,6 +1282,7 @@ pub fn dialect_from_str(dialect_name: impl AsRef<str>) -> Option<Box<dyn Dialect
         "ansi" => Some(Box::new(AnsiDialect {})),
         "duckdb" => Some(Box::new(DuckDbDialect {})),
         "databricks" => Some(Box::new(DatabricksDialect {})),
+        "oracle" => Some(Box::new(OracleDialect {})),
         _ => None,
     }
 }

src/dialect/oracle.rs

@@ -0,0 +1,102 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use log::debug;
+
+use crate::{dialect::DEFAULT_PREC_VALUE_MUL_DIV_MOD_OP, tokenizer::Token};
+
+use super::Dialect;
+
+/// A [`Dialect`] for [Oracle Databases](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/index.html)
+#[derive(Debug)]
+pub struct OracleDialect;
+
+impl Dialect for OracleDialect {
+    // ~ appears not to be called anywhere
+    fn identifier_quote_style(&self, _identifier: &str) -> Option<char> {
+        Some('"')
+    }
+
+    fn is_delimited_identifier_start(&self, ch: char) -> bool {
+        ch == '"'
+    }
+
+    fn is_identifier_start(&self, ch: char) -> bool {
+        ch.is_alphabetic()
+    }
+
+    fn is_identifier_part(&self, ch: char) -> bool {
+        ch.is_alphanumeric() || ch == '_' || ch == '$' || ch == '#' || ch == '@'
+    }
+
+    fn supports_outer_join_operator(&self) -> bool {
+        true
+    }
+
+    fn supports_connect_by(&self) -> bool {
+        true
+    }
+
+    fn supports_execute_immediate(&self) -> bool {
+        true
+    }
+
+    fn supports_match_recognize(&self) -> bool {
+        true
+    }
+
+    fn supports_window_function_null_treatment_arg(&self) -> bool {
+        true
+    }
+
+    fn supports_boolean_literals(&self) -> bool {
+        false
+    }
+
+    fn supports_comment_on(&self) -> bool {
+        true
+    }
+
+    fn supports_create_table_select(&self) -> bool {
+        true
+    }
+
+    fn supports_set_stmt_without_operator(&self) -> bool {
+        true
+    }
+
+    fn get_next_precedence(
+        &self,
+        _parser: &crate::parser::Parser,
+    ) -> Option<Result<u8, crate::parser::ParserError>> {
+        let t = _parser.peek_token();
+        debug!("get_next_precedence() {t:?}");
+
+        match t.token {
+            Token::StringConcat => {
+                // ~ overriding the default precedence to the same level as mul-div-mod
+                // ~ see: https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/About-SQL-Operators.html
+                Some(Ok(DEFAULT_PREC_VALUE_MUL_DIV_MOD_OP))
+            }
+            _ => None,
+        }
+    }
+
+    fn supports_group_by_expr(&self) -> bool {
+        true
+    }
+}

src/keywords.rs

@@ -220,6 +220,7 @@ define_keywords!(
     COMMITTED,
     COMMUTATOR,
     COMPATIBLE,
+    COMPRESS,
     COMPRESSION,
     COMPUPDATE,
     COMPUTE,
@@ -464,6 +465,7 @@ define_keywords!(
     IAM_ROLE,
     ICEBERG,
     ID,
+    IDENTIFIED,
     IDENTITY,
     IDENTITY_INSERT,
     IF,
@@ -567,6 +569,7 @@ define_keywords!(
     LOG,
     LOGIN,
     LOGS,
+    LONG,
     LONGBLOB,
     LONGTEXT,
     LOWCARDINALITY,
@@ -652,6 +655,7 @@ define_keywords!(
     NFKD,
     NO,
     NOBYPASSRLS,
+    NOCOMPRESS,
     NOCREATEDB,
     NOCREATEROLE,
     NOINHERIT,
@@ -675,6 +679,7 @@ define_keywords!(
     NULLABLE,
     NULLIF,
     NULLS,
+    NUMBER,
     NUMERIC,
     NVARCHAR,
     OBJECT,
@@ -741,6 +746,7 @@ define_keywords!(
     PAST,
     PATH,
     PATTERN,
+    PCTFREE,
     PER,
     PERCENT,
     PERCENTILE_CONT,
@@ -913,6 +919,7 @@ define_keywords!(
     SIGNED,
     SIMILAR,
     SIMPLE,
+    SIZE,
     SKIP,
     SLOW,
     SMALLINT,
@@ -974,6 +981,7 @@ define_keywords!(
     SWAP,
     SYMMETRIC,
     SYNC,
+    SYNONYM,
     SYSTEM,
     SYSTEM_TIME,
     SYSTEM_USER,
@@ -1085,6 +1093,7 @@ define_keywords!(
     VARBINARY,
     VARBIT,
     VARCHAR,
+    VARCHAR2,
     VARIABLE,
     VARIABLES,
     VARYING,

src/parser/mod.rs

@@ -12228,7 +12228,7 @@ impl<'a> Parser<'a> {
         let (tables, with_from_keyword) = if !self.parse_keyword(Keyword::FROM) {
             // `FROM` keyword is optional in BigQuery SQL.
             // https://cloud.google.com/bigquery/docs/reference/standard-sql/dml-syntax#delete_statement
-            if dialect_of!(self is BigQueryDialect | GenericDialect) {
+            if dialect_of!(self is BigQueryDialect | OracleDialect | GenericDialect) {
                 (vec![], false)
             } else {
                 let tables = self.parse_comma_separated(|p| p.parse_object_name(false))?;

src/test_utils.rs

@@ -291,6 +291,7 @@ pub fn all_dialects() -> TestedDialects {
         Box::new(DuckDbDialect {}),
         Box::new(DatabricksDialect {}),
         Box::new(ClickHouseDialect {}),
+        Box::new(OracleDialect {}),
     ])
 }
 

tests/sqlparser_common.rs

@@ -34,8 +34,8 @@ use sqlparser::ast::TableFactor::{Pivot, Unpivot};
 use sqlparser::ast::*;
 use sqlparser::dialect::{
     AnsiDialect, BigQueryDialect, ClickHouseDialect, DatabricksDialect, Dialect, DuckDbDialect,
-    GenericDialect, HiveDialect, MsSqlDialect, MySqlDialect, PostgreSqlDialect, RedshiftSqlDialect,
-    SQLiteDialect, SnowflakeDialect,
+    GenericDialect, HiveDialect, MsSqlDialect, MySqlDialect, OracleDialect, PostgreSqlDialect,
+    RedshiftSqlDialect, SQLiteDialect, SnowflakeDialect,
 };
 use sqlparser::keywords::{Keyword, ALL_KEYWORDS};
 use sqlparser::parser::{Parser, ParserError, ParserOptions};
@@ -712,7 +712,9 @@ fn parse_delete_statement() {
 fn parse_delete_without_from_error() {
     let sql = "DELETE \"table\" WHERE 1";
 
-    let dialects = all_dialects_except(|d| d.is::<BigQueryDialect>() || d.is::<GenericDialect>());
+    let dialects = all_dialects_except(|d| {
+        d.is::<BigQueryDialect>() || d.is::<OracleDialect>() || d.is::<GenericDialect>()
+    });
     let res = dialects.parse_sql_statements(sql);
     assert_eq!(
         ParserError::ParserError("Expected: FROM, found: WHERE".to_string()),
@@ -723,7 +725,9 @@ fn parse_delete_without_from_error() {
 #[test]
 fn parse_delete_statement_for_multi_tables() {
     let sql = "DELETE schema1.table1, schema2.table2 FROM schema1.table1 JOIN schema2.table2 ON schema2.table2.col1 = schema1.table1.col1 WHERE schema2.table2.col2 = 1";
-    let dialects = all_dialects_except(|d| d.is::<BigQueryDialect>() || d.is::<GenericDialect>());
+    let dialects = all_dialects_except(|d| {
+        d.is::<BigQueryDialect>() || d.is::<OracleDialect>() || d.is::<GenericDialect>()
+    });
     match dialects.verified_stmt(sql) {
         Statement::Delete(Delete {
             tables,
@@ -12943,7 +12947,7 @@ fn test_match_recognize_patterns() {
     fn check(pattern: &str, expect: MatchRecognizePattern) {
         let select =
             all_dialects_where(|d| d.supports_match_recognize()).verified_only_select(&format!(
-                "SELECT * FROM my_table MATCH_RECOGNIZE(PATTERN ({pattern}) DEFINE DUMMY AS true)" // "select * from my_table match_recognize ("
+                "SELECT * FROM my_table MATCH_RECOGNIZE(PATTERN ({pattern}) DEFINE DUMMY AS 1 = 1)" // "select * from my_table match_recognize ("
             ));
         let TableFactor::MatchRecognize {
             pattern: actual, ..