Add TABLESPACE coverage for MySQL and PostgreSQL

Author: LucaCappelletti94

tests/sqlparser_mysql.rs

@@ -4905,3 +4905,107 @@ 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_tablespace() {
+    let sql =
+        "CREATE TABLESPACE ts ADD DATAFILE 'ts.ibd' FILE_BLOCK_SIZE = 4096 ENCRYPTION = 'Y' ENGINE = InnoDB ENGINE_ATTRIBUTE = 'ndb_general'";
+    let stmt = mysql_and_generic().verified_stmt(sql);
+
+    let Statement::CreateTablespace(CreateTablespace { name, definition }) = stmt else {
+        panic!("Expected CREATE TABLESPACE");
+    };
+    assert_eq!(name.value, "ts");
+
+    let CreateTablespaceDefinition::MySql { undo, options } = definition else {
+        panic!("Expected MySQL CREATE TABLESPACE definition");
+    };
+    assert!(!undo);
+    assert_eq!(
+        options[0],
+        MySqlCreateTablespaceOption::AddDatafile("ts.ibd".to_string())
+    );
+    assert_eq!(options[1].to_string(), "FILE_BLOCK_SIZE = 4096");
+    assert_eq!(options[2].to_string(), "ENCRYPTION = 'Y'");
+    assert_eq!(options[3].to_string(), "ENGINE = InnoDB");
+    assert_eq!(options[4].to_string(), "ENGINE_ATTRIBUTE = 'ndb_general'");
+}
+
+#[test]
+fn parse_mysql_create_tablespace_without_add_datafile() {
+    mysql_and_generic().one_statement_parses_to(
+        "CREATE TABLESPACE ts ENGINE InnoDB",
+        "CREATE TABLESPACE ts ENGINE = InnoDB",
+    );
+}
+
+#[test]
+fn parse_mysql_create_undo_tablespace() {
+    mysql_and_generic().one_statement_parses_to(
+        "CREATE UNDO TABLESPACE undo_ts ADD DATAFILE 'undo_001.ibu' ENGINE InnoDB",
+        "CREATE UNDO TABLESPACE undo_ts ADD DATAFILE 'undo_001.ibu' ENGINE = InnoDB",
+    );
+}
+
+#[test]
+fn parse_mysql_alter_tablespace() {
+    let stmt = mysql_and_generic().verified_stmt(
+        "ALTER TABLESPACE ts ADD DATAFILE 'ts2.ibd' INITIAL_SIZE = 16 AUTOEXTEND_SIZE = 32 WAIT ENGINE = InnoDB ENGINE_ATTRIBUTE = 'ndb_general'",
+    );
+    let Statement::AlterTablespace(AlterTablespace {
+        name,
+        operation: AlterTablespaceOperation::MySql { undo, options },
+    }) = stmt
+    else {
+        panic!("Expected MySQL ALTER TABLESPACE ADD DATAFILE");
+    };
+
+    assert_eq!(name.value, "ts");
+    assert!(!undo);
+    assert_eq!(
+        options
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<String>>(),
+        vec![
+            "ADD DATAFILE 'ts2.ibd'",
+            "INITIAL_SIZE = 16",
+            "AUTOEXTEND_SIZE = 32",
+            "WAIT",
+            "ENGINE = InnoDB",
+            "ENGINE_ATTRIBUTE = 'ndb_general'",
+        ]
+    );
+
+    mysql_and_generic().one_statement_parses_to(
+        "ALTER UNDO TABLESPACE undo_ts SET ACTIVE",
+        "ALTER UNDO TABLESPACE undo_ts SET ACTIVE",
+    );
+}
+
+#[test]
+fn parse_mysql_drop_tablespace() {
+    let stmt = mysql_and_generic().one_statement_parses_to(
+        "DROP UNDO TABLESPACE undo_ts ENGINE InnoDB",
+        "DROP UNDO TABLESPACE undo_ts ENGINE = InnoDB",
+    );
+    let Statement::DropTablespace(DropTablespace {
+        if_exists,
+        undo,
+        name,
+        engine,
+    }) = stmt
+    else {
+        panic!("Expected DROP TABLESPACE");
+    };
+
+    assert!(!if_exists);
+    assert!(undo);
+    assert_eq!(name.value, "undo_ts");
+    assert_eq!(engine.as_ref().map(|i| i.value.as_str()), Some("InnoDB"));
+
+    mysql_and_generic().one_statement_parses_to(
+        "DROP TABLESPACE ts ENGINE InnoDB",
+        "DROP TABLESPACE ts ENGINE = InnoDB",
+    );
+}

tests/sqlparser_postgres.rs

@@ -24,7 +24,7 @@ mod test_utils;
 
 use helpers::attached_token::AttachedToken;
 use sqlparser::ast::*;
-use sqlparser::dialect::{GenericDialect, PostgreSqlDialect};
+use sqlparser::dialect::{GenericDialect, MySqlDialect, PostgreSqlDialect};
 use sqlparser::parser::ParserError;
 use sqlparser::tokenizer::Span;
 use test_utils::*;
@@ -9243,3 +9243,130 @@ fn parse_lock_table() {
         }
     }
 }
+
+#[test]
+fn parse_tablespace_and_reindex_regression_cases() {
+    for sql in [
+        "CREATE TABLESPACE regress_tblspace LOCATION 'relative'",
+        "CREATE TABLESPACE regress_tblspace LOCATION ''",
+        "CREATE TABLESPACE regress_tblspacewith LOCATION '' WITH (some_nonexistent_parameter = true)",
+        "CREATE TABLESPACE regress_tblspacewith LOCATION '' WITH (random_page_cost = 3.0)",
+        "DROP TABLESPACE regress_tblspacewith",
+        "ALTER TABLESPACE regress_tblspace SET (random_page_cost = 1.0, seq_page_cost = 1.1)",
+        "ALTER TABLESPACE regress_tblspace SET (some_nonexistent_parameter = true)",
+        "ALTER TABLESPACE regress_tblspace RESET (random_page_cost = 2.0)",
+        "ALTER TABLESPACE regress_tblspace RESET (random_page_cost, effective_io_concurrency)",
+        "REINDEX (TABLESPACE regress_tblspace) TABLE pg_am",
+        "REINDEX (TABLESPACE regress_tblspace) TABLE CONCURRENTLY pg_am",
+        "REINDEX (TABLESPACE regress_tblspace) TABLE pg_authid",
+        "REINDEX (TABLESPACE regress_tblspace) TABLE CONCURRENTLY pg_authid",
+        "REINDEX (TABLESPACE regress_tblspace) INDEX pg_toast.pg_toast_1262_index",
+        "REINDEX (TABLESPACE regress_tblspace) INDEX CONCURRENTLY pg_toast.pg_toast_1262_index",
+        "REINDEX (TABLESPACE regress_tblspace) TABLE pg_toast.pg_toast_1262",
+        "REINDEX (TABLESPACE regress_tblspace) TABLE CONCURRENTLY pg_toast.pg_toast_1262",
+        "REINDEX (TABLESPACE pg_global) TABLE pg_authid",
+        "REINDEX (TABLESPACE pg_global) TABLE CONCURRENTLY pg_authid",
+        "REINDEX (TABLESPACE pg_global) INDEX regress_tblspace_test_tbl_idx",
+        "REINDEX (TABLESPACE pg_global) INDEX CONCURRENTLY regress_tblspace_test_tbl_idx",
+        "REINDEX (TABLESPACE regress_tblspace) INDEX regress_tblspace_test_tbl_idx",
+        "REINDEX (TABLESPACE regress_tblspace) TABLE regress_tblspace_test_tbl",
+    ] {
+        pg_and_generic().verified_stmt(sql);
+    }
+}
+
+#[test]
+fn parse_alter_tablespace_reset_assignment_option() {
+    let stmt = pg_and_generic()
+        .verified_stmt("ALTER TABLESPACE regress_tblspace RESET (random_page_cost = 2.0)");
+    let Statement::AlterTablespace(AlterTablespace {
+        name,
+        operation: AlterTablespaceOperation::Reset { options },
+    }) = stmt
+    else {
+        panic!("Expected ALTER TABLESPACE RESET statement");
+    };
+
+    assert_eq!(name.value, "regress_tblspace");
+    assert_eq!(options.len(), 1);
+    let TablespaceResetOption::Assign { key, value } = &options[0] else {
+        panic!("Expected assignment form in RESET option list");
+    };
+    assert_eq!(key.value, "random_page_cost");
+    assert_eq!(value.to_string(), "2.0");
+}
+
+#[test]
+fn parse_reindex_with_tablespace_utility_option() {
+    let stmt = pg_and_generic()
+        .verified_stmt("REINDEX (TABLESPACE regress_tblspace) TABLE CONCURRENTLY pg_am");
+    let Statement::Reindex(ReindexStatement {
+        options,
+        object_type,
+        concurrently,
+        name,
+    }) = stmt
+    else {
+        panic!("Expected REINDEX statement");
+    };
+
+    assert_eq!(object_type, ReindexObjectType::Table);
+    assert!(concurrently);
+    assert_eq!(name.to_string(), "pg_am");
+
+    let options = options.expect("Expected utility options");
+    assert_eq!(options.len(), 1);
+    assert_eq!(options[0].name.value, "TABLESPACE");
+    assert_eq!(
+        options[0].arg.as_ref().map(ToString::to_string),
+        Some("regress_tblspace".to_string())
+    );
+}
+
+#[test]
+fn reject_postgres_tablespace_forms_in_mysql_dialect() {
+    let mysql = TestedDialects::new(vec![Box::new(MySqlDialect {})]);
+    assert!(mysql
+        .parse_sql_statements("CREATE TABLESPACE t LOCATION ''")
+        .is_err());
+    assert!(mysql
+        .parse_sql_statements("ALTER TABLESPACE t SET (random_page_cost = 1.0)")
+        .is_err());
+    assert!(mysql
+        .parse_sql_statements("DROP TABLESPACE IF EXISTS t")
+        .is_err());
+    assert!(mysql
+        .parse_sql_statements("REINDEX (TABLESPACE t) TABLE pg_am")
+        .is_err());
+}
+
+#[test]
+fn parse_drop_tablespace_in_postgres() {
+    let stmt = pg_and_generic().verified_stmt("DROP TABLESPACE IF EXISTS regress_tblspace");
+    let Statement::DropTablespace(DropTablespace {
+        if_exists,
+        undo,
+        name,
+        engine,
+    }) = stmt
+    else {
+        panic!("Expected DROP TABLESPACE statement");
+    };
+
+    assert!(if_exists);
+    assert!(!undo);
+    assert_eq!(name.value, "regress_tblspace");
+    assert!(engine.is_none());
+}
+
+#[test]
+fn reject_drop_tablespace_cascade_in_postgres() {
+    let err = pg()
+        .parse_sql_statements("DROP TABLESPACE regress_tblspace CASCADE")
+        .unwrap_err()
+        .to_string();
+    assert!(
+        err.contains("Expected: end of DROP TABLESPACE statement"),
+        "unexpected error: {err}"
+    );
+}