Support CREATE VECTOR INDEX

Several dialects create a vector index for approximate nearest-neighbor search
over an embedding column with a `CREATE VECTOR INDEX` statement — BigQuery,
Oracle, SQL Server, MariaDB and TiDB. `VECTOR` is not a keyword, so
`parse_create` previously failed with
`Expected: an object type after CREATE, found: VECTOR`.

The common core is `CREATE [OR REPLACE] VECTOR INDEX [IF NOT EXISTS] <name> ON
<table>(<column | expr>)`, after which dialects add different trailers
(BigQuery `OPTIONS(...)`, SQL Server `WITH (...)`, Oracle `INCLUDE`/bare
clauses, TiDB `USING`). It is parsed permissively for every dialect.

### Changes
- Add `vector`, `or_replace` and `options` fields to `CreateIndex`. `VECTOR` is
  a modifier on `CREATE INDEX` (like `UNIQUE`), so it reuses the existing node
  rather than a new statement variant. `Display` renders
  `CREATE [OR REPLACE ]VECTOR INDEX ...` and the `OPTIONS(...)` trailer.
- Route `CREATE VECTOR INDEX` through `parse_create_index`, so it inherits the
  existing index trailers — `USING`, `INCLUDE`, `WITH`, expression targets and
  index options — that cover the Oracle / SQL Server / TiDB variants. The
  BigQuery `OPTIONS(...)` clause reuses `parse_options` / `SqlOption`, parsing
  and rendering like `CREATE TABLE` / `CREATE VIEW` OPTIONS.
- Plain `CREATE INDEX` is unchanged (the three fields default to false/empty).
- Test `parse_create_vector_index` in `tests/sqlparser_common.rs` verifies the
  round-trip across all dialects and covers `OR REPLACE`, `IF NOT EXISTS`,
  schema-qualified names, `OPTIONS(...)` and the shared `INCLUDE` trailer.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: moshap-firebolt

src/ast/ddl.rs

@@ -2827,6 +2827,11 @@ pub struct CreateIndex {
     pub using: Option<IndexType>,
     /// columns included in the index
     pub columns: Vec<IndexColumn>,
+    /// whether this is a `CREATE VECTOR INDEX` (BigQuery, Oracle, SQL Server,
+    /// MariaDB, TiDB)
+    pub vector: bool,
+    /// whether the statement is `CREATE OR REPLACE`
+    pub or_replace: bool,
     /// whether the index is unique
     pub unique: bool,
     /// whether the index is created concurrently
@@ -2843,6 +2848,8 @@ pub struct CreateIndex {
     pub nulls_distinct: Option<bool>,
     /// WITH clause: <https://www.postgresql.org/docs/current/sql-createindex.html>
     pub with: Vec<Expr>,
+    /// `OPTIONS(...)` clause (BigQuery, e.g. on `CREATE VECTOR INDEX`)
+    pub options: Vec<SqlOption>,
     /// WHERE clause: <https://www.postgresql.org/docs/current/sql-createindex.html>
     pub predicate: Option<Expr>,
     /// Index options: <https://www.postgresql.org/docs/current/sql-createindex.html>
@@ -2860,8 +2867,10 @@ impl fmt::Display for CreateIndex {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
-            "CREATE {unique}INDEX {concurrently}{async_}{if_not_exists}",
+            "CREATE {or_replace}{unique}{vector}INDEX {concurrently}{async_}{if_not_exists}",
+            or_replace = if self.or_replace { "OR REPLACE " } else { "" },
             unique = if self.unique { "UNIQUE " } else { "" },
+            vector = if self.vector { "VECTOR " } else { "" },
             concurrently = if self.concurrently {
                 "CONCURRENTLY "
             } else {
@@ -2895,6 +2904,9 @@ impl fmt::Display for CreateIndex {
         if !self.with.is_empty() {
             write!(f, " WITH ({})", display_comma_separated(&self.with))?;
         }
+        if !self.options.is_empty() {
+            write!(f, " OPTIONS({})", display_comma_separated(&self.options))?;
+        }
         if let Some(predicate) = &self.predicate {
             write!(f, " WHERE {predicate}")?;
         }

src/ast/spans.rs

@@ -699,13 +699,16 @@ impl Spanned for CreateIndex {
             table_name,
             using: _,
             columns,
+            vector: _,        // bool
+            or_replace: _,    // bool
             unique: _,        // bool
             concurrently: _,  // bool
             r#async: _,       // bool
             if_not_exists: _, // bool
             include,
             nulls_distinct: _, // bool
             with,
+            options,
             predicate,
             index_options: _,
             alter_options,
@@ -718,6 +721,7 @@ impl Spanned for CreateIndex {
                 .chain(columns.iter().map(|i| i.column.span()))
                 .chain(include.iter().map(|i| i.span))
                 .chain(with.iter().map(|i| i.span()))
+                .chain(options.iter().map(|i| i.span()))
                 .chain(predicate.iter().map(|i| i.span()))
                 .chain(alter_options.iter().map(|i| i.span())),
         )

src/parser/mod.rs

@@ -5288,6 +5288,16 @@ impl<'a> Parser<'a> {
             self.parse_create_schema(or_replace)
         } else if self.parse_keyword(Keyword::WAREHOUSE) {
             self.parse_create_warehouse(or_replace).map(Into::into)
+        } else if matches!(
+            &self.peek_token_ref().token,
+            Token::Word(w) if w.keyword == Keyword::NoKeyword && w.value.eq_ignore_ascii_case("VECTOR")
+        ) {
+            // `CREATE [OR REPLACE] VECTOR INDEX ...` (BigQuery, Oracle, SQL Server,
+            // MariaDB, TiDB). VECTOR is not a reserved keyword.
+            self.next_token();
+            self.expect_keyword_is(Keyword::INDEX)?;
+            self.parse_create_index_inner(false, true, or_replace)
+                .map(Into::into)
         } else if or_replace {
             self.expected_ref(
                 "[EXTERNAL] TABLE or [MATERIALIZED] VIEW or FUNCTION or SCHEMA or WAREHOUSE after CREATE OR REPLACE",
@@ -8247,6 +8257,24 @@ impl<'a> Parser<'a> {
 
     /// Parse a `CREATE INDEX` statement.
     pub fn parse_create_index(&mut self, unique: bool) -> Result<CreateIndex, ParserError> {
+        self.parse_create_index_inner(unique, false, false)
+    }
+
+    /// Parse the body of a `CREATE [UNIQUE | VECTOR] INDEX` statement, with the
+    /// leading `[UNIQUE | VECTOR] INDEX` keywords already consumed.
+    ///
+    /// `CREATE VECTOR INDEX` is supported by several dialects (BigQuery, Oracle,
+    /// SQL Server, MariaDB, TiDB) and is parsed permissively for all of them.
+    /// Its common core is `... name ON tbl(column | expr)`; the dialect-specific
+    /// trailers reuse the standard index clauses parsed below — `USING <method>`
+    /// (TiDB), `INCLUDE (...)` (Oracle/SQL Server), `WITH (...)` (SQL Server),
+    /// and the BigQuery `OPTIONS(...)` clause.
+    fn parse_create_index_inner(
+        &mut self,
+        unique: bool,
+        vector: bool,
+        or_replace: bool,
+    ) -> Result<CreateIndex, ParserError> {
         let concurrently = self.parse_keyword(Keyword::CONCURRENTLY);
         let r#async = self.parse_keyword(Keyword::ASYNC);
         let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
@@ -8299,6 +8327,10 @@ impl<'a> Parser<'a> {
             Vec::new()
         };
 
+        // BigQuery `OPTIONS(...)` clause (e.g. on `CREATE VECTOR INDEX`); no-op
+        // when absent, so it is harmless on a plain `CREATE INDEX`.
+        let options = self.parse_options(Keyword::OPTIONS)?;
+
         let predicate = if self.parse_keyword(Keyword::WHERE) {
             Some(self.parse_expr()?)
         } else {
@@ -8326,13 +8358,16 @@ impl<'a> Parser<'a> {
             table_name,
             using,
             columns,
+            vector,
+            or_replace,
             unique,
             concurrently,
             r#async,
             if_not_exists,
             include,
             nulls_distinct,
             with,
+            options,
             predicate,
             index_options,
             alter_options,

tests/sqlparser_common.rs

@@ -9728,6 +9728,9 @@ fn test_create_index_with_using_function() {
             predicate: None,
             index_options,
             alter_options,
+            vector: _,
+            or_replace: _,
+            options: _,
         }) => {
             assert_eq!("idx_name", name.to_string());
             assert_eq!("test", table_name.to_string());
@@ -9785,6 +9788,9 @@ fn test_create_index_with_with_clause() {
             predicate: None,
             index_options,
             alter_options,
+            vector: _,
+            or_replace: _,
+            options: _,
         }) => {
             pretty_assertions::assert_eq!("title_idx", name.to_string());
             pretty_assertions::assert_eq!("films", table_name.to_string());
@@ -9808,6 +9814,95 @@ fn parse_create_index_async() {
     verified_stmt("CREATE UNIQUE INDEX ASYNC my_index ON my_table(col1)");
 }
 
+#[test]
+fn parse_create_vector_index() {
+    // `CREATE VECTOR INDEX` is not dialect-specific — BigQuery, Oracle,
+    // SQL Server, MariaDB and TiDB all have it — so it is parsed for every
+    // dialect, as a `CreateIndex` flagged `vector`. Its common core is
+    // `... name ON tbl(column)`; the BigQuery `OPTIONS(...)` trailer lands in
+    // `options`, and the standard index trailers (`INCLUDE`, `USING`, `WITH`)
+    // are shared with `CREATE INDEX`.
+    let sql =
+        "CREATE VECTOR INDEX emb ON t(embedding) OPTIONS(distance_type = 'COSINE', dimension = 4)";
+    match verified_stmt(sql) {
+        Statement::CreateIndex(CreateIndex {
+            name,
+            table_name,
+            using,
+            columns,
+            vector,
+            or_replace,
+            unique,
+            if_not_exists,
+            with,
+            options,
+            ..
+        }) => {
+            assert!(vector);
+            assert!(!or_replace);
+            assert!(!unique);
+            assert!(!if_not_exists);
+            assert_eq!(name.unwrap().to_string(), "emb");
+            assert_eq!(table_name.to_string(), "t");
+            assert_eq!(using, None);
+            assert!(with.is_empty());
+            assert_eq!(
+                columns.iter().map(|c| c.to_string()).collect::<Vec<_>>(),
+                vec!["embedding"]
+            );
+            assert_eq!(
+                options,
+                vec![
+                    SqlOption::KeyValue {
+                        key: Ident::new("distance_type"),
+                        value: Expr::Value(
+                            Value::SingleQuotedString("COSINE".to_string()).with_empty_span()
+                        ),
+                    },
+                    SqlOption::KeyValue {
+                        key: Ident::new("dimension"),
+                        value: Expr::value(number("4")),
+                    },
+                ]
+            );
+        }
+        other => panic!("expected CreateIndex, got {other:?}"),
+    }
+
+    // `OR REPLACE` (BigQuery, MariaDB).
+    match verified_stmt(
+        "CREATE OR REPLACE VECTOR INDEX emb ON t(embedding) OPTIONS(distance_type = 'COSINE')",
+    ) {
+        Statement::CreateIndex(CreateIndex {
+            vector, or_replace, ..
+        }) => {
+            assert!(vector);
+            assert!(or_replace);
+        }
+        other => panic!("expected CreateIndex, got {other:?}"),
+    }
+
+    // `IF NOT EXISTS` and schema-qualified names.
+    match verified_stmt(
+        "CREATE VECTOR INDEX IF NOT EXISTS s.emb ON s.t(embedding) OPTIONS(distance_type = 'EUCLIDEAN')",
+    ) {
+        Statement::CreateIndex(CreateIndex {
+            vector,
+            if_not_exists,
+            ..
+        }) => {
+            assert!(vector);
+            assert!(if_not_exists);
+        }
+        other => panic!("expected CreateIndex, got {other:?}"),
+    }
+
+    // The bare common core, and the shared `INCLUDE` covering-column trailer
+    // (Oracle / SQL Server), both round-trip.
+    verified_stmt("CREATE VECTOR INDEX emb ON t(embedding)");
+    verified_stmt("CREATE VECTOR INDEX emb ON t(embedding) INCLUDE (a, b)");
+}
+
 #[test]
 fn parse_drop_index() {
     let sql = "DROP INDEX idx_a";

tests/sqlparser_postgres.rs

@@ -2993,6 +2993,9 @@ fn parse_create_index() {
             predicate: None,
             index_options,
             alter_options,
+            vector: _,
+            or_replace: _,
+            options: _,
         }) => {
             assert_eq_vec(&["my_index"], &name);
             assert_eq_vec(&["my_table"], &table_name);
@@ -3030,6 +3033,9 @@ fn parse_create_anonymous_index() {
             predicate: None,
             index_options,
             alter_options,
+            vector: _,
+            or_replace: _,
+            options: _,
         }) => {
             assert_eq!(None, name);
             assert_eq_vec(&["my_table"], &table_name);
@@ -3150,6 +3156,9 @@ fn parse_create_indices_with_operator_classes() {
                     predicate: None,
                     index_options,
                     alter_options,
+                    vector: _,
+                    or_replace: _,
+                    options: _,
                 }) => {
                     assert_eq_vec(&["the_index_name"], &name);
                     assert_eq_vec(&["users"], &table_name);
@@ -3179,6 +3188,9 @@ fn parse_create_indices_with_operator_classes() {
                     predicate: None,
                     index_options,
                     alter_options,
+                    vector: _,
+                    or_replace: _,
+                    options: _,
                 }) => {
                     assert_eq_vec(&["the_index_name"], &name);
                     assert_eq_vec(&["users"], &table_name);
@@ -3263,6 +3275,9 @@ fn parse_create_bloom() {
             predicate: None,
             index_options,
             alter_options,
+            vector: _,
+            or_replace: _,
+            options: _,
         }) => {
             assert_eq_vec(&["bloomidx"], &name);
             assert_eq_vec(&["tbloom"], &table_name);
@@ -3320,6 +3335,9 @@ fn parse_create_brin() {
             predicate: None,
             index_options,
             alter_options,
+            vector: _,
+            or_replace: _,
+            options: _,
         }) => {
             assert_eq_vec(&["brin_sensor_data_recorded_at"], &name);
             assert_eq_vec(&["sensor_data"], &table_name);
@@ -3388,6 +3406,9 @@ fn parse_create_index_concurrently() {
             predicate: None,
             index_options,
             alter_options,
+            vector: _,
+            or_replace: _,
+            options: _,
         }) => {
             assert_eq_vec(&["my_index"], &name);
             assert_eq_vec(&["my_table"], &table_name);
@@ -3425,6 +3446,9 @@ fn parse_create_index_with_predicate() {
             predicate: Some(_),
             index_options,
             alter_options,
+            vector: _,
+            or_replace: _,
+            options: _,
         }) => {
             assert_eq_vec(&["my_index"], &name);
             assert_eq_vec(&["my_table"], &table_name);
@@ -3462,6 +3486,9 @@ fn parse_create_index_with_include() {
             predicate: None,
             index_options,
             alter_options,
+            vector: _,
+            or_replace: _,
+            options: _,
         }) => {
             assert_eq_vec(&["my_index"], &name);
             assert_eq_vec(&["my_table"], &table_name);
@@ -3499,6 +3526,9 @@ fn parse_create_index_with_nulls_distinct() {
             predicate: None,
             index_options,
             alter_options,
+            vector: _,
+            or_replace: _,
+            options: _,
         }) => {
             assert_eq_vec(&["my_index"], &name);
             assert_eq_vec(&["my_table"], &table_name);
@@ -3534,6 +3564,9 @@ fn parse_create_index_with_nulls_distinct() {
             predicate: None,
             index_options,
             alter_options,
+            vector: _,
+            or_replace: _,
+            options: _,
         }) => {
             assert_eq_vec(&["my_index"], &name);
             assert_eq_vec(&["my_table"], &table_name);