You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datafusion.apache.org by lu...@apache.org on 2026/10/18 13:36:37 UTC

(datafusion-sqlparser-rs) 01/01: SQLite: Support `INDEXED BY` and `NOT INDEXED`

This is an automated email from the ASF dual-hosted git repository.

LucaCappelletti94 pushed a commit to branch sqlite-indexed-by
in repository https://gitbox.apache.org/repos/asf/datafusion-sqlparser-rs.git

commit 1c4a54a8dbe96056b0af5888833a0f29dec3a08a
Author: LucaCappelletti94 <ca...@gmail.com>
AuthorDate: Wed Sep 23 09:40:39 2026 +0200

    SQLite: Support `INDEXED BY` and `NOT INDEXED`
---
 src/ast/mod.rs            |  2 +-
 src/ast/query.rs          | 29 ++++++++++++++++++++++++++---
 src/dialect/mod.rs        |  7 +++++++
 src/dialect/sqlite.rs     | 15 ++++++++++++++-
 src/keywords.rs           |  1 +
 src/parser/mod.rs         | 16 +++++++++++-----
 tests/sqlparser_common.rs |  8 ++++----
 tests/sqlparser_sqlite.rs | 42 ++++++++++++++++++++++++++++++++++++++++++
 8 files changed, 106 insertions(+), 14 deletions(-)

diff --git a/src/ast/mod.rs b/src/ast/mod.rs
index c0fb446d2..650f5423a 100644
--- a/src/ast/mod.rs
+++ b/src/ast/mod.rs
@@ -107,7 +107,7 @@ pub use self::query::{
     RepetitionQuantifier, ReplaceSelectElement, ReplaceSelectItem, RowsPerMatch, Select,
     SelectFlavor, SelectInto, SelectItem, SelectItemQualifiedWildcardKind, SelectModifiers,
     SetExpr, SetOperator, SetQuantifier, Setting, SymbolDefinition, Table, TableAlias,
-    TableAliasColumnDef, TableFactor, TableFunctionArgs, TableIndexHintForClause,
+    TableAliasColumnDef, TableFactor, TableFunctionArgs, TableIndexHint, TableIndexHintForClause,
     TableIndexHintType, TableIndexHints, TableIndexType, TableSample, TableSampleBucket,
     TableSampleKind, TableSampleMethod, TableSampleModifier, TableSampleQuantity, TableSampleSeed,
     TableSampleSeedModifier, TableSampleUnit, TableVersion, TableWithJoins, Top, TopQuantity,
diff --git a/src/ast/query.rs b/src/ast/query.rs
index 4aa82c7c3..59153767e 100644
--- a/src/ast/query.rs
+++ b/src/ast/query.rs
@@ -1453,6 +1453,30 @@ impl fmt::Display for TableIndexHints {
     }
 }
 
+/// An index hint attached to a table, see [`TableFactor::Table::index_hints`].
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum TableIndexHint {
+    /// `{USE | IGNORE | FORCE} {INDEX | KEY} [FOR ...] (index_name, ...)`, see
+    /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/index-hints.html)
+    MySql(TableIndexHints),
+    /// `INDEXED BY index_name`, see [SQLite](https://www.sqlite.org/lang_indexedby.html)
+    IndexedBy(Ident),
+    /// `NOT INDEXED`, see [SQLite](https://www.sqlite.org/lang_indexedby.html)
+    NotIndexed,
+}
+
+impl fmt::Display for TableIndexHint {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            TableIndexHint::MySql(hint) => hint.fmt(f),
+            TableIndexHint::IndexedBy(name) => write!(f, "INDEXED BY {name}"),
+            TableIndexHint::NotIndexed => f.write_str("NOT INDEXED"),
+        }
+    }
+}
+
 /// A table name or a parenthesized subquery with an optional alias
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -1490,9 +1514,8 @@ pub enum TableFactor {
         /// Optional table sample modifier
         /// See: <https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#sample-clause>
         sample: Option<TableSampleKind>,
-        /// Optional index hints(mysql)
-        /// See: <https://dev.mysql.com/doc/refman/8.4/en/index-hints.html>
-        index_hints: Vec<TableIndexHints>,
+        /// Optional index hints, MySQL's `USE INDEX (...)` or SQLite's `INDEXED BY`.
+        index_hints: Vec<TableIndexHint>,
     },
     /// A derived table (a parenthesized subquery), optionally `LATERAL`.
     Derived {
diff --git a/src/dialect/mod.rs b/src/dialect/mod.rs
index 512af328e..4a4b2f8b9 100644
--- a/src/dialect/mod.rs
+++ b/src/dialect/mod.rs
@@ -1551,6 +1551,13 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if the dialect supports SQLite's `INDEXED BY` and `NOT INDEXED` table hints.
+    ///
+    /// See <https://www.sqlite.org/lang_indexedby.html>
+    fn supports_indexed_by(&self) -> bool {
+        false
+    }
+
     /// Returns true if this dialect requires a whitespace character after `--` to start a single line comment.
     ///
     /// MySQL: <https://dev.mysql.com/doc/refman/8.4/en/ansi-diff-comments.html>
diff --git a/src/dialect/sqlite.rs b/src/dialect/sqlite.rs
index f63e4cbe1..6b5160afa 100644
--- a/src/dialect/sqlite.rs
+++ b/src/dialect/sqlite.rs
@@ -21,7 +21,7 @@ use alloc::boxed::Box;
 use crate::ast::BinaryOperator;
 use crate::ast::{Expr, Statement};
 use crate::dialect::Dialect;
-use crate::keywords::Keyword;
+use crate::keywords::{self, Keyword};
 use crate::parser::{Parser, ParserError};
 
 /// A [`Dialect`] for [SQLite](https://www.sqlite.org)
@@ -146,4 +146,17 @@ impl Dialect for SQLiteDialect {
     fn supports_parens_around_table_factor(&self) -> bool {
         true
     }
+
+    fn supports_indexed_by(&self) -> bool {
+        true
+    }
+
+    /// `INDEXED BY` and `NOT INDEXED` follow the table name or alias.
+    fn is_table_alias(&self, kw: &Keyword, parser: &mut Parser) -> bool {
+        match kw {
+            Keyword::INDEXED => false,
+            Keyword::NOT => !parser.peek_keyword(Keyword::INDEXED),
+            _ => !keywords::RESERVED_FOR_TABLE_ALIAS.contains(kw),
+        }
+    }
 }
diff --git a/src/keywords.rs b/src/keywords.rs
index 7e9382241..bde973be3 100644
--- a/src/keywords.rs
+++ b/src/keywords.rs
@@ -519,6 +519,7 @@ define_keywords!(
     INCREMENT,
     INCREMENTAL,
     INDEX,
+    INDEXED,
     INDICATOR,
     INHERIT,
     INHERITS,
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index db54296fc..164458245 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -13635,7 +13635,7 @@ impl<'a> Parser<'a> {
         }
     }
 
-    fn parse_table_index_hints(&mut self) -> Result<Vec<TableIndexHints>, ParserError> {
+    fn parse_table_index_hints(&mut self) -> Result<Vec<TableIndexHint>, ParserError> {
         let mut hints = vec![];
         while let Some(hint_type) =
             self.parse_one_of_keywords(&[Keyword::USE, Keyword::IGNORE, Keyword::FORCE])
@@ -13684,12 +13684,12 @@ impl<'a> Parser<'a> {
                 vec![]
             };
             self.expect_token(&Token::RParen)?;
-            hints.push(TableIndexHints {
+            hints.push(TableIndexHint::MySql(TableIndexHints {
                 hint_type,
                 index_type,
                 for_clause,
                 index_names,
-            });
+            }));
         }
         Ok(hints)
     }
@@ -17044,13 +17044,19 @@ impl<'a> Parser<'a> {
 
             let alias = self.maybe_parse_table_alias()?;
 
-            // MYSQL-specific table hints:
-            let index_hints = if self.dialect.supports_table_hints() {
+            let mut index_hints = if self.dialect.supports_table_hints() {
                 self.maybe_parse(|p| p.parse_table_index_hints())?
                     .unwrap_or(vec![])
             } else {
                 vec![]
             };
+            if self.dialect.supports_indexed_by() {
+                if self.parse_keywords(&[Keyword::INDEXED, Keyword::BY]) {
+                    index_hints.push(TableIndexHint::IndexedBy(self.parse_identifier()?));
+                } else if self.parse_keywords(&[Keyword::NOT, Keyword::INDEXED]) {
+                    index_hints.push(TableIndexHint::NotIndexed);
+                }
+            }
 
             // MSSQL-specific table hints:
             let mut with_hints = vec![];
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
index 61fcb8131..8a1ddb0ab 100644
--- a/tests/sqlparser_common.rs
+++ b/tests/sqlparser_common.rs
@@ -12299,18 +12299,18 @@ fn parse_select_table_with_index_hints() {
     if let TableFactor::Table { index_hints, .. } = &s.from[0].relation {
         assert_eq!(
             vec![
-                TableIndexHints {
+                TableIndexHint::MySql(TableIndexHints {
                     hint_type: TableIndexHintType::Use,
                     index_names: vec!["i1".into()],
                     index_type: TableIndexType::Index,
                     for_clause: None,
-                },
-                TableIndexHints {
+                }),
+                TableIndexHint::MySql(TableIndexHints {
                     hint_type: TableIndexHintType::Ignore,
                     index_names: vec!["i2".into()],
                     index_type: TableIndexType::Index,
                     for_clause: Some(TableIndexHintForClause::OrderBy),
-                },
+                }),
             ],
             *index_hints
         );
diff --git a/tests/sqlparser_sqlite.rs b/tests/sqlparser_sqlite.rs
index 2e60c75ef..254a02710 100644
--- a/tests/sqlparser_sqlite.rs
+++ b/tests/sqlparser_sqlite.rs
@@ -1142,6 +1142,48 @@ fn parse_parenthesized_table_factor() {
     );
 }
 
+#[test]
+fn parse_indexed_by() {
+    let index_hints = |relation: &TableFactor| match relation {
+        TableFactor::Table { index_hints, .. } => index_hints.clone(),
+        _ => panic!("expected TableFactor::Table"),
+    };
+
+    let select = sqlite().verified_only_select("SELECT * FROM t INDEXED BY i WHERE a = 1");
+    assert_eq!(
+        index_hints(&select.from[0].relation),
+        vec![TableIndexHint::IndexedBy(Ident::new("i"))]
+    );
+
+    let select = sqlite().verified_only_select("SELECT * FROM t AS x NOT INDEXED");
+    assert_eq!(
+        index_hints(&select.from[0].relation),
+        vec![TableIndexHint::NotIndexed]
+    );
+
+    let select = sqlite().verified_only_select("SELECT * FROM t INDEXED BY i, t AS u NOT INDEXED");
+    assert_eq!(
+        index_hints(&select.from[0].relation),
+        vec![TableIndexHint::IndexedBy(Ident::new("i"))]
+    );
+    assert_eq!(
+        index_hints(&select.from[1].relation),
+        vec![TableIndexHint::NotIndexed]
+    );
+
+    sqlite().verified_stmt("SELECT * FROM t AS x INDEXED BY i WHERE a = 1");
+    sqlite().verified_stmt("DELETE FROM t INDEXED BY i WHERE a = 1");
+    sqlite().verified_stmt("UPDATE t INDEXED BY i SET a = 2 WHERE a = 1");
+
+    assert_eq!(
+        all_dialects_where(|d| !d.supports_indexed_by())
+            .parse_sql_statements("SELECT * FROM t INDEXED BY i"),
+        Err(ParserError::ParserError(
+            "Expected: end of statement, found: BY".to_string()
+        ))
+    );
+}
+
 fn sqlite() -> TestedDialects {
     TestedDialects::new(vec![Box::new(SQLiteDialect {})])
 }


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datafusion.apache.org
For additional commands, e-mail: commits-help@datafusion.apache.org