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