#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandGetSqlInfo {
#[prost(uint32, repeated, tag = "1")]
pub info: ::prost::alloc::vec::Vec<u32>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandGetXdbcTypeInfo {
#[prost(int32, optional, tag = "1")]
pub data_type: ::core::option::Option<i32>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandGetCatalogs {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandGetDbSchemas {
#[prost(string, optional, tag = "1")]
pub catalog: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "2")]
pub db_schema_filter_pattern: ::core::option::Option<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandGetTables {
#[prost(string, optional, tag = "1")]
pub catalog: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "2")]
pub db_schema_filter_pattern: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "3")]
pub table_name_filter_pattern: ::core::option::Option<
::prost::alloc::string::String,
>,
#[prost(string, repeated, tag = "4")]
pub table_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(bool, tag = "5")]
pub include_schema: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandGetTableTypes {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandGetPrimaryKeys {
#[prost(string, optional, tag = "1")]
pub catalog: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "2")]
pub db_schema: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, tag = "3")]
pub table: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandGetExportedKeys {
#[prost(string, optional, tag = "1")]
pub catalog: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "2")]
pub db_schema: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, tag = "3")]
pub table: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandGetImportedKeys {
#[prost(string, optional, tag = "1")]
pub catalog: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "2")]
pub db_schema: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, tag = "3")]
pub table: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandGetCrossReference {
#[prost(string, optional, tag = "1")]
pub pk_catalog: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "2")]
pub pk_db_schema: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, tag = "3")]
pub pk_table: ::prost::alloc::string::String,
#[prost(string, optional, tag = "4")]
pub fk_catalog: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "5")]
pub fk_db_schema: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, tag = "6")]
pub fk_table: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActionCreatePreparedStatementRequest {
#[prost(string, tag = "1")]
pub query: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActionCreatePreparedStatementResult {
#[prost(bytes = "bytes", tag = "1")]
pub prepared_statement_handle: ::prost::bytes::Bytes,
#[prost(bytes = "bytes", tag = "2")]
pub dataset_schema: ::prost::bytes::Bytes,
#[prost(bytes = "bytes", tag = "3")]
pub parameter_schema: ::prost::bytes::Bytes,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActionClosePreparedStatementRequest {
#[prost(bytes = "bytes", tag = "1")]
pub prepared_statement_handle: ::prost::bytes::Bytes,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandStatementQuery {
#[prost(string, tag = "1")]
pub query: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TicketStatementQuery {
#[prost(bytes = "bytes", tag = "1")]
pub statement_handle: ::prost::bytes::Bytes,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandPreparedStatementQuery {
#[prost(bytes = "bytes", tag = "1")]
pub prepared_statement_handle: ::prost::bytes::Bytes,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandStatementUpdate {
#[prost(string, tag = "1")]
pub query: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandPreparedStatementUpdate {
#[prost(bytes = "bytes", tag = "1")]
pub prepared_statement_handle: ::prost::bytes::Bytes,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DoPutUpdateResult {
#[prost(int64, tag = "1")]
pub record_count: i64,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlInfo {
FlightSqlServerName = 0,
FlightSqlServerVersion = 1,
FlightSqlServerArrowVersion = 2,
FlightSqlServerReadOnly = 3,
SqlDdlCatalog = 500,
SqlDdlSchema = 501,
SqlDdlTable = 502,
SqlIdentifierCase = 503,
SqlIdentifierQuoteChar = 504,
SqlQuotedIdentifierCase = 505,
SqlAllTablesAreSelectable = 506,
SqlNullOrdering = 507,
SqlKeywords = 508,
SqlNumericFunctions = 509,
SqlStringFunctions = 510,
SqlSystemFunctions = 511,
SqlDatetimeFunctions = 512,
SqlSearchStringEscape = 513,
SqlExtraNameCharacters = 514,
SqlSupportsColumnAliasing = 515,
SqlNullPlusNullIsNull = 516,
SqlSupportsConvert = 517,
SqlSupportsTableCorrelationNames = 518,
SqlSupportsDifferentTableCorrelationNames = 519,
SqlSupportsExpressionsInOrderBy = 520,
SqlSupportsOrderByUnrelated = 521,
SqlSupportedGroupBy = 522,
SqlSupportsLikeEscapeClause = 523,
SqlSupportsNonNullableColumns = 524,
SqlSupportedGrammar = 525,
SqlAnsi92SupportedLevel = 526,
SqlSupportsIntegrityEnhancementFacility = 527,
SqlOuterJoinsSupportLevel = 528,
SqlSchemaTerm = 529,
SqlProcedureTerm = 530,
SqlCatalogTerm = 531,
SqlCatalogAtStart = 532,
SqlSchemasSupportedActions = 533,
SqlCatalogsSupportedActions = 534,
SqlSupportedPositionedCommands = 535,
SqlSelectForUpdateSupported = 536,
SqlStoredProceduresSupported = 537,
SqlSupportedSubqueries = 538,
SqlCorrelatedSubqueriesSupported = 539,
SqlSupportedUnions = 540,
SqlMaxBinaryLiteralLength = 541,
SqlMaxCharLiteralLength = 542,
SqlMaxColumnNameLength = 543,
SqlMaxColumnsInGroupBy = 544,
SqlMaxColumnsInIndex = 545,
SqlMaxColumnsInOrderBy = 546,
SqlMaxColumnsInSelect = 547,
SqlMaxColumnsInTable = 548,
SqlMaxConnections = 549,
SqlMaxCursorNameLength = 550,
SqlMaxIndexLength = 551,
SqlDbSchemaNameLength = 552,
SqlMaxProcedureNameLength = 553,
SqlMaxCatalogNameLength = 554,
SqlMaxRowSize = 555,
SqlMaxRowSizeIncludesBlobs = 556,
SqlMaxStatementLength = 557,
SqlMaxStatements = 558,
SqlMaxTableNameLength = 559,
SqlMaxTablesInSelect = 560,
SqlMaxUsernameLength = 561,
SqlDefaultTransactionIsolation = 562,
SqlTransactionsSupported = 563,
SqlSupportedTransactionsIsolationLevels = 564,
SqlDataDefinitionCausesTransactionCommit = 565,
SqlDataDefinitionsInTransactionsIgnored = 566,
SqlSupportedResultSetTypes = 567,
SqlSupportedConcurrenciesForResultSetUnspecified = 568,
SqlSupportedConcurrenciesForResultSetForwardOnly = 569,
SqlSupportedConcurrenciesForResultSetScrollSensitive = 570,
SqlSupportedConcurrenciesForResultSetScrollInsensitive = 571,
SqlBatchUpdatesSupported = 572,
SqlSavepointsSupported = 573,
SqlNamedParametersSupported = 574,
SqlLocatorsUpdateCopy = 575,
SqlStoredFunctionsUsingCallSyntaxSupported = 576,
}
impl SqlInfo {
pub fn as_str_name(&self) -> &'static str {
match self {
SqlInfo::FlightSqlServerName => "FLIGHT_SQL_SERVER_NAME",
SqlInfo::FlightSqlServerVersion => "FLIGHT_SQL_SERVER_VERSION",
SqlInfo::FlightSqlServerArrowVersion => "FLIGHT_SQL_SERVER_ARROW_VERSION",
SqlInfo::FlightSqlServerReadOnly => "FLIGHT_SQL_SERVER_READ_ONLY",
SqlInfo::SqlDdlCatalog => "SQL_DDL_CATALOG",
SqlInfo::SqlDdlSchema => "SQL_DDL_SCHEMA",
SqlInfo::SqlDdlTable => "SQL_DDL_TABLE",
SqlInfo::SqlIdentifierCase => "SQL_IDENTIFIER_CASE",
SqlInfo::SqlIdentifierQuoteChar => "SQL_IDENTIFIER_QUOTE_CHAR",
SqlInfo::SqlQuotedIdentifierCase => "SQL_QUOTED_IDENTIFIER_CASE",
SqlInfo::SqlAllTablesAreSelectable => "SQL_ALL_TABLES_ARE_SELECTABLE",
SqlInfo::SqlNullOrdering => "SQL_NULL_ORDERING",
SqlInfo::SqlKeywords => "SQL_KEYWORDS",
SqlInfo::SqlNumericFunctions => "SQL_NUMERIC_FUNCTIONS",
SqlInfo::SqlStringFunctions => "SQL_STRING_FUNCTIONS",
SqlInfo::SqlSystemFunctions => "SQL_SYSTEM_FUNCTIONS",
SqlInfo::SqlDatetimeFunctions => "SQL_DATETIME_FUNCTIONS",
SqlInfo::SqlSearchStringEscape => "SQL_SEARCH_STRING_ESCAPE",
SqlInfo::SqlExtraNameCharacters => "SQL_EXTRA_NAME_CHARACTERS",
SqlInfo::SqlSupportsColumnAliasing => "SQL_SUPPORTS_COLUMN_ALIASING",
SqlInfo::SqlNullPlusNullIsNull => "SQL_NULL_PLUS_NULL_IS_NULL",
SqlInfo::SqlSupportsConvert => "SQL_SUPPORTS_CONVERT",
SqlInfo::SqlSupportsTableCorrelationNames => {
"SQL_SUPPORTS_TABLE_CORRELATION_NAMES"
}
SqlInfo::SqlSupportsDifferentTableCorrelationNames => {
"SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES"
}
SqlInfo::SqlSupportsExpressionsInOrderBy => {
"SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY"
}
SqlInfo::SqlSupportsOrderByUnrelated => "SQL_SUPPORTS_ORDER_BY_UNRELATED",
SqlInfo::SqlSupportedGroupBy => "SQL_SUPPORTED_GROUP_BY",
SqlInfo::SqlSupportsLikeEscapeClause => "SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE",
SqlInfo::SqlSupportsNonNullableColumns => "SQL_SUPPORTS_NON_NULLABLE_COLUMNS",
SqlInfo::SqlSupportedGrammar => "SQL_SUPPORTED_GRAMMAR",
SqlInfo::SqlAnsi92SupportedLevel => "SQL_ANSI92_SUPPORTED_LEVEL",
SqlInfo::SqlSupportsIntegrityEnhancementFacility => {
"SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY"
}
SqlInfo::SqlOuterJoinsSupportLevel => "SQL_OUTER_JOINS_SUPPORT_LEVEL",
SqlInfo::SqlSchemaTerm => "SQL_SCHEMA_TERM",
SqlInfo::SqlProcedureTerm => "SQL_PROCEDURE_TERM",
SqlInfo::SqlCatalogTerm => "SQL_CATALOG_TERM",
SqlInfo::SqlCatalogAtStart => "SQL_CATALOG_AT_START",
SqlInfo::SqlSchemasSupportedActions => "SQL_SCHEMAS_SUPPORTED_ACTIONS",
SqlInfo::SqlCatalogsSupportedActions => "SQL_CATALOGS_SUPPORTED_ACTIONS",
SqlInfo::SqlSupportedPositionedCommands => {
"SQL_SUPPORTED_POSITIONED_COMMANDS"
}
SqlInfo::SqlSelectForUpdateSupported => "SQL_SELECT_FOR_UPDATE_SUPPORTED",
SqlInfo::SqlStoredProceduresSupported => "SQL_STORED_PROCEDURES_SUPPORTED",
SqlInfo::SqlSupportedSubqueries => "SQL_SUPPORTED_SUBQUERIES",
SqlInfo::SqlCorrelatedSubqueriesSupported => {
"SQL_CORRELATED_SUBQUERIES_SUPPORTED"
}
SqlInfo::SqlSupportedUnions => "SQL_SUPPORTED_UNIONS",
SqlInfo::SqlMaxBinaryLiteralLength => "SQL_MAX_BINARY_LITERAL_LENGTH",
SqlInfo::SqlMaxCharLiteralLength => "SQL_MAX_CHAR_LITERAL_LENGTH",
SqlInfo::SqlMaxColumnNameLength => "SQL_MAX_COLUMN_NAME_LENGTH",
SqlInfo::SqlMaxColumnsInGroupBy => "SQL_MAX_COLUMNS_IN_GROUP_BY",
SqlInfo::SqlMaxColumnsInIndex => "SQL_MAX_COLUMNS_IN_INDEX",
SqlInfo::SqlMaxColumnsInOrderBy => "SQL_MAX_COLUMNS_IN_ORDER_BY",
SqlInfo::SqlMaxColumnsInSelect => "SQL_MAX_COLUMNS_IN_SELECT",
SqlInfo::SqlMaxColumnsInTable => "SQL_MAX_COLUMNS_IN_TABLE",
SqlInfo::SqlMaxConnections => "SQL_MAX_CONNECTIONS",
SqlInfo::SqlMaxCursorNameLength => "SQL_MAX_CURSOR_NAME_LENGTH",
SqlInfo::SqlMaxIndexLength => "SQL_MAX_INDEX_LENGTH",
SqlInfo::SqlDbSchemaNameLength => "SQL_DB_SCHEMA_NAME_LENGTH",
SqlInfo::SqlMaxProcedureNameLength => "SQL_MAX_PROCEDURE_NAME_LENGTH",
SqlInfo::SqlMaxCatalogNameLength => "SQL_MAX_CATALOG_NAME_LENGTH",
SqlInfo::SqlMaxRowSize => "SQL_MAX_ROW_SIZE",
SqlInfo::SqlMaxRowSizeIncludesBlobs => "SQL_MAX_ROW_SIZE_INCLUDES_BLOBS",
SqlInfo::SqlMaxStatementLength => "SQL_MAX_STATEMENT_LENGTH",
SqlInfo::SqlMaxStatements => "SQL_MAX_STATEMENTS",
SqlInfo::SqlMaxTableNameLength => "SQL_MAX_TABLE_NAME_LENGTH",
SqlInfo::SqlMaxTablesInSelect => "SQL_MAX_TABLES_IN_SELECT",
SqlInfo::SqlMaxUsernameLength => "SQL_MAX_USERNAME_LENGTH",
SqlInfo::SqlDefaultTransactionIsolation => {
"SQL_DEFAULT_TRANSACTION_ISOLATION"
}
SqlInfo::SqlTransactionsSupported => "SQL_TRANSACTIONS_SUPPORTED",
SqlInfo::SqlSupportedTransactionsIsolationLevels => {
"SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS"
}
SqlInfo::SqlDataDefinitionCausesTransactionCommit => {
"SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT"
}
SqlInfo::SqlDataDefinitionsInTransactionsIgnored => {
"SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED"
}
SqlInfo::SqlSupportedResultSetTypes => "SQL_SUPPORTED_RESULT_SET_TYPES",
SqlInfo::SqlSupportedConcurrenciesForResultSetUnspecified => {
"SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED"
}
SqlInfo::SqlSupportedConcurrenciesForResultSetForwardOnly => {
"SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY"
}
SqlInfo::SqlSupportedConcurrenciesForResultSetScrollSensitive => {
"SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE"
}
SqlInfo::SqlSupportedConcurrenciesForResultSetScrollInsensitive => {
"SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE"
}
SqlInfo::SqlBatchUpdatesSupported => "SQL_BATCH_UPDATES_SUPPORTED",
SqlInfo::SqlSavepointsSupported => "SQL_SAVEPOINTS_SUPPORTED",
SqlInfo::SqlNamedParametersSupported => "SQL_NAMED_PARAMETERS_SUPPORTED",
SqlInfo::SqlLocatorsUpdateCopy => "SQL_LOCATORS_UPDATE_COPY",
SqlInfo::SqlStoredFunctionsUsingCallSyntaxSupported => {
"SQL_STORED_FUNCTIONS_USING_CALL_SYNTAX_SUPPORTED"
}
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"FLIGHT_SQL_SERVER_NAME" => Some(Self::FlightSqlServerName),
"FLIGHT_SQL_SERVER_VERSION" => Some(Self::FlightSqlServerVersion),
"FLIGHT_SQL_SERVER_ARROW_VERSION" => Some(Self::FlightSqlServerArrowVersion),
"FLIGHT_SQL_SERVER_READ_ONLY" => Some(Self::FlightSqlServerReadOnly),
"SQL_DDL_CATALOG" => Some(Self::SqlDdlCatalog),
"SQL_DDL_SCHEMA" => Some(Self::SqlDdlSchema),
"SQL_DDL_TABLE" => Some(Self::SqlDdlTable),
"SQL_IDENTIFIER_CASE" => Some(Self::SqlIdentifierCase),
"SQL_IDENTIFIER_QUOTE_CHAR" => Some(Self::SqlIdentifierQuoteChar),
"SQL_QUOTED_IDENTIFIER_CASE" => Some(Self::SqlQuotedIdentifierCase),
"SQL_ALL_TABLES_ARE_SELECTABLE" => Some(Self::SqlAllTablesAreSelectable),
"SQL_NULL_ORDERING" => Some(Self::SqlNullOrdering),
"SQL_KEYWORDS" => Some(Self::SqlKeywords),
"SQL_NUMERIC_FUNCTIONS" => Some(Self::SqlNumericFunctions),
"SQL_STRING_FUNCTIONS" => Some(Self::SqlStringFunctions),
"SQL_SYSTEM_FUNCTIONS" => Some(Self::SqlSystemFunctions),
"SQL_DATETIME_FUNCTIONS" => Some(Self::SqlDatetimeFunctions),
"SQL_SEARCH_STRING_ESCAPE" => Some(Self::SqlSearchStringEscape),
"SQL_EXTRA_NAME_CHARACTERS" => Some(Self::SqlExtraNameCharacters),
"SQL_SUPPORTS_COLUMN_ALIASING" => Some(Self::SqlSupportsColumnAliasing),
"SQL_NULL_PLUS_NULL_IS_NULL" => Some(Self::SqlNullPlusNullIsNull),
"SQL_SUPPORTS_CONVERT" => Some(Self::SqlSupportsConvert),
"SQL_SUPPORTS_TABLE_CORRELATION_NAMES" => {
Some(Self::SqlSupportsTableCorrelationNames)
}
"SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES" => {
Some(Self::SqlSupportsDifferentTableCorrelationNames)
}
"SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY" => {
Some(Self::SqlSupportsExpressionsInOrderBy)
}
"SQL_SUPPORTS_ORDER_BY_UNRELATED" => Some(Self::SqlSupportsOrderByUnrelated),
"SQL_SUPPORTED_GROUP_BY" => Some(Self::SqlSupportedGroupBy),
"SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE" => Some(Self::SqlSupportsLikeEscapeClause),
"SQL_SUPPORTS_NON_NULLABLE_COLUMNS" => {
Some(Self::SqlSupportsNonNullableColumns)
}
"SQL_SUPPORTED_GRAMMAR" => Some(Self::SqlSupportedGrammar),
"SQL_ANSI92_SUPPORTED_LEVEL" => Some(Self::SqlAnsi92SupportedLevel),
"SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY" => {
Some(Self::SqlSupportsIntegrityEnhancementFacility)
}
"SQL_OUTER_JOINS_SUPPORT_LEVEL" => Some(Self::SqlOuterJoinsSupportLevel),
"SQL_SCHEMA_TERM" => Some(Self::SqlSchemaTerm),
"SQL_PROCEDURE_TERM" => Some(Self::SqlProcedureTerm),
"SQL_CATALOG_TERM" => Some(Self::SqlCatalogTerm),
"SQL_CATALOG_AT_START" => Some(Self::SqlCatalogAtStart),
"SQL_SCHEMAS_SUPPORTED_ACTIONS" => Some(Self::SqlSchemasSupportedActions),
"SQL_CATALOGS_SUPPORTED_ACTIONS" => Some(Self::SqlCatalogsSupportedActions),
"SQL_SUPPORTED_POSITIONED_COMMANDS" => {
Some(Self::SqlSupportedPositionedCommands)
}
"SQL_SELECT_FOR_UPDATE_SUPPORTED" => Some(Self::SqlSelectForUpdateSupported),
"SQL_STORED_PROCEDURES_SUPPORTED" => Some(Self::SqlStoredProceduresSupported),
"SQL_SUPPORTED_SUBQUERIES" => Some(Self::SqlSupportedSubqueries),
"SQL_CORRELATED_SUBQUERIES_SUPPORTED" => {
Some(Self::SqlCorrelatedSubqueriesSupported)
}
"SQL_SUPPORTED_UNIONS" => Some(Self::SqlSupportedUnions),
"SQL_MAX_BINARY_LITERAL_LENGTH" => Some(Self::SqlMaxBinaryLiteralLength),
"SQL_MAX_CHAR_LITERAL_LENGTH" => Some(Self::SqlMaxCharLiteralLength),
"SQL_MAX_COLUMN_NAME_LENGTH" => Some(Self::SqlMaxColumnNameLength),
"SQL_MAX_COLUMNS_IN_GROUP_BY" => Some(Self::SqlMaxColumnsInGroupBy),
"SQL_MAX_COLUMNS_IN_INDEX" => Some(Self::SqlMaxColumnsInIndex),
"SQL_MAX_COLUMNS_IN_ORDER_BY" => Some(Self::SqlMaxColumnsInOrderBy),
"SQL_MAX_COLUMNS_IN_SELECT" => Some(Self::SqlMaxColumnsInSelect),
"SQL_MAX_COLUMNS_IN_TABLE" => Some(Self::SqlMaxColumnsInTable),
"SQL_MAX_CONNECTIONS" => Some(Self::SqlMaxConnections),
"SQL_MAX_CURSOR_NAME_LENGTH" => Some(Self::SqlMaxCursorNameLength),
"SQL_MAX_INDEX_LENGTH" => Some(Self::SqlMaxIndexLength),
"SQL_DB_SCHEMA_NAME_LENGTH" => Some(Self::SqlDbSchemaNameLength),
"SQL_MAX_PROCEDURE_NAME_LENGTH" => Some(Self::SqlMaxProcedureNameLength),
"SQL_MAX_CATALOG_NAME_LENGTH" => Some(Self::SqlMaxCatalogNameLength),
"SQL_MAX_ROW_SIZE" => Some(Self::SqlMaxRowSize),
"SQL_MAX_ROW_SIZE_INCLUDES_BLOBS" => Some(Self::SqlMaxRowSizeIncludesBlobs),
"SQL_MAX_STATEMENT_LENGTH" => Some(Self::SqlMaxStatementLength),
"SQL_MAX_STATEMENTS" => Some(Self::SqlMaxStatements),
"SQL_MAX_TABLE_NAME_LENGTH" => Some(Self::SqlMaxTableNameLength),
"SQL_MAX_TABLES_IN_SELECT" => Some(Self::SqlMaxTablesInSelect),
"SQL_MAX_USERNAME_LENGTH" => Some(Self::SqlMaxUsernameLength),
"SQL_DEFAULT_TRANSACTION_ISOLATION" => {
Some(Self::SqlDefaultTransactionIsolation)
}
"SQL_TRANSACTIONS_SUPPORTED" => Some(Self::SqlTransactionsSupported),
"SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS" => {
Some(Self::SqlSupportedTransactionsIsolationLevels)
}
"SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT" => {
Some(Self::SqlDataDefinitionCausesTransactionCommit)
}
"SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED" => {
Some(Self::SqlDataDefinitionsInTransactionsIgnored)
}
"SQL_SUPPORTED_RESULT_SET_TYPES" => Some(Self::SqlSupportedResultSetTypes),
"SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED" => {
Some(Self::SqlSupportedConcurrenciesForResultSetUnspecified)
}
"SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY" => {
Some(Self::SqlSupportedConcurrenciesForResultSetForwardOnly)
}
"SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE" => {
Some(Self::SqlSupportedConcurrenciesForResultSetScrollSensitive)
}
"SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE" => {
Some(Self::SqlSupportedConcurrenciesForResultSetScrollInsensitive)
}
"SQL_BATCH_UPDATES_SUPPORTED" => Some(Self::SqlBatchUpdatesSupported),
"SQL_SAVEPOINTS_SUPPORTED" => Some(Self::SqlSavepointsSupported),
"SQL_NAMED_PARAMETERS_SUPPORTED" => Some(Self::SqlNamedParametersSupported),
"SQL_LOCATORS_UPDATE_COPY" => Some(Self::SqlLocatorsUpdateCopy),
"SQL_STORED_FUNCTIONS_USING_CALL_SYNTAX_SUPPORTED" => {
Some(Self::SqlStoredFunctionsUsingCallSyntaxSupported)
}
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedCaseSensitivity {
SqlCaseSensitivityUnknown = 0,
SqlCaseSensitivityCaseInsensitive = 1,
SqlCaseSensitivityUppercase = 2,
SqlCaseSensitivityLowercase = 3,
}
impl SqlSupportedCaseSensitivity {
pub fn as_str_name(&self) -> &'static str {
match self {
SqlSupportedCaseSensitivity::SqlCaseSensitivityUnknown => {
"SQL_CASE_SENSITIVITY_UNKNOWN"
}
SqlSupportedCaseSensitivity::SqlCaseSensitivityCaseInsensitive => {
"SQL_CASE_SENSITIVITY_CASE_INSENSITIVE"
}
SqlSupportedCaseSensitivity::SqlCaseSensitivityUppercase => {
"SQL_CASE_SENSITIVITY_UPPERCASE"
}
SqlSupportedCaseSensitivity::SqlCaseSensitivityLowercase => {
"SQL_CASE_SENSITIVITY_LOWERCASE"
}
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"SQL_CASE_SENSITIVITY_UNKNOWN" => Some(Self::SqlCaseSensitivityUnknown),
"SQL_CASE_SENSITIVITY_CASE_INSENSITIVE" => {
Some(Self::SqlCaseSensitivityCaseInsensitive)
}
"SQL_CASE_SENSITIVITY_UPPERCASE" => Some(Self::SqlCaseSensitivityUppercase),
"SQL_CASE_SENSITIVITY_LOWERCASE" => Some(Self::SqlCaseSensitivityLowercase),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlNullOrdering {
SqlNullsSortedHigh = 0,
SqlNullsSortedLow = 1,
SqlNullsSortedAtStart = 2,
SqlNullsSortedAtEnd = 3,
}
impl SqlNullOrdering {
pub fn as_str_name(&self) -> &'static str {
match self {
SqlNullOrdering::SqlNullsSortedHigh => "SQL_NULLS_SORTED_HIGH",
SqlNullOrdering::SqlNullsSortedLow => "SQL_NULLS_SORTED_LOW",
SqlNullOrdering::SqlNullsSortedAtStart => "SQL_NULLS_SORTED_AT_START",
SqlNullOrdering::SqlNullsSortedAtEnd => "SQL_NULLS_SORTED_AT_END",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"SQL_NULLS_SORTED_HIGH" => Some(Self::SqlNullsSortedHigh),
"SQL_NULLS_SORTED_LOW" => Some(Self::SqlNullsSortedLow),
"SQL_NULLS_SORTED_AT_START" => Some(Self::SqlNullsSortedAtStart),
"SQL_NULLS_SORTED_AT_END" => Some(Self::SqlNullsSortedAtEnd),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SupportedSqlGrammar {
SqlMinimumGrammar = 0,
SqlCoreGrammar = 1,
SqlExtendedGrammar = 2,
}
impl SupportedSqlGrammar {
pub fn as_str_name(&self) -> &'static str {
match self {
SupportedSqlGrammar::SqlMinimumGrammar => "SQL_MINIMUM_GRAMMAR",
SupportedSqlGrammar::SqlCoreGrammar => "SQL_CORE_GRAMMAR",
SupportedSqlGrammar::SqlExtendedGrammar => "SQL_EXTENDED_GRAMMAR",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"SQL_MINIMUM_GRAMMAR" => Some(Self::SqlMinimumGrammar),
"SQL_CORE_GRAMMAR" => Some(Self::SqlCoreGrammar),
"SQL_EXTENDED_GRAMMAR" => Some(Self::SqlExtendedGrammar),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SupportedAnsi92SqlGrammarLevel {
Ansi92EntrySql = 0,
Ansi92IntermediateSql = 1,
Ansi92FullSql = 2,
}
impl SupportedAnsi92SqlGrammarLevel {
pub fn as_str_name(&self) -> &'static str {
match self {
SupportedAnsi92SqlGrammarLevel::Ansi92EntrySql => "ANSI92_ENTRY_SQL",
SupportedAnsi92SqlGrammarLevel::Ansi92IntermediateSql => {
"ANSI92_INTERMEDIATE_SQL"
}
SupportedAnsi92SqlGrammarLevel::Ansi92FullSql => "ANSI92_FULL_SQL",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"ANSI92_ENTRY_SQL" => Some(Self::Ansi92EntrySql),
"ANSI92_INTERMEDIATE_SQL" => Some(Self::Ansi92IntermediateSql),
"ANSI92_FULL_SQL" => Some(Self::Ansi92FullSql),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlOuterJoinsSupportLevel {
SqlJoinsUnsupported = 0,
SqlLimitedOuterJoins = 1,
SqlFullOuterJoins = 2,
}
impl SqlOuterJoinsSupportLevel {
pub fn as_str_name(&self) -> &'static str {
match self {
SqlOuterJoinsSupportLevel::SqlJoinsUnsupported => "SQL_JOINS_UNSUPPORTED",
SqlOuterJoinsSupportLevel::SqlLimitedOuterJoins => "SQL_LIMITED_OUTER_JOINS",
SqlOuterJoinsSupportLevel::SqlFullOuterJoins => "SQL_FULL_OUTER_JOINS",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"SQL_JOINS_UNSUPPORTED" => Some(Self::SqlJoinsUnsupported),
"SQL_LIMITED_OUTER_JOINS" => Some(Self::SqlLimitedOuterJoins),
"SQL_FULL_OUTER_JOINS" => Some(Self::SqlFullOuterJoins),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedGroupBy {
SqlGroupByUnrelated = 0,
SqlGroupByBeyondSelect = 1,
}
impl SqlSupportedGroupBy {
pub fn as_str_name(&self) -> &'static str {
match self {
SqlSupportedGroupBy::SqlGroupByUnrelated => "SQL_GROUP_BY_UNRELATED",
SqlSupportedGroupBy::SqlGroupByBeyondSelect => "SQL_GROUP_BY_BEYOND_SELECT",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"SQL_GROUP_BY_UNRELATED" => Some(Self::SqlGroupByUnrelated),
"SQL_GROUP_BY_BEYOND_SELECT" => Some(Self::SqlGroupByBeyondSelect),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedElementActions {
SqlElementInProcedureCalls = 0,
SqlElementInIndexDefinitions = 1,
SqlElementInPrivilegeDefinitions = 2,
}
impl SqlSupportedElementActions {
pub fn as_str_name(&self) -> &'static str {
match self {
SqlSupportedElementActions::SqlElementInProcedureCalls => {
"SQL_ELEMENT_IN_PROCEDURE_CALLS"
}
SqlSupportedElementActions::SqlElementInIndexDefinitions => {
"SQL_ELEMENT_IN_INDEX_DEFINITIONS"
}
SqlSupportedElementActions::SqlElementInPrivilegeDefinitions => {
"SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS"
}
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"SQL_ELEMENT_IN_PROCEDURE_CALLS" => Some(Self::SqlElementInProcedureCalls),
"SQL_ELEMENT_IN_INDEX_DEFINITIONS" => {
Some(Self::SqlElementInIndexDefinitions)
}
"SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS" => {
Some(Self::SqlElementInPrivilegeDefinitions)
}
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedPositionedCommands {
SqlPositionedDelete = 0,
SqlPositionedUpdate = 1,
}
impl SqlSupportedPositionedCommands {
pub fn as_str_name(&self) -> &'static str {
match self {
SqlSupportedPositionedCommands::SqlPositionedDelete => {
"SQL_POSITIONED_DELETE"
}
SqlSupportedPositionedCommands::SqlPositionedUpdate => {
"SQL_POSITIONED_UPDATE"
}
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"SQL_POSITIONED_DELETE" => Some(Self::SqlPositionedDelete),
"SQL_POSITIONED_UPDATE" => Some(Self::SqlPositionedUpdate),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedSubqueries {
SqlSubqueriesInComparisons = 0,
SqlSubqueriesInExists = 1,
SqlSubqueriesInIns = 2,
SqlSubqueriesInQuantifieds = 3,
}
impl SqlSupportedSubqueries {
pub fn as_str_name(&self) -> &'static str {
match self {
SqlSupportedSubqueries::SqlSubqueriesInComparisons => {
"SQL_SUBQUERIES_IN_COMPARISONS"
}
SqlSupportedSubqueries::SqlSubqueriesInExists => "SQL_SUBQUERIES_IN_EXISTS",
SqlSupportedSubqueries::SqlSubqueriesInIns => "SQL_SUBQUERIES_IN_INS",
SqlSupportedSubqueries::SqlSubqueriesInQuantifieds => {
"SQL_SUBQUERIES_IN_QUANTIFIEDS"
}
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"SQL_SUBQUERIES_IN_COMPARISONS" => Some(Self::SqlSubqueriesInComparisons),
"SQL_SUBQUERIES_IN_EXISTS" => Some(Self::SqlSubqueriesInExists),
"SQL_SUBQUERIES_IN_INS" => Some(Self::SqlSubqueriesInIns),
"SQL_SUBQUERIES_IN_QUANTIFIEDS" => Some(Self::SqlSubqueriesInQuantifieds),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedUnions {
SqlUnion = 0,
SqlUnionAll = 1,
}
impl SqlSupportedUnions {
pub fn as_str_name(&self) -> &'static str {
match self {
SqlSupportedUnions::SqlUnion => "SQL_UNION",
SqlSupportedUnions::SqlUnionAll => "SQL_UNION_ALL",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"SQL_UNION" => Some(Self::SqlUnion),
"SQL_UNION_ALL" => Some(Self::SqlUnionAll),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlTransactionIsolationLevel {
SqlTransactionNone = 0,
SqlTransactionReadUncommitted = 1,
SqlTransactionReadCommitted = 2,
SqlTransactionRepeatableRead = 3,
SqlTransactionSerializable = 4,
}
impl SqlTransactionIsolationLevel {
pub fn as_str_name(&self) -> &'static str {
match self {
SqlTransactionIsolationLevel::SqlTransactionNone => "SQL_TRANSACTION_NONE",
SqlTransactionIsolationLevel::SqlTransactionReadUncommitted => {
"SQL_TRANSACTION_READ_UNCOMMITTED"
}
SqlTransactionIsolationLevel::SqlTransactionReadCommitted => {
"SQL_TRANSACTION_READ_COMMITTED"
}
SqlTransactionIsolationLevel::SqlTransactionRepeatableRead => {
"SQL_TRANSACTION_REPEATABLE_READ"
}
SqlTransactionIsolationLevel::SqlTransactionSerializable => {
"SQL_TRANSACTION_SERIALIZABLE"
}
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"SQL_TRANSACTION_NONE" => Some(Self::SqlTransactionNone),
"SQL_TRANSACTION_READ_UNCOMMITTED" => {
Some(Self::SqlTransactionReadUncommitted)
}
"SQL_TRANSACTION_READ_COMMITTED" => Some(Self::SqlTransactionReadCommitted),
"SQL_TRANSACTION_REPEATABLE_READ" => Some(Self::SqlTransactionRepeatableRead),
"SQL_TRANSACTION_SERIALIZABLE" => Some(Self::SqlTransactionSerializable),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedTransactions {
SqlTransactionUnspecified = 0,
SqlDataDefinitionTransactions = 1,
SqlDataManipulationTransactions = 2,
}
impl SqlSupportedTransactions {
pub fn as_str_name(&self) -> &'static str {
match self {
SqlSupportedTransactions::SqlTransactionUnspecified => {
"SQL_TRANSACTION_UNSPECIFIED"
}
SqlSupportedTransactions::SqlDataDefinitionTransactions => {
"SQL_DATA_DEFINITION_TRANSACTIONS"
}
SqlSupportedTransactions::SqlDataManipulationTransactions => {
"SQL_DATA_MANIPULATION_TRANSACTIONS"
}
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"SQL_TRANSACTION_UNSPECIFIED" => Some(Self::SqlTransactionUnspecified),
"SQL_DATA_DEFINITION_TRANSACTIONS" => {
Some(Self::SqlDataDefinitionTransactions)
}
"SQL_DATA_MANIPULATION_TRANSACTIONS" => {
Some(Self::SqlDataManipulationTransactions)
}
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedResultSetType {
SqlResultSetTypeUnspecified = 0,
SqlResultSetTypeForwardOnly = 1,
SqlResultSetTypeScrollInsensitive = 2,
SqlResultSetTypeScrollSensitive = 3,
}
impl SqlSupportedResultSetType {
pub fn as_str_name(&self) -> &'static str {
match self {
SqlSupportedResultSetType::SqlResultSetTypeUnspecified => {
"SQL_RESULT_SET_TYPE_UNSPECIFIED"
}
SqlSupportedResultSetType::SqlResultSetTypeForwardOnly => {
"SQL_RESULT_SET_TYPE_FORWARD_ONLY"
}
SqlSupportedResultSetType::SqlResultSetTypeScrollInsensitive => {
"SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE"
}
SqlSupportedResultSetType::SqlResultSetTypeScrollSensitive => {
"SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE"
}
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"SQL_RESULT_SET_TYPE_UNSPECIFIED" => Some(Self::SqlResultSetTypeUnspecified),
"SQL_RESULT_SET_TYPE_FORWARD_ONLY" => Some(Self::SqlResultSetTypeForwardOnly),
"SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE" => {
Some(Self::SqlResultSetTypeScrollInsensitive)
}
"SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE" => {
Some(Self::SqlResultSetTypeScrollSensitive)
}
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedResultSetConcurrency {
SqlResultSetConcurrencyUnspecified = 0,
SqlResultSetConcurrencyReadOnly = 1,
SqlResultSetConcurrencyUpdatable = 2,
}
impl SqlSupportedResultSetConcurrency {
pub fn as_str_name(&self) -> &'static str {
match self {
SqlSupportedResultSetConcurrency::SqlResultSetConcurrencyUnspecified => {
"SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED"
}
SqlSupportedResultSetConcurrency::SqlResultSetConcurrencyReadOnly => {
"SQL_RESULT_SET_CONCURRENCY_READ_ONLY"
}
SqlSupportedResultSetConcurrency::SqlResultSetConcurrencyUpdatable => {
"SQL_RESULT_SET_CONCURRENCY_UPDATABLE"
}
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED" => {
Some(Self::SqlResultSetConcurrencyUnspecified)
}
"SQL_RESULT_SET_CONCURRENCY_READ_ONLY" => {
Some(Self::SqlResultSetConcurrencyReadOnly)
}
"SQL_RESULT_SET_CONCURRENCY_UPDATABLE" => {
Some(Self::SqlResultSetConcurrencyUpdatable)
}
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportsConvert {
SqlConvertBigint = 0,
SqlConvertBinary = 1,
SqlConvertBit = 2,
SqlConvertChar = 3,
SqlConvertDate = 4,
SqlConvertDecimal = 5,
SqlConvertFloat = 6,
SqlConvertInteger = 7,
SqlConvertIntervalDayTime = 8,
SqlConvertIntervalYearMonth = 9,
SqlConvertLongvarbinary = 10,
SqlConvertLongvarchar = 11,
SqlConvertNumeric = 12,
SqlConvertReal = 13,
SqlConvertSmallint = 14,
SqlConvertTime = 15,
SqlConvertTimestamp = 16,
SqlConvertTinyint = 17,
SqlConvertVarbinary = 18,
SqlConvertVarchar = 19,
}
impl SqlSupportsConvert {
pub fn as_str_name(&self) -> &'static str {
match self {
SqlSupportsConvert::SqlConvertBigint => "SQL_CONVERT_BIGINT",
SqlSupportsConvert::SqlConvertBinary => "SQL_CONVERT_BINARY",
SqlSupportsConvert::SqlConvertBit => "SQL_CONVERT_BIT",
SqlSupportsConvert::SqlConvertChar => "SQL_CONVERT_CHAR",
SqlSupportsConvert::SqlConvertDate => "SQL_CONVERT_DATE",
SqlSupportsConvert::SqlConvertDecimal => "SQL_CONVERT_DECIMAL",
SqlSupportsConvert::SqlConvertFloat => "SQL_CONVERT_FLOAT",
SqlSupportsConvert::SqlConvertInteger => "SQL_CONVERT_INTEGER",
SqlSupportsConvert::SqlConvertIntervalDayTime => {
"SQL_CONVERT_INTERVAL_DAY_TIME"
}
SqlSupportsConvert::SqlConvertIntervalYearMonth => {
"SQL_CONVERT_INTERVAL_YEAR_MONTH"
}
SqlSupportsConvert::SqlConvertLongvarbinary => "SQL_CONVERT_LONGVARBINARY",
SqlSupportsConvert::SqlConvertLongvarchar => "SQL_CONVERT_LONGVARCHAR",
SqlSupportsConvert::SqlConvertNumeric => "SQL_CONVERT_NUMERIC",
SqlSupportsConvert::SqlConvertReal => "SQL_CONVERT_REAL",
SqlSupportsConvert::SqlConvertSmallint => "SQL_CONVERT_SMALLINT",
SqlSupportsConvert::SqlConvertTime => "SQL_CONVERT_TIME",
SqlSupportsConvert::SqlConvertTimestamp => "SQL_CONVERT_TIMESTAMP",
SqlSupportsConvert::SqlConvertTinyint => "SQL_CONVERT_TINYINT",
SqlSupportsConvert::SqlConvertVarbinary => "SQL_CONVERT_VARBINARY",
SqlSupportsConvert::SqlConvertVarchar => "SQL_CONVERT_VARCHAR",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"SQL_CONVERT_BIGINT" => Some(Self::SqlConvertBigint),
"SQL_CONVERT_BINARY" => Some(Self::SqlConvertBinary),
"SQL_CONVERT_BIT" => Some(Self::SqlConvertBit),
"SQL_CONVERT_CHAR" => Some(Self::SqlConvertChar),
"SQL_CONVERT_DATE" => Some(Self::SqlConvertDate),
"SQL_CONVERT_DECIMAL" => Some(Self::SqlConvertDecimal),
"SQL_CONVERT_FLOAT" => Some(Self::SqlConvertFloat),
"SQL_CONVERT_INTEGER" => Some(Self::SqlConvertInteger),
"SQL_CONVERT_INTERVAL_DAY_TIME" => Some(Self::SqlConvertIntervalDayTime),
"SQL_CONVERT_INTERVAL_YEAR_MONTH" => Some(Self::SqlConvertIntervalYearMonth),
"SQL_CONVERT_LONGVARBINARY" => Some(Self::SqlConvertLongvarbinary),
"SQL_CONVERT_LONGVARCHAR" => Some(Self::SqlConvertLongvarchar),
"SQL_CONVERT_NUMERIC" => Some(Self::SqlConvertNumeric),
"SQL_CONVERT_REAL" => Some(Self::SqlConvertReal),
"SQL_CONVERT_SMALLINT" => Some(Self::SqlConvertSmallint),
"SQL_CONVERT_TIME" => Some(Self::SqlConvertTime),
"SQL_CONVERT_TIMESTAMP" => Some(Self::SqlConvertTimestamp),
"SQL_CONVERT_TINYINT" => Some(Self::SqlConvertTinyint),
"SQL_CONVERT_VARBINARY" => Some(Self::SqlConvertVarbinary),
"SQL_CONVERT_VARCHAR" => Some(Self::SqlConvertVarchar),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum XdbcDataType {
XdbcUnknownType = 0,
XdbcChar = 1,
XdbcNumeric = 2,
XdbcDecimal = 3,
XdbcInteger = 4,
XdbcSmallint = 5,
XdbcFloat = 6,
XdbcReal = 7,
XdbcDouble = 8,
XdbcDatetime = 9,
XdbcInterval = 10,
XdbcVarchar = 12,
XdbcDate = 91,
XdbcTime = 92,
XdbcTimestamp = 93,
XdbcLongvarchar = -1,
XdbcBinary = -2,
XdbcVarbinary = -3,
XdbcLongvarbinary = -4,
XdbcBigint = -5,
XdbcTinyint = -6,
XdbcBit = -7,
XdbcWchar = -8,
XdbcWvarchar = -9,
}
impl XdbcDataType {
pub fn as_str_name(&self) -> &'static str {
match self {
XdbcDataType::XdbcUnknownType => "XDBC_UNKNOWN_TYPE",
XdbcDataType::XdbcChar => "XDBC_CHAR",
XdbcDataType::XdbcNumeric => "XDBC_NUMERIC",
XdbcDataType::XdbcDecimal => "XDBC_DECIMAL",
XdbcDataType::XdbcInteger => "XDBC_INTEGER",
XdbcDataType::XdbcSmallint => "XDBC_SMALLINT",
XdbcDataType::XdbcFloat => "XDBC_FLOAT",
XdbcDataType::XdbcReal => "XDBC_REAL",
XdbcDataType::XdbcDouble => "XDBC_DOUBLE",
XdbcDataType::XdbcDatetime => "XDBC_DATETIME",
XdbcDataType::XdbcInterval => "XDBC_INTERVAL",
XdbcDataType::XdbcVarchar => "XDBC_VARCHAR",
XdbcDataType::XdbcDate => "XDBC_DATE",
XdbcDataType::XdbcTime => "XDBC_TIME",
XdbcDataType::XdbcTimestamp => "XDBC_TIMESTAMP",
XdbcDataType::XdbcLongvarchar => "XDBC_LONGVARCHAR",
XdbcDataType::XdbcBinary => "XDBC_BINARY",
XdbcDataType::XdbcVarbinary => "XDBC_VARBINARY",
XdbcDataType::XdbcLongvarbinary => "XDBC_LONGVARBINARY",
XdbcDataType::XdbcBigint => "XDBC_BIGINT",
XdbcDataType::XdbcTinyint => "XDBC_TINYINT",
XdbcDataType::XdbcBit => "XDBC_BIT",
XdbcDataType::XdbcWchar => "XDBC_WCHAR",
XdbcDataType::XdbcWvarchar => "XDBC_WVARCHAR",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"XDBC_UNKNOWN_TYPE" => Some(Self::XdbcUnknownType),
"XDBC_CHAR" => Some(Self::XdbcChar),
"XDBC_NUMERIC" => Some(Self::XdbcNumeric),
"XDBC_DECIMAL" => Some(Self::XdbcDecimal),
"XDBC_INTEGER" => Some(Self::XdbcInteger),
"XDBC_SMALLINT" => Some(Self::XdbcSmallint),
"XDBC_FLOAT" => Some(Self::XdbcFloat),
"XDBC_REAL" => Some(Self::XdbcReal),
"XDBC_DOUBLE" => Some(Self::XdbcDouble),
"XDBC_DATETIME" => Some(Self::XdbcDatetime),
"XDBC_INTERVAL" => Some(Self::XdbcInterval),
"XDBC_VARCHAR" => Some(Self::XdbcVarchar),
"XDBC_DATE" => Some(Self::XdbcDate),
"XDBC_TIME" => Some(Self::XdbcTime),
"XDBC_TIMESTAMP" => Some(Self::XdbcTimestamp),
"XDBC_LONGVARCHAR" => Some(Self::XdbcLongvarchar),
"XDBC_BINARY" => Some(Self::XdbcBinary),
"XDBC_VARBINARY" => Some(Self::XdbcVarbinary),
"XDBC_LONGVARBINARY" => Some(Self::XdbcLongvarbinary),
"XDBC_BIGINT" => Some(Self::XdbcBigint),
"XDBC_TINYINT" => Some(Self::XdbcTinyint),
"XDBC_BIT" => Some(Self::XdbcBit),
"XDBC_WCHAR" => Some(Self::XdbcWchar),
"XDBC_WVARCHAR" => Some(Self::XdbcWvarchar),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum XdbcDatetimeSubcode {
XdbcSubcodeUnknown = 0,
XdbcSubcodeYear = 1,
XdbcSubcodeTime = 2,
XdbcSubcodeTimestamp = 3,
XdbcSubcodeTimeWithTimezone = 4,
XdbcSubcodeTimestampWithTimezone = 5,
XdbcSubcodeSecond = 6,
XdbcSubcodeYearToMonth = 7,
XdbcSubcodeDayToHour = 8,
XdbcSubcodeDayToMinute = 9,
XdbcSubcodeDayToSecond = 10,
XdbcSubcodeHourToMinute = 11,
XdbcSubcodeHourToSecond = 12,
XdbcSubcodeMinuteToSecond = 13,
XdbcSubcodeIntervalYear = 101,
XdbcSubcodeIntervalMonth = 102,
XdbcSubcodeIntervalDay = 103,
XdbcSubcodeIntervalHour = 104,
XdbcSubcodeIntervalMinute = 105,
XdbcSubcodeIntervalSecond = 106,
XdbcSubcodeIntervalYearToMonth = 107,
XdbcSubcodeIntervalDayToHour = 108,
XdbcSubcodeIntervalDayToMinute = 109,
XdbcSubcodeIntervalDayToSecond = 110,
XdbcSubcodeIntervalHourToMinute = 111,
XdbcSubcodeIntervalHourToSecond = 112,
XdbcSubcodeIntervalMinuteToSecond = 113,
}
impl XdbcDatetimeSubcode {
pub fn as_str_name(&self) -> &'static str {
match self {
XdbcDatetimeSubcode::XdbcSubcodeUnknown => "XDBC_SUBCODE_UNKNOWN",
XdbcDatetimeSubcode::XdbcSubcodeYear => "XDBC_SUBCODE_YEAR",
XdbcDatetimeSubcode::XdbcSubcodeTime => "XDBC_SUBCODE_TIME",
XdbcDatetimeSubcode::XdbcSubcodeTimestamp => "XDBC_SUBCODE_TIMESTAMP",
XdbcDatetimeSubcode::XdbcSubcodeTimeWithTimezone => {
"XDBC_SUBCODE_TIME_WITH_TIMEZONE"
}
XdbcDatetimeSubcode::XdbcSubcodeTimestampWithTimezone => {
"XDBC_SUBCODE_TIMESTAMP_WITH_TIMEZONE"
}
XdbcDatetimeSubcode::XdbcSubcodeSecond => "XDBC_SUBCODE_SECOND",
XdbcDatetimeSubcode::XdbcSubcodeYearToMonth => "XDBC_SUBCODE_YEAR_TO_MONTH",
XdbcDatetimeSubcode::XdbcSubcodeDayToHour => "XDBC_SUBCODE_DAY_TO_HOUR",
XdbcDatetimeSubcode::XdbcSubcodeDayToMinute => "XDBC_SUBCODE_DAY_TO_MINUTE",
XdbcDatetimeSubcode::XdbcSubcodeDayToSecond => "XDBC_SUBCODE_DAY_TO_SECOND",
XdbcDatetimeSubcode::XdbcSubcodeHourToMinute => "XDBC_SUBCODE_HOUR_TO_MINUTE",
XdbcDatetimeSubcode::XdbcSubcodeHourToSecond => "XDBC_SUBCODE_HOUR_TO_SECOND",
XdbcDatetimeSubcode::XdbcSubcodeMinuteToSecond => {
"XDBC_SUBCODE_MINUTE_TO_SECOND"
}
XdbcDatetimeSubcode::XdbcSubcodeIntervalYear => "XDBC_SUBCODE_INTERVAL_YEAR",
XdbcDatetimeSubcode::XdbcSubcodeIntervalMonth => {
"XDBC_SUBCODE_INTERVAL_MONTH"
}
XdbcDatetimeSubcode::XdbcSubcodeIntervalDay => "XDBC_SUBCODE_INTERVAL_DAY",
XdbcDatetimeSubcode::XdbcSubcodeIntervalHour => "XDBC_SUBCODE_INTERVAL_HOUR",
XdbcDatetimeSubcode::XdbcSubcodeIntervalMinute => {
"XDBC_SUBCODE_INTERVAL_MINUTE"
}
XdbcDatetimeSubcode::XdbcSubcodeIntervalSecond => {
"XDBC_SUBCODE_INTERVAL_SECOND"
}
XdbcDatetimeSubcode::XdbcSubcodeIntervalYearToMonth => {
"XDBC_SUBCODE_INTERVAL_YEAR_TO_MONTH"
}
XdbcDatetimeSubcode::XdbcSubcodeIntervalDayToHour => {
"XDBC_SUBCODE_INTERVAL_DAY_TO_HOUR"
}
XdbcDatetimeSubcode::XdbcSubcodeIntervalDayToMinute => {
"XDBC_SUBCODE_INTERVAL_DAY_TO_MINUTE"
}
XdbcDatetimeSubcode::XdbcSubcodeIntervalDayToSecond => {
"XDBC_SUBCODE_INTERVAL_DAY_TO_SECOND"
}
XdbcDatetimeSubcode::XdbcSubcodeIntervalHourToMinute => {
"XDBC_SUBCODE_INTERVAL_HOUR_TO_MINUTE"
}
XdbcDatetimeSubcode::XdbcSubcodeIntervalHourToSecond => {
"XDBC_SUBCODE_INTERVAL_HOUR_TO_SECOND"
}
XdbcDatetimeSubcode::XdbcSubcodeIntervalMinuteToSecond => {
"XDBC_SUBCODE_INTERVAL_MINUTE_TO_SECOND"
}
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"XDBC_SUBCODE_UNKNOWN" => Some(Self::XdbcSubcodeUnknown),
"XDBC_SUBCODE_YEAR" => Some(Self::XdbcSubcodeYear),
"XDBC_SUBCODE_TIME" => Some(Self::XdbcSubcodeTime),
"XDBC_SUBCODE_TIMESTAMP" => Some(Self::XdbcSubcodeTimestamp),
"XDBC_SUBCODE_TIME_WITH_TIMEZONE" => Some(Self::XdbcSubcodeTimeWithTimezone),
"XDBC_SUBCODE_TIMESTAMP_WITH_TIMEZONE" => {
Some(Self::XdbcSubcodeTimestampWithTimezone)
}
"XDBC_SUBCODE_SECOND" => Some(Self::XdbcSubcodeSecond),
"XDBC_SUBCODE_YEAR_TO_MONTH" => Some(Self::XdbcSubcodeYearToMonth),
"XDBC_SUBCODE_DAY_TO_HOUR" => Some(Self::XdbcSubcodeDayToHour),
"XDBC_SUBCODE_DAY_TO_MINUTE" => Some(Self::XdbcSubcodeDayToMinute),
"XDBC_SUBCODE_DAY_TO_SECOND" => Some(Self::XdbcSubcodeDayToSecond),
"XDBC_SUBCODE_HOUR_TO_MINUTE" => Some(Self::XdbcSubcodeHourToMinute),
"XDBC_SUBCODE_HOUR_TO_SECOND" => Some(Self::XdbcSubcodeHourToSecond),
"XDBC_SUBCODE_MINUTE_TO_SECOND" => Some(Self::XdbcSubcodeMinuteToSecond),
"XDBC_SUBCODE_INTERVAL_YEAR" => Some(Self::XdbcSubcodeIntervalYear),
"XDBC_SUBCODE_INTERVAL_MONTH" => Some(Self::XdbcSubcodeIntervalMonth),
"XDBC_SUBCODE_INTERVAL_DAY" => Some(Self::XdbcSubcodeIntervalDay),
"XDBC_SUBCODE_INTERVAL_HOUR" => Some(Self::XdbcSubcodeIntervalHour),
"XDBC_SUBCODE_INTERVAL_MINUTE" => Some(Self::XdbcSubcodeIntervalMinute),
"XDBC_SUBCODE_INTERVAL_SECOND" => Some(Self::XdbcSubcodeIntervalSecond),
"XDBC_SUBCODE_INTERVAL_YEAR_TO_MONTH" => {
Some(Self::XdbcSubcodeIntervalYearToMonth)
}
"XDBC_SUBCODE_INTERVAL_DAY_TO_HOUR" => {
Some(Self::XdbcSubcodeIntervalDayToHour)
}
"XDBC_SUBCODE_INTERVAL_DAY_TO_MINUTE" => {
Some(Self::XdbcSubcodeIntervalDayToMinute)
}
"XDBC_SUBCODE_INTERVAL_DAY_TO_SECOND" => {
Some(Self::XdbcSubcodeIntervalDayToSecond)
}
"XDBC_SUBCODE_INTERVAL_HOUR_TO_MINUTE" => {
Some(Self::XdbcSubcodeIntervalHourToMinute)
}
"XDBC_SUBCODE_INTERVAL_HOUR_TO_SECOND" => {
Some(Self::XdbcSubcodeIntervalHourToSecond)
}
"XDBC_SUBCODE_INTERVAL_MINUTE_TO_SECOND" => {
Some(Self::XdbcSubcodeIntervalMinuteToSecond)
}
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Nullable {
NullabilityNoNulls = 0,
NullabilityNullable = 1,
NullabilityUnknown = 2,
}
impl Nullable {
pub fn as_str_name(&self) -> &'static str {
match self {
Nullable::NullabilityNoNulls => "NULLABILITY_NO_NULLS",
Nullable::NullabilityNullable => "NULLABILITY_NULLABLE",
Nullable::NullabilityUnknown => "NULLABILITY_UNKNOWN",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"NULLABILITY_NO_NULLS" => Some(Self::NullabilityNoNulls),
"NULLABILITY_NULLABLE" => Some(Self::NullabilityNullable),
"NULLABILITY_UNKNOWN" => Some(Self::NullabilityUnknown),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Searchable {
None = 0,
Char = 1,
Basic = 2,
Full = 3,
}
impl Searchable {
pub fn as_str_name(&self) -> &'static str {
match self {
Searchable::None => "SEARCHABLE_NONE",
Searchable::Char => "SEARCHABLE_CHAR",
Searchable::Basic => "SEARCHABLE_BASIC",
Searchable::Full => "SEARCHABLE_FULL",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"SEARCHABLE_NONE" => Some(Self::None),
"SEARCHABLE_CHAR" => Some(Self::Char),
"SEARCHABLE_BASIC" => Some(Self::Basic),
"SEARCHABLE_FULL" => Some(Self::Full),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum UpdateDeleteRules {
Cascade = 0,
Restrict = 1,
SetNull = 2,
NoAction = 3,
SetDefault = 4,
}
impl UpdateDeleteRules {
pub fn as_str_name(&self) -> &'static str {
match self {
UpdateDeleteRules::Cascade => "CASCADE",
UpdateDeleteRules::Restrict => "RESTRICT",
UpdateDeleteRules::SetNull => "SET_NULL",
UpdateDeleteRules::NoAction => "NO_ACTION",
UpdateDeleteRules::SetDefault => "SET_DEFAULT",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"CASCADE" => Some(Self::Cascade),
"RESTRICT" => Some(Self::Restrict),
"SET_NULL" => Some(Self::SetNull),
"NO_ACTION" => Some(Self::NoAction),
"SET_DEFAULT" => Some(Self::SetDefault),
_ => None,
}
}
}