Cover more CREATE VECTOR INDEX dialect variants

Extend the shared `CREATE VECTOR INDEX` parsing to the trailers used by the
other dialects, and add per-dialect tests:

- `STORING(...)` covering-column clause (BigQuery); new `storing` field on
  `CreateIndex`, rendered after `INCLUDE`.
- Accept a `WITH (...)` options clause on a vector index in every dialect
  (SQL Server `WITH (METRIC = ..., TYPE = ..., MAXDOP = ...)`), not only the
  dialects that enable it for a plain `CREATE INDEX`.

Tests:
- `tests/sqlparser_common.rs` — the generic core plus the shared trailers
  (`INCLUDE`, `STORING`, `WITH`, `USING`, expression targets) across all dialects.
- `tests/sqlparser_bigquery.rs` — `OPTIONS(...)` with index_type / distance_type
  / JSON tuning keys, and `STORING(...)`.
- `tests/sqlparser_mssql.rs` — bracket-quoted names with `WITH (...)`.
- `tests/sqlparser_mysql.rs` — TiDB's distance-function target with `USING`.

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

Author: moshap-firebolt

src/ast/ddl.rs

@@ -2843,6 +2843,8 @@ pub struct CreateIndex {
     pub if_not_exists: bool,
     /// INCLUDE clause: <https://www.postgresql.org/docs/current/sql-createindex.html>
     pub include: Vec<Ident>,
+    /// `STORING(...)` clause (covering columns on a `CREATE VECTOR INDEX`)
+    pub storing: Vec<Ident>,
     /// NULLS DISTINCT / NOT DISTINCT clause: <https://www.postgresql.org/docs/current/sql-createindex.html>
     pub nulls_distinct: Option<bool>,
     /// WITH clause: <https://www.postgresql.org/docs/current/sql-createindex.html>
@@ -2893,6 +2895,9 @@ impl fmt::Display for CreateIndex {
         if !self.include.is_empty() {
             write!(f, " INCLUDE ({})", display_comma_separated(&self.include))?;
         }
+        if !self.storing.is_empty() {
+            write!(f, " STORING({})", display_comma_separated(&self.storing))?;
+        }
         if let Some(value) = self.nulls_distinct {
             if value {
                 write!(f, " NULLS DISTINCT")?;

src/ast/spans.rs

@@ -706,6 +706,7 @@ impl Spanned for CreateIndex {
             r#async: _,       // bool
             if_not_exists: _, // bool
             include,
+            storing,
             nulls_distinct: _, // bool
             with,
             options,
@@ -720,6 +721,7 @@ impl Spanned for CreateIndex {
                 .chain(core::iter::once(table_name.span()))
                 .chain(columns.iter().map(|i| i.column.span()))
                 .chain(include.iter().map(|i| i.span))
+                .chain(storing.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()))

src/keywords.rs

@@ -1008,6 +1008,7 @@ define_keywords!(
     STORAGE_INTEGRATION,
     STORAGE_SERIALIZATION_POLICY,
     STORED,
+    STORING,
     STRAIGHT_JOIN,
     STREAM,
     STRICT,

src/parser/mod.rs

@@ -8300,6 +8300,16 @@ impl<'a> Parser<'a> {
             vec![]
         };
 
+        // `STORING(...)` covering columns (e.g. `CREATE VECTOR INDEX`).
+        let storing = if self.parse_keyword(Keyword::STORING) {
+            self.expect_token(&Token::LParen)?;
+            let columns = self.parse_comma_separated(|p| p.parse_identifier())?;
+            self.expect_token(&Token::RParen)?;
+            columns
+        } else {
+            vec![]
+        };
+
         let nulls_distinct = if self.parse_keyword(Keyword::NULLS) {
             let not = self.parse_keyword(Keyword::NOT);
             self.expect_keyword_is(Keyword::DISTINCT)?;
@@ -8308,7 +8318,9 @@ impl<'a> Parser<'a> {
             None
         };
 
-        let with = if self.dialect.supports_create_index_with_clause()
+        // A vector index accepts a `WITH (...)` options clause in every dialect
+        // (e.g. SQL Server `WITH (METRIC = ..., TYPE = ...)`).
+        let with = if (self.dialect.supports_create_index_with_clause() || vector)
             && self.parse_keyword(Keyword::WITH)
         {
             self.expect_token(&Token::LParen)?;
@@ -8356,6 +8368,7 @@ impl<'a> Parser<'a> {
             r#async,
             if_not_exists,
             include,
+            storing,
             nulls_distinct,
             with,
             options,

tests/sqlparser_bigquery.rs

@@ -2950,3 +2950,15 @@ fn test_create_snapshot_table() {
         "CREATE SNAPSHOT TABLE IF NOT EXISTS dataset_id.table1 CLONE dataset_id.table2 FOR SYSTEM_TIME AS OF TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 1 HOUR) OPTIONS(expiration_timestamp = TIMESTAMP '2025-01-01 00:00:00 UTC')",
     );
 }
+
+#[test]
+fn parse_bigquery_create_vector_index() {
+    // BigQuery's form: an `OPTIONS(...)` clause with its index_type / distance_type
+    // / JSON tuning keys, and a `STORING(...)` covering-column list.
+    bigquery().verified_stmt(
+        "CREATE VECTOR INDEX my_index ON my_dataset.my_table(embedding) OPTIONS(index_type = 'IVF', distance_type = 'COSINE', ivf_options = '{\"num_lists\": 2500}')",
+    );
+    bigquery().verified_stmt(
+        "CREATE OR REPLACE VECTOR INDEX my_index ON my_dataset.my_table(embedding) STORING(type, creation_time) OPTIONS(index_type = 'TREE_AH', distance_type = 'EUCLIDEAN')",
+    );
+}

tests/sqlparser_common.rs

@@ -9731,6 +9731,7 @@ fn test_create_index_with_using_function() {
             vector: _,
             or_replace: _,
             options: _,
+            storing: _,
         }) => {
             assert_eq!("idx_name", name.to_string());
             assert_eq!("test", table_name.to_string());
@@ -9791,6 +9792,7 @@ fn test_create_index_with_with_clause() {
             vector: _,
             or_replace: _,
             options: _,
+            storing: _,
         }) => {
             pretty_assertions::assert_eq!("title_idx", name.to_string());
             pretty_assertions::assert_eq!("films", table_name.to_string());
@@ -9893,11 +9895,15 @@ fn parse_create_vector_index() {
         other => panic!("expected CreateIndex, got {other:?}"),
     }
 
-    // The bare core, an `INCLUDE` covering-column trailer, and an expression
-    // target all round-trip.
+    // The bare core plus the shared trailers all round-trip across dialects: an
+    // expression target, `INCLUDE` / `STORING` covering columns, a `WITH`
+    // options clause, and a trailing `USING <method>`.
     verified_stmt("CREATE VECTOR INDEX emb ON t(embedding)");
-    verified_stmt("CREATE VECTOR INDEX emb ON t(embedding) INCLUDE (a, b)");
     verified_stmt("CREATE VECTOR INDEX emb ON t(VEC_COSINE_DISTANCE(embedding))");
+    verified_stmt("CREATE VECTOR INDEX emb ON t(embedding) INCLUDE (a, b)");
+    verified_stmt("CREATE VECTOR INDEX emb ON t(embedding) STORING(a, b)");
+    verified_stmt("CREATE VECTOR INDEX emb ON t(embedding) WITH (metric = 'cosine')");
+    verified_stmt("CREATE VECTOR INDEX emb ON t(embedding) USING HNSW");
 }
 
 #[test]

tests/sqlparser_mssql.rs

@@ -2925,3 +2925,12 @@ fn parse_mssql_money_constants() {
         expr_from_projection(only(&select.projection)),
     );
 }
+
+#[test]
+fn parse_mssql_create_vector_index() {
+    // SQL Server's form: bracket-quoted names and a `WITH (...)` options clause
+    // (`METRIC` / `TYPE` / `MAXDOP`).
+    ms().verified_stmt(
+        "CREATE VECTOR INDEX vec_idx ON [dbo].[articles]([title_vector]) WITH (METRIC = 'cosine', TYPE = 'DiskANN', MAXDOP = 8)",
+    );
+}

tests/sqlparser_mysql.rs

@@ -4946,3 +4946,12 @@ fn parse_adjacent_string_literal_concatenation() {
 fn parse_group_by_with_rollup() {
     mysql().verified_stmt("SELECT * FROM tbl GROUP BY col1, col2 WITH ROLLUP");
 }
+
+#[test]
+fn parse_mysql_create_vector_index() {
+    // TiDB's form: the vector column is wrapped in a distance function and the
+    // algorithm is named with a trailing `USING`.
+    mysql().verified_stmt(
+        "CREATE VECTOR INDEX idx_cos ON tidb_vectors((VEC_COSINE_DISTANCE(embedding))) USING HNSW",
+    );
+}

tests/sqlparser_postgres.rs

@@ -2996,6 +2996,7 @@ fn parse_create_index() {
             vector: _,
             or_replace: _,
             options: _,
+            storing: _,
         }) => {
             assert_eq_vec(&["my_index"], &name);
             assert_eq_vec(&["my_table"], &table_name);
@@ -3036,6 +3037,7 @@ fn parse_create_anonymous_index() {
             vector: _,
             or_replace: _,
             options: _,
+            storing: _,
         }) => {
             assert_eq!(None, name);
             assert_eq_vec(&["my_table"], &table_name);
@@ -3159,6 +3161,7 @@ fn parse_create_indices_with_operator_classes() {
                     vector: _,
                     or_replace: _,
                     options: _,
+                    storing: _,
                 }) => {
                     assert_eq_vec(&["the_index_name"], &name);
                     assert_eq_vec(&["users"], &table_name);
@@ -3191,6 +3194,7 @@ fn parse_create_indices_with_operator_classes() {
                     vector: _,
                     or_replace: _,
                     options: _,
+                    storing: _,
                 }) => {
                     assert_eq_vec(&["the_index_name"], &name);
                     assert_eq_vec(&["users"], &table_name);
@@ -3278,6 +3282,7 @@ fn parse_create_bloom() {
             vector: _,
             or_replace: _,
             options: _,
+            storing: _,
         }) => {
             assert_eq_vec(&["bloomidx"], &name);
             assert_eq_vec(&["tbloom"], &table_name);
@@ -3338,6 +3343,7 @@ fn parse_create_brin() {
             vector: _,
             or_replace: _,
             options: _,
+            storing: _,
         }) => {
             assert_eq_vec(&["brin_sensor_data_recorded_at"], &name);
             assert_eq_vec(&["sensor_data"], &table_name);
@@ -3409,6 +3415,7 @@ fn parse_create_index_concurrently() {
             vector: _,
             or_replace: _,
             options: _,
+            storing: _,
         }) => {
             assert_eq_vec(&["my_index"], &name);
             assert_eq_vec(&["my_table"], &table_name);
@@ -3449,6 +3456,7 @@ fn parse_create_index_with_predicate() {
             vector: _,
             or_replace: _,
             options: _,
+            storing: _,
         }) => {
             assert_eq_vec(&["my_index"], &name);
             assert_eq_vec(&["my_table"], &table_name);
@@ -3489,6 +3497,7 @@ fn parse_create_index_with_include() {
             vector: _,
             or_replace: _,
             options: _,
+            storing: _,
         }) => {
             assert_eq_vec(&["my_index"], &name);
             assert_eq_vec(&["my_table"], &table_name);
@@ -3529,6 +3538,7 @@ fn parse_create_index_with_nulls_distinct() {
             vector: _,
             or_replace: _,
             options: _,
+            storing: _,
         }) => {
             assert_eq_vec(&["my_index"], &name);
             assert_eq_vec(&["my_table"], &table_name);
@@ -3567,6 +3577,7 @@ fn parse_create_index_with_nulls_distinct() {
             vector: _,
             or_replace: _,
             options: _,
+            storing: _,
         }) => {
             assert_eq_vec(&["my_index"], &name);
             assert_eq_vec(&["my_table"], &table_name);