iffyio commented on code in PR #1454:
URL:
https://github.com/apache/datafusion-sqlparser-rs/pull/1454#discussion_r1798036375
##########
src/ast/ddl.rs:
##########
@@ -1096,17 +1096,172 @@ impl fmt::Display for ColumnOptionDef {
}
}
+/// Identity is a column option for defining an identity or autoincrement
column in a creating table statement.
+/// Syntax
+/// ```sql
+/// { IDENTITY | AUTOINCREMENT } [ (seed , increment) | START num INCREMENT
num ] [ ORDER | NOORDER ]
+/// ```
+/// [MS SQL Server]:
https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum Identity {
+ Autoincrement(IdentityProperty),
+ Identity(IdentityProperty),
Review Comment:
```suggestion
/// An identity property declared via the `AUTOINCREMENT` key word
/// Example:
/// ```sql
/// AUTOINCREMENT(100, 1) NOORDER
/// ```
/// [Snowflake]:
https://docs.snowflake.com/en/sql-reference/sql/create-table
Autoincrement(IdentityProperty),
/// An identity property declared via the `IDENTITY` key word
/// Example:
/// ```sql
/// IDENTITY START 100 INCREMENT 1 ORDER
/// ```
Identity(IdentityProperty),
```
For the comments, I would write something like this, think mostly clearer
that the enum kinds show which variant is supported, and which dialect supports
them where applicable
##########
src/ast/ddl.rs:
##########
@@ -1096,17 +1096,172 @@ impl fmt::Display for ColumnOptionDef {
}
}
+/// Identity is a column option for defining an identity or autoincrement
column in a creating table statement.
+/// Syntax
+/// ```sql
+/// { IDENTITY | AUTOINCREMENT } [ (seed , increment) | START num INCREMENT
num ] [ ORDER | NOORDER ]
+/// ```
+/// [MS SQL Server]:
https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum Identity {
+ Autoincrement(IdentityProperty),
+ Identity(IdentityProperty),
+}
+
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
pub struct IdentityProperty {
+ pub parameters: Option<IdentityFormat>,
+ pub order: Option<IdentityOrder>,
+}
+
+/// A format of parameters of identity column.
+///
+/// It is [Snowflake] specific.
+/// Syntax
+/// ```sql
+/// (seed , increment) | START num INCREMENT num
+/// ```
+/// [MS SQL Server] uses one way of representing these parameters.
+/// Syntax
+/// ```sql
+/// (seed , increment)
+/// ```
+/// [MS SQL Server]:
https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum IdentityFormat {
+ FunctionCall(IdentityParameters),
+ StartAndIncrement(IdentityParameters),
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct IdentityParameters {
pub seed: Expr,
pub increment: Expr,
}
-impl fmt::Display for IdentityProperty {
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum IdentityOrder {
+ Order,
+ NoOrder,
+}
+
+impl fmt::Display for Identity {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let (command, property) = match self {
+ Identity::Identity(property) => ("IDENTITY", property),
+ Identity::Autoincrement(property) => ("AUTOINCREMENT", property),
+ };
+ write!(f, "{command}")?;
+ if let Some(parameters) = &property.parameters {
+ write!(f, "{parameters}")?;
+ }
+ if let Some(order) = &property.order {
+ write!(f, "{order}")?;
+ }
+ Ok(())
+ }
+}
+
+impl fmt::Display for IdentityFormat {
Review Comment:
Similarly, we canmove the impl to right after the struct decl
##########
src/ast/ddl.rs:
##########
@@ -1096,17 +1096,172 @@ impl fmt::Display for ColumnOptionDef {
}
}
+/// Identity is a column option for defining an identity or autoincrement
column in a creating table statement.
+/// Syntax
+/// ```sql
+/// { IDENTITY | AUTOINCREMENT } [ (seed , increment) | START num INCREMENT
num ] [ ORDER | NOORDER ]
+/// ```
+/// [MS SQL Server]:
https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum Identity {
Review Comment:
```suggestion
pub enum IdentityPropertyKind {
```
Since this isn't an identity itself, rather its representing the types of
identity properties supported
##########
src/ast/ddl.rs:
##########
@@ -1096,17 +1096,172 @@ impl fmt::Display for ColumnOptionDef {
}
}
+/// Identity is a column option for defining an identity or autoincrement
column in a creating table statement.
Review Comment:
```suggestion
/// Identity is a column option for defining an identity or autoincrement
column in a `CREATE TABLE` statement.
```
##########
src/ast/ddl.rs:
##########
@@ -1096,17 +1096,172 @@ impl fmt::Display for ColumnOptionDef {
}
}
+/// Identity is a column option for defining an identity or autoincrement
column in a creating table statement.
+/// Syntax
+/// ```sql
+/// { IDENTITY | AUTOINCREMENT } [ (seed , increment) | START num INCREMENT
num ] [ ORDER | NOORDER ]
+/// ```
+/// [MS SQL Server]:
https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum Identity {
+ Autoincrement(IdentityProperty),
+ Identity(IdentityProperty),
+}
+
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
pub struct IdentityProperty {
+ pub parameters: Option<IdentityFormat>,
+ pub order: Option<IdentityOrder>,
+}
+
+/// A format of parameters of identity column.
+///
+/// It is [Snowflake] specific.
+/// Syntax
+/// ```sql
+/// (seed , increment) | START num INCREMENT num
+/// ```
+/// [MS SQL Server] uses one way of representing these parameters.
+/// Syntax
+/// ```sql
+/// (seed , increment)
+/// ```
+/// [MS SQL Server]:
https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum IdentityFormat {
+ FunctionCall(IdentityParameters),
+ StartAndIncrement(IdentityParameters),
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct IdentityParameters {
pub seed: Expr,
pub increment: Expr,
}
-impl fmt::Display for IdentityProperty {
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum IdentityOrder {
+ Order,
+ NoOrder,
+}
+
+impl fmt::Display for Identity {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let (command, property) = match self {
+ Identity::Identity(property) => ("IDENTITY", property),
+ Identity::Autoincrement(property) => ("AUTOINCREMENT", property),
+ };
+ write!(f, "{command}")?;
+ if let Some(parameters) = &property.parameters {
+ write!(f, "{parameters}")?;
+ }
+ if let Some(order) = &property.order {
+ write!(f, "{order}")?;
+ }
+ Ok(())
+ }
+}
+
+impl fmt::Display for IdentityFormat {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ IdentityFormat::FunctionCall(parameters) => {
+ write!(f, "({}, {})", parameters.seed, parameters.increment)
+ }
+ IdentityFormat::StartAndIncrement(parameters) => {
+ write!(
+ f,
+ " START {} INCREMENT {}",
+ parameters.seed, parameters.increment
+ )
+ }
+ }
+ }
+}
+
+impl fmt::Display for IdentityOrder {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ IdentityOrder::Order => write!(f, " ORDER"),
+ IdentityOrder::NoOrder => write!(f, " NOORDER"),
+ }
+ }
+}
+
+/// Column policy that identify a security policy of access to a column.
+/// Syntax
+/// ```sql
+/// [ WITH ] MASKING POLICY <policy_name> [ USING ( <col_name> , <cond_col1> ,
... ) ]
+/// [ WITH ] PROJECTION POLICY <policy_name>
+/// ```
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum ColumnPolicy {
+ MaskingPolicy(ColumnPolicyProperty),
+ ProjectionPolicy(ColumnPolicyProperty),
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct ColumnPolicyProperty {
+ pub with: bool,
+ pub policy_name: Ident,
+ pub using_columns: Option<Vec<Ident>>,
+}
+
+impl fmt::Display for ColumnPolicy {
Review Comment:
We can move the impl to follow the struct decl
##########
src/ast/ddl.rs:
##########
@@ -1096,17 +1096,172 @@ impl fmt::Display for ColumnOptionDef {
}
}
+/// Identity is a column option for defining an identity or autoincrement
column in a creating table statement.
+/// Syntax
+/// ```sql
+/// { IDENTITY | AUTOINCREMENT } [ (seed , increment) | START num INCREMENT
num ] [ ORDER | NOORDER ]
+/// ```
+/// [MS SQL Server]:
https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum Identity {
+ Autoincrement(IdentityProperty),
+ Identity(IdentityProperty),
+}
+
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
pub struct IdentityProperty {
+ pub parameters: Option<IdentityFormat>,
+ pub order: Option<IdentityOrder>,
+}
+
+/// A format of parameters of identity column.
+///
+/// It is [Snowflake] specific.
+/// Syntax
+/// ```sql
+/// (seed , increment) | START num INCREMENT num
+/// ```
+/// [MS SQL Server] uses one way of representing these parameters.
+/// Syntax
+/// ```sql
+/// (seed , increment)
+/// ```
+/// [MS SQL Server]:
https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum IdentityFormat {
+ FunctionCall(IdentityParameters),
+ StartAndIncrement(IdentityParameters),
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct IdentityParameters {
pub seed: Expr,
pub increment: Expr,
}
-impl fmt::Display for IdentityProperty {
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum IdentityOrder {
+ Order,
+ NoOrder,
+}
+
+impl fmt::Display for Identity {
Review Comment:
Can we move this impl to right after the struct declaration?
##########
src/ast/ddl.rs:
##########
@@ -1096,17 +1096,172 @@ impl fmt::Display for ColumnOptionDef {
}
}
+/// Identity is a column option for defining an identity or autoincrement
column in a creating table statement.
+/// Syntax
+/// ```sql
+/// { IDENTITY | AUTOINCREMENT } [ (seed , increment) | START num INCREMENT
num ] [ ORDER | NOORDER ]
+/// ```
+/// [MS SQL Server]:
https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum Identity {
+ Autoincrement(IdentityProperty),
+ Identity(IdentityProperty),
+}
+
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
pub struct IdentityProperty {
+ pub parameters: Option<IdentityFormat>,
+ pub order: Option<IdentityOrder>,
+}
+
+/// A format of parameters of identity column.
+///
+/// It is [Snowflake] specific.
+/// Syntax
+/// ```sql
+/// (seed , increment) | START num INCREMENT num
+/// ```
+/// [MS SQL Server] uses one way of representing these parameters.
+/// Syntax
+/// ```sql
+/// (seed , increment)
+/// ```
+/// [MS SQL Server]:
https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum IdentityFormat {
Review Comment:
```suggestion
pub enum IdentityPropertyFormatKind {
```
##########
src/ast/ddl.rs:
##########
@@ -1096,17 +1096,172 @@ impl fmt::Display for ColumnOptionDef {
}
}
+/// Identity is a column option for defining an identity or autoincrement
column in a creating table statement.
+/// Syntax
+/// ```sql
+/// { IDENTITY | AUTOINCREMENT } [ (seed , increment) | START num INCREMENT
num ] [ ORDER | NOORDER ]
+/// ```
+/// [MS SQL Server]:
https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum Identity {
+ Autoincrement(IdentityProperty),
+ Identity(IdentityProperty),
+}
+
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
pub struct IdentityProperty {
+ pub parameters: Option<IdentityFormat>,
+ pub order: Option<IdentityOrder>,
+}
+
+/// A format of parameters of identity column.
+///
+/// It is [Snowflake] specific.
+/// Syntax
+/// ```sql
+/// (seed , increment) | START num INCREMENT num
+/// ```
+/// [MS SQL Server] uses one way of representing these parameters.
+/// Syntax
+/// ```sql
+/// (seed , increment)
+/// ```
+/// [MS SQL Server]:
https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum IdentityFormat {
+ FunctionCall(IdentityParameters),
+ StartAndIncrement(IdentityParameters),
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct IdentityParameters {
pub seed: Expr,
pub increment: Expr,
}
-impl fmt::Display for IdentityProperty {
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum IdentityOrder {
+ Order,
+ NoOrder,
+}
+
+impl fmt::Display for Identity {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let (command, property) = match self {
+ Identity::Identity(property) => ("IDENTITY", property),
+ Identity::Autoincrement(property) => ("AUTOINCREMENT", property),
+ };
+ write!(f, "{command}")?;
+ if let Some(parameters) = &property.parameters {
+ write!(f, "{parameters}")?;
+ }
+ if let Some(order) = &property.order {
+ write!(f, "{order}")?;
+ }
+ Ok(())
+ }
+}
+
+impl fmt::Display for IdentityFormat {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ IdentityFormat::FunctionCall(parameters) => {
+ write!(f, "({}, {})", parameters.seed, parameters.increment)
+ }
+ IdentityFormat::StartAndIncrement(parameters) => {
+ write!(
+ f,
+ " START {} INCREMENT {}",
+ parameters.seed, parameters.increment
+ )
+ }
+ }
+ }
+}
+
+impl fmt::Display for IdentityOrder {
Review Comment:
```suggestion
impl fmt::Display for IdentityPropertyOrder {
```
##########
src/ast/ddl.rs:
##########
@@ -1096,17 +1096,172 @@ impl fmt::Display for ColumnOptionDef {
}
}
+/// Identity is a column option for defining an identity or autoincrement
column in a creating table statement.
+/// Syntax
+/// ```sql
+/// { IDENTITY | AUTOINCREMENT } [ (seed , increment) | START num INCREMENT
num ] [ ORDER | NOORDER ]
+/// ```
+/// [MS SQL Server]:
https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum Identity {
+ Autoincrement(IdentityProperty),
+ Identity(IdentityProperty),
+}
+
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
pub struct IdentityProperty {
+ pub parameters: Option<IdentityFormat>,
+ pub order: Option<IdentityOrder>,
+}
+
+/// A format of parameters of identity column.
+///
+/// It is [Snowflake] specific.
+/// Syntax
+/// ```sql
+/// (seed , increment) | START num INCREMENT num
+/// ```
+/// [MS SQL Server] uses one way of representing these parameters.
+/// Syntax
+/// ```sql
+/// (seed , increment)
+/// ```
+/// [MS SQL Server]:
https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum IdentityFormat {
+ FunctionCall(IdentityParameters),
+ StartAndIncrement(IdentityParameters),
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct IdentityParameters {
pub seed: Expr,
pub increment: Expr,
}
-impl fmt::Display for IdentityProperty {
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum IdentityOrder {
+ Order,
+ NoOrder,
+}
+
+impl fmt::Display for Identity {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let (command, property) = match self {
+ Identity::Identity(property) => ("IDENTITY", property),
+ Identity::Autoincrement(property) => ("AUTOINCREMENT", property),
+ };
+ write!(f, "{command}")?;
+ if let Some(parameters) = &property.parameters {
+ write!(f, "{parameters}")?;
+ }
+ if let Some(order) = &property.order {
+ write!(f, "{order}")?;
+ }
+ Ok(())
+ }
+}
+
+impl fmt::Display for IdentityFormat {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ IdentityFormat::FunctionCall(parameters) => {
+ write!(f, "({}, {})", parameters.seed, parameters.increment)
+ }
+ IdentityFormat::StartAndIncrement(parameters) => {
+ write!(
+ f,
+ " START {} INCREMENT {}",
+ parameters.seed, parameters.increment
+ )
+ }
+ }
+ }
+}
+
+impl fmt::Display for IdentityOrder {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ IdentityOrder::Order => write!(f, " ORDER"),
+ IdentityOrder::NoOrder => write!(f, " NOORDER"),
+ }
+ }
+}
+
+/// Column policy that identify a security policy of access to a column.
+/// Syntax
+/// ```sql
+/// [ WITH ] MASKING POLICY <policy_name> [ USING ( <col_name> , <cond_col1> ,
... ) ]
+/// [ WITH ] PROJECTION POLICY <policy_name>
+/// ```
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum ColumnPolicy {
+ MaskingPolicy(ColumnPolicyProperty),
+ ProjectionPolicy(ColumnPolicyProperty),
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct ColumnPolicyProperty {
+ pub with: bool,
+ pub policy_name: Ident,
+ pub using_columns: Option<Vec<Ident>>,
+}
+
+impl fmt::Display for ColumnPolicy {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let (command, property) = match self {
+ ColumnPolicy::MaskingPolicy(property) => ("MASKING POLICY",
property),
+ ColumnPolicy::ProjectionPolicy(property) => ("PROJECTION POLICY",
property),
+ };
+ if property.with {
+ write!(f, "WITH ")?;
+ }
+ write!(f, "{command} {}", property.policy_name)?;
+ if let Some(using_columns) = &property.using_columns {
+ write!(f, " USING ({})", display_comma_separated(using_columns))?;
+ }
+ Ok(())
+ }
+}
+
+/// Tags option of column
+/// Syntax
+/// ```sql
+/// [ WITH ] TAG ( <tag_name> = '<tag_value>' [ , <tag_name> = '<tag_value>' ,
... ] )
+/// ```
+/// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct TagsColumnOption {
+ pub with: bool,
Review Comment:
Can we add a comment mentioning what the `with` parameter is for? since its
a custom and public parameter
##########
src/parser/mod.rs:
##########
@@ -6251,10 +6265,30 @@ impl<'a> Parser<'a> {
Keyword::REPLACE,
])?,
)))
+ } else if self.parse_keywords(&[Keyword::TAG])
Review Comment:
To avoid prematurely consuming the with and then later potentially rewinding
to prev token, we can probably do something like
```rust
else if (self.parse_keyword([TAG) || self.parse_keywords([WITH, TAG])) &&
dialect_of()
```
Also can we switch the dialect_of for a dialect method similar to the
others? Related question: is the tags support here so that we can also cover
generic dialect? (if so and we didn't have support for the generic dialect
previously, then I'm thinking we can just keep it limited to snowflake and move
the code over to the dialect)
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
