impl serde::Serialize for Column {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.name.is_empty() {
len += 1;
}
if !self.type_text.is_empty() {
len += 1;
}
if !self.type_json.is_empty() {
len += 1;
}
if self.position.is_some() {
len += 1;
}
if self.type_name != 0 {
len += 1;
}
if self.type_precision.is_some() {
len += 1;
}
if self.type_scale.is_some() {
len += 1;
}
if self.type_interval_type.is_some() {
len += 1;
}
if self.comment.is_some() {
len += 1;
}
if self.nullable.is_some() {
len += 1;
}
if self.partition_index.is_some() {
len += 1;
}
if self.column_id.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.tables.v1.Column", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if !self.type_text.is_empty() {
struct_ser.serialize_field("type_text", &self.type_text)?;
}
if !self.type_json.is_empty() {
struct_ser.serialize_field("type_json", &self.type_json)?;
}
if let Some(v) = self.position.as_ref() {
struct_ser.serialize_field("position", v)?;
}
if self.type_name != 0 {
let v = ColumnTypeName::try_from(self.type_name)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.type_name)))?;
struct_ser.serialize_field("type_name", &v)?;
}
if let Some(v) = self.type_precision.as_ref() {
struct_ser.serialize_field("type_precision", v)?;
}
if let Some(v) = self.type_scale.as_ref() {
struct_ser.serialize_field("type_scale", v)?;
}
if let Some(v) = self.type_interval_type.as_ref() {
struct_ser.serialize_field("type_interval_type", v)?;
}
if let Some(v) = self.comment.as_ref() {
struct_ser.serialize_field("comment", v)?;
}
if let Some(v) = self.nullable.as_ref() {
struct_ser.serialize_field("nullable", v)?;
}
if let Some(v) = self.partition_index.as_ref() {
struct_ser.serialize_field("partition_index", v)?;
}
if let Some(v) = self.column_id.as_ref() {
struct_ser.serialize_field("column_id", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Column {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"type_text",
"typeText",
"type_json",
"typeJson",
"position",
"type_name",
"typeName",
"type_precision",
"typePrecision",
"type_scale",
"typeScale",
"type_interval_type",
"typeIntervalType",
"comment",
"nullable",
"partition_index",
"partitionIndex",
"column_id",
"columnId",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
TypeText,
TypeJson,
Position,
TypeName,
TypePrecision,
TypeScale,
TypeIntervalType,
Comment,
Nullable,
PartitionIndex,
ColumnId,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"name" => Ok(GeneratedField::Name),
"typeText" | "type_text" => Ok(GeneratedField::TypeText),
"typeJson" | "type_json" => Ok(GeneratedField::TypeJson),
"position" => Ok(GeneratedField::Position),
"typeName" | "type_name" => Ok(GeneratedField::TypeName),
"typePrecision" | "type_precision" => Ok(GeneratedField::TypePrecision),
"typeScale" | "type_scale" => Ok(GeneratedField::TypeScale),
"typeIntervalType" | "type_interval_type" => Ok(GeneratedField::TypeIntervalType),
"comment" => Ok(GeneratedField::Comment),
"nullable" => Ok(GeneratedField::Nullable),
"partitionIndex" | "partition_index" => Ok(GeneratedField::PartitionIndex),
"columnId" | "column_id" => Ok(GeneratedField::ColumnId),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Column;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.tables.v1.Column")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Column, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut type_text__ = None;
let mut type_json__ = None;
let mut position__ = None;
let mut type_name__ = None;
let mut type_precision__ = None;
let mut type_scale__ = None;
let mut type_interval_type__ = None;
let mut comment__ = None;
let mut nullable__ = None;
let mut partition_index__ = None;
let mut column_id__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
GeneratedField::TypeText => {
if type_text__.is_some() {
return Err(serde::de::Error::duplicate_field("typeText"));
}
type_text__ = Some(map_.next_value()?);
}
GeneratedField::TypeJson => {
if type_json__.is_some() {
return Err(serde::de::Error::duplicate_field("typeJson"));
}
type_json__ = Some(map_.next_value()?);
}
GeneratedField::Position => {
if position__.is_some() {
return Err(serde::de::Error::duplicate_field("position"));
}
position__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::TypeName => {
if type_name__.is_some() {
return Err(serde::de::Error::duplicate_field("typeName"));
}
type_name__ = Some(map_.next_value::<ColumnTypeName>()? as i32);
}
GeneratedField::TypePrecision => {
if type_precision__.is_some() {
return Err(serde::de::Error::duplicate_field("typePrecision"));
}
type_precision__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::TypeScale => {
if type_scale__.is_some() {
return Err(serde::de::Error::duplicate_field("typeScale"));
}
type_scale__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::TypeIntervalType => {
if type_interval_type__.is_some() {
return Err(serde::de::Error::duplicate_field("typeIntervalType"));
}
type_interval_type__ = map_.next_value()?;
}
GeneratedField::Comment => {
if comment__.is_some() {
return Err(serde::de::Error::duplicate_field("comment"));
}
comment__ = map_.next_value()?;
}
GeneratedField::Nullable => {
if nullable__.is_some() {
return Err(serde::de::Error::duplicate_field("nullable"));
}
nullable__ = map_.next_value()?;
}
GeneratedField::PartitionIndex => {
if partition_index__.is_some() {
return Err(serde::de::Error::duplicate_field("partitionIndex"));
}
partition_index__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::ColumnId => {
if column_id__.is_some() {
return Err(serde::de::Error::duplicate_field("columnId"));
}
column_id__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(Column {
name: name__.unwrap_or_default(),
type_text: type_text__.unwrap_or_default(),
type_json: type_json__.unwrap_or_default(),
position: position__,
type_name: type_name__.unwrap_or_default(),
type_precision: type_precision__,
type_scale: type_scale__,
type_interval_type: type_interval_type__,
comment: comment__,
nullable: nullable__,
partition_index: partition_index__,
column_id: column_id__,
})
}
}
deserializer.deserialize_struct("unitycatalog.tables.v1.Column", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ColumnTypeName {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let variant = match self {
Self::Unspecified => "COLUMN_TYPE_NAME_UNSPECIFIED",
Self::Boolean => "BOOLEAN",
Self::Byte => "BYTE",
Self::Short => "SHORT",
Self::Int => "INT",
Self::Long => "LONG",
Self::Float => "FLOAT",
Self::Double => "DOUBLE",
Self::Date => "DATE",
Self::Timestamp => "TIMESTAMP",
Self::String => "STRING",
Self::Binary => "BINARY",
Self::Decimal => "DECIMAL",
Self::Interval => "INTERVAL",
Self::Array => "ARRAY",
Self::Struct => "STRUCT",
Self::Map => "MAP",
Self::Char => "CHAR",
Self::Null => "NULL",
Self::UserDefinedType => "USER_DEFINED_TYPE",
Self::TimestampNtz => "TIMESTAMP_NTZ",
Self::Variant => "VARIANT",
Self::TableType => "TABLE_TYPE",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for ColumnTypeName {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"COLUMN_TYPE_NAME_UNSPECIFIED",
"BOOLEAN",
"BYTE",
"SHORT",
"INT",
"LONG",
"FLOAT",
"DOUBLE",
"DATE",
"TIMESTAMP",
"STRING",
"BINARY",
"DECIMAL",
"INTERVAL",
"ARRAY",
"STRUCT",
"MAP",
"CHAR",
"NULL",
"USER_DEFINED_TYPE",
"TIMESTAMP_NTZ",
"VARIANT",
"TABLE_TYPE",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ColumnTypeName;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
})
}
fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
})
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
"COLUMN_TYPE_NAME_UNSPECIFIED" => Ok(ColumnTypeName::Unspecified),
"BOOLEAN" => Ok(ColumnTypeName::Boolean),
"BYTE" => Ok(ColumnTypeName::Byte),
"SHORT" => Ok(ColumnTypeName::Short),
"INT" => Ok(ColumnTypeName::Int),
"LONG" => Ok(ColumnTypeName::Long),
"FLOAT" => Ok(ColumnTypeName::Float),
"DOUBLE" => Ok(ColumnTypeName::Double),
"DATE" => Ok(ColumnTypeName::Date),
"TIMESTAMP" => Ok(ColumnTypeName::Timestamp),
"STRING" => Ok(ColumnTypeName::String),
"BINARY" => Ok(ColumnTypeName::Binary),
"DECIMAL" => Ok(ColumnTypeName::Decimal),
"INTERVAL" => Ok(ColumnTypeName::Interval),
"ARRAY" => Ok(ColumnTypeName::Array),
"STRUCT" => Ok(ColumnTypeName::Struct),
"MAP" => Ok(ColumnTypeName::Map),
"CHAR" => Ok(ColumnTypeName::Char),
"NULL" => Ok(ColumnTypeName::Null),
"USER_DEFINED_TYPE" => Ok(ColumnTypeName::UserDefinedType),
"TIMESTAMP_NTZ" => Ok(ColumnTypeName::TimestampNtz),
"VARIANT" => Ok(ColumnTypeName::Variant),
"TABLE_TYPE" => Ok(ColumnTypeName::TableType),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for CreateTableRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.name.is_empty() {
len += 1;
}
if !self.schema_name.is_empty() {
len += 1;
}
if !self.catalog_name.is_empty() {
len += 1;
}
if self.table_type != 0 {
len += 1;
}
if self.data_source_format != 0 {
len += 1;
}
if !self.columns.is_empty() {
len += 1;
}
if self.storage_location.is_some() {
len += 1;
}
if self.comment.is_some() {
len += 1;
}
if !self.properties.is_empty() {
len += 1;
}
if self.view_definition.is_some() {
len += 1;
}
if self.view_dependencies.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.tables.v1.CreateTableRequest", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if !self.schema_name.is_empty() {
struct_ser.serialize_field("schema_name", &self.schema_name)?;
}
if !self.catalog_name.is_empty() {
struct_ser.serialize_field("catalog_name", &self.catalog_name)?;
}
if self.table_type != 0 {
let v = TableType::try_from(self.table_type)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.table_type)))?;
struct_ser.serialize_field("table_type", &v)?;
}
if self.data_source_format != 0 {
let v = DataSourceFormat::try_from(self.data_source_format)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.data_source_format)))?;
struct_ser.serialize_field("data_source_format", &v)?;
}
if !self.columns.is_empty() {
struct_ser.serialize_field("columns", &self.columns)?;
}
if let Some(v) = self.storage_location.as_ref() {
struct_ser.serialize_field("storage_location", v)?;
}
if let Some(v) = self.comment.as_ref() {
struct_ser.serialize_field("comment", v)?;
}
if !self.properties.is_empty() {
struct_ser.serialize_field("properties", &self.properties)?;
}
if let Some(v) = self.view_definition.as_ref() {
struct_ser.serialize_field("view_definition", v)?;
}
if let Some(v) = self.view_dependencies.as_ref() {
struct_ser.serialize_field("view_dependencies", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for CreateTableRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"schema_name",
"schemaName",
"catalog_name",
"catalogName",
"table_type",
"tableType",
"data_source_format",
"dataSourceFormat",
"columns",
"storage_location",
"storageLocation",
"comment",
"properties",
"view_definition",
"viewDefinition",
"view_dependencies",
"viewDependencies",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
SchemaName,
CatalogName,
TableType,
DataSourceFormat,
Columns,
StorageLocation,
Comment,
Properties,
ViewDefinition,
ViewDependencies,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"name" => Ok(GeneratedField::Name),
"schemaName" | "schema_name" => Ok(GeneratedField::SchemaName),
"catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
"tableType" | "table_type" => Ok(GeneratedField::TableType),
"dataSourceFormat" | "data_source_format" => Ok(GeneratedField::DataSourceFormat),
"columns" => Ok(GeneratedField::Columns),
"storageLocation" | "storage_location" => Ok(GeneratedField::StorageLocation),
"comment" => Ok(GeneratedField::Comment),
"properties" => Ok(GeneratedField::Properties),
"viewDefinition" | "view_definition" => Ok(GeneratedField::ViewDefinition),
"viewDependencies" | "view_dependencies" => Ok(GeneratedField::ViewDependencies),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = CreateTableRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.tables.v1.CreateTableRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut schema_name__ = None;
let mut catalog_name__ = None;
let mut table_type__ = None;
let mut data_source_format__ = None;
let mut columns__ = None;
let mut storage_location__ = None;
let mut comment__ = None;
let mut properties__ = None;
let mut view_definition__ = None;
let mut view_dependencies__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
GeneratedField::SchemaName => {
if schema_name__.is_some() {
return Err(serde::de::Error::duplicate_field("schemaName"));
}
schema_name__ = Some(map_.next_value()?);
}
GeneratedField::CatalogName => {
if catalog_name__.is_some() {
return Err(serde::de::Error::duplicate_field("catalogName"));
}
catalog_name__ = Some(map_.next_value()?);
}
GeneratedField::TableType => {
if table_type__.is_some() {
return Err(serde::de::Error::duplicate_field("tableType"));
}
table_type__ = Some(map_.next_value::<TableType>()? as i32);
}
GeneratedField::DataSourceFormat => {
if data_source_format__.is_some() {
return Err(serde::de::Error::duplicate_field("dataSourceFormat"));
}
data_source_format__ = Some(map_.next_value::<DataSourceFormat>()? as i32);
}
GeneratedField::Columns => {
if columns__.is_some() {
return Err(serde::de::Error::duplicate_field("columns"));
}
columns__ = Some(map_.next_value()?);
}
GeneratedField::StorageLocation => {
if storage_location__.is_some() {
return Err(serde::de::Error::duplicate_field("storageLocation"));
}
storage_location__ = map_.next_value()?;
}
GeneratedField::Comment => {
if comment__.is_some() {
return Err(serde::de::Error::duplicate_field("comment"));
}
comment__ = map_.next_value()?;
}
GeneratedField::Properties => {
if properties__.is_some() {
return Err(serde::de::Error::duplicate_field("properties"));
}
properties__ = Some(
map_.next_value::<std::collections::HashMap<_, _>>()?
);
}
GeneratedField::ViewDefinition => {
if view_definition__.is_some() {
return Err(serde::de::Error::duplicate_field("viewDefinition"));
}
view_definition__ = map_.next_value()?;
}
GeneratedField::ViewDependencies => {
if view_dependencies__.is_some() {
return Err(serde::de::Error::duplicate_field("viewDependencies"));
}
view_dependencies__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(CreateTableRequest {
name: name__.unwrap_or_default(),
schema_name: schema_name__.unwrap_or_default(),
catalog_name: catalog_name__.unwrap_or_default(),
table_type: table_type__.unwrap_or_default(),
data_source_format: data_source_format__.unwrap_or_default(),
columns: columns__.unwrap_or_default(),
storage_location: storage_location__,
comment: comment__,
properties: properties__.unwrap_or_default(),
view_definition: view_definition__,
view_dependencies: view_dependencies__,
})
}
}
deserializer.deserialize_struct("unitycatalog.tables.v1.CreateTableRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for DataSourceFormat {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let variant = match self {
Self::Unspecified => "DATA_SOURCE_FORMAT_UNSPECIFIED",
Self::Delta => "DELTA",
Self::Iceberg => "ICEBERG",
Self::Hudi => "HUDI",
Self::Parquet => "PARQUET",
Self::Csv => "CSV",
Self::Json => "JSON",
Self::Orc => "ORC",
Self::Avro => "AVRO",
Self::Text => "TEXT",
Self::UnityCatalog => "UNITY_CATALOG",
Self::Deltasharing => "DELTASHARING",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for DataSourceFormat {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"DATA_SOURCE_FORMAT_UNSPECIFIED",
"DELTA",
"ICEBERG",
"HUDI",
"PARQUET",
"CSV",
"JSON",
"ORC",
"AVRO",
"TEXT",
"UNITY_CATALOG",
"DELTASHARING",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = DataSourceFormat;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
})
}
fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
})
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
"DATA_SOURCE_FORMAT_UNSPECIFIED" => Ok(DataSourceFormat::Unspecified),
"DELTA" => Ok(DataSourceFormat::Delta),
"ICEBERG" => Ok(DataSourceFormat::Iceberg),
"HUDI" => Ok(DataSourceFormat::Hudi),
"PARQUET" => Ok(DataSourceFormat::Parquet),
"CSV" => Ok(DataSourceFormat::Csv),
"JSON" => Ok(DataSourceFormat::Json),
"ORC" => Ok(DataSourceFormat::Orc),
"AVRO" => Ok(DataSourceFormat::Avro),
"TEXT" => Ok(DataSourceFormat::Text),
"UNITY_CATALOG" => Ok(DataSourceFormat::UnityCatalog),
"DELTASHARING" => Ok(DataSourceFormat::Deltasharing),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for DeleteTableRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.full_name.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.tables.v1.DeleteTableRequest", len)?;
if !self.full_name.is_empty() {
struct_ser.serialize_field("full_name", &self.full_name)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for DeleteTableRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"full_name",
"fullName",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
FullName,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"fullName" | "full_name" => Ok(GeneratedField::FullName),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = DeleteTableRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.tables.v1.DeleteTableRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteTableRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut full_name__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::FullName => {
if full_name__.is_some() {
return Err(serde::de::Error::duplicate_field("fullName"));
}
full_name__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(DeleteTableRequest {
full_name: full_name__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("unitycatalog.tables.v1.DeleteTableRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Dependency {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.dependency.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.tables.v1.Dependency", len)?;
if let Some(v) = self.dependency.as_ref() {
match v {
dependency::Dependency::Table(v) => {
struct_ser.serialize_field("table", v)?;
}
dependency::Dependency::Function(v) => {
struct_ser.serialize_field("function", v)?;
}
}
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Dependency {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"table",
"function",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Table,
Function,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"table" => Ok(GeneratedField::Table),
"function" => Ok(GeneratedField::Function),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Dependency;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.tables.v1.Dependency")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dependency, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut dependency__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Table => {
if dependency__.is_some() {
return Err(serde::de::Error::duplicate_field("table"));
}
dependency__ = map_.next_value::<::std::option::Option<_>>()?.map(dependency::Dependency::Table)
;
}
GeneratedField::Function => {
if dependency__.is_some() {
return Err(serde::de::Error::duplicate_field("function"));
}
dependency__ = map_.next_value::<::std::option::Option<_>>()?.map(dependency::Dependency::Function)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(Dependency {
dependency: dependency__,
})
}
}
deserializer.deserialize_struct("unitycatalog.tables.v1.Dependency", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for DependencyList {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.dependencies.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.tables.v1.DependencyList", len)?;
if !self.dependencies.is_empty() {
struct_ser.serialize_field("dependencies", &self.dependencies)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for DependencyList {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"dependencies",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Dependencies,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"dependencies" => Ok(GeneratedField::Dependencies),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = DependencyList;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.tables.v1.DependencyList")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<DependencyList, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut dependencies__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Dependencies => {
if dependencies__.is_some() {
return Err(serde::de::Error::duplicate_field("dependencies"));
}
dependencies__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(DependencyList {
dependencies: dependencies__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("unitycatalog.tables.v1.DependencyList", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for FunctionDependency {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.function_full_name.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.tables.v1.FunctionDependency", len)?;
if !self.function_full_name.is_empty() {
struct_ser.serialize_field("function_full_name", &self.function_full_name)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for FunctionDependency {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"function_full_name",
"functionFullName",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
FunctionFullName,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"functionFullName" | "function_full_name" => Ok(GeneratedField::FunctionFullName),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = FunctionDependency;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.tables.v1.FunctionDependency")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<FunctionDependency, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut function_full_name__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::FunctionFullName => {
if function_full_name__.is_some() {
return Err(serde::de::Error::duplicate_field("functionFullName"));
}
function_full_name__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(FunctionDependency {
function_full_name: function_full_name__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("unitycatalog.tables.v1.FunctionDependency", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetTableExistsRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.full_name.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.tables.v1.GetTableExistsRequest", len)?;
if !self.full_name.is_empty() {
struct_ser.serialize_field("full_name", &self.full_name)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetTableExistsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"full_name",
"fullName",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
FullName,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"fullName" | "full_name" => Ok(GeneratedField::FullName),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetTableExistsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.tables.v1.GetTableExistsRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableExistsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut full_name__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::FullName => {
if full_name__.is_some() {
return Err(serde::de::Error::duplicate_field("fullName"));
}
full_name__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(GetTableExistsRequest {
full_name: full_name__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("unitycatalog.tables.v1.GetTableExistsRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetTableExistsResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.table_exists {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.tables.v1.GetTableExistsResponse", len)?;
if self.table_exists {
struct_ser.serialize_field("table_exists", &self.table_exists)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetTableExistsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"table_exists",
"tableExists",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
TableExists,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"tableExists" | "table_exists" => Ok(GeneratedField::TableExists),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetTableExistsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.tables.v1.GetTableExistsResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableExistsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut table_exists__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::TableExists => {
if table_exists__.is_some() {
return Err(serde::de::Error::duplicate_field("tableExists"));
}
table_exists__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(GetTableExistsResponse {
table_exists: table_exists__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("unitycatalog.tables.v1.GetTableExistsResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetTableRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.full_name.is_empty() {
len += 1;
}
if self.include_delta_metadata.is_some() {
len += 1;
}
if self.include_browse.is_some() {
len += 1;
}
if self.include_manifest_capabilities.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.tables.v1.GetTableRequest", len)?;
if !self.full_name.is_empty() {
struct_ser.serialize_field("full_name", &self.full_name)?;
}
if let Some(v) = self.include_delta_metadata.as_ref() {
struct_ser.serialize_field("include_delta_metadata", v)?;
}
if let Some(v) = self.include_browse.as_ref() {
struct_ser.serialize_field("include_browse", v)?;
}
if let Some(v) = self.include_manifest_capabilities.as_ref() {
struct_ser.serialize_field("include_manifest_capabilities", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetTableRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"full_name",
"fullName",
"include_delta_metadata",
"includeDeltaMetadata",
"include_browse",
"includeBrowse",
"include_manifest_capabilities",
"includeManifestCapabilities",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
FullName,
IncludeDeltaMetadata,
IncludeBrowse,
IncludeManifestCapabilities,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"fullName" | "full_name" => Ok(GeneratedField::FullName),
"includeDeltaMetadata" | "include_delta_metadata" => Ok(GeneratedField::IncludeDeltaMetadata),
"includeBrowse" | "include_browse" => Ok(GeneratedField::IncludeBrowse),
"includeManifestCapabilities" | "include_manifest_capabilities" => Ok(GeneratedField::IncludeManifestCapabilities),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetTableRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.tables.v1.GetTableRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut full_name__ = None;
let mut include_delta_metadata__ = None;
let mut include_browse__ = None;
let mut include_manifest_capabilities__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::FullName => {
if full_name__.is_some() {
return Err(serde::de::Error::duplicate_field("fullName"));
}
full_name__ = Some(map_.next_value()?);
}
GeneratedField::IncludeDeltaMetadata => {
if include_delta_metadata__.is_some() {
return Err(serde::de::Error::duplicate_field("includeDeltaMetadata"));
}
include_delta_metadata__ = map_.next_value()?;
}
GeneratedField::IncludeBrowse => {
if include_browse__.is_some() {
return Err(serde::de::Error::duplicate_field("includeBrowse"));
}
include_browse__ = map_.next_value()?;
}
GeneratedField::IncludeManifestCapabilities => {
if include_manifest_capabilities__.is_some() {
return Err(serde::de::Error::duplicate_field("includeManifestCapabilities"));
}
include_manifest_capabilities__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(GetTableRequest {
full_name: full_name__.unwrap_or_default(),
include_delta_metadata: include_delta_metadata__,
include_browse: include_browse__,
include_manifest_capabilities: include_manifest_capabilities__,
})
}
}
deserializer.deserialize_struct("unitycatalog.tables.v1.GetTableRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListTableSummariesRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.catalog_name.is_empty() {
len += 1;
}
if self.schema_name_pattern.is_some() {
len += 1;
}
if self.table_name_pattern.is_some() {
len += 1;
}
if self.max_results.is_some() {
len += 1;
}
if self.page_token.is_some() {
len += 1;
}
if self.include_manifest_capabilities.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.tables.v1.ListTableSummariesRequest", len)?;
if !self.catalog_name.is_empty() {
struct_ser.serialize_field("catalog_name", &self.catalog_name)?;
}
if let Some(v) = self.schema_name_pattern.as_ref() {
struct_ser.serialize_field("schema_name_pattern", v)?;
}
if let Some(v) = self.table_name_pattern.as_ref() {
struct_ser.serialize_field("table_name_pattern", v)?;
}
if let Some(v) = self.max_results.as_ref() {
struct_ser.serialize_field("max_results", v)?;
}
if let Some(v) = self.page_token.as_ref() {
struct_ser.serialize_field("page_token", v)?;
}
if let Some(v) = self.include_manifest_capabilities.as_ref() {
struct_ser.serialize_field("include_manifest_capabilities", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListTableSummariesRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"catalog_name",
"catalogName",
"schema_name_pattern",
"schemaNamePattern",
"table_name_pattern",
"tableNamePattern",
"max_results",
"maxResults",
"page_token",
"pageToken",
"include_manifest_capabilities",
"includeManifestCapabilities",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
CatalogName,
SchemaNamePattern,
TableNamePattern,
MaxResults,
PageToken,
IncludeManifestCapabilities,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
"schemaNamePattern" | "schema_name_pattern" => Ok(GeneratedField::SchemaNamePattern),
"tableNamePattern" | "table_name_pattern" => Ok(GeneratedField::TableNamePattern),
"maxResults" | "max_results" => Ok(GeneratedField::MaxResults),
"pageToken" | "page_token" => Ok(GeneratedField::PageToken),
"includeManifestCapabilities" | "include_manifest_capabilities" => Ok(GeneratedField::IncludeManifestCapabilities),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListTableSummariesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.tables.v1.ListTableSummariesRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableSummariesRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut catalog_name__ = None;
let mut schema_name_pattern__ = None;
let mut table_name_pattern__ = None;
let mut max_results__ = None;
let mut page_token__ = None;
let mut include_manifest_capabilities__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::CatalogName => {
if catalog_name__.is_some() {
return Err(serde::de::Error::duplicate_field("catalogName"));
}
catalog_name__ = Some(map_.next_value()?);
}
GeneratedField::SchemaNamePattern => {
if schema_name_pattern__.is_some() {
return Err(serde::de::Error::duplicate_field("schemaNamePattern"));
}
schema_name_pattern__ = map_.next_value()?;
}
GeneratedField::TableNamePattern => {
if table_name_pattern__.is_some() {
return Err(serde::de::Error::duplicate_field("tableNamePattern"));
}
table_name_pattern__ = map_.next_value()?;
}
GeneratedField::MaxResults => {
if max_results__.is_some() {
return Err(serde::de::Error::duplicate_field("maxResults"));
}
max_results__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::PageToken => {
if page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("pageToken"));
}
page_token__ = map_.next_value()?;
}
GeneratedField::IncludeManifestCapabilities => {
if include_manifest_capabilities__.is_some() {
return Err(serde::de::Error::duplicate_field("includeManifestCapabilities"));
}
include_manifest_capabilities__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListTableSummariesRequest {
catalog_name: catalog_name__.unwrap_or_default(),
schema_name_pattern: schema_name_pattern__,
table_name_pattern: table_name_pattern__,
max_results: max_results__,
page_token: page_token__,
include_manifest_capabilities: include_manifest_capabilities__,
})
}
}
deserializer.deserialize_struct("unitycatalog.tables.v1.ListTableSummariesRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListTableSummariesResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.tables.is_empty() {
len += 1;
}
if self.next_page_token.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.tables.v1.ListTableSummariesResponse", len)?;
if !self.tables.is_empty() {
struct_ser.serialize_field("tables", &self.tables)?;
}
if let Some(v) = self.next_page_token.as_ref() {
struct_ser.serialize_field("next_page_token", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListTableSummariesResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"tables",
"next_page_token",
"nextPageToken",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Tables,
NextPageToken,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"tables" => Ok(GeneratedField::Tables),
"nextPageToken" | "next_page_token" => Ok(GeneratedField::NextPageToken),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListTableSummariesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.tables.v1.ListTableSummariesResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableSummariesResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut tables__ = None;
let mut next_page_token__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Tables => {
if tables__.is_some() {
return Err(serde::de::Error::duplicate_field("tables"));
}
tables__ = Some(map_.next_value()?);
}
GeneratedField::NextPageToken => {
if next_page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("nextPageToken"));
}
next_page_token__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListTableSummariesResponse {
tables: tables__.unwrap_or_default(),
next_page_token: next_page_token__,
})
}
}
deserializer.deserialize_struct("unitycatalog.tables.v1.ListTableSummariesResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListTablesRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.catalog_name.is_empty() {
len += 1;
}
if !self.schema_name.is_empty() {
len += 1;
}
if self.max_results.is_some() {
len += 1;
}
if self.page_token.is_some() {
len += 1;
}
if self.include_delta_metadata.is_some() {
len += 1;
}
if self.omit_columns.is_some() {
len += 1;
}
if self.omit_properties.is_some() {
len += 1;
}
if self.omit_username.is_some() {
len += 1;
}
if self.include_browse.is_some() {
len += 1;
}
if self.include_manifest_capabilities.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.tables.v1.ListTablesRequest", len)?;
if !self.catalog_name.is_empty() {
struct_ser.serialize_field("catalog_name", &self.catalog_name)?;
}
if !self.schema_name.is_empty() {
struct_ser.serialize_field("schema_name", &self.schema_name)?;
}
if let Some(v) = self.max_results.as_ref() {
struct_ser.serialize_field("max_results", v)?;
}
if let Some(v) = self.page_token.as_ref() {
struct_ser.serialize_field("page_token", v)?;
}
if let Some(v) = self.include_delta_metadata.as_ref() {
struct_ser.serialize_field("include_delta_metadata", v)?;
}
if let Some(v) = self.omit_columns.as_ref() {
struct_ser.serialize_field("omit_columns", v)?;
}
if let Some(v) = self.omit_properties.as_ref() {
struct_ser.serialize_field("omit_properties", v)?;
}
if let Some(v) = self.omit_username.as_ref() {
struct_ser.serialize_field("omit_username", v)?;
}
if let Some(v) = self.include_browse.as_ref() {
struct_ser.serialize_field("include_browse", v)?;
}
if let Some(v) = self.include_manifest_capabilities.as_ref() {
struct_ser.serialize_field("include_manifest_capabilities", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListTablesRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"catalog_name",
"catalogName",
"schema_name",
"schemaName",
"max_results",
"maxResults",
"page_token",
"pageToken",
"include_delta_metadata",
"includeDeltaMetadata",
"omit_columns",
"omitColumns",
"omit_properties",
"omitProperties",
"omit_username",
"omitUsername",
"include_browse",
"includeBrowse",
"include_manifest_capabilities",
"includeManifestCapabilities",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
CatalogName,
SchemaName,
MaxResults,
PageToken,
IncludeDeltaMetadata,
OmitColumns,
OmitProperties,
OmitUsername,
IncludeBrowse,
IncludeManifestCapabilities,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
"schemaName" | "schema_name" => Ok(GeneratedField::SchemaName),
"maxResults" | "max_results" => Ok(GeneratedField::MaxResults),
"pageToken" | "page_token" => Ok(GeneratedField::PageToken),
"includeDeltaMetadata" | "include_delta_metadata" => Ok(GeneratedField::IncludeDeltaMetadata),
"omitColumns" | "omit_columns" => Ok(GeneratedField::OmitColumns),
"omitProperties" | "omit_properties" => Ok(GeneratedField::OmitProperties),
"omitUsername" | "omit_username" => Ok(GeneratedField::OmitUsername),
"includeBrowse" | "include_browse" => Ok(GeneratedField::IncludeBrowse),
"includeManifestCapabilities" | "include_manifest_capabilities" => Ok(GeneratedField::IncludeManifestCapabilities),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListTablesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.tables.v1.ListTablesRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTablesRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut catalog_name__ = None;
let mut schema_name__ = None;
let mut max_results__ = None;
let mut page_token__ = None;
let mut include_delta_metadata__ = None;
let mut omit_columns__ = None;
let mut omit_properties__ = None;
let mut omit_username__ = None;
let mut include_browse__ = None;
let mut include_manifest_capabilities__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::CatalogName => {
if catalog_name__.is_some() {
return Err(serde::de::Error::duplicate_field("catalogName"));
}
catalog_name__ = Some(map_.next_value()?);
}
GeneratedField::SchemaName => {
if schema_name__.is_some() {
return Err(serde::de::Error::duplicate_field("schemaName"));
}
schema_name__ = Some(map_.next_value()?);
}
GeneratedField::MaxResults => {
if max_results__.is_some() {
return Err(serde::de::Error::duplicate_field("maxResults"));
}
max_results__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::PageToken => {
if page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("pageToken"));
}
page_token__ = map_.next_value()?;
}
GeneratedField::IncludeDeltaMetadata => {
if include_delta_metadata__.is_some() {
return Err(serde::de::Error::duplicate_field("includeDeltaMetadata"));
}
include_delta_metadata__ = map_.next_value()?;
}
GeneratedField::OmitColumns => {
if omit_columns__.is_some() {
return Err(serde::de::Error::duplicate_field("omitColumns"));
}
omit_columns__ = map_.next_value()?;
}
GeneratedField::OmitProperties => {
if omit_properties__.is_some() {
return Err(serde::de::Error::duplicate_field("omitProperties"));
}
omit_properties__ = map_.next_value()?;
}
GeneratedField::OmitUsername => {
if omit_username__.is_some() {
return Err(serde::de::Error::duplicate_field("omitUsername"));
}
omit_username__ = map_.next_value()?;
}
GeneratedField::IncludeBrowse => {
if include_browse__.is_some() {
return Err(serde::de::Error::duplicate_field("includeBrowse"));
}
include_browse__ = map_.next_value()?;
}
GeneratedField::IncludeManifestCapabilities => {
if include_manifest_capabilities__.is_some() {
return Err(serde::de::Error::duplicate_field("includeManifestCapabilities"));
}
include_manifest_capabilities__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListTablesRequest {
catalog_name: catalog_name__.unwrap_or_default(),
schema_name: schema_name__.unwrap_or_default(),
max_results: max_results__,
page_token: page_token__,
include_delta_metadata: include_delta_metadata__,
omit_columns: omit_columns__,
omit_properties: omit_properties__,
omit_username: omit_username__,
include_browse: include_browse__,
include_manifest_capabilities: include_manifest_capabilities__,
})
}
}
deserializer.deserialize_struct("unitycatalog.tables.v1.ListTablesRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListTablesResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.tables.is_empty() {
len += 1;
}
if self.next_page_token.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.tables.v1.ListTablesResponse", len)?;
if !self.tables.is_empty() {
struct_ser.serialize_field("tables", &self.tables)?;
}
if let Some(v) = self.next_page_token.as_ref() {
struct_ser.serialize_field("next_page_token", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListTablesResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"tables",
"next_page_token",
"nextPageToken",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Tables,
NextPageToken,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"tables" => Ok(GeneratedField::Tables),
"nextPageToken" | "next_page_token" => Ok(GeneratedField::NextPageToken),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListTablesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.tables.v1.ListTablesResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTablesResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut tables__ = None;
let mut next_page_token__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Tables => {
if tables__.is_some() {
return Err(serde::de::Error::duplicate_field("tables"));
}
tables__ = Some(map_.next_value()?);
}
GeneratedField::NextPageToken => {
if next_page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("nextPageToken"));
}
next_page_token__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListTablesResponse {
tables: tables__.unwrap_or_default(),
next_page_token: next_page_token__,
})
}
}
deserializer.deserialize_struct("unitycatalog.tables.v1.ListTablesResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Table {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.name.is_empty() {
len += 1;
}
if !self.catalog_name.is_empty() {
len += 1;
}
if !self.schema_name.is_empty() {
len += 1;
}
if self.table_type != 0 {
len += 1;
}
if self.data_source_format != 0 {
len += 1;
}
if !self.columns.is_empty() {
len += 1;
}
if self.storage_location.is_some() {
len += 1;
}
if self.view_definition.is_some() {
len += 1;
}
if self.view_dependencies.is_some() {
len += 1;
}
if self.owner.is_some() {
len += 1;
}
if self.comment.is_some() {
len += 1;
}
if !self.properties.is_empty() {
len += 1;
}
if self.storage_credential_name.is_some() {
len += 1;
}
if !self.full_name.is_empty() {
len += 1;
}
if self.created_at.is_some() {
len += 1;
}
if self.created_by.is_some() {
len += 1;
}
if self.updated_at.is_some() {
len += 1;
}
if self.updated_by.is_some() {
len += 1;
}
if self.deleted_at.is_some() {
len += 1;
}
if self.table_id.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.tables.v1.Table", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if !self.catalog_name.is_empty() {
struct_ser.serialize_field("catalog_name", &self.catalog_name)?;
}
if !self.schema_name.is_empty() {
struct_ser.serialize_field("schema_name", &self.schema_name)?;
}
if self.table_type != 0 {
let v = TableType::try_from(self.table_type)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.table_type)))?;
struct_ser.serialize_field("table_type", &v)?;
}
if self.data_source_format != 0 {
let v = DataSourceFormat::try_from(self.data_source_format)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.data_source_format)))?;
struct_ser.serialize_field("data_source_format", &v)?;
}
if !self.columns.is_empty() {
struct_ser.serialize_field("columns", &self.columns)?;
}
if let Some(v) = self.storage_location.as_ref() {
struct_ser.serialize_field("storage_location", v)?;
}
if let Some(v) = self.view_definition.as_ref() {
struct_ser.serialize_field("view_definition", v)?;
}
if let Some(v) = self.view_dependencies.as_ref() {
struct_ser.serialize_field("view_dependencies", v)?;
}
if let Some(v) = self.owner.as_ref() {
struct_ser.serialize_field("owner", v)?;
}
if let Some(v) = self.comment.as_ref() {
struct_ser.serialize_field("comment", v)?;
}
if !self.properties.is_empty() {
struct_ser.serialize_field("properties", &self.properties)?;
}
if let Some(v) = self.storage_credential_name.as_ref() {
struct_ser.serialize_field("storage_credential_name", v)?;
}
if !self.full_name.is_empty() {
struct_ser.serialize_field("full_name", &self.full_name)?;
}
if let Some(v) = self.created_at.as_ref() {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("created_at", ToString::to_string(&v).as_str())?;
}
if let Some(v) = self.created_by.as_ref() {
struct_ser.serialize_field("created_by", v)?;
}
if let Some(v) = self.updated_at.as_ref() {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("updated_at", ToString::to_string(&v).as_str())?;
}
if let Some(v) = self.updated_by.as_ref() {
struct_ser.serialize_field("updated_by", v)?;
}
if let Some(v) = self.deleted_at.as_ref() {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("deleted_at", ToString::to_string(&v).as_str())?;
}
if let Some(v) = self.table_id.as_ref() {
struct_ser.serialize_field("table_id", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Table {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"catalog_name",
"catalogName",
"schema_name",
"schemaName",
"table_type",
"tableType",
"data_source_format",
"dataSourceFormat",
"columns",
"storage_location",
"storageLocation",
"view_definition",
"viewDefinition",
"view_dependencies",
"viewDependencies",
"owner",
"comment",
"properties",
"storage_credential_name",
"storageCredentialName",
"full_name",
"fullName",
"created_at",
"createdAt",
"created_by",
"createdBy",
"updated_at",
"updatedAt",
"updated_by",
"updatedBy",
"deleted_at",
"deletedAt",
"table_id",
"tableId",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
CatalogName,
SchemaName,
TableType,
DataSourceFormat,
Columns,
StorageLocation,
ViewDefinition,
ViewDependencies,
Owner,
Comment,
Properties,
StorageCredentialName,
FullName,
CreatedAt,
CreatedBy,
UpdatedAt,
UpdatedBy,
DeletedAt,
TableId,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"name" => Ok(GeneratedField::Name),
"catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
"schemaName" | "schema_name" => Ok(GeneratedField::SchemaName),
"tableType" | "table_type" => Ok(GeneratedField::TableType),
"dataSourceFormat" | "data_source_format" => Ok(GeneratedField::DataSourceFormat),
"columns" => Ok(GeneratedField::Columns),
"storageLocation" | "storage_location" => Ok(GeneratedField::StorageLocation),
"viewDefinition" | "view_definition" => Ok(GeneratedField::ViewDefinition),
"viewDependencies" | "view_dependencies" => Ok(GeneratedField::ViewDependencies),
"owner" => Ok(GeneratedField::Owner),
"comment" => Ok(GeneratedField::Comment),
"properties" => Ok(GeneratedField::Properties),
"storageCredentialName" | "storage_credential_name" => Ok(GeneratedField::StorageCredentialName),
"fullName" | "full_name" => Ok(GeneratedField::FullName),
"createdAt" | "created_at" => Ok(GeneratedField::CreatedAt),
"createdBy" | "created_by" => Ok(GeneratedField::CreatedBy),
"updatedAt" | "updated_at" => Ok(GeneratedField::UpdatedAt),
"updatedBy" | "updated_by" => Ok(GeneratedField::UpdatedBy),
"deletedAt" | "deleted_at" => Ok(GeneratedField::DeletedAt),
"tableId" | "table_id" => Ok(GeneratedField::TableId),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Table;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.tables.v1.Table")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Table, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut catalog_name__ = None;
let mut schema_name__ = None;
let mut table_type__ = None;
let mut data_source_format__ = None;
let mut columns__ = None;
let mut storage_location__ = None;
let mut view_definition__ = None;
let mut view_dependencies__ = None;
let mut owner__ = None;
let mut comment__ = None;
let mut properties__ = None;
let mut storage_credential_name__ = None;
let mut full_name__ = None;
let mut created_at__ = None;
let mut created_by__ = None;
let mut updated_at__ = None;
let mut updated_by__ = None;
let mut deleted_at__ = None;
let mut table_id__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
GeneratedField::CatalogName => {
if catalog_name__.is_some() {
return Err(serde::de::Error::duplicate_field("catalogName"));
}
catalog_name__ = Some(map_.next_value()?);
}
GeneratedField::SchemaName => {
if schema_name__.is_some() {
return Err(serde::de::Error::duplicate_field("schemaName"));
}
schema_name__ = Some(map_.next_value()?);
}
GeneratedField::TableType => {
if table_type__.is_some() {
return Err(serde::de::Error::duplicate_field("tableType"));
}
table_type__ = Some(map_.next_value::<TableType>()? as i32);
}
GeneratedField::DataSourceFormat => {
if data_source_format__.is_some() {
return Err(serde::de::Error::duplicate_field("dataSourceFormat"));
}
data_source_format__ = Some(map_.next_value::<DataSourceFormat>()? as i32);
}
GeneratedField::Columns => {
if columns__.is_some() {
return Err(serde::de::Error::duplicate_field("columns"));
}
columns__ = Some(map_.next_value()?);
}
GeneratedField::StorageLocation => {
if storage_location__.is_some() {
return Err(serde::de::Error::duplicate_field("storageLocation"));
}
storage_location__ = map_.next_value()?;
}
GeneratedField::ViewDefinition => {
if view_definition__.is_some() {
return Err(serde::de::Error::duplicate_field("viewDefinition"));
}
view_definition__ = map_.next_value()?;
}
GeneratedField::ViewDependencies => {
if view_dependencies__.is_some() {
return Err(serde::de::Error::duplicate_field("viewDependencies"));
}
view_dependencies__ = map_.next_value()?;
}
GeneratedField::Owner => {
if owner__.is_some() {
return Err(serde::de::Error::duplicate_field("owner"));
}
owner__ = map_.next_value()?;
}
GeneratedField::Comment => {
if comment__.is_some() {
return Err(serde::de::Error::duplicate_field("comment"));
}
comment__ = map_.next_value()?;
}
GeneratedField::Properties => {
if properties__.is_some() {
return Err(serde::de::Error::duplicate_field("properties"));
}
properties__ = Some(
map_.next_value::<std::collections::HashMap<_, _>>()?
);
}
GeneratedField::StorageCredentialName => {
if storage_credential_name__.is_some() {
return Err(serde::de::Error::duplicate_field("storageCredentialName"));
}
storage_credential_name__ = map_.next_value()?;
}
GeneratedField::FullName => {
if full_name__.is_some() {
return Err(serde::de::Error::duplicate_field("fullName"));
}
full_name__ = Some(map_.next_value()?);
}
GeneratedField::CreatedAt => {
if created_at__.is_some() {
return Err(serde::de::Error::duplicate_field("createdAt"));
}
created_at__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::CreatedBy => {
if created_by__.is_some() {
return Err(serde::de::Error::duplicate_field("createdBy"));
}
created_by__ = map_.next_value()?;
}
GeneratedField::UpdatedAt => {
if updated_at__.is_some() {
return Err(serde::de::Error::duplicate_field("updatedAt"));
}
updated_at__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::UpdatedBy => {
if updated_by__.is_some() {
return Err(serde::de::Error::duplicate_field("updatedBy"));
}
updated_by__ = map_.next_value()?;
}
GeneratedField::DeletedAt => {
if deleted_at__.is_some() {
return Err(serde::de::Error::duplicate_field("deletedAt"));
}
deleted_at__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::TableId => {
if table_id__.is_some() {
return Err(serde::de::Error::duplicate_field("tableId"));
}
table_id__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(Table {
name: name__.unwrap_or_default(),
catalog_name: catalog_name__.unwrap_or_default(),
schema_name: schema_name__.unwrap_or_default(),
table_type: table_type__.unwrap_or_default(),
data_source_format: data_source_format__.unwrap_or_default(),
columns: columns__.unwrap_or_default(),
storage_location: storage_location__,
view_definition: view_definition__,
view_dependencies: view_dependencies__,
owner: owner__,
comment: comment__,
properties: properties__.unwrap_or_default(),
storage_credential_name: storage_credential_name__,
full_name: full_name__.unwrap_or_default(),
created_at: created_at__,
created_by: created_by__,
updated_at: updated_at__,
updated_by: updated_by__,
deleted_at: deleted_at__,
table_id: table_id__,
})
}
}
deserializer.deserialize_struct("unitycatalog.tables.v1.Table", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for TableDependency {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.table_full_name.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.tables.v1.TableDependency", len)?;
if !self.table_full_name.is_empty() {
struct_ser.serialize_field("table_full_name", &self.table_full_name)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for TableDependency {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"table_full_name",
"tableFullName",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
TableFullName,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"tableFullName" | "table_full_name" => Ok(GeneratedField::TableFullName),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = TableDependency;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.tables.v1.TableDependency")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableDependency, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut table_full_name__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::TableFullName => {
if table_full_name__.is_some() {
return Err(serde::de::Error::duplicate_field("tableFullName"));
}
table_full_name__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(TableDependency {
table_full_name: table_full_name__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("unitycatalog.tables.v1.TableDependency", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for TableSummary {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.full_name.is_empty() {
len += 1;
}
if self.table_type != 0 {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.tables.v1.TableSummary", len)?;
if !self.full_name.is_empty() {
struct_ser.serialize_field("full_name", &self.full_name)?;
}
if self.table_type != 0 {
let v = TableType::try_from(self.table_type)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.table_type)))?;
struct_ser.serialize_field("table_type", &v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for TableSummary {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"full_name",
"fullName",
"table_type",
"tableType",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
FullName,
TableType,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"fullName" | "full_name" => Ok(GeneratedField::FullName),
"tableType" | "table_type" => Ok(GeneratedField::TableType),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = TableSummary;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.tables.v1.TableSummary")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSummary, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut full_name__ = None;
let mut table_type__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::FullName => {
if full_name__.is_some() {
return Err(serde::de::Error::duplicate_field("fullName"));
}
full_name__ = Some(map_.next_value()?);
}
GeneratedField::TableType => {
if table_type__.is_some() {
return Err(serde::de::Error::duplicate_field("tableType"));
}
table_type__ = Some(map_.next_value::<TableType>()? as i32);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(TableSummary {
full_name: full_name__.unwrap_or_default(),
table_type: table_type__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("unitycatalog.tables.v1.TableSummary", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for TableType {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let variant = match self {
Self::Unspecified => "TABLE_TYPE_UNSPECIFIED",
Self::Managed => "MANAGED",
Self::External => "EXTERNAL",
Self::View => "VIEW",
Self::MaterializedView => "MATERIALIZED_VIEW",
Self::StreamingTable => "STREAMING_TABLE",
Self::MetricView => "METRIC_VIEW",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for TableType {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"TABLE_TYPE_UNSPECIFIED",
"MANAGED",
"EXTERNAL",
"VIEW",
"MATERIALIZED_VIEW",
"STREAMING_TABLE",
"METRIC_VIEW",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = TableType;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
})
}
fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
})
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
"TABLE_TYPE_UNSPECIFIED" => Ok(TableType::Unspecified),
"MANAGED" => Ok(TableType::Managed),
"EXTERNAL" => Ok(TableType::External),
"VIEW" => Ok(TableType::View),
"MATERIALIZED_VIEW" => Ok(TableType::MaterializedView),
"STREAMING_TABLE" => Ok(TableType::StreamingTable),
"METRIC_VIEW" => Ok(TableType::MetricView),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}