Merge pull request #15 from Embucket/issues/1418_external_volume

CREATE EXTERNAL VOLUME sql

Author: osipovartem

.github/workflows/rust.yml

@@ -38,6 +38,8 @@ jobs:
       - uses: actions/checkout@v4
       - name: Setup Rust Toolchain
         uses: ./.github/actions/setup-builder
+        with:
+          rust-version: "1.86.0"
       - run: cargo clippy --all-targets --all-features -- -D warnings
 
   benchmark-lint:
@@ -46,6 +48,8 @@ jobs:
       - uses: actions/checkout@v4
       - name: Setup Rust Toolchain
         uses: ./.github/actions/setup-builder
+        with:
+          rust-version: "1.86.0"
       - run: cd sqlparser_bench && cargo clippy --all-targets --all-features -- -D warnings
 
   compile:

src/ast/mod.rs

@@ -3990,6 +3990,18 @@ pub enum Statement {
         option: Option<ReferentialAction>,
     },
     /// ```sql
+    /// CREATE EXTERNAL VOLUME
+    /// ```
+    /// See <https://docs.snowflake.com/en/sql-reference/sql/create-external-volume>
+    CreateExternalVolume {
+        or_replace: bool,
+        if_not_exists: bool,
+        name: ObjectName,
+        storage_locations: Vec<CloudProviderParams>,
+        allow_writes: Option<bool>,
+        comment: Option<String>,
+    },
+    /// ```sql
     /// CREATE PROCEDURE
     /// ```
     CreateProcedure {
@@ -5002,6 +5014,39 @@ impl fmt::Display for Statement {
                 }
                 Ok(())
             }
+            Statement::CreateExternalVolume {
+                or_replace,
+                if_not_exists,
+                name,
+                storage_locations,
+                allow_writes,
+                comment,
+            } => {
+                write!(
+                    f,
+                    "CREATE {or_replace}EXTERNAL VOLUME {if_not_exists}{name}",
+                    or_replace = if *or_replace { "OR REPLACE " } else { "" },
+                    if_not_exists = if *if_not_exists { " IF NOT EXISTS" } else { "" },
+                )?;
+                if !storage_locations.is_empty() {
+                    write!(
+                        f,
+                        " STORAGE_LOCATIONS = ({})",
+                        storage_locations
+                            .iter()
+                            .map(|loc| format!("({})", loc))
+                            .collect::<Vec<_>>()
+                            .join(", ")
+                    )?;
+                }
+                if let Some(true) = allow_writes {
+                    write!(f, " ALLOW_WRITES = TRUE")?;
+                }
+                if let Some(c) = comment {
+                    write!(f, " COMMENT = '{c}'")?;
+                }
+                Ok(())
+            }
             Statement::CreateProcedure {
                 name,
                 or_alter,
@@ -10223,6 +10268,74 @@ impl fmt::Display for MemberOf {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CloudProviderParams {
+    pub name: String,
+    pub provider: String,
+    pub base_url: Option<String>,
+    pub aws_role_arn: Option<String>,
+    pub aws_access_point_arn: Option<String>,
+    pub aws_external_id: Option<String>,
+    pub azure_tenant_id: Option<String>,
+    pub storage_endpoint: Option<String>,
+    pub use_private_link_endpoint: Option<bool>,
+    pub encryption: KeyValueOptions,
+    pub credentials: KeyValueOptions,
+}
+
+impl fmt::Display for CloudProviderParams {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "NAME = '{}' STORAGE_PROVIDER = '{}'",
+            self.name, self.provider
+        )?;
+
+        if let Some(base_url) = &self.base_url {
+            write!(f, " STORAGE_BASE_URL = '{base_url}'")?;
+        }
+
+        if let Some(arn) = &self.aws_role_arn {
+            write!(f, " STORAGE_AWS_ROLE_ARN = '{arn}'")?;
+        }
+
+        if let Some(ap_arn) = &self.aws_access_point_arn {
+            write!(f, " STORAGE_AWS_ACCESS_POINT_ARN = '{ap_arn}'")?;
+        }
+
+        if let Some(ext_id) = &self.aws_external_id {
+            write!(f, " STORAGE_AWS_EXTERNAL_ID = '{ext_id}'")?;
+        }
+
+        if let Some(tenant_id) = &self.azure_tenant_id {
+            write!(f, " AZURE_TENANT_ID = '{tenant_id}'")?;
+        }
+
+        if let Some(endpoint) = &self.storage_endpoint {
+            write!(f, " STORAGE_ENDPOINT = '{endpoint}'")?;
+        }
+
+        if let Some(use_pl) = self.use_private_link_endpoint {
+            write!(
+                f,
+                " USE_PRIVATELINK_ENDPOINT = {}",
+                if use_pl { "TRUE" } else { "FALSE" }
+            )?;
+        }
+
+        if !self.encryption.options.is_empty() {
+            write!(f, " ENCRYPTION=({})", self.encryption)?;
+        }
+
+        if !self.credentials.options.is_empty() {
+            write!(f, " CREDENTIALS=({})", self.credentials)?;
+        }
+        Ok(())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::tokenizer::Location;

src/ast/spans.rs

@@ -267,6 +267,7 @@ impl Spanned for Values {
 /// - [Statement::CreateFunction]
 /// - [Statement::CreateTrigger]
 /// - [Statement::DropTrigger]
+/// - [Statement::CreateExternalVolume]
 /// - [Statement::CreateProcedure]
 /// - [Statement::CreateMacro]
 /// - [Statement::CreateStage]
@@ -488,6 +489,7 @@ impl Spanned for Statement {
             Statement::CreateDomain { .. } => Span::empty(),
             Statement::CreateTrigger { .. } => Span::empty(),
             Statement::DropTrigger { .. } => Span::empty(),
+            Statement::CreateExternalVolume { .. } => Span::empty(),
             Statement::CreateProcedure { .. } => Span::empty(),
             Statement::CreateMacro { .. } => Span::empty(),
             Statement::CreateStage { .. } => Span::empty(),

src/dialect/snowflake.rs

@@ -15,22 +15,21 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use super::keywords::RESERVED_FOR_IDENTIFIER;
 #[cfg(not(feature = "std"))]
 use crate::alloc::string::ToString;
-use crate::ast::helpers::key_value_options::{
-    KeyValueOption, KeyValueOptionType, KeyValueOptions,
-};
+use crate::ast::helpers::key_value_options::{KeyValueOption, KeyValueOptionType, KeyValueOptions};
 use crate::ast::helpers::stmt_create_database::CreateDatabaseBuilder;
 use crate::ast::helpers::stmt_create_table::CreateTableBuilder;
 use crate::ast::helpers::stmt_data_loading::{
     FileStagingCommand, StageLoadSelectItem, StageLoadSelectItemKind, StageParamsObject,
 };
 use crate::ast::{
-    CatalogSyncNamespaceMode, ColumnOption, ColumnPolicy, ColumnPolicyProperty, ContactEntry,
-    CopyIntoSnowflakeKind, DollarQuotedString, Ident, IdentityParameters, IdentityProperty,
-    IdentityPropertyFormatKind, IdentityPropertyKind, IdentityPropertyOrder, ObjectName,
-    ObjectNamePart, RowAccessPolicy, ShowObjects, SqlOption, Statement, StorageSerializationPolicy,
-    TagsColumnOption, WrappedCollection,
+    CatalogSyncNamespaceMode, CloudProviderParams, ColumnOption, ColumnPolicy,
+    ColumnPolicyProperty, ContactEntry, CopyIntoSnowflakeKind, DollarQuotedString, Ident,
+    IdentityParameters, IdentityProperty, IdentityPropertyFormatKind, IdentityPropertyKind,
+    IdentityPropertyOrder, ObjectName, ObjectNamePart, RowAccessPolicy, ShowObjects, SqlOption,
+    Statement, StorageSerializationPolicy, TagsColumnOption, WrappedCollection,
 };
 use crate::dialect::{Dialect, Precedence};
 use crate::keywords::Keyword;
@@ -45,8 +44,6 @@ use alloc::vec::Vec;
 #[cfg(not(feature = "std"))]
 use alloc::{format, vec};
 
-use super::keywords::RESERVED_FOR_IDENTIFIER;
-
 const RESERVED_KEYWORDS_FOR_SELECT_ITEM_OPERATOR: [Keyword; 1] = [Keyword::CONNECT_BY_ROOT];
 /// A [`Dialect`] for [Snowflake](https://www.snowflake.com/)
 #[derive(Debug, Default)]
@@ -187,6 +184,8 @@ impl Dialect for SnowflakeDialect {
                 ));
             } else if parser.parse_keyword(Keyword::DATABASE) {
                 return Some(parse_create_database(or_replace, transient, parser));
+            } else if parser.parse_keywords(&[Keyword::EXTERNAL, Keyword::VOLUME]) {
+                return Some(parse_create_external_volume(or_replace, parser));
             } else {
                 // need to go back with the cursor
                 let mut back = 1;
@@ -323,7 +322,7 @@ impl Dialect for SnowflakeDialect {
             Keyword::LIMIT | Keyword::OFFSET if peek_for_limit_options(parser) => false,
 
             // `FETCH` can be considered an alias as long as it's not followed by `FIRST`` or `NEXT`
-            // which would give it a different meanings, for example: 
+            // which would give it a different meanings, for example:
             // `SELECT 1 FETCH FIRST 10 ROWS` - not an alias
             // `SELECT 1 FETCH 10` - not an alias
             Keyword::FETCH if parser.peek_one_of_keywords(&[Keyword::FIRST, Keyword::NEXT]).is_some()
@@ -840,6 +839,146 @@ pub fn parse_create_database(
     Ok(builder.build())
 }
 
+fn parse_create_external_volume(
+    or_replace: bool,
+    parser: &mut Parser,
+) -> Result<Statement, ParserError> {
+    let if_not_exists = parser.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
+    let name = parser.parse_object_name(false)?;
+    let mut comment = None;
+    let mut allow_writes = None;
+    let mut storage_locations = Vec::new();
+
+    // STORAGE_LOCATIONS (...)
+    if parser.parse_keywords(&[Keyword::STORAGE_LOCATIONS]) {
+        parser.expect_token(&Token::Eq)?;
+        storage_locations = parse_storage_locations(parser)?;
+    };
+
+    // ALLOW_WRITES [ = true | false ]
+    if parser.parse_keyword(Keyword::ALLOW_WRITES) {
+        parser.expect_token(&Token::Eq)?;
+        allow_writes = Some(parser.parse_boolean_string()?);
+    }
+
+    // COMMENT = '...'
+    if parser.parse_keyword(Keyword::COMMENT) {
+        parser.expect_token(&Token::Eq)?;
+        comment = Some(parser.parse_literal_string()?);
+    }
+
+    if storage_locations.is_empty() {
+        return Err(ParserError::ParserError(
+            "STORAGE_LOCATIONS is required for CREATE EXTERNAL VOLUME".to_string(),
+        ));
+    }
+
+    Ok(Statement::CreateExternalVolume {
+        or_replace,
+        if_not_exists,
+        name,
+        allow_writes,
+        comment,
+        storage_locations,
+    })
+}
+
+fn parse_storage_locations(parser: &mut Parser) -> Result<Vec<CloudProviderParams>, ParserError> {
+    let mut locations = Vec::new();
+    parser.expect_token(&Token::LParen)?;
+
+    loop {
+        parser.expect_token(&Token::LParen)?;
+
+        // START OF ONE CloudProviderParams BLOCK
+        let mut name = None;
+        let mut provider = None;
+        let mut base_url = None;
+        let mut aws_role_arn = None;
+        let mut aws_access_point_arn = None;
+        let mut aws_external_id = None;
+        let mut azure_tenant_id = None;
+        let mut storage_endpoint = None;
+        let mut use_private_link_endpoint = None;
+        let mut encryption: KeyValueOptions = KeyValueOptions { options: vec![] };
+        let mut credentials: KeyValueOptions = KeyValueOptions { options: vec![] };
+
+        loop {
+            if parser.parse_keyword(Keyword::NAME) {
+                parser.expect_token(&Token::Eq)?;
+                name = Some(parser.parse_literal_string()?);
+            } else if parser.parse_keyword(Keyword::STORAGE_PROVIDER) {
+                parser.expect_token(&Token::Eq)?;
+                provider = Some(parser.parse_literal_string()?);
+            } else if parser.parse_keyword(Keyword::STORAGE_BASE_URL) {
+                parser.expect_token(&Token::Eq)?;
+                base_url = Some(parser.parse_literal_string()?);
+            } else if parser.parse_keyword(Keyword::STORAGE_AWS_ROLE_ARN) {
+                parser.expect_token(&Token::Eq)?;
+                aws_role_arn = Some(parser.parse_literal_string()?);
+            } else if parser.parse_keyword(Keyword::STORAGE_AWS_ACCESS_POINT_ARN) {
+                parser.expect_token(&Token::Eq)?;
+                aws_access_point_arn = Some(parser.parse_literal_string()?);
+            } else if parser.parse_keyword(Keyword::STORAGE_AWS_EXTERNAL_ID) {
+                parser.expect_token(&Token::Eq)?;
+                aws_external_id = Some(parser.parse_literal_string()?);
+            } else if parser.parse_keyword(Keyword::AZURE_TENANT_ID) {
+                parser.expect_token(&Token::Eq)?;
+                azure_tenant_id = Some(parser.parse_literal_string()?);
+            } else if parser.parse_keyword(Keyword::STORAGE_ENDPOINT) {
+                parser.expect_token(&Token::Eq)?;
+                storage_endpoint = Some(parser.parse_literal_string()?);
+            } else if parser.parse_keyword(Keyword::USE_PRIVATELINK_ENDPOINT) {
+                parser.expect_token(&Token::Eq)?;
+                use_private_link_endpoint = Some(parser.parse_boolean_string()?);
+            } else if parser.parse_keyword(Keyword::ENCRYPTION) {
+                parser.expect_token(&Token::Eq)?;
+                encryption = KeyValueOptions {
+                    options: parse_parentheses_options(parser)?,
+                };
+            } else if parser.parse_keyword(Keyword::CREDENTIALS) {
+                parser.expect_token(&Token::Eq)?;
+                credentials = KeyValueOptions {
+                    options: parse_parentheses_options(parser)?,
+                };
+            } else if parser.consume_token(&Token::RParen) {
+                break;
+            } else {
+                return parser.expected("a valid key or closing paren", parser.peek_token());
+            }
+        }
+
+        let Some(name) = name else {
+            return parser.expected("NAME = '...'", parser.peek_token());
+        };
+
+        let Some(provider) = provider else {
+            return parser.expected("STORAGE_PROVIDER = '...'", parser.peek_token());
+        };
+
+        locations.push(CloudProviderParams {
+            name,
+            provider,
+            base_url,
+            aws_role_arn,
+            aws_access_point_arn,
+            aws_external_id,
+            azure_tenant_id,
+            storage_endpoint,
+            use_private_link_endpoint,
+            encryption,
+            credentials,
+        });
+        // EXIT if next token is RParen
+        if parser.consume_token(&Token::RParen) {
+            break;
+        }
+        // Otherwise expect a comma before next object
+        parser.expect_token(&Token::Comma)?;
+    }
+    Ok(locations)
+}
+
 pub fn parse_storage_serialization_policy(
     parser: &mut Parser,
 ) -> Result<StorageSerializationPolicy, ParserError> {