arrow_flight/sql/arrow.flight.protocol.sql.rs
1// This file was automatically generated through the build.rs script, and should not be edited.
2
3// This file is @generated by prost-build.
4///
5/// Represents a metadata request. Used in the command member of FlightDescriptor
6/// for the following RPC calls:
7/// - GetSchema: return the Arrow schema of the query.
8/// - GetFlightInfo: execute the metadata request.
9///
10/// The returned Arrow schema will be:
11/// <
12/// info_name: uint32 not null,
13/// value: dense_union<
14/// string_value: utf8,
15/// bool_value: bool,
16/// bigint_value: int64,
17/// int32_bitmask: int32,
18/// string_list: list<string_data: utf8>
19/// int32_to_int32_list_map: map<key: int32, value: list<$data$: int32>>
20/// >
21/// where there is one row per requested piece of metadata information.
22#[allow(clippy::all)]
23#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
24pub struct CommandGetSqlInfo {
25 ///
26 /// Values are modelled after ODBC's SQLGetInfo() function. This information is intended to provide
27 /// Flight SQL clients with basic, SQL syntax and SQL functions related information.
28 /// More information types can be added in future releases.
29 /// E.g. more SQL syntax support types, scalar functions support, type conversion support etc.
30 ///
31 /// Note that the set of metadata may expand.
32 ///
33 /// Initially, Flight SQL will support the following information types:
34 /// - Server Information - Range [0-500)
35 /// - Syntax Information - Range [500-1000)
36 /// Range [0-10,000) is reserved for defaults (see SqlInfo enum for default options).
37 /// Custom options should start at 10,000.
38 ///
39 /// If omitted, then all metadata will be retrieved.
40 /// Flight SQL Servers may choose to include additional metadata above and beyond the specified set, however they must
41 /// at least return the specified set. IDs ranging from 0 to 10,000 (exclusive) are reserved for future use.
42 /// If additional metadata is included, the metadata IDs should start from 10,000.
43 #[prost(uint32, repeated, tag = "1")]
44 pub info: ::prost::alloc::vec::Vec<u32>,
45}
46///
47/// Represents a request to retrieve information about data type supported on a Flight SQL enabled backend.
48/// Used in the command member of FlightDescriptor for the following RPC calls:
49/// - GetSchema: return the schema of the query.
50/// - GetFlightInfo: execute the catalog metadata request.
51///
52/// The returned schema will be:
53/// <
54/// type_name: utf8 not null (The name of the data type, for example: VARCHAR, INTEGER, etc),
55/// data_type: int32 not null (The SQL data type),
56/// column_size: int32 (The maximum size supported by that column.
57/// In case of exact numeric types, this represents the maximum precision.
58/// In case of string types, this represents the character length.
59/// In case of datetime data types, this represents the length in characters of the string representation.
60/// NULL is returned for data types where column size is not applicable.),
61/// literal_prefix: utf8 (Character or characters used to prefix a literal, NULL is returned for
62/// data types where a literal prefix is not applicable.),
63/// literal_suffix: utf8 (Character or characters used to terminate a literal,
64/// NULL is returned for data types where a literal suffix is not applicable.),
65/// create_params: list<utf8 not null>
66/// (A list of keywords corresponding to which parameters can be used when creating
67/// a column for that specific type.
68/// NULL is returned if there are no parameters for the data type definition.),
69/// nullable: int32 not null (Shows if the data type accepts a NULL value. The possible values can be seen in the
70/// Nullable enum.),
71/// case_sensitive: bool not null (Shows if a character data type is case-sensitive in collations and comparisons),
72/// searchable: int32 not null (Shows how the data type is used in a WHERE clause. The possible values can be seen in the
73/// Searchable enum.),
74/// unsigned_attribute: bool (Shows if the data type is unsigned. NULL is returned if the attribute is
75/// not applicable to the data type or the data type is not numeric.),
76/// fixed_prec_scale: bool not null (Shows if the data type has predefined fixed precision and scale.),
77/// auto_increment: bool (Shows if the data type is auto incremental. NULL is returned if the attribute
78/// is not applicable to the data type or the data type is not numeric.),
79/// local_type_name: utf8 (Localized version of the data source-dependent name of the data type. NULL
80/// is returned if a localized name is not supported by the data source),
81/// minimum_scale: int32 (The minimum scale of the data type on the data source.
82/// If a data type has a fixed scale, the MINIMUM_SCALE and MAXIMUM_SCALE
83/// columns both contain this value. NULL is returned if scale is not applicable.),
84/// maximum_scale: int32 (The maximum scale of the data type on the data source.
85/// NULL is returned if scale is not applicable.),
86/// sql_data_type: int32 not null (The value of the SQL DATA TYPE which has the same values
87/// as data_type value. Except for interval and datetime, which
88/// uses generic values. More info about those types can be
89/// obtained through datetime_subcode. The possible values can be seen
90/// in the XdbcDataType enum.),
91/// datetime_subcode: int32 (Only used when the SQL DATA TYPE is interval or datetime. It contains
92/// its sub types. For type different from interval and datetime, this value
93/// is NULL. The possible values can be seen in the XdbcDatetimeSubcode enum.),
94/// num_prec_radix: int32 (If the data type is an approximate numeric type, this column contains
95/// the value 2 to indicate that COLUMN_SIZE specifies a number of bits. For
96/// exact numeric types, this column contains the value 10 to indicate that
97/// column size specifies a number of decimal digits. Otherwise, this column is NULL.),
98/// interval_precision: int32 (If the data type is an interval data type, then this column contains the value
99/// of the interval leading precision. Otherwise, this column is NULL. This fields
100/// is only relevant to be used by ODBC).
101/// >
102/// The returned data should be ordered by data_type and then by type_name.
103#[allow(clippy::all)]
104#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
105pub struct CommandGetXdbcTypeInfo {
106 ///
107 /// Specifies the data type to search for the info.
108 #[prost(int32, optional, tag = "1")]
109 pub data_type: ::core::option::Option<i32>,
110}
111///
112/// Represents a request to retrieve the list of catalogs on a Flight SQL enabled backend.
113/// The definition of a catalog depends on vendor/implementation. It is usually the database itself
114/// Used in the command member of FlightDescriptor for the following RPC calls:
115/// - GetSchema: return the Arrow schema of the query.
116/// - GetFlightInfo: execute the catalog metadata request.
117///
118/// The returned Arrow schema will be:
119/// <
120/// catalog_name: utf8 not null
121/// >
122/// The returned data should be ordered by catalog_name.
123#[allow(clippy::all)]
124#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
125pub struct CommandGetCatalogs {}
126///
127/// Represents a request to retrieve the list of database schemas on a Flight SQL enabled backend.
128/// The definition of a database schema depends on vendor/implementation. It is usually a collection of tables.
129/// Used in the command member of FlightDescriptor for the following RPC calls:
130/// - GetSchema: return the Arrow schema of the query.
131/// - GetFlightInfo: execute the catalog metadata request.
132///
133/// The returned Arrow schema will be:
134/// <
135/// catalog_name: utf8,
136/// db_schema_name: utf8 not null
137/// >
138/// The returned data should be ordered by catalog_name, then db_schema_name.
139#[allow(clippy::all)]
140#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
141pub struct CommandGetDbSchemas {
142 ///
143 /// Specifies the Catalog to search for the tables.
144 /// An empty string retrieves those without a catalog.
145 /// If omitted the catalog name should not be used to narrow the search.
146 #[prost(string, optional, tag = "1")]
147 pub catalog: ::core::option::Option<::prost::alloc::string::String>,
148 ///
149 /// Specifies a filter pattern for schemas to search for.
150 /// When no db_schema_filter_pattern is provided, the pattern will not be used to narrow the search.
151 /// In the pattern string, two special characters can be used to denote matching rules:
152 /// - "%" means to match any substring with 0 or more characters.
153 /// - "_" means to match any one character.
154 #[prost(string, optional, tag = "2")]
155 pub db_schema_filter_pattern: ::core::option::Option<::prost::alloc::string::String>,
156}
157///
158/// Represents a request to retrieve the list of tables, and optionally their schemas, on a Flight SQL enabled backend.
159/// Used in the command member of FlightDescriptor for the following RPC calls:
160/// - GetSchema: return the Arrow schema of the query.
161/// - GetFlightInfo: execute the catalog metadata request.
162///
163/// The returned Arrow schema will be:
164/// <
165/// catalog_name: utf8,
166/// db_schema_name: utf8,
167/// table_name: utf8 not null,
168/// table_type: utf8 not null,
169/// \[optional\] table_schema: bytes not null (schema of the table as described in Schema.fbs::Schema,
170/// it is serialized as an IPC message.)
171/// >
172/// Fields on table_schema may contain the following metadata:
173/// - ARROW:FLIGHT:SQL:CATALOG_NAME - Table's catalog name
174/// - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME - Database schema name
175/// - ARROW:FLIGHT:SQL:TABLE_NAME - Table name
176/// - ARROW:FLIGHT:SQL:TYPE_NAME - The data source-specific name for the data type of the column.
177/// - ARROW:FLIGHT:SQL:PRECISION - Column precision/size
178/// - ARROW:FLIGHT:SQL:SCALE - Column scale/decimal digits if applicable
179/// - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
180/// - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
181/// - ARROW:FLIGHT:SQL:IS_READ_ONLY - "1" indicates if the column is read only, "0" otherwise.
182/// - ARROW:FLIGHT:SQL:IS_SEARCHABLE - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
183/// - ARROW:FLIGHT:SQL:REMARKS - A comment describing the column. This field has been added after all others, clients should be prepared to find it missing.
184/// The returned data should be ordered by catalog_name, db_schema_name, table_name, then table_type, followed by table_schema if requested.
185#[allow(clippy::all)]
186#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
187pub struct CommandGetTables {
188 ///
189 /// Specifies the Catalog to search for the tables.
190 /// An empty string retrieves those without a catalog.
191 /// If omitted the catalog name should not be used to narrow the search.
192 #[prost(string, optional, tag = "1")]
193 pub catalog: ::core::option::Option<::prost::alloc::string::String>,
194 ///
195 /// Specifies a filter pattern for schemas to search for.
196 /// When no db_schema_filter_pattern is provided, all schemas matching other filters are searched.
197 /// In the pattern string, two special characters can be used to denote matching rules:
198 /// - "%" means to match any substring with 0 or more characters.
199 /// - "_" means to match any one character.
200 #[prost(string, optional, tag = "2")]
201 pub db_schema_filter_pattern: ::core::option::Option<::prost::alloc::string::String>,
202 ///
203 /// Specifies a filter pattern for tables to search for.
204 /// When no table_name_filter_pattern is provided, all tables matching other filters are searched.
205 /// In the pattern string, two special characters can be used to denote matching rules:
206 /// - "%" means to match any substring with 0 or more characters.
207 /// - "_" means to match any one character.
208 #[prost(string, optional, tag = "3")]
209 pub table_name_filter_pattern: ::core::option::Option<
210 ::prost::alloc::string::String,
211 >,
212 ///
213 /// Specifies a filter of table types which must match.
214 /// The table types depend on vendor/implementation. It is usually used to separate tables from views or system tables.
215 /// TABLE, VIEW, and SYSTEM TABLE are commonly supported.
216 #[prost(string, repeated, tag = "4")]
217 pub table_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
218 /// Specifies if the Arrow schema should be returned for found tables.
219 #[prost(bool, tag = "5")]
220 pub include_schema: bool,
221}
222///
223/// Represents a request to retrieve the list of table types on a Flight SQL enabled backend.
224/// The table types depend on vendor/implementation. It is usually used to separate tables from views or system tables.
225/// TABLE, VIEW, and SYSTEM TABLE are commonly supported.
226/// Used in the command member of FlightDescriptor for the following RPC calls:
227/// - GetSchema: return the Arrow schema of the query.
228/// - GetFlightInfo: execute the catalog metadata request.
229///
230/// The returned Arrow schema will be:
231/// <
232/// table_type: utf8 not null
233/// >
234/// The returned data should be ordered by table_type.
235#[allow(clippy::all)]
236#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
237pub struct CommandGetTableTypes {}
238///
239/// Represents a request to retrieve the primary keys of a table on a Flight SQL enabled backend.
240/// Used in the command member of FlightDescriptor for the following RPC calls:
241/// - GetSchema: return the Arrow schema of the query.
242/// - GetFlightInfo: execute the catalog metadata request.
243///
244/// The returned Arrow schema will be:
245/// <
246/// catalog_name: utf8,
247/// db_schema_name: utf8,
248/// table_name: utf8 not null,
249/// column_name: utf8 not null,
250/// key_name: utf8,
251/// key_sequence: int32 not null
252/// >
253/// The returned data should be ordered by catalog_name, db_schema_name, table_name, key_name, then key_sequence.
254#[allow(clippy::all)]
255#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
256pub struct CommandGetPrimaryKeys {
257 ///
258 /// Specifies the catalog to search for the table.
259 /// An empty string retrieves those without a catalog.
260 /// If omitted the catalog name should not be used to narrow the search.
261 #[prost(string, optional, tag = "1")]
262 pub catalog: ::core::option::Option<::prost::alloc::string::String>,
263 ///
264 /// Specifies the schema to search for the table.
265 /// An empty string retrieves those without a schema.
266 /// If omitted the schema name should not be used to narrow the search.
267 #[prost(string, optional, tag = "2")]
268 pub db_schema: ::core::option::Option<::prost::alloc::string::String>,
269 /// Specifies the table to get the primary keys for.
270 #[prost(string, tag = "3")]
271 pub table: ::prost::alloc::string::String,
272}
273///
274/// Represents a request to retrieve a description of the foreign key columns that reference the given table's
275/// primary key columns (the foreign keys exported by a table) of a table on a Flight SQL enabled backend.
276/// Used in the command member of FlightDescriptor for the following RPC calls:
277/// - GetSchema: return the Arrow schema of the query.
278/// - GetFlightInfo: execute the catalog metadata request.
279///
280/// The returned Arrow schema will be:
281/// <
282/// pk_catalog_name: utf8,
283/// pk_db_schema_name: utf8,
284/// pk_table_name: utf8 not null,
285/// pk_column_name: utf8 not null,
286/// fk_catalog_name: utf8,
287/// fk_db_schema_name: utf8,
288/// fk_table_name: utf8 not null,
289/// fk_column_name: utf8 not null,
290/// key_sequence: int32 not null,
291/// fk_key_name: utf8,
292/// pk_key_name: utf8,
293/// update_rule: uint8 not null,
294/// delete_rule: uint8 not null
295/// >
296/// The returned data should be ordered by fk_catalog_name, fk_db_schema_name, fk_table_name, fk_key_name, then key_sequence.
297/// update_rule and delete_rule returns a byte that is equivalent to actions declared on UpdateDeleteRules enum.
298#[allow(clippy::all)]
299#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
300pub struct CommandGetExportedKeys {
301 ///
302 /// Specifies the catalog to search for the foreign key table.
303 /// An empty string retrieves those without a catalog.
304 /// If omitted the catalog name should not be used to narrow the search.
305 #[prost(string, optional, tag = "1")]
306 pub catalog: ::core::option::Option<::prost::alloc::string::String>,
307 ///
308 /// Specifies the schema to search for the foreign key table.
309 /// An empty string retrieves those without a schema.
310 /// If omitted the schema name should not be used to narrow the search.
311 #[prost(string, optional, tag = "2")]
312 pub db_schema: ::core::option::Option<::prost::alloc::string::String>,
313 /// Specifies the foreign key table to get the foreign keys for.
314 #[prost(string, tag = "3")]
315 pub table: ::prost::alloc::string::String,
316}
317///
318/// Represents a request to retrieve the foreign keys of a table on a Flight SQL enabled backend.
319/// Used in the command member of FlightDescriptor for the following RPC calls:
320/// - GetSchema: return the Arrow schema of the query.
321/// - GetFlightInfo: execute the catalog metadata request.
322///
323/// The returned Arrow schema will be:
324/// <
325/// pk_catalog_name: utf8,
326/// pk_db_schema_name: utf8,
327/// pk_table_name: utf8 not null,
328/// pk_column_name: utf8 not null,
329/// fk_catalog_name: utf8,
330/// fk_db_schema_name: utf8,
331/// fk_table_name: utf8 not null,
332/// fk_column_name: utf8 not null,
333/// key_sequence: int32 not null,
334/// fk_key_name: utf8,
335/// pk_key_name: utf8,
336/// update_rule: uint8 not null,
337/// delete_rule: uint8 not null
338/// >
339/// The returned data should be ordered by pk_catalog_name, pk_db_schema_name, pk_table_name, pk_key_name, then key_sequence.
340/// update_rule and delete_rule returns a byte that is equivalent to actions:
341/// - 0 = CASCADE
342/// - 1 = RESTRICT
343/// - 2 = SET NULL
344/// - 3 = NO ACTION
345/// - 4 = SET DEFAULT
346#[allow(clippy::all)]
347#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
348pub struct CommandGetImportedKeys {
349 ///
350 /// Specifies the catalog to search for the primary key table.
351 /// An empty string retrieves those without a catalog.
352 /// If omitted the catalog name should not be used to narrow the search.
353 #[prost(string, optional, tag = "1")]
354 pub catalog: ::core::option::Option<::prost::alloc::string::String>,
355 ///
356 /// Specifies the schema to search for the primary key table.
357 /// An empty string retrieves those without a schema.
358 /// If omitted the schema name should not be used to narrow the search.
359 #[prost(string, optional, tag = "2")]
360 pub db_schema: ::core::option::Option<::prost::alloc::string::String>,
361 /// Specifies the primary key table to get the foreign keys for.
362 #[prost(string, tag = "3")]
363 pub table: ::prost::alloc::string::String,
364}
365///
366/// Represents a request to retrieve a description of the foreign key columns in the given foreign key table that
367/// reference the primary key or the columns representing a unique constraint of the parent table (could be the same
368/// or a different table) on a Flight SQL enabled backend.
369/// Used in the command member of FlightDescriptor for the following RPC calls:
370/// - GetSchema: return the Arrow schema of the query.
371/// - GetFlightInfo: execute the catalog metadata request.
372///
373/// The returned Arrow schema will be:
374/// <
375/// pk_catalog_name: utf8,
376/// pk_db_schema_name: utf8,
377/// pk_table_name: utf8 not null,
378/// pk_column_name: utf8 not null,
379/// fk_catalog_name: utf8,
380/// fk_db_schema_name: utf8,
381/// fk_table_name: utf8 not null,
382/// fk_column_name: utf8 not null,
383/// key_sequence: int32 not null,
384/// fk_key_name: utf8,
385/// pk_key_name: utf8,
386/// update_rule: uint8 not null,
387/// delete_rule: uint8 not null
388/// >
389/// The returned data should be ordered by pk_catalog_name, pk_db_schema_name, pk_table_name, pk_key_name, then key_sequence.
390/// update_rule and delete_rule returns a byte that is equivalent to actions:
391/// - 0 = CASCADE
392/// - 1 = RESTRICT
393/// - 2 = SET NULL
394/// - 3 = NO ACTION
395/// - 4 = SET DEFAULT
396#[allow(clippy::all)]
397#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
398pub struct CommandGetCrossReference {
399 /// *
400 /// The catalog name where the parent table is.
401 /// An empty string retrieves those without a catalog.
402 /// If omitted the catalog name should not be used to narrow the search.
403 #[prost(string, optional, tag = "1")]
404 pub pk_catalog: ::core::option::Option<::prost::alloc::string::String>,
405 /// *
406 /// The Schema name where the parent table is.
407 /// An empty string retrieves those without a schema.
408 /// If omitted the schema name should not be used to narrow the search.
409 #[prost(string, optional, tag = "2")]
410 pub pk_db_schema: ::core::option::Option<::prost::alloc::string::String>,
411 /// *
412 /// The parent table name. It cannot be null.
413 #[prost(string, tag = "3")]
414 pub pk_table: ::prost::alloc::string::String,
415 /// *
416 /// The catalog name where the foreign table is.
417 /// An empty string retrieves those without a catalog.
418 /// If omitted the catalog name should not be used to narrow the search.
419 #[prost(string, optional, tag = "4")]
420 pub fk_catalog: ::core::option::Option<::prost::alloc::string::String>,
421 /// *
422 /// The schema name where the foreign table is.
423 /// An empty string retrieves those without a schema.
424 /// If omitted the schema name should not be used to narrow the search.
425 #[prost(string, optional, tag = "5")]
426 pub fk_db_schema: ::core::option::Option<::prost::alloc::string::String>,
427 /// *
428 /// The foreign table name. It cannot be null.
429 #[prost(string, tag = "6")]
430 pub fk_table: ::prost::alloc::string::String,
431}
432///
433/// Request message for the "CreatePreparedStatement" action on a Flight SQL enabled backend.
434#[allow(clippy::all)]
435#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
436pub struct ActionCreatePreparedStatementRequest {
437 /// The valid SQL string to create a prepared statement for.
438 #[prost(string, tag = "1")]
439 pub query: ::prost::alloc::string::String,
440 /// Create/execute the prepared statement as part of this transaction (if
441 /// unset, executions of the prepared statement will be auto-committed).
442 #[prost(bytes = "bytes", optional, tag = "2")]
443 pub transaction_id: ::core::option::Option<::prost::bytes::Bytes>,
444}
445///
446/// An embedded message describing a Substrait plan to execute.
447#[allow(clippy::all)]
448#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
449pub struct SubstraitPlan {
450 /// The serialized substrait.Plan to create a prepared statement for.
451 /// XXX(ARROW-16902): this is bytes instead of an embedded message
452 /// because Protobuf does not really support one DLL using Protobuf
453 /// definitions from another DLL.
454 #[prost(bytes = "bytes", tag = "1")]
455 pub plan: ::prost::bytes::Bytes,
456 /// The Substrait release, e.g. "0.12.0". This information is not
457 /// tracked in the plan itself, so this is the only way for consumers
458 /// to potentially know if they can handle the plan.
459 #[prost(string, tag = "2")]
460 pub version: ::prost::alloc::string::String,
461}
462///
463/// Request message for the "CreatePreparedSubstraitPlan" action on a Flight SQL enabled backend.
464#[allow(clippy::all)]
465#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
466pub struct ActionCreatePreparedSubstraitPlanRequest {
467 /// The serialized substrait.Plan to create a prepared statement for.
468 #[prost(message, optional, tag = "1")]
469 pub plan: ::core::option::Option<SubstraitPlan>,
470 /// Create/execute the prepared statement as part of this transaction (if
471 /// unset, executions of the prepared statement will be auto-committed).
472 #[prost(bytes = "bytes", optional, tag = "2")]
473 pub transaction_id: ::core::option::Option<::prost::bytes::Bytes>,
474}
475///
476/// Wrap the result of a "CreatePreparedStatement" or "CreatePreparedSubstraitPlan" action.
477///
478/// The resultant PreparedStatement can be closed either:
479/// - Manually, through the "ClosePreparedStatement" action;
480/// - Automatically, by a server timeout.
481///
482/// The result should be wrapped in a google.protobuf.Any message.
483#[allow(clippy::all)]
484#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
485pub struct ActionCreatePreparedStatementResult {
486 /// Opaque handle for the prepared statement on the server.
487 #[prost(bytes = "bytes", tag = "1")]
488 pub prepared_statement_handle: ::prost::bytes::Bytes,
489 /// If a result set generating query was provided, dataset_schema contains the
490 /// schema of the result set. It should be an IPC-encapsulated Schema, as described in Schema.fbs.
491 /// For some queries, the schema of the results may depend on the schema of the parameters. The server
492 /// should provide its best guess as to the schema at this point. Clients must not assume that this
493 /// schema, if provided, will be accurate.
494 #[prost(bytes = "bytes", tag = "2")]
495 pub dataset_schema: ::prost::bytes::Bytes,
496 /// If the query provided contained parameters, parameter_schema contains the
497 /// schema of the expected parameters. It should be an IPC-encapsulated Schema, as described in Schema.fbs.
498 #[prost(bytes = "bytes", tag = "3")]
499 pub parameter_schema: ::prost::bytes::Bytes,
500}
501///
502/// Request message for the "ClosePreparedStatement" action on a Flight SQL enabled backend.
503/// Closes server resources associated with the prepared statement handle.
504#[allow(clippy::all)]
505#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
506pub struct ActionClosePreparedStatementRequest {
507 /// Opaque handle for the prepared statement on the server.
508 #[prost(bytes = "bytes", tag = "1")]
509 pub prepared_statement_handle: ::prost::bytes::Bytes,
510}
511///
512/// Request message for the "BeginTransaction" action.
513/// Begins a transaction.
514#[allow(clippy::all)]
515#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
516pub struct ActionBeginTransactionRequest {}
517///
518/// Request message for the "BeginSavepoint" action.
519/// Creates a savepoint within a transaction.
520///
521/// Only supported if FLIGHT_SQL_SERVER_TRANSACTION returns
522/// SQL_SUPPORTED_TRANSACTION_SAVEPOINT.
523#[allow(clippy::all)]
524#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
525pub struct ActionBeginSavepointRequest {
526 /// The transaction to which a savepoint belongs.
527 #[prost(bytes = "bytes", tag = "1")]
528 pub transaction_id: ::prost::bytes::Bytes,
529 /// Name for the savepoint.
530 #[prost(string, tag = "2")]
531 pub name: ::prost::alloc::string::String,
532}
533///
534/// The result of a "BeginTransaction" action.
535///
536/// The transaction can be manipulated with the "EndTransaction" action, or
537/// automatically via server timeout. If the transaction times out, then it is
538/// automatically rolled back.
539///
540/// The result should be wrapped in a google.protobuf.Any message.
541#[allow(clippy::all)]
542#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
543pub struct ActionBeginTransactionResult {
544 /// Opaque handle for the transaction on the server.
545 #[prost(bytes = "bytes", tag = "1")]
546 pub transaction_id: ::prost::bytes::Bytes,
547}
548///
549/// The result of a "BeginSavepoint" action.
550///
551/// The transaction can be manipulated with the "EndSavepoint" action.
552/// If the associated transaction is committed, rolled back, or times
553/// out, then the savepoint is also invalidated.
554///
555/// The result should be wrapped in a google.protobuf.Any message.
556#[allow(clippy::all)]
557#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
558pub struct ActionBeginSavepointResult {
559 /// Opaque handle for the savepoint on the server.
560 #[prost(bytes = "bytes", tag = "1")]
561 pub savepoint_id: ::prost::bytes::Bytes,
562}
563///
564/// Request message for the "EndTransaction" action.
565///
566/// Commit (COMMIT) or rollback (ROLLBACK) the transaction.
567///
568/// If the action completes successfully, the transaction handle is
569/// invalidated, as are all associated savepoints.
570#[allow(clippy::all)]
571#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
572pub struct ActionEndTransactionRequest {
573 /// Opaque handle for the transaction on the server.
574 #[prost(bytes = "bytes", tag = "1")]
575 pub transaction_id: ::prost::bytes::Bytes,
576 /// Whether to commit/rollback the given transaction.
577 #[prost(enumeration = "action_end_transaction_request::EndTransaction", tag = "2")]
578 pub action: i32,
579}
580/// Nested message and enum types in `ActionEndTransactionRequest`.
581pub mod action_end_transaction_request {
582 #[allow(clippy::all)]
583 #[derive(
584 Clone,
585 Copy,
586 Debug,
587 PartialEq,
588 Eq,
589 Hash,
590 PartialOrd,
591 Ord,
592 ::prost::Enumeration
593 )]
594 #[repr(i32)]
595 pub enum EndTransaction {
596 Unspecified = 0,
597 /// Commit the transaction.
598 Commit = 1,
599 /// Roll back the transaction.
600 Rollback = 2,
601 }
602 impl EndTransaction {
603 /// String value of the enum field names used in the ProtoBuf definition.
604 ///
605 /// The values are not transformed in any way and thus are considered stable
606 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
607 pub fn as_str_name(&self) -> &'static str {
608 match self {
609 Self::Unspecified => "END_TRANSACTION_UNSPECIFIED",
610 Self::Commit => "END_TRANSACTION_COMMIT",
611 Self::Rollback => "END_TRANSACTION_ROLLBACK",
612 }
613 }
614 /// Creates an enum from field names used in the ProtoBuf definition.
615 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
616 match value {
617 "END_TRANSACTION_UNSPECIFIED" => Some(Self::Unspecified),
618 "END_TRANSACTION_COMMIT" => Some(Self::Commit),
619 "END_TRANSACTION_ROLLBACK" => Some(Self::Rollback),
620 _ => None,
621 }
622 }
623 }
624}
625///
626/// Request message for the "EndSavepoint" action.
627///
628/// Release (RELEASE) the savepoint or rollback (ROLLBACK) to the
629/// savepoint.
630///
631/// Releasing a savepoint invalidates that savepoint. Rolling back to
632/// a savepoint does not invalidate the savepoint, but invalidates all
633/// savepoints created after the current savepoint.
634#[allow(clippy::all)]
635#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
636pub struct ActionEndSavepointRequest {
637 /// Opaque handle for the savepoint on the server.
638 #[prost(bytes = "bytes", tag = "1")]
639 pub savepoint_id: ::prost::bytes::Bytes,
640 /// Whether to rollback/release the given savepoint.
641 #[prost(enumeration = "action_end_savepoint_request::EndSavepoint", tag = "2")]
642 pub action: i32,
643}
644/// Nested message and enum types in `ActionEndSavepointRequest`.
645pub mod action_end_savepoint_request {
646 #[allow(clippy::all)]
647 #[derive(
648 Clone,
649 Copy,
650 Debug,
651 PartialEq,
652 Eq,
653 Hash,
654 PartialOrd,
655 Ord,
656 ::prost::Enumeration
657 )]
658 #[repr(i32)]
659 pub enum EndSavepoint {
660 Unspecified = 0,
661 /// Release the savepoint.
662 Release = 1,
663 /// Roll back to a savepoint.
664 Rollback = 2,
665 }
666 impl EndSavepoint {
667 /// String value of the enum field names used in the ProtoBuf definition.
668 ///
669 /// The values are not transformed in any way and thus are considered stable
670 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
671 pub fn as_str_name(&self) -> &'static str {
672 match self {
673 Self::Unspecified => "END_SAVEPOINT_UNSPECIFIED",
674 Self::Release => "END_SAVEPOINT_RELEASE",
675 Self::Rollback => "END_SAVEPOINT_ROLLBACK",
676 }
677 }
678 /// Creates an enum from field names used in the ProtoBuf definition.
679 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
680 match value {
681 "END_SAVEPOINT_UNSPECIFIED" => Some(Self::Unspecified),
682 "END_SAVEPOINT_RELEASE" => Some(Self::Release),
683 "END_SAVEPOINT_ROLLBACK" => Some(Self::Rollback),
684 _ => None,
685 }
686 }
687 }
688}
689///
690/// Represents a SQL query. Used in the command member of FlightDescriptor
691/// for the following RPC calls:
692/// - GetSchema: return the Arrow schema of the query.
693/// Fields on this schema may contain the following metadata:
694/// - ARROW:FLIGHT:SQL:CATALOG_NAME - Table's catalog name
695/// - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME - Database schema name
696/// - ARROW:FLIGHT:SQL:TABLE_NAME - Table name
697/// - ARROW:FLIGHT:SQL:TYPE_NAME - The data source-specific name for the data type of the column.
698/// - ARROW:FLIGHT:SQL:PRECISION - Column precision/size
699/// - ARROW:FLIGHT:SQL:SCALE - Column scale/decimal digits if applicable
700/// - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
701/// - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
702/// - ARROW:FLIGHT:SQL:IS_READ_ONLY - "1" indicates if the column is read only, "0" otherwise.
703/// - ARROW:FLIGHT:SQL:IS_SEARCHABLE - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
704/// - ARROW:FLIGHT:SQL:REMARKS - A comment describing the column. This field has been added after all others, clients should be prepared to find it missing.
705/// - GetFlightInfo: execute the query.
706#[allow(clippy::all)]
707#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
708pub struct CommandStatementQuery {
709 /// The SQL syntax.
710 #[prost(string, tag = "1")]
711 pub query: ::prost::alloc::string::String,
712 /// Include the query as part of this transaction (if unset, the query is auto-committed).
713 #[prost(bytes = "bytes", optional, tag = "2")]
714 pub transaction_id: ::core::option::Option<::prost::bytes::Bytes>,
715}
716///
717/// Represents a Substrait plan. Used in the command member of FlightDescriptor
718/// for the following RPC calls:
719/// - GetSchema: return the Arrow schema of the query.
720/// Fields on this schema may contain the following metadata:
721/// - ARROW:FLIGHT:SQL:CATALOG_NAME - Table's catalog name
722/// - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME - Database schema name
723/// - ARROW:FLIGHT:SQL:TABLE_NAME - Table name
724/// - ARROW:FLIGHT:SQL:TYPE_NAME - The data source-specific name for the data type of the column.
725/// - ARROW:FLIGHT:SQL:PRECISION - Column precision/size
726/// - ARROW:FLIGHT:SQL:SCALE - Column scale/decimal digits if applicable
727/// - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
728/// - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
729/// - ARROW:FLIGHT:SQL:IS_READ_ONLY - "1" indicates if the column is read only, "0" otherwise.
730/// - ARROW:FLIGHT:SQL:IS_SEARCHABLE - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
731/// - ARROW:FLIGHT:SQL:REMARKS - A comment describing the column. This field has been added after all others, clients should be prepared to find it missing.
732/// - GetFlightInfo: execute the query.
733/// - DoPut: execute the query.
734#[allow(clippy::all)]
735#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
736pub struct CommandStatementSubstraitPlan {
737 /// A serialized substrait.Plan
738 #[prost(message, optional, tag = "1")]
739 pub plan: ::core::option::Option<SubstraitPlan>,
740 /// Include the query as part of this transaction (if unset, the query is auto-committed).
741 #[prost(bytes = "bytes", optional, tag = "2")]
742 pub transaction_id: ::core::option::Option<::prost::bytes::Bytes>,
743}
744/// *
745/// Represents a ticket resulting from GetFlightInfo with a CommandStatementQuery.
746/// This should be used only once and treated as an opaque value, that is, clients should not attempt to parse this.
747#[allow(clippy::all)]
748#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
749pub struct TicketStatementQuery {
750 /// Unique identifier for the instance of the statement to execute.
751 #[prost(bytes = "bytes", tag = "1")]
752 pub statement_handle: ::prost::bytes::Bytes,
753}
754///
755/// Represents an instance of executing a prepared statement. Used in the command member of FlightDescriptor for
756/// the following RPC calls:
757/// - GetSchema: return the Arrow schema of the query.
758/// Fields on this schema may contain the following metadata:
759/// - ARROW:FLIGHT:SQL:CATALOG_NAME - Table's catalog name
760/// - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME - Database schema name
761/// - ARROW:FLIGHT:SQL:TABLE_NAME - Table name
762/// - ARROW:FLIGHT:SQL:TYPE_NAME - The data source-specific name for the data type of the column.
763/// - ARROW:FLIGHT:SQL:PRECISION - Column precision/size
764/// - ARROW:FLIGHT:SQL:SCALE - Column scale/decimal digits if applicable
765/// - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
766/// - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
767/// - ARROW:FLIGHT:SQL:IS_READ_ONLY - "1" indicates if the column is read only, "0" otherwise.
768/// - ARROW:FLIGHT:SQL:IS_SEARCHABLE - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
769/// - ARROW:FLIGHT:SQL:REMARKS - A comment describing the column. This field has been added after all others, clients should be prepared to find it missing.
770///
771/// If the schema is retrieved after parameter values have been bound with DoPut, then the server should account
772/// for the parameters when determining the schema.
773/// - DoPut: bind parameter values. All of the bound parameter sets will be executed as a single atomic execution.
774/// - GetFlightInfo: execute the prepared statement instance.
775#[allow(clippy::all)]
776#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
777pub struct CommandPreparedStatementQuery {
778 /// Opaque handle for the prepared statement on the server.
779 #[prost(bytes = "bytes", tag = "1")]
780 pub prepared_statement_handle: ::prost::bytes::Bytes,
781}
782///
783/// Represents a SQL update query. Used in the command member of FlightDescriptor
784/// for the RPC call DoPut to cause the server to execute the included SQL update.
785#[allow(clippy::all)]
786#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
787pub struct CommandStatementUpdate {
788 /// The SQL syntax.
789 #[prost(string, tag = "1")]
790 pub query: ::prost::alloc::string::String,
791 /// Include the query as part of this transaction (if unset, the query is auto-committed).
792 #[prost(bytes = "bytes", optional, tag = "2")]
793 pub transaction_id: ::core::option::Option<::prost::bytes::Bytes>,
794}
795///
796/// Represents a SQL update query. Used in the command member of FlightDescriptor
797/// for the RPC call DoPut to cause the server to execute the included
798/// prepared statement handle as an update.
799#[allow(clippy::all)]
800#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
801pub struct CommandPreparedStatementUpdate {
802 /// Opaque handle for the prepared statement on the server.
803 #[prost(bytes = "bytes", tag = "1")]
804 pub prepared_statement_handle: ::prost::bytes::Bytes,
805}
806///
807/// Represents a bulk ingestion request. Used in the command member of FlightDescriptor
808/// for the RPC call DoPut to cause the server load the contents of the stream's
809/// FlightData into the target destination.
810#[allow(clippy::all)]
811#[derive(Clone, PartialEq, ::prost::Message)]
812pub struct CommandStatementIngest {
813 /// The behavior for handling the table definition.
814 #[prost(message, optional, tag = "1")]
815 pub table_definition_options: ::core::option::Option<
816 command_statement_ingest::TableDefinitionOptions,
817 >,
818 /// The table to load data into.
819 #[prost(string, tag = "2")]
820 pub table: ::prost::alloc::string::String,
821 /// The db_schema of the destination table to load data into. If unset, a backend-specific default may be used.
822 #[prost(string, optional, tag = "3")]
823 pub schema: ::core::option::Option<::prost::alloc::string::String>,
824 /// The catalog of the destination table to load data into. If unset, a backend-specific default may be used.
825 #[prost(string, optional, tag = "4")]
826 pub catalog: ::core::option::Option<::prost::alloc::string::String>,
827 ///
828 /// Store ingested data in a temporary table.
829 /// The effect of setting temporary is to place the table in a backend-defined namespace, and to drop the table at the end of the session.
830 /// The namespacing may make use of a backend-specific schema and/or catalog.
831 /// The server should return an error if an explicit choice of schema or catalog is incompatible with the server's namespacing decision.
832 #[prost(bool, tag = "5")]
833 pub temporary: bool,
834 /// Perform the ingestion as part of this transaction. If specified, results should not be committed in the event of an error/cancellation.
835 #[prost(bytes = "bytes", optional, tag = "6")]
836 pub transaction_id: ::core::option::Option<::prost::bytes::Bytes>,
837 /// Backend-specific options.
838 #[prost(map = "string, string", tag = "1000")]
839 pub options: ::std::collections::HashMap<
840 ::prost::alloc::string::String,
841 ::prost::alloc::string::String,
842 >,
843}
844/// Nested message and enum types in `CommandStatementIngest`.
845pub mod command_statement_ingest {
846 /// Options for table definition behavior
847 #[allow(clippy::all)]
848 #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
849 pub struct TableDefinitionOptions {
850 #[prost(
851 enumeration = "table_definition_options::TableNotExistOption",
852 tag = "1"
853 )]
854 pub if_not_exist: i32,
855 #[prost(enumeration = "table_definition_options::TableExistsOption", tag = "2")]
856 pub if_exists: i32,
857 }
858 /// Nested message and enum types in `TableDefinitionOptions`.
859 pub mod table_definition_options {
860 /// The action to take if the target table does not exist
861 #[allow(clippy::all)]
862 #[derive(
863 Clone,
864 Copy,
865 Debug,
866 PartialEq,
867 Eq,
868 Hash,
869 PartialOrd,
870 Ord,
871 ::prost::Enumeration
872 )]
873 #[repr(i32)]
874 pub enum TableNotExistOption {
875 /// Do not use. Servers should error if this is specified by a client.
876 Unspecified = 0,
877 /// Create the table if it does not exist
878 Create = 1,
879 /// Fail if the table does not exist
880 Fail = 2,
881 }
882 impl TableNotExistOption {
883 /// String value of the enum field names used in the ProtoBuf definition.
884 ///
885 /// The values are not transformed in any way and thus are considered stable
886 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
887 pub fn as_str_name(&self) -> &'static str {
888 match self {
889 Self::Unspecified => "TABLE_NOT_EXIST_OPTION_UNSPECIFIED",
890 Self::Create => "TABLE_NOT_EXIST_OPTION_CREATE",
891 Self::Fail => "TABLE_NOT_EXIST_OPTION_FAIL",
892 }
893 }
894 /// Creates an enum from field names used in the ProtoBuf definition.
895 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
896 match value {
897 "TABLE_NOT_EXIST_OPTION_UNSPECIFIED" => Some(Self::Unspecified),
898 "TABLE_NOT_EXIST_OPTION_CREATE" => Some(Self::Create),
899 "TABLE_NOT_EXIST_OPTION_FAIL" => Some(Self::Fail),
900 _ => None,
901 }
902 }
903 }
904 /// The action to take if the target table already exists
905 #[allow(clippy::all)]
906 #[derive(
907 Clone,
908 Copy,
909 Debug,
910 PartialEq,
911 Eq,
912 Hash,
913 PartialOrd,
914 Ord,
915 ::prost::Enumeration
916 )]
917 #[repr(i32)]
918 pub enum TableExistsOption {
919 /// Do not use. Servers should error if this is specified by a client.
920 Unspecified = 0,
921 /// Fail if the table already exists
922 Fail = 1,
923 /// Append to the table if it already exists
924 Append = 2,
925 /// Drop and recreate the table if it already exists
926 Replace = 3,
927 }
928 impl TableExistsOption {
929 /// String value of the enum field names used in the ProtoBuf definition.
930 ///
931 /// The values are not transformed in any way and thus are considered stable
932 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
933 pub fn as_str_name(&self) -> &'static str {
934 match self {
935 Self::Unspecified => "TABLE_EXISTS_OPTION_UNSPECIFIED",
936 Self::Fail => "TABLE_EXISTS_OPTION_FAIL",
937 Self::Append => "TABLE_EXISTS_OPTION_APPEND",
938 Self::Replace => "TABLE_EXISTS_OPTION_REPLACE",
939 }
940 }
941 /// Creates an enum from field names used in the ProtoBuf definition.
942 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
943 match value {
944 "TABLE_EXISTS_OPTION_UNSPECIFIED" => Some(Self::Unspecified),
945 "TABLE_EXISTS_OPTION_FAIL" => Some(Self::Fail),
946 "TABLE_EXISTS_OPTION_APPEND" => Some(Self::Append),
947 "TABLE_EXISTS_OPTION_REPLACE" => Some(Self::Replace),
948 _ => None,
949 }
950 }
951 }
952 }
953}
954///
955/// Returned from the RPC call DoPut when a CommandStatementUpdate,
956/// CommandPreparedStatementUpdate, or CommandStatementIngest was
957/// in the request, containing results from the update.
958#[allow(clippy::all)]
959#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
960pub struct DoPutUpdateResult {
961 /// The number of records updated. A return value of -1 represents
962 /// an unknown updated record count.
963 #[prost(int64, tag = "1")]
964 pub record_count: i64,
965}
966/// An *optional* response returned when `DoPut` is called with `CommandPreparedStatementQuery`.
967///
968/// *Note on legacy behavior*: previous versions of the protocol did not return any result for
969/// this command, and that behavior should still be supported by clients. In that case, the client
970/// can continue as though the fields in this message were not provided or set to sensible default values.
971#[allow(clippy::all)]
972#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
973pub struct DoPutPreparedStatementResult {
974 /// Represents a (potentially updated) opaque handle for the prepared statement on the server.
975 /// Because the handle could potentially be updated, any previous handles for this prepared
976 /// statement should be considered invalid, and all subsequent requests for this prepared
977 /// statement must use this new handle.
978 /// The updated handle allows implementing query parameters with stateless services.
979 ///
980 /// When an updated handle is not provided by the server, clients should continue
981 /// using the previous handle provided by `ActionCreatePreparedStatementResult`.
982 #[prost(bytes = "bytes", optional, tag = "1")]
983 pub prepared_statement_handle: ::core::option::Option<::prost::bytes::Bytes>,
984}
985///
986/// Request message for the "CancelQuery" action.
987///
988/// Explicitly cancel a running query.
989///
990/// This lets a single client explicitly cancel work, no matter how many clients
991/// are involved/whether the query is distributed or not, given server support.
992/// The transaction/statement is not rolled back; it is the application's job to
993/// commit or rollback as appropriate. This only indicates the client no longer
994/// wishes to read the remainder of the query results or continue submitting
995/// data.
996///
997/// This command is idempotent.
998///
999/// This command is deprecated since 13.0.0. Use the "CancelFlightInfo"
1000/// action with DoAction instead.
1001#[allow(clippy::all)]
1002#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1003pub struct ActionCancelQueryRequest {
1004 /// The result of the GetFlightInfo RPC that initiated the query.
1005 /// XXX(ARROW-16902): this must be a serialized FlightInfo, but is
1006 /// rendered as bytes because Protobuf does not really support one
1007 /// DLL using Protobuf definitions from another DLL.
1008 #[prost(bytes = "bytes", tag = "1")]
1009 pub info: ::prost::bytes::Bytes,
1010}
1011///
1012/// The result of cancelling a query.
1013///
1014/// The result should be wrapped in a google.protobuf.Any message.
1015///
1016/// This command is deprecated since 13.0.0. Use the "CancelFlightInfo"
1017/// action with DoAction instead.
1018#[allow(clippy::all)]
1019#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1020pub struct ActionCancelQueryResult {
1021 #[prost(enumeration = "action_cancel_query_result::CancelResult", tag = "1")]
1022 pub result: i32,
1023}
1024/// Nested message and enum types in `ActionCancelQueryResult`.
1025pub mod action_cancel_query_result {
1026 #[allow(clippy::all)]
1027 #[derive(
1028 Clone,
1029 Copy,
1030 Debug,
1031 PartialEq,
1032 Eq,
1033 Hash,
1034 PartialOrd,
1035 Ord,
1036 ::prost::Enumeration
1037 )]
1038 #[repr(i32)]
1039 pub enum CancelResult {
1040 /// The cancellation status is unknown. Servers should avoid using
1041 /// this value (send a NOT_FOUND error if the requested query is
1042 /// not known). Clients can retry the request.
1043 Unspecified = 0,
1044 /// The cancellation request is complete. Subsequent requests with
1045 /// the same payload may return CANCELLED or a NOT_FOUND error.
1046 Cancelled = 1,
1047 /// The cancellation request is in progress. The client may retry
1048 /// the cancellation request.
1049 Cancelling = 2,
1050 /// The query is not cancellable. The client should not retry the
1051 /// cancellation request.
1052 NotCancellable = 3,
1053 }
1054 impl CancelResult {
1055 /// String value of the enum field names used in the ProtoBuf definition.
1056 ///
1057 /// The values are not transformed in any way and thus are considered stable
1058 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1059 pub fn as_str_name(&self) -> &'static str {
1060 match self {
1061 Self::Unspecified => "CANCEL_RESULT_UNSPECIFIED",
1062 Self::Cancelled => "CANCEL_RESULT_CANCELLED",
1063 Self::Cancelling => "CANCEL_RESULT_CANCELLING",
1064 Self::NotCancellable => "CANCEL_RESULT_NOT_CANCELLABLE",
1065 }
1066 }
1067 /// Creates an enum from field names used in the ProtoBuf definition.
1068 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1069 match value {
1070 "CANCEL_RESULT_UNSPECIFIED" => Some(Self::Unspecified),
1071 "CANCEL_RESULT_CANCELLED" => Some(Self::Cancelled),
1072 "CANCEL_RESULT_CANCELLING" => Some(Self::Cancelling),
1073 "CANCEL_RESULT_NOT_CANCELLABLE" => Some(Self::NotCancellable),
1074 _ => None,
1075 }
1076 }
1077 }
1078}
1079/// Options for CommandGetSqlInfo.
1080#[allow(clippy::all)]
1081#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1082#[repr(i32)]
1083pub enum SqlInfo {
1084 /// Retrieves a UTF-8 string with the name of the Flight SQL Server.
1085 FlightSqlServerName = 0,
1086 /// Retrieves a UTF-8 string with the native version of the Flight SQL Server.
1087 FlightSqlServerVersion = 1,
1088 /// Retrieves a UTF-8 string with the Arrow format version of the Flight SQL Server.
1089 FlightSqlServerArrowVersion = 2,
1090 ///
1091 /// Retrieves a boolean value indicating whether the Flight SQL Server is read only.
1092 ///
1093 /// Returns:
1094 /// - false: if read-write
1095 /// - true: if read only
1096 FlightSqlServerReadOnly = 3,
1097 ///
1098 /// Retrieves a boolean value indicating whether the Flight SQL Server supports executing
1099 /// SQL queries.
1100 ///
1101 /// Note that the absence of this info (as opposed to a false value) does not necessarily
1102 /// mean that SQL is not supported, as this property was not originally defined.
1103 FlightSqlServerSql = 4,
1104 ///
1105 /// Retrieves a boolean value indicating whether the Flight SQL Server supports executing
1106 /// Substrait plans.
1107 FlightSqlServerSubstrait = 5,
1108 ///
1109 /// Retrieves a string value indicating the minimum supported Substrait version, or null
1110 /// if Substrait is not supported.
1111 FlightSqlServerSubstraitMinVersion = 6,
1112 ///
1113 /// Retrieves a string value indicating the maximum supported Substrait version, or null
1114 /// if Substrait is not supported.
1115 FlightSqlServerSubstraitMaxVersion = 7,
1116 ///
1117 /// Retrieves an int32 indicating whether the Flight SQL Server supports the
1118 /// BeginTransaction/EndTransaction/BeginSavepoint/EndSavepoint actions.
1119 ///
1120 /// Even if this is not supported, the database may still support explicit "BEGIN
1121 /// TRANSACTION"/"COMMIT" SQL statements (see SQL_TRANSACTIONS_SUPPORTED); this property
1122 /// is only about whether the server implements the Flight SQL API endpoints.
1123 ///
1124 /// The possible values are listed in `SqlSupportedTransaction`.
1125 FlightSqlServerTransaction = 8,
1126 ///
1127 /// Retrieves a boolean value indicating whether the Flight SQL Server supports explicit
1128 /// query cancellation (the CancelQuery action).
1129 FlightSqlServerCancel = 9,
1130 ///
1131 /// Retrieves a boolean value indicating whether the Flight SQL Server supports executing
1132 /// bulk ingestion.
1133 FlightSqlServerBulkIngestion = 10,
1134 ///
1135 /// Retrieves a boolean value indicating whether transactions are supported for bulk ingestion. If not, invoking
1136 /// the method commit in the context of a bulk ingestion is a noop, and the isolation level is
1137 /// `arrow.flight.protocol.sql.SqlTransactionIsolationLevel.TRANSACTION_NONE`.
1138 ///
1139 /// Returns:
1140 /// - false: if bulk ingestion transactions are unsupported;
1141 /// - true: if bulk ingestion transactions are supported.
1142 FlightSqlServerIngestTransactionsSupported = 11,
1143 ///
1144 /// Retrieves an int32 indicating the timeout (in milliseconds) for prepared statement handles.
1145 ///
1146 /// If 0, there is no timeout. Servers should reset the timeout when the handle is used in a command.
1147 FlightSqlServerStatementTimeout = 100,
1148 ///
1149 /// Retrieves an int32 indicating the timeout (in milliseconds) for transactions, since transactions are not tied to a connection.
1150 ///
1151 /// If 0, there is no timeout. Servers should reset the timeout when the handle is used in a command.
1152 FlightSqlServerTransactionTimeout = 101,
1153 ///
1154 /// Retrieves a boolean value indicating whether the Flight SQL Server supports CREATE and DROP of catalogs.
1155 ///
1156 /// Returns:
1157 /// - false: if it doesn't support CREATE and DROP of catalogs.
1158 /// - true: if it supports CREATE and DROP of catalogs.
1159 SqlDdlCatalog = 500,
1160 ///
1161 /// Retrieves a boolean value indicating whether the Flight SQL Server supports CREATE and DROP of schemas.
1162 ///
1163 /// Returns:
1164 /// - false: if it doesn't support CREATE and DROP of schemas.
1165 /// - true: if it supports CREATE and DROP of schemas.
1166 SqlDdlSchema = 501,
1167 ///
1168 /// Indicates whether the Flight SQL Server supports CREATE and DROP of tables.
1169 ///
1170 /// Returns:
1171 /// - false: if it doesn't support CREATE and DROP of tables.
1172 /// - true: if it supports CREATE and DROP of tables.
1173 SqlDdlTable = 502,
1174 ///
1175 /// Retrieves an int32 ordinal representing the case sensitivity of catalog, table, schema and table names.
1176 ///
1177 /// The possible values are listed in `arrow.flight.protocol.sql.SqlSupportedCaseSensitivity`.
1178 SqlIdentifierCase = 503,
1179 /// Retrieves a UTF-8 string with the supported character(s) used to surround a delimited identifier.
1180 SqlIdentifierQuoteChar = 504,
1181 ///
1182 /// Retrieves an int32 describing the case sensitivity of quoted identifiers.
1183 ///
1184 /// The possible values are listed in `arrow.flight.protocol.sql.SqlSupportedCaseSensitivity`.
1185 SqlQuotedIdentifierCase = 505,
1186 ///
1187 /// Retrieves a boolean value indicating whether all tables are selectable.
1188 ///
1189 /// Returns:
1190 /// - false: if not all tables are selectable or if none are;
1191 /// - true: if all tables are selectable.
1192 SqlAllTablesAreSelectable = 506,
1193 ///
1194 /// Retrieves the null ordering.
1195 ///
1196 /// Returns an int32 ordinal for the null ordering being used, as described in
1197 /// `arrow.flight.protocol.sql.SqlNullOrdering`.
1198 SqlNullOrdering = 507,
1199 /// Retrieves a UTF-8 string list with values of the supported keywords.
1200 SqlKeywords = 508,
1201 /// Retrieves a UTF-8 string list with values of the supported numeric functions.
1202 SqlNumericFunctions = 509,
1203 /// Retrieves a UTF-8 string list with values of the supported string functions.
1204 SqlStringFunctions = 510,
1205 /// Retrieves a UTF-8 string list with values of the supported system functions.
1206 SqlSystemFunctions = 511,
1207 /// Retrieves a UTF-8 string list with values of the supported datetime functions.
1208 SqlDatetimeFunctions = 512,
1209 ///
1210 /// Retrieves the UTF-8 string that can be used to escape wildcard characters.
1211 /// This is the string that can be used to escape '_' or '%' in the catalog search parameters that are a pattern
1212 /// (and therefore use one of the wildcard characters).
1213 /// The '_' character represents any single character; the '%' character represents any sequence of zero or more
1214 /// characters.
1215 SqlSearchStringEscape = 513,
1216 ///
1217 /// Retrieves a UTF-8 string with all the "extra" characters that can be used in unquoted identifier names
1218 /// (those beyond a-z, A-Z, 0-9 and _).
1219 SqlExtraNameCharacters = 514,
1220 ///
1221 /// Retrieves a boolean value indicating whether column aliasing is supported.
1222 /// If so, the SQL AS clause can be used to provide names for computed columns or to provide alias names for columns
1223 /// as required.
1224 ///
1225 /// Returns:
1226 /// - false: if column aliasing is unsupported;
1227 /// - true: if column aliasing is supported.
1228 SqlSupportsColumnAliasing = 515,
1229 ///
1230 /// Retrieves a boolean value indicating whether concatenations between null and non-null values being
1231 /// null are supported.
1232 ///
1233 /// Returns:
1234 /// - false: if concatenations between null and non-null values being null are unsupported;
1235 /// - true: if concatenations between null and non-null values being null are supported.
1236 SqlNullPlusNullIsNull = 516,
1237 ///
1238 /// Retrieves a map where the key is the type to convert from and the value is a list with the types to convert to,
1239 /// indicating the supported conversions. Each key and each item on the list value is a value to a predefined type on
1240 /// SqlSupportsConvert enum.
1241 /// The returned map will be: map<int32, list<int32>>
1242 SqlSupportsConvert = 517,
1243 ///
1244 /// Retrieves a boolean value indicating whether, when table correlation names are supported,
1245 /// they are restricted to being different from the names of the tables.
1246 ///
1247 /// Returns:
1248 /// - false: if table correlation names are unsupported;
1249 /// - true: if table correlation names are supported.
1250 SqlSupportsTableCorrelationNames = 518,
1251 ///
1252 /// Retrieves a boolean value indicating whether, when table correlation names are supported,
1253 /// they are restricted to being different from the names of the tables.
1254 ///
1255 /// Returns:
1256 /// - false: if different table correlation names are unsupported;
1257 /// - true: if different table correlation names are supported
1258 SqlSupportsDifferentTableCorrelationNames = 519,
1259 ///
1260 /// Retrieves a boolean value indicating whether expressions in ORDER BY lists are supported.
1261 ///
1262 /// Returns:
1263 /// - false: if expressions in ORDER BY are unsupported;
1264 /// - true: if expressions in ORDER BY are supported;
1265 SqlSupportsExpressionsInOrderBy = 520,
1266 ///
1267 /// Retrieves a boolean value indicating whether using a column that is not in the SELECT statement in a GROUP BY
1268 /// clause is supported.
1269 ///
1270 /// Returns:
1271 /// - false: if using a column that is not in the SELECT statement in a GROUP BY clause is unsupported;
1272 /// - true: if using a column that is not in the SELECT statement in a GROUP BY clause is supported.
1273 SqlSupportsOrderByUnrelated = 521,
1274 ///
1275 /// Retrieves the supported GROUP BY commands;
1276 ///
1277 /// Returns an int32 bitmask value representing the supported commands.
1278 /// The returned bitmask should be parsed in order to retrieve the supported commands.
1279 ///
1280 /// For instance:
1281 /// - return 0 (\b0) => \[\] (GROUP BY is unsupported);
1282 /// - return 1 (\b1) => \[SQL_GROUP_BY_UNRELATED\];
1283 /// - return 2 (\b10) => \[SQL_GROUP_BY_BEYOND_SELECT\];
1284 /// - return 3 (\b11) => \[SQL_GROUP_BY_UNRELATED, SQL_GROUP_BY_BEYOND_SELECT\].
1285 /// Valid GROUP BY types are described under `arrow.flight.protocol.sql.SqlSupportedGroupBy`.
1286 SqlSupportedGroupBy = 522,
1287 ///
1288 /// Retrieves a boolean value indicating whether specifying a LIKE escape clause is supported.
1289 ///
1290 /// Returns:
1291 /// - false: if specifying a LIKE escape clause is unsupported;
1292 /// - true: if specifying a LIKE escape clause is supported.
1293 SqlSupportsLikeEscapeClause = 523,
1294 ///
1295 /// Retrieves a boolean value indicating whether columns may be defined as non-nullable.
1296 ///
1297 /// Returns:
1298 /// - false: if columns cannot be defined as non-nullable;
1299 /// - true: if columns may be defined as non-nullable.
1300 SqlSupportsNonNullableColumns = 524,
1301 ///
1302 /// Retrieves the supported SQL grammar level as per the ODBC specification.
1303 ///
1304 /// Returns an int32 bitmask value representing the supported SQL grammar level.
1305 /// The returned bitmask should be parsed in order to retrieve the supported grammar levels.
1306 ///
1307 /// For instance:
1308 /// - return 0 (\b0) => \[\] (SQL grammar is unsupported);
1309 /// - return 1 (\b1) => \[SQL_MINIMUM_GRAMMAR\];
1310 /// - return 2 (\b10) => \[SQL_CORE_GRAMMAR\];
1311 /// - return 3 (\b11) => \[SQL_MINIMUM_GRAMMAR, SQL_CORE_GRAMMAR\];
1312 /// - return 4 (\b100) => \[SQL_EXTENDED_GRAMMAR\];
1313 /// - return 5 (\b101) => \[SQL_MINIMUM_GRAMMAR, SQL_EXTENDED_GRAMMAR\];
1314 /// - return 6 (\b110) => \[SQL_CORE_GRAMMAR, SQL_EXTENDED_GRAMMAR\];
1315 /// - return 7 (\b111) => \[SQL_MINIMUM_GRAMMAR, SQL_CORE_GRAMMAR, SQL_EXTENDED_GRAMMAR\].
1316 /// Valid SQL grammar levels are described under `arrow.flight.protocol.sql.SupportedSqlGrammar`.
1317 SqlSupportedGrammar = 525,
1318 ///
1319 /// Retrieves the supported ANSI92 SQL grammar level.
1320 ///
1321 /// Returns an int32 bitmask value representing the supported ANSI92 SQL grammar level.
1322 /// The returned bitmask should be parsed in order to retrieve the supported commands.
1323 ///
1324 /// For instance:
1325 /// - return 0 (\b0) => \[\] (ANSI92 SQL grammar is unsupported);
1326 /// - return 1 (\b1) => \[ANSI92_ENTRY_SQL\];
1327 /// - return 2 (\b10) => \[ANSI92_INTERMEDIATE_SQL\];
1328 /// - return 3 (\b11) => \[ANSI92_ENTRY_SQL, ANSI92_INTERMEDIATE_SQL\];
1329 /// - return 4 (\b100) => \[ANSI92_FULL_SQL\];
1330 /// - return 5 (\b101) => \[ANSI92_ENTRY_SQL, ANSI92_FULL_SQL\];
1331 /// - return 6 (\b110) => \[ANSI92_INTERMEDIATE_SQL, ANSI92_FULL_SQL\];
1332 /// - return 7 (\b111) => \[ANSI92_ENTRY_SQL, ANSI92_INTERMEDIATE_SQL, ANSI92_FULL_SQL\].
1333 /// Valid ANSI92 SQL grammar levels are described under `arrow.flight.protocol.sql.SupportedAnsi92SqlGrammarLevel`.
1334 SqlAnsi92SupportedLevel = 526,
1335 ///
1336 /// Retrieves a boolean value indicating whether the SQL Integrity Enhancement Facility is supported.
1337 ///
1338 /// Returns:
1339 /// - false: if the SQL Integrity Enhancement Facility is unsupported;
1340 /// - true: if the SQL Integrity Enhancement Facility is supported.
1341 SqlSupportsIntegrityEnhancementFacility = 527,
1342 ///
1343 /// Retrieves the support level for SQL OUTER JOINs.
1344 ///
1345 /// Returns an int32 ordinal for the SQL ordering being used, as described in
1346 /// `arrow.flight.protocol.sql.SqlOuterJoinsSupportLevel`.
1347 SqlOuterJoinsSupportLevel = 528,
1348 /// Retrieves a UTF-8 string with the preferred term for "schema".
1349 SqlSchemaTerm = 529,
1350 /// Retrieves a UTF-8 string with the preferred term for "procedure".
1351 SqlProcedureTerm = 530,
1352 ///
1353 /// Retrieves a UTF-8 string with the preferred term for "catalog".
1354 /// If an empty string is returned it is assumed that the server does NOT support catalogs.
1355 SqlCatalogTerm = 531,
1356 ///
1357 /// Retrieves a boolean value indicating whether a catalog appears at the start of a fully qualified table name.
1358 ///
1359 /// - false: if a catalog does not appear at the start of a fully qualified table name;
1360 /// - true: if a catalog appears at the start of a fully qualified table name.
1361 SqlCatalogAtStart = 532,
1362 ///
1363 /// Retrieves the supported actions for a SQL schema.
1364 ///
1365 /// Returns an int32 bitmask value representing the supported actions for a SQL schema.
1366 /// The returned bitmask should be parsed in order to retrieve the supported actions for a SQL schema.
1367 ///
1368 /// For instance:
1369 /// - return 0 (\b0) => \[\] (no supported actions for SQL schema);
1370 /// - return 1 (\b1) => \[SQL_ELEMENT_IN_PROCEDURE_CALLS\];
1371 /// - return 2 (\b10) => \[SQL_ELEMENT_IN_INDEX_DEFINITIONS\];
1372 /// - return 3 (\b11) => \[SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS\];
1373 /// - return 4 (\b100) => \[SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\];
1374 /// - return 5 (\b101) => \[SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\];
1375 /// - return 6 (\b110) => \[SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\];
1376 /// - return 7 (\b111) => \[SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\].
1377 /// Valid actions for a SQL schema are described under `arrow.flight.protocol.sql.SqlSupportedElementActions`.
1378 SqlSchemasSupportedActions = 533,
1379 ///
1380 /// Retrieves the supported actions for a SQL catalog.
1381 ///
1382 /// Returns an int32 bitmask value representing the supported actions for a SQL catalog.
1383 /// The returned bitmask should be parsed in order to retrieve the supported actions for a SQL catalog.
1384 ///
1385 /// For instance:
1386 /// - return 0 (\b0) => \[\] (no supported actions for SQL catalog);
1387 /// - return 1 (\b1) => \[SQL_ELEMENT_IN_PROCEDURE_CALLS\];
1388 /// - return 2 (\b10) => \[SQL_ELEMENT_IN_INDEX_DEFINITIONS\];
1389 /// - return 3 (\b11) => \[SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS\];
1390 /// - return 4 (\b100) => \[SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\];
1391 /// - return 5 (\b101) => \[SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\];
1392 /// - return 6 (\b110) => \[SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\];
1393 /// - return 7 (\b111) => \[SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\].
1394 /// Valid actions for a SQL catalog are described under `arrow.flight.protocol.sql.SqlSupportedElementActions`.
1395 SqlCatalogsSupportedActions = 534,
1396 ///
1397 /// Retrieves the supported SQL positioned commands.
1398 ///
1399 /// Returns an int32 bitmask value representing the supported SQL positioned commands.
1400 /// The returned bitmask should be parsed in order to retrieve the supported SQL positioned commands.
1401 ///
1402 /// For instance:
1403 /// - return 0 (\b0) => \[\] (no supported SQL positioned commands);
1404 /// - return 1 (\b1) => \[SQL_POSITIONED_DELETE\];
1405 /// - return 2 (\b10) => \[SQL_POSITIONED_UPDATE\];
1406 /// - return 3 (\b11) => \[SQL_POSITIONED_DELETE, SQL_POSITIONED_UPDATE\].
1407 /// Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlSupportedPositionedCommands`.
1408 SqlSupportedPositionedCommands = 535,
1409 ///
1410 /// Retrieves a boolean value indicating whether SELECT FOR UPDATE statements are supported.
1411 ///
1412 /// Returns:
1413 /// - false: if SELECT FOR UPDATE statements are unsupported;
1414 /// - true: if SELECT FOR UPDATE statements are supported.
1415 SqlSelectForUpdateSupported = 536,
1416 ///
1417 /// Retrieves a boolean value indicating whether stored procedure calls that use the stored procedure escape syntax
1418 /// are supported.
1419 ///
1420 /// Returns:
1421 /// - false: if stored procedure calls that use the stored procedure escape syntax are unsupported;
1422 /// - true: if stored procedure calls that use the stored procedure escape syntax are supported.
1423 SqlStoredProceduresSupported = 537,
1424 ///
1425 /// Retrieves the supported SQL subqueries.
1426 ///
1427 /// Returns an int32 bitmask value representing the supported SQL subqueries.
1428 /// The returned bitmask should be parsed in order to retrieve the supported SQL subqueries.
1429 ///
1430 /// For instance:
1431 /// - return 0 (\b0) => \[\] (no supported SQL subqueries);
1432 /// - return 1 (\b1) => \[SQL_SUBQUERIES_IN_COMPARISONS\];
1433 /// - return 2 (\b10) => \[SQL_SUBQUERIES_IN_EXISTS\];
1434 /// - return 3 (\b11) => \[SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS\];
1435 /// - return 4 (\b100) => \[SQL_SUBQUERIES_IN_INS\];
1436 /// - return 5 (\b101) => \[SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_INS\];
1437 /// - return 6 (\b110) => \[SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_EXISTS\];
1438 /// - return 7 (\b111) => \[SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS\];
1439 /// - return 8 (\b1000) => \[SQL_SUBQUERIES_IN_QUANTIFIEDS\];
1440 /// - return 9 (\b1001) => \[SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_QUANTIFIEDS\];
1441 /// - return 10 (\b1010) => \[SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_QUANTIFIEDS\];
1442 /// - return 11 (\b1011) => \[SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_QUANTIFIEDS\];
1443 /// - return 12 (\b1100) => \[SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS\];
1444 /// - return 13 (\b1101) => \[SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS\];
1445 /// - return 14 (\b1110) => \[SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS\];
1446 /// - return 15 (\b1111) => \[SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS\];
1447 /// - ...
1448 /// Valid SQL subqueries are described under `arrow.flight.protocol.sql.SqlSupportedSubqueries`.
1449 SqlSupportedSubqueries = 538,
1450 ///
1451 /// Retrieves a boolean value indicating whether correlated subqueries are supported.
1452 ///
1453 /// Returns:
1454 /// - false: if correlated subqueries are unsupported;
1455 /// - true: if correlated subqueries are supported.
1456 SqlCorrelatedSubqueriesSupported = 539,
1457 ///
1458 /// Retrieves the supported SQL UNIONs.
1459 ///
1460 /// Returns an int32 bitmask value representing the supported SQL UNIONs.
1461 /// The returned bitmask should be parsed in order to retrieve the supported SQL UNIONs.
1462 ///
1463 /// For instance:
1464 /// - return 0 (\b0) => \[\] (no supported SQL UNIONs);
1465 /// - return 1 (\b1) => \[SQL_UNION\];
1466 /// - return 2 (\b10) => \[SQL_UNION_ALL\];
1467 /// - return 3 (\b11) => \[SQL_UNION, SQL_UNION_ALL\].
1468 /// Valid SQL UNIONs are described under `arrow.flight.protocol.sql.SqlSupportedUnions`.
1469 SqlSupportedUnions = 540,
1470 /// Retrieves an int64 value representing the maximum number of hex characters allowed in an inline binary literal.
1471 SqlMaxBinaryLiteralLength = 541,
1472 /// Retrieves an int64 value representing the maximum number of characters allowed for a character literal.
1473 SqlMaxCharLiteralLength = 542,
1474 /// Retrieves an int64 value representing the maximum number of characters allowed for a column name.
1475 SqlMaxColumnNameLength = 543,
1476 /// Retrieves an int64 value representing the maximum number of columns allowed in a GROUP BY clause.
1477 SqlMaxColumnsInGroupBy = 544,
1478 /// Retrieves an int64 value representing the maximum number of columns allowed in an index.
1479 SqlMaxColumnsInIndex = 545,
1480 /// Retrieves an int64 value representing the maximum number of columns allowed in an ORDER BY clause.
1481 SqlMaxColumnsInOrderBy = 546,
1482 /// Retrieves an int64 value representing the maximum number of columns allowed in a SELECT list.
1483 SqlMaxColumnsInSelect = 547,
1484 /// Retrieves an int64 value representing the maximum number of columns allowed in a table.
1485 SqlMaxColumnsInTable = 548,
1486 /// Retrieves an int64 value representing the maximum number of concurrent connections possible.
1487 SqlMaxConnections = 549,
1488 /// Retrieves an int64 value representing the maximum number of characters allowed in a cursor name.
1489 SqlMaxCursorNameLength = 550,
1490 ///
1491 /// Retrieves an int64 value representing the maximum number of bytes allowed for an index,
1492 /// including all of the parts of the index.
1493 SqlMaxIndexLength = 551,
1494 /// Retrieves an int64 value representing the maximum number of characters allowed in a schema name.
1495 SqlDbSchemaNameLength = 552,
1496 /// Retrieves an int64 value representing the maximum number of characters allowed in a procedure name.
1497 SqlMaxProcedureNameLength = 553,
1498 /// Retrieves an int64 value representing the maximum number of characters allowed in a catalog name.
1499 SqlMaxCatalogNameLength = 554,
1500 /// Retrieves an int64 value representing the maximum number of bytes allowed in a single row.
1501 SqlMaxRowSize = 555,
1502 ///
1503 /// Retrieves a boolean indicating whether the return value for the JDBC method getMaxRowSize includes the SQL
1504 /// data types LONGVARCHAR and LONGVARBINARY.
1505 ///
1506 /// Returns:
1507 /// - false: if return value for the JDBC method getMaxRowSize does
1508 /// not include the SQL data types LONGVARCHAR and LONGVARBINARY;
1509 /// - true: if return value for the JDBC method getMaxRowSize includes
1510 /// the SQL data types LONGVARCHAR and LONGVARBINARY.
1511 SqlMaxRowSizeIncludesBlobs = 556,
1512 ///
1513 /// Retrieves an int64 value representing the maximum number of characters allowed for an SQL statement;
1514 /// a result of 0 (zero) means that there is no limit or the limit is not known.
1515 SqlMaxStatementLength = 557,
1516 /// Retrieves an int64 value representing the maximum number of active statements that can be open at the same time.
1517 SqlMaxStatements = 558,
1518 /// Retrieves an int64 value representing the maximum number of characters allowed in a table name.
1519 SqlMaxTableNameLength = 559,
1520 /// Retrieves an int64 value representing the maximum number of tables allowed in a SELECT statement.
1521 SqlMaxTablesInSelect = 560,
1522 /// Retrieves an int64 value representing the maximum number of characters allowed in a user name.
1523 SqlMaxUsernameLength = 561,
1524 ///
1525 /// Retrieves this database's default transaction isolation level as described in
1526 /// `arrow.flight.protocol.sql.SqlTransactionIsolationLevel`.
1527 ///
1528 /// Returns an int32 ordinal for the SQL transaction isolation level.
1529 SqlDefaultTransactionIsolation = 562,
1530 ///
1531 /// Retrieves a boolean value indicating whether transactions are supported. If not, invoking the method commit is a
1532 /// noop, and the isolation level is `arrow.flight.protocol.sql.SqlTransactionIsolationLevel.TRANSACTION_NONE`.
1533 ///
1534 /// Returns:
1535 /// - false: if transactions are unsupported;
1536 /// - true: if transactions are supported.
1537 SqlTransactionsSupported = 563,
1538 ///
1539 /// Retrieves the supported transactions isolation levels.
1540 ///
1541 /// Returns an int32 bitmask value representing the supported transactions isolation levels.
1542 /// The returned bitmask should be parsed in order to retrieve the supported transactions isolation levels.
1543 ///
1544 /// For instance:
1545 /// - return 0 (\b0) => \[\] (no supported SQL transactions isolation levels);
1546 /// - return 1 (\b1) => \[SQL_TRANSACTION_NONE\];
1547 /// - return 2 (\b10) => \[SQL_TRANSACTION_READ_UNCOMMITTED\];
1548 /// - return 3 (\b11) => \[SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED\];
1549 /// - return 4 (\b100) => \[SQL_TRANSACTION_READ_COMMITTED\];
1550 /// - return 5 (\b101) => \[SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_COMMITTED\];
1551 /// - return 6 (\b110) => \[SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_READ_COMMITTED\];
1552 /// - return 7 (\b111) => \[SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_READ_COMMITTED\];
1553 /// - return 8 (\b1000) => \[SQL_TRANSACTION_REPEATABLE_READ\];
1554 /// - return 9 (\b1001) => \[SQL_TRANSACTION_NONE, SQL_TRANSACTION_REPEATABLE_READ\];
1555 /// - return 10 (\b1010) => \[SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ\];
1556 /// - return 11 (\b1011) => \[SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ\];
1557 /// - return 12 (\b1100) => \[SQL_TRANSACTION_READ_COMMITTED, SQL_TRANSACTION_REPEATABLE_READ\];
1558 /// - return 13 (\b1101) => \[SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_COMMITTED, SQL_TRANSACTION_REPEATABLE_READ\];
1559 /// - return 14 (\b1110) => \[SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_READ_COMMITTED, SQL_TRANSACTION_REPEATABLE_READ\];
1560 /// - return 15 (\b1111) => \[SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_READ_COMMITTED, SQL_TRANSACTION_REPEATABLE_READ\];
1561 /// - return 16 (\b10000) => \[SQL_TRANSACTION_SERIALIZABLE\];
1562 /// - ...
1563 /// Valid SQL transaction isolation levels are described under `arrow.flight.protocol.sql.SqlTransactionIsolationLevel`.
1564 SqlSupportedTransactionsIsolationLevels = 564,
1565 ///
1566 /// Retrieves a boolean value indicating whether a data definition statement within a transaction forces
1567 /// the transaction to commit.
1568 ///
1569 /// Returns:
1570 /// - false: if a data definition statement within a transaction does not force the transaction to commit;
1571 /// - true: if a data definition statement within a transaction forces the transaction to commit.
1572 SqlDataDefinitionCausesTransactionCommit = 565,
1573 ///
1574 /// Retrieves a boolean value indicating whether a data definition statement within a transaction is ignored.
1575 ///
1576 /// Returns:
1577 /// - false: if a data definition statement within a transaction is taken into account;
1578 /// - true: a data definition statement within a transaction is ignored.
1579 SqlDataDefinitionsInTransactionsIgnored = 566,
1580 ///
1581 /// Retrieves an int32 bitmask value representing the supported result set types.
1582 /// The returned bitmask should be parsed in order to retrieve the supported result set types.
1583 ///
1584 /// For instance:
1585 /// - return 0 (\b0) => \[\] (no supported result set types);
1586 /// - return 1 (\b1) => \[SQL_RESULT_SET_TYPE_UNSPECIFIED\];
1587 /// - return 2 (\b10) => \[SQL_RESULT_SET_TYPE_FORWARD_ONLY\];
1588 /// - return 3 (\b11) => \[SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_FORWARD_ONLY\];
1589 /// - return 4 (\b100) => \[SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE\];
1590 /// - return 5 (\b101) => \[SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE\];
1591 /// - return 6 (\b110) => \[SQL_RESULT_SET_TYPE_FORWARD_ONLY, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE\];
1592 /// - return 7 (\b111) => \[SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_FORWARD_ONLY, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE\];
1593 /// - return 8 (\b1000) => \[SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE\];
1594 /// - ...
1595 /// Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetType`.
1596 SqlSupportedResultSetTypes = 567,
1597 ///
1598 /// Returns an int32 bitmask value representing the concurrency types supported for
1599 /// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_UNSPECIFIED`.
1600 ///
1601 /// For instance:
1602 /// - return 0 (\b0) => \[\] (no supported concurrency types for this result set type)
1603 /// - return 1 (\b1) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED\]
1604 /// - return 2 (\b10) => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
1605 /// - return 3 (\b11) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
1606 /// - return 4 (\b100) => \[SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
1607 /// - return 5 (\b101) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
1608 /// - return 6 (\b110) => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
1609 /// - return 7 (\b111) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
1610 /// Valid result set concurrency types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
1611 SqlSupportedConcurrenciesForResultSetUnspecified = 568,
1612 ///
1613 /// Returns an int32 bitmask value representing the concurrency types supported for
1614 /// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_FORWARD_ONLY`.
1615 ///
1616 /// For instance:
1617 /// - return 0 (\b0) => \[\] (no supported concurrency types for this result set type)
1618 /// - return 1 (\b1) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED\]
1619 /// - return 2 (\b10) => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
1620 /// - return 3 (\b11) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
1621 /// - return 4 (\b100) => \[SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
1622 /// - return 5 (\b101) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
1623 /// - return 6 (\b110) => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
1624 /// - return 7 (\b111) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
1625 /// Valid result set concurrency types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
1626 SqlSupportedConcurrenciesForResultSetForwardOnly = 569,
1627 ///
1628 /// Returns an int32 bitmask value representing the concurrency types supported for
1629 /// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE`.
1630 ///
1631 /// For instance:
1632 /// - return 0 (\b0) => \[\] (no supported concurrency types for this result set type)
1633 /// - return 1 (\b1) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED\]
1634 /// - return 2 (\b10) => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
1635 /// - return 3 (\b11) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
1636 /// - return 4 (\b100) => \[SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
1637 /// - return 5 (\b101) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
1638 /// - return 6 (\b110) => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
1639 /// - return 7 (\b111) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
1640 /// Valid result set concurrency types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
1641 SqlSupportedConcurrenciesForResultSetScrollSensitive = 570,
1642 ///
1643 /// Returns an int32 bitmask value representing the concurrency types supported for
1644 /// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE`.
1645 ///
1646 /// For instance:
1647 /// - return 0 (\b0) => \[\] (no supported concurrency types for this result set type)
1648 /// - return 1 (\b1) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED\]
1649 /// - return 2 (\b10) => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
1650 /// - return 3 (\b11) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
1651 /// - return 4 (\b100) => \[SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
1652 /// - return 5 (\b101) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
1653 /// - return 6 (\b110) => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
1654 /// - return 7 (\b111) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
1655 /// Valid result set concurrency types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
1656 SqlSupportedConcurrenciesForResultSetScrollInsensitive = 571,
1657 ///
1658 /// Retrieves a boolean value indicating whether this database supports batch updates.
1659 ///
1660 /// - false: if this database does not support batch updates;
1661 /// - true: if this database supports batch updates.
1662 SqlBatchUpdatesSupported = 572,
1663 ///
1664 /// Retrieves a boolean value indicating whether this database supports savepoints.
1665 ///
1666 /// Returns:
1667 /// - false: if this database does not support savepoints;
1668 /// - true: if this database supports savepoints.
1669 SqlSavepointsSupported = 573,
1670 ///
1671 /// Retrieves a boolean value indicating whether named parameters are supported in callable statements.
1672 ///
1673 /// Returns:
1674 /// - false: if named parameters in callable statements are unsupported;
1675 /// - true: if named parameters in callable statements are supported.
1676 SqlNamedParametersSupported = 574,
1677 ///
1678 /// Retrieves a boolean value indicating whether updates made to a LOB are made on a copy or directly to the LOB.
1679 ///
1680 /// Returns:
1681 /// - false: if updates made to a LOB are made directly to the LOB;
1682 /// - true: if updates made to a LOB are made on a copy.
1683 SqlLocatorsUpdateCopy = 575,
1684 ///
1685 /// Retrieves a boolean value indicating whether invoking user-defined or vendor functions
1686 /// using the stored procedure escape syntax is supported.
1687 ///
1688 /// Returns:
1689 /// - false: if invoking user-defined or vendor functions using the stored procedure escape syntax is unsupported;
1690 /// - true: if invoking user-defined or vendor functions using the stored procedure escape syntax is supported.
1691 SqlStoredFunctionsUsingCallSyntaxSupported = 576,
1692}
1693impl SqlInfo {
1694 /// String value of the enum field names used in the ProtoBuf definition.
1695 ///
1696 /// The values are not transformed in any way and thus are considered stable
1697 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1698 pub fn as_str_name(&self) -> &'static str {
1699 match self {
1700 Self::FlightSqlServerName => "FLIGHT_SQL_SERVER_NAME",
1701 Self::FlightSqlServerVersion => "FLIGHT_SQL_SERVER_VERSION",
1702 Self::FlightSqlServerArrowVersion => "FLIGHT_SQL_SERVER_ARROW_VERSION",
1703 Self::FlightSqlServerReadOnly => "FLIGHT_SQL_SERVER_READ_ONLY",
1704 Self::FlightSqlServerSql => "FLIGHT_SQL_SERVER_SQL",
1705 Self::FlightSqlServerSubstrait => "FLIGHT_SQL_SERVER_SUBSTRAIT",
1706 Self::FlightSqlServerSubstraitMinVersion => {
1707 "FLIGHT_SQL_SERVER_SUBSTRAIT_MIN_VERSION"
1708 }
1709 Self::FlightSqlServerSubstraitMaxVersion => {
1710 "FLIGHT_SQL_SERVER_SUBSTRAIT_MAX_VERSION"
1711 }
1712 Self::FlightSqlServerTransaction => "FLIGHT_SQL_SERVER_TRANSACTION",
1713 Self::FlightSqlServerCancel => "FLIGHT_SQL_SERVER_CANCEL",
1714 Self::FlightSqlServerBulkIngestion => "FLIGHT_SQL_SERVER_BULK_INGESTION",
1715 Self::FlightSqlServerIngestTransactionsSupported => {
1716 "FLIGHT_SQL_SERVER_INGEST_TRANSACTIONS_SUPPORTED"
1717 }
1718 Self::FlightSqlServerStatementTimeout => {
1719 "FLIGHT_SQL_SERVER_STATEMENT_TIMEOUT"
1720 }
1721 Self::FlightSqlServerTransactionTimeout => {
1722 "FLIGHT_SQL_SERVER_TRANSACTION_TIMEOUT"
1723 }
1724 Self::SqlDdlCatalog => "SQL_DDL_CATALOG",
1725 Self::SqlDdlSchema => "SQL_DDL_SCHEMA",
1726 Self::SqlDdlTable => "SQL_DDL_TABLE",
1727 Self::SqlIdentifierCase => "SQL_IDENTIFIER_CASE",
1728 Self::SqlIdentifierQuoteChar => "SQL_IDENTIFIER_QUOTE_CHAR",
1729 Self::SqlQuotedIdentifierCase => "SQL_QUOTED_IDENTIFIER_CASE",
1730 Self::SqlAllTablesAreSelectable => "SQL_ALL_TABLES_ARE_SELECTABLE",
1731 Self::SqlNullOrdering => "SQL_NULL_ORDERING",
1732 Self::SqlKeywords => "SQL_KEYWORDS",
1733 Self::SqlNumericFunctions => "SQL_NUMERIC_FUNCTIONS",
1734 Self::SqlStringFunctions => "SQL_STRING_FUNCTIONS",
1735 Self::SqlSystemFunctions => "SQL_SYSTEM_FUNCTIONS",
1736 Self::SqlDatetimeFunctions => "SQL_DATETIME_FUNCTIONS",
1737 Self::SqlSearchStringEscape => "SQL_SEARCH_STRING_ESCAPE",
1738 Self::SqlExtraNameCharacters => "SQL_EXTRA_NAME_CHARACTERS",
1739 Self::SqlSupportsColumnAliasing => "SQL_SUPPORTS_COLUMN_ALIASING",
1740 Self::SqlNullPlusNullIsNull => "SQL_NULL_PLUS_NULL_IS_NULL",
1741 Self::SqlSupportsConvert => "SQL_SUPPORTS_CONVERT",
1742 Self::SqlSupportsTableCorrelationNames => {
1743 "SQL_SUPPORTS_TABLE_CORRELATION_NAMES"
1744 }
1745 Self::SqlSupportsDifferentTableCorrelationNames => {
1746 "SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES"
1747 }
1748 Self::SqlSupportsExpressionsInOrderBy => {
1749 "SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY"
1750 }
1751 Self::SqlSupportsOrderByUnrelated => "SQL_SUPPORTS_ORDER_BY_UNRELATED",
1752 Self::SqlSupportedGroupBy => "SQL_SUPPORTED_GROUP_BY",
1753 Self::SqlSupportsLikeEscapeClause => "SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE",
1754 Self::SqlSupportsNonNullableColumns => "SQL_SUPPORTS_NON_NULLABLE_COLUMNS",
1755 Self::SqlSupportedGrammar => "SQL_SUPPORTED_GRAMMAR",
1756 Self::SqlAnsi92SupportedLevel => "SQL_ANSI92_SUPPORTED_LEVEL",
1757 Self::SqlSupportsIntegrityEnhancementFacility => {
1758 "SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY"
1759 }
1760 Self::SqlOuterJoinsSupportLevel => "SQL_OUTER_JOINS_SUPPORT_LEVEL",
1761 Self::SqlSchemaTerm => "SQL_SCHEMA_TERM",
1762 Self::SqlProcedureTerm => "SQL_PROCEDURE_TERM",
1763 Self::SqlCatalogTerm => "SQL_CATALOG_TERM",
1764 Self::SqlCatalogAtStart => "SQL_CATALOG_AT_START",
1765 Self::SqlSchemasSupportedActions => "SQL_SCHEMAS_SUPPORTED_ACTIONS",
1766 Self::SqlCatalogsSupportedActions => "SQL_CATALOGS_SUPPORTED_ACTIONS",
1767 Self::SqlSupportedPositionedCommands => "SQL_SUPPORTED_POSITIONED_COMMANDS",
1768 Self::SqlSelectForUpdateSupported => "SQL_SELECT_FOR_UPDATE_SUPPORTED",
1769 Self::SqlStoredProceduresSupported => "SQL_STORED_PROCEDURES_SUPPORTED",
1770 Self::SqlSupportedSubqueries => "SQL_SUPPORTED_SUBQUERIES",
1771 Self::SqlCorrelatedSubqueriesSupported => {
1772 "SQL_CORRELATED_SUBQUERIES_SUPPORTED"
1773 }
1774 Self::SqlSupportedUnions => "SQL_SUPPORTED_UNIONS",
1775 Self::SqlMaxBinaryLiteralLength => "SQL_MAX_BINARY_LITERAL_LENGTH",
1776 Self::SqlMaxCharLiteralLength => "SQL_MAX_CHAR_LITERAL_LENGTH",
1777 Self::SqlMaxColumnNameLength => "SQL_MAX_COLUMN_NAME_LENGTH",
1778 Self::SqlMaxColumnsInGroupBy => "SQL_MAX_COLUMNS_IN_GROUP_BY",
1779 Self::SqlMaxColumnsInIndex => "SQL_MAX_COLUMNS_IN_INDEX",
1780 Self::SqlMaxColumnsInOrderBy => "SQL_MAX_COLUMNS_IN_ORDER_BY",
1781 Self::SqlMaxColumnsInSelect => "SQL_MAX_COLUMNS_IN_SELECT",
1782 Self::SqlMaxColumnsInTable => "SQL_MAX_COLUMNS_IN_TABLE",
1783 Self::SqlMaxConnections => "SQL_MAX_CONNECTIONS",
1784 Self::SqlMaxCursorNameLength => "SQL_MAX_CURSOR_NAME_LENGTH",
1785 Self::SqlMaxIndexLength => "SQL_MAX_INDEX_LENGTH",
1786 Self::SqlDbSchemaNameLength => "SQL_DB_SCHEMA_NAME_LENGTH",
1787 Self::SqlMaxProcedureNameLength => "SQL_MAX_PROCEDURE_NAME_LENGTH",
1788 Self::SqlMaxCatalogNameLength => "SQL_MAX_CATALOG_NAME_LENGTH",
1789 Self::SqlMaxRowSize => "SQL_MAX_ROW_SIZE",
1790 Self::SqlMaxRowSizeIncludesBlobs => "SQL_MAX_ROW_SIZE_INCLUDES_BLOBS",
1791 Self::SqlMaxStatementLength => "SQL_MAX_STATEMENT_LENGTH",
1792 Self::SqlMaxStatements => "SQL_MAX_STATEMENTS",
1793 Self::SqlMaxTableNameLength => "SQL_MAX_TABLE_NAME_LENGTH",
1794 Self::SqlMaxTablesInSelect => "SQL_MAX_TABLES_IN_SELECT",
1795 Self::SqlMaxUsernameLength => "SQL_MAX_USERNAME_LENGTH",
1796 Self::SqlDefaultTransactionIsolation => "SQL_DEFAULT_TRANSACTION_ISOLATION",
1797 Self::SqlTransactionsSupported => "SQL_TRANSACTIONS_SUPPORTED",
1798 Self::SqlSupportedTransactionsIsolationLevels => {
1799 "SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS"
1800 }
1801 Self::SqlDataDefinitionCausesTransactionCommit => {
1802 "SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT"
1803 }
1804 Self::SqlDataDefinitionsInTransactionsIgnored => {
1805 "SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED"
1806 }
1807 Self::SqlSupportedResultSetTypes => "SQL_SUPPORTED_RESULT_SET_TYPES",
1808 Self::SqlSupportedConcurrenciesForResultSetUnspecified => {
1809 "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED"
1810 }
1811 Self::SqlSupportedConcurrenciesForResultSetForwardOnly => {
1812 "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY"
1813 }
1814 Self::SqlSupportedConcurrenciesForResultSetScrollSensitive => {
1815 "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE"
1816 }
1817 Self::SqlSupportedConcurrenciesForResultSetScrollInsensitive => {
1818 "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE"
1819 }
1820 Self::SqlBatchUpdatesSupported => "SQL_BATCH_UPDATES_SUPPORTED",
1821 Self::SqlSavepointsSupported => "SQL_SAVEPOINTS_SUPPORTED",
1822 Self::SqlNamedParametersSupported => "SQL_NAMED_PARAMETERS_SUPPORTED",
1823 Self::SqlLocatorsUpdateCopy => "SQL_LOCATORS_UPDATE_COPY",
1824 Self::SqlStoredFunctionsUsingCallSyntaxSupported => {
1825 "SQL_STORED_FUNCTIONS_USING_CALL_SYNTAX_SUPPORTED"
1826 }
1827 }
1828 }
1829 /// Creates an enum from field names used in the ProtoBuf definition.
1830 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1831 match value {
1832 "FLIGHT_SQL_SERVER_NAME" => Some(Self::FlightSqlServerName),
1833 "FLIGHT_SQL_SERVER_VERSION" => Some(Self::FlightSqlServerVersion),
1834 "FLIGHT_SQL_SERVER_ARROW_VERSION" => Some(Self::FlightSqlServerArrowVersion),
1835 "FLIGHT_SQL_SERVER_READ_ONLY" => Some(Self::FlightSqlServerReadOnly),
1836 "FLIGHT_SQL_SERVER_SQL" => Some(Self::FlightSqlServerSql),
1837 "FLIGHT_SQL_SERVER_SUBSTRAIT" => Some(Self::FlightSqlServerSubstrait),
1838 "FLIGHT_SQL_SERVER_SUBSTRAIT_MIN_VERSION" => {
1839 Some(Self::FlightSqlServerSubstraitMinVersion)
1840 }
1841 "FLIGHT_SQL_SERVER_SUBSTRAIT_MAX_VERSION" => {
1842 Some(Self::FlightSqlServerSubstraitMaxVersion)
1843 }
1844 "FLIGHT_SQL_SERVER_TRANSACTION" => Some(Self::FlightSqlServerTransaction),
1845 "FLIGHT_SQL_SERVER_CANCEL" => Some(Self::FlightSqlServerCancel),
1846 "FLIGHT_SQL_SERVER_BULK_INGESTION" => {
1847 Some(Self::FlightSqlServerBulkIngestion)
1848 }
1849 "FLIGHT_SQL_SERVER_INGEST_TRANSACTIONS_SUPPORTED" => {
1850 Some(Self::FlightSqlServerIngestTransactionsSupported)
1851 }
1852 "FLIGHT_SQL_SERVER_STATEMENT_TIMEOUT" => {
1853 Some(Self::FlightSqlServerStatementTimeout)
1854 }
1855 "FLIGHT_SQL_SERVER_TRANSACTION_TIMEOUT" => {
1856 Some(Self::FlightSqlServerTransactionTimeout)
1857 }
1858 "SQL_DDL_CATALOG" => Some(Self::SqlDdlCatalog),
1859 "SQL_DDL_SCHEMA" => Some(Self::SqlDdlSchema),
1860 "SQL_DDL_TABLE" => Some(Self::SqlDdlTable),
1861 "SQL_IDENTIFIER_CASE" => Some(Self::SqlIdentifierCase),
1862 "SQL_IDENTIFIER_QUOTE_CHAR" => Some(Self::SqlIdentifierQuoteChar),
1863 "SQL_QUOTED_IDENTIFIER_CASE" => Some(Self::SqlQuotedIdentifierCase),
1864 "SQL_ALL_TABLES_ARE_SELECTABLE" => Some(Self::SqlAllTablesAreSelectable),
1865 "SQL_NULL_ORDERING" => Some(Self::SqlNullOrdering),
1866 "SQL_KEYWORDS" => Some(Self::SqlKeywords),
1867 "SQL_NUMERIC_FUNCTIONS" => Some(Self::SqlNumericFunctions),
1868 "SQL_STRING_FUNCTIONS" => Some(Self::SqlStringFunctions),
1869 "SQL_SYSTEM_FUNCTIONS" => Some(Self::SqlSystemFunctions),
1870 "SQL_DATETIME_FUNCTIONS" => Some(Self::SqlDatetimeFunctions),
1871 "SQL_SEARCH_STRING_ESCAPE" => Some(Self::SqlSearchStringEscape),
1872 "SQL_EXTRA_NAME_CHARACTERS" => Some(Self::SqlExtraNameCharacters),
1873 "SQL_SUPPORTS_COLUMN_ALIASING" => Some(Self::SqlSupportsColumnAliasing),
1874 "SQL_NULL_PLUS_NULL_IS_NULL" => Some(Self::SqlNullPlusNullIsNull),
1875 "SQL_SUPPORTS_CONVERT" => Some(Self::SqlSupportsConvert),
1876 "SQL_SUPPORTS_TABLE_CORRELATION_NAMES" => {
1877 Some(Self::SqlSupportsTableCorrelationNames)
1878 }
1879 "SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES" => {
1880 Some(Self::SqlSupportsDifferentTableCorrelationNames)
1881 }
1882 "SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY" => {
1883 Some(Self::SqlSupportsExpressionsInOrderBy)
1884 }
1885 "SQL_SUPPORTS_ORDER_BY_UNRELATED" => Some(Self::SqlSupportsOrderByUnrelated),
1886 "SQL_SUPPORTED_GROUP_BY" => Some(Self::SqlSupportedGroupBy),
1887 "SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE" => Some(Self::SqlSupportsLikeEscapeClause),
1888 "SQL_SUPPORTS_NON_NULLABLE_COLUMNS" => {
1889 Some(Self::SqlSupportsNonNullableColumns)
1890 }
1891 "SQL_SUPPORTED_GRAMMAR" => Some(Self::SqlSupportedGrammar),
1892 "SQL_ANSI92_SUPPORTED_LEVEL" => Some(Self::SqlAnsi92SupportedLevel),
1893 "SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY" => {
1894 Some(Self::SqlSupportsIntegrityEnhancementFacility)
1895 }
1896 "SQL_OUTER_JOINS_SUPPORT_LEVEL" => Some(Self::SqlOuterJoinsSupportLevel),
1897 "SQL_SCHEMA_TERM" => Some(Self::SqlSchemaTerm),
1898 "SQL_PROCEDURE_TERM" => Some(Self::SqlProcedureTerm),
1899 "SQL_CATALOG_TERM" => Some(Self::SqlCatalogTerm),
1900 "SQL_CATALOG_AT_START" => Some(Self::SqlCatalogAtStart),
1901 "SQL_SCHEMAS_SUPPORTED_ACTIONS" => Some(Self::SqlSchemasSupportedActions),
1902 "SQL_CATALOGS_SUPPORTED_ACTIONS" => Some(Self::SqlCatalogsSupportedActions),
1903 "SQL_SUPPORTED_POSITIONED_COMMANDS" => {
1904 Some(Self::SqlSupportedPositionedCommands)
1905 }
1906 "SQL_SELECT_FOR_UPDATE_SUPPORTED" => Some(Self::SqlSelectForUpdateSupported),
1907 "SQL_STORED_PROCEDURES_SUPPORTED" => Some(Self::SqlStoredProceduresSupported),
1908 "SQL_SUPPORTED_SUBQUERIES" => Some(Self::SqlSupportedSubqueries),
1909 "SQL_CORRELATED_SUBQUERIES_SUPPORTED" => {
1910 Some(Self::SqlCorrelatedSubqueriesSupported)
1911 }
1912 "SQL_SUPPORTED_UNIONS" => Some(Self::SqlSupportedUnions),
1913 "SQL_MAX_BINARY_LITERAL_LENGTH" => Some(Self::SqlMaxBinaryLiteralLength),
1914 "SQL_MAX_CHAR_LITERAL_LENGTH" => Some(Self::SqlMaxCharLiteralLength),
1915 "SQL_MAX_COLUMN_NAME_LENGTH" => Some(Self::SqlMaxColumnNameLength),
1916 "SQL_MAX_COLUMNS_IN_GROUP_BY" => Some(Self::SqlMaxColumnsInGroupBy),
1917 "SQL_MAX_COLUMNS_IN_INDEX" => Some(Self::SqlMaxColumnsInIndex),
1918 "SQL_MAX_COLUMNS_IN_ORDER_BY" => Some(Self::SqlMaxColumnsInOrderBy),
1919 "SQL_MAX_COLUMNS_IN_SELECT" => Some(Self::SqlMaxColumnsInSelect),
1920 "SQL_MAX_COLUMNS_IN_TABLE" => Some(Self::SqlMaxColumnsInTable),
1921 "SQL_MAX_CONNECTIONS" => Some(Self::SqlMaxConnections),
1922 "SQL_MAX_CURSOR_NAME_LENGTH" => Some(Self::SqlMaxCursorNameLength),
1923 "SQL_MAX_INDEX_LENGTH" => Some(Self::SqlMaxIndexLength),
1924 "SQL_DB_SCHEMA_NAME_LENGTH" => Some(Self::SqlDbSchemaNameLength),
1925 "SQL_MAX_PROCEDURE_NAME_LENGTH" => Some(Self::SqlMaxProcedureNameLength),
1926 "SQL_MAX_CATALOG_NAME_LENGTH" => Some(Self::SqlMaxCatalogNameLength),
1927 "SQL_MAX_ROW_SIZE" => Some(Self::SqlMaxRowSize),
1928 "SQL_MAX_ROW_SIZE_INCLUDES_BLOBS" => Some(Self::SqlMaxRowSizeIncludesBlobs),
1929 "SQL_MAX_STATEMENT_LENGTH" => Some(Self::SqlMaxStatementLength),
1930 "SQL_MAX_STATEMENTS" => Some(Self::SqlMaxStatements),
1931 "SQL_MAX_TABLE_NAME_LENGTH" => Some(Self::SqlMaxTableNameLength),
1932 "SQL_MAX_TABLES_IN_SELECT" => Some(Self::SqlMaxTablesInSelect),
1933 "SQL_MAX_USERNAME_LENGTH" => Some(Self::SqlMaxUsernameLength),
1934 "SQL_DEFAULT_TRANSACTION_ISOLATION" => {
1935 Some(Self::SqlDefaultTransactionIsolation)
1936 }
1937 "SQL_TRANSACTIONS_SUPPORTED" => Some(Self::SqlTransactionsSupported),
1938 "SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS" => {
1939 Some(Self::SqlSupportedTransactionsIsolationLevels)
1940 }
1941 "SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT" => {
1942 Some(Self::SqlDataDefinitionCausesTransactionCommit)
1943 }
1944 "SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED" => {
1945 Some(Self::SqlDataDefinitionsInTransactionsIgnored)
1946 }
1947 "SQL_SUPPORTED_RESULT_SET_TYPES" => Some(Self::SqlSupportedResultSetTypes),
1948 "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED" => {
1949 Some(Self::SqlSupportedConcurrenciesForResultSetUnspecified)
1950 }
1951 "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY" => {
1952 Some(Self::SqlSupportedConcurrenciesForResultSetForwardOnly)
1953 }
1954 "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE" => {
1955 Some(Self::SqlSupportedConcurrenciesForResultSetScrollSensitive)
1956 }
1957 "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE" => {
1958 Some(Self::SqlSupportedConcurrenciesForResultSetScrollInsensitive)
1959 }
1960 "SQL_BATCH_UPDATES_SUPPORTED" => Some(Self::SqlBatchUpdatesSupported),
1961 "SQL_SAVEPOINTS_SUPPORTED" => Some(Self::SqlSavepointsSupported),
1962 "SQL_NAMED_PARAMETERS_SUPPORTED" => Some(Self::SqlNamedParametersSupported),
1963 "SQL_LOCATORS_UPDATE_COPY" => Some(Self::SqlLocatorsUpdateCopy),
1964 "SQL_STORED_FUNCTIONS_USING_CALL_SYNTAX_SUPPORTED" => {
1965 Some(Self::SqlStoredFunctionsUsingCallSyntaxSupported)
1966 }
1967 _ => None,
1968 }
1969 }
1970}
1971/// The level of support for Flight SQL transaction RPCs.
1972#[allow(clippy::all)]
1973#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1974#[repr(i32)]
1975pub enum SqlSupportedTransaction {
1976 /// Unknown/not indicated/no support
1977 None = 0,
1978 /// Transactions, but not savepoints.
1979 /// A savepoint is a mark within a transaction that can be individually
1980 /// rolled back to. Not all databases support savepoints.
1981 Transaction = 1,
1982 /// Transactions and savepoints
1983 Savepoint = 2,
1984}
1985impl SqlSupportedTransaction {
1986 /// String value of the enum field names used in the ProtoBuf definition.
1987 ///
1988 /// The values are not transformed in any way and thus are considered stable
1989 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1990 pub fn as_str_name(&self) -> &'static str {
1991 match self {
1992 Self::None => "SQL_SUPPORTED_TRANSACTION_NONE",
1993 Self::Transaction => "SQL_SUPPORTED_TRANSACTION_TRANSACTION",
1994 Self::Savepoint => "SQL_SUPPORTED_TRANSACTION_SAVEPOINT",
1995 }
1996 }
1997 /// Creates an enum from field names used in the ProtoBuf definition.
1998 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1999 match value {
2000 "SQL_SUPPORTED_TRANSACTION_NONE" => Some(Self::None),
2001 "SQL_SUPPORTED_TRANSACTION_TRANSACTION" => Some(Self::Transaction),
2002 "SQL_SUPPORTED_TRANSACTION_SAVEPOINT" => Some(Self::Savepoint),
2003 _ => None,
2004 }
2005 }
2006}
2007#[allow(clippy::all)]
2008#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2009#[repr(i32)]
2010pub enum SqlSupportedCaseSensitivity {
2011 SqlCaseSensitivityUnknown = 0,
2012 SqlCaseSensitivityCaseInsensitive = 1,
2013 SqlCaseSensitivityUppercase = 2,
2014 SqlCaseSensitivityLowercase = 3,
2015}
2016impl SqlSupportedCaseSensitivity {
2017 /// String value of the enum field names used in the ProtoBuf definition.
2018 ///
2019 /// The values are not transformed in any way and thus are considered stable
2020 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2021 pub fn as_str_name(&self) -> &'static str {
2022 match self {
2023 Self::SqlCaseSensitivityUnknown => "SQL_CASE_SENSITIVITY_UNKNOWN",
2024 Self::SqlCaseSensitivityCaseInsensitive => {
2025 "SQL_CASE_SENSITIVITY_CASE_INSENSITIVE"
2026 }
2027 Self::SqlCaseSensitivityUppercase => "SQL_CASE_SENSITIVITY_UPPERCASE",
2028 Self::SqlCaseSensitivityLowercase => "SQL_CASE_SENSITIVITY_LOWERCASE",
2029 }
2030 }
2031 /// Creates an enum from field names used in the ProtoBuf definition.
2032 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2033 match value {
2034 "SQL_CASE_SENSITIVITY_UNKNOWN" => Some(Self::SqlCaseSensitivityUnknown),
2035 "SQL_CASE_SENSITIVITY_CASE_INSENSITIVE" => {
2036 Some(Self::SqlCaseSensitivityCaseInsensitive)
2037 }
2038 "SQL_CASE_SENSITIVITY_UPPERCASE" => Some(Self::SqlCaseSensitivityUppercase),
2039 "SQL_CASE_SENSITIVITY_LOWERCASE" => Some(Self::SqlCaseSensitivityLowercase),
2040 _ => None,
2041 }
2042 }
2043}
2044#[allow(clippy::all)]
2045#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2046#[repr(i32)]
2047pub enum SqlNullOrdering {
2048 SqlNullsSortedHigh = 0,
2049 SqlNullsSortedLow = 1,
2050 SqlNullsSortedAtStart = 2,
2051 SqlNullsSortedAtEnd = 3,
2052}
2053impl SqlNullOrdering {
2054 /// String value of the enum field names used in the ProtoBuf definition.
2055 ///
2056 /// The values are not transformed in any way and thus are considered stable
2057 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2058 pub fn as_str_name(&self) -> &'static str {
2059 match self {
2060 Self::SqlNullsSortedHigh => "SQL_NULLS_SORTED_HIGH",
2061 Self::SqlNullsSortedLow => "SQL_NULLS_SORTED_LOW",
2062 Self::SqlNullsSortedAtStart => "SQL_NULLS_SORTED_AT_START",
2063 Self::SqlNullsSortedAtEnd => "SQL_NULLS_SORTED_AT_END",
2064 }
2065 }
2066 /// Creates an enum from field names used in the ProtoBuf definition.
2067 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2068 match value {
2069 "SQL_NULLS_SORTED_HIGH" => Some(Self::SqlNullsSortedHigh),
2070 "SQL_NULLS_SORTED_LOW" => Some(Self::SqlNullsSortedLow),
2071 "SQL_NULLS_SORTED_AT_START" => Some(Self::SqlNullsSortedAtStart),
2072 "SQL_NULLS_SORTED_AT_END" => Some(Self::SqlNullsSortedAtEnd),
2073 _ => None,
2074 }
2075 }
2076}
2077#[allow(clippy::all)]
2078#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2079#[repr(i32)]
2080pub enum SupportedSqlGrammar {
2081 SqlMinimumGrammar = 0,
2082 SqlCoreGrammar = 1,
2083 SqlExtendedGrammar = 2,
2084}
2085impl SupportedSqlGrammar {
2086 /// String value of the enum field names used in the ProtoBuf definition.
2087 ///
2088 /// The values are not transformed in any way and thus are considered stable
2089 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2090 pub fn as_str_name(&self) -> &'static str {
2091 match self {
2092 Self::SqlMinimumGrammar => "SQL_MINIMUM_GRAMMAR",
2093 Self::SqlCoreGrammar => "SQL_CORE_GRAMMAR",
2094 Self::SqlExtendedGrammar => "SQL_EXTENDED_GRAMMAR",
2095 }
2096 }
2097 /// Creates an enum from field names used in the ProtoBuf definition.
2098 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2099 match value {
2100 "SQL_MINIMUM_GRAMMAR" => Some(Self::SqlMinimumGrammar),
2101 "SQL_CORE_GRAMMAR" => Some(Self::SqlCoreGrammar),
2102 "SQL_EXTENDED_GRAMMAR" => Some(Self::SqlExtendedGrammar),
2103 _ => None,
2104 }
2105 }
2106}
2107#[allow(clippy::all)]
2108#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2109#[repr(i32)]
2110pub enum SupportedAnsi92SqlGrammarLevel {
2111 Ansi92EntrySql = 0,
2112 Ansi92IntermediateSql = 1,
2113 Ansi92FullSql = 2,
2114}
2115impl SupportedAnsi92SqlGrammarLevel {
2116 /// String value of the enum field names used in the ProtoBuf definition.
2117 ///
2118 /// The values are not transformed in any way and thus are considered stable
2119 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2120 pub fn as_str_name(&self) -> &'static str {
2121 match self {
2122 Self::Ansi92EntrySql => "ANSI92_ENTRY_SQL",
2123 Self::Ansi92IntermediateSql => "ANSI92_INTERMEDIATE_SQL",
2124 Self::Ansi92FullSql => "ANSI92_FULL_SQL",
2125 }
2126 }
2127 /// Creates an enum from field names used in the ProtoBuf definition.
2128 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2129 match value {
2130 "ANSI92_ENTRY_SQL" => Some(Self::Ansi92EntrySql),
2131 "ANSI92_INTERMEDIATE_SQL" => Some(Self::Ansi92IntermediateSql),
2132 "ANSI92_FULL_SQL" => Some(Self::Ansi92FullSql),
2133 _ => None,
2134 }
2135 }
2136}
2137#[allow(clippy::all)]
2138#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2139#[repr(i32)]
2140pub enum SqlOuterJoinsSupportLevel {
2141 SqlJoinsUnsupported = 0,
2142 SqlLimitedOuterJoins = 1,
2143 SqlFullOuterJoins = 2,
2144}
2145impl SqlOuterJoinsSupportLevel {
2146 /// String value of the enum field names used in the ProtoBuf definition.
2147 ///
2148 /// The values are not transformed in any way and thus are considered stable
2149 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2150 pub fn as_str_name(&self) -> &'static str {
2151 match self {
2152 Self::SqlJoinsUnsupported => "SQL_JOINS_UNSUPPORTED",
2153 Self::SqlLimitedOuterJoins => "SQL_LIMITED_OUTER_JOINS",
2154 Self::SqlFullOuterJoins => "SQL_FULL_OUTER_JOINS",
2155 }
2156 }
2157 /// Creates an enum from field names used in the ProtoBuf definition.
2158 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2159 match value {
2160 "SQL_JOINS_UNSUPPORTED" => Some(Self::SqlJoinsUnsupported),
2161 "SQL_LIMITED_OUTER_JOINS" => Some(Self::SqlLimitedOuterJoins),
2162 "SQL_FULL_OUTER_JOINS" => Some(Self::SqlFullOuterJoins),
2163 _ => None,
2164 }
2165 }
2166}
2167#[allow(clippy::all)]
2168#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2169#[repr(i32)]
2170pub enum SqlSupportedGroupBy {
2171 SqlGroupByUnrelated = 0,
2172 SqlGroupByBeyondSelect = 1,
2173}
2174impl SqlSupportedGroupBy {
2175 /// String value of the enum field names used in the ProtoBuf definition.
2176 ///
2177 /// The values are not transformed in any way and thus are considered stable
2178 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2179 pub fn as_str_name(&self) -> &'static str {
2180 match self {
2181 Self::SqlGroupByUnrelated => "SQL_GROUP_BY_UNRELATED",
2182 Self::SqlGroupByBeyondSelect => "SQL_GROUP_BY_BEYOND_SELECT",
2183 }
2184 }
2185 /// Creates an enum from field names used in the ProtoBuf definition.
2186 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2187 match value {
2188 "SQL_GROUP_BY_UNRELATED" => Some(Self::SqlGroupByUnrelated),
2189 "SQL_GROUP_BY_BEYOND_SELECT" => Some(Self::SqlGroupByBeyondSelect),
2190 _ => None,
2191 }
2192 }
2193}
2194#[allow(clippy::all)]
2195#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2196#[repr(i32)]
2197pub enum SqlSupportedElementActions {
2198 SqlElementInProcedureCalls = 0,
2199 SqlElementInIndexDefinitions = 1,
2200 SqlElementInPrivilegeDefinitions = 2,
2201}
2202impl SqlSupportedElementActions {
2203 /// String value of the enum field names used in the ProtoBuf definition.
2204 ///
2205 /// The values are not transformed in any way and thus are considered stable
2206 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2207 pub fn as_str_name(&self) -> &'static str {
2208 match self {
2209 Self::SqlElementInProcedureCalls => "SQL_ELEMENT_IN_PROCEDURE_CALLS",
2210 Self::SqlElementInIndexDefinitions => "SQL_ELEMENT_IN_INDEX_DEFINITIONS",
2211 Self::SqlElementInPrivilegeDefinitions => {
2212 "SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS"
2213 }
2214 }
2215 }
2216 /// Creates an enum from field names used in the ProtoBuf definition.
2217 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2218 match value {
2219 "SQL_ELEMENT_IN_PROCEDURE_CALLS" => Some(Self::SqlElementInProcedureCalls),
2220 "SQL_ELEMENT_IN_INDEX_DEFINITIONS" => {
2221 Some(Self::SqlElementInIndexDefinitions)
2222 }
2223 "SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS" => {
2224 Some(Self::SqlElementInPrivilegeDefinitions)
2225 }
2226 _ => None,
2227 }
2228 }
2229}
2230#[allow(clippy::all)]
2231#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2232#[repr(i32)]
2233pub enum SqlSupportedPositionedCommands {
2234 SqlPositionedDelete = 0,
2235 SqlPositionedUpdate = 1,
2236}
2237impl SqlSupportedPositionedCommands {
2238 /// String value of the enum field names used in the ProtoBuf definition.
2239 ///
2240 /// The values are not transformed in any way and thus are considered stable
2241 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2242 pub fn as_str_name(&self) -> &'static str {
2243 match self {
2244 Self::SqlPositionedDelete => "SQL_POSITIONED_DELETE",
2245 Self::SqlPositionedUpdate => "SQL_POSITIONED_UPDATE",
2246 }
2247 }
2248 /// Creates an enum from field names used in the ProtoBuf definition.
2249 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2250 match value {
2251 "SQL_POSITIONED_DELETE" => Some(Self::SqlPositionedDelete),
2252 "SQL_POSITIONED_UPDATE" => Some(Self::SqlPositionedUpdate),
2253 _ => None,
2254 }
2255 }
2256}
2257#[allow(clippy::all)]
2258#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2259#[repr(i32)]
2260pub enum SqlSupportedSubqueries {
2261 SqlSubqueriesInComparisons = 0,
2262 SqlSubqueriesInExists = 1,
2263 SqlSubqueriesInIns = 2,
2264 SqlSubqueriesInQuantifieds = 3,
2265}
2266impl SqlSupportedSubqueries {
2267 /// String value of the enum field names used in the ProtoBuf definition.
2268 ///
2269 /// The values are not transformed in any way and thus are considered stable
2270 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2271 pub fn as_str_name(&self) -> &'static str {
2272 match self {
2273 Self::SqlSubqueriesInComparisons => "SQL_SUBQUERIES_IN_COMPARISONS",
2274 Self::SqlSubqueriesInExists => "SQL_SUBQUERIES_IN_EXISTS",
2275 Self::SqlSubqueriesInIns => "SQL_SUBQUERIES_IN_INS",
2276 Self::SqlSubqueriesInQuantifieds => "SQL_SUBQUERIES_IN_QUANTIFIEDS",
2277 }
2278 }
2279 /// Creates an enum from field names used in the ProtoBuf definition.
2280 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2281 match value {
2282 "SQL_SUBQUERIES_IN_COMPARISONS" => Some(Self::SqlSubqueriesInComparisons),
2283 "SQL_SUBQUERIES_IN_EXISTS" => Some(Self::SqlSubqueriesInExists),
2284 "SQL_SUBQUERIES_IN_INS" => Some(Self::SqlSubqueriesInIns),
2285 "SQL_SUBQUERIES_IN_QUANTIFIEDS" => Some(Self::SqlSubqueriesInQuantifieds),
2286 _ => None,
2287 }
2288 }
2289}
2290#[allow(clippy::all)]
2291#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2292#[repr(i32)]
2293pub enum SqlSupportedUnions {
2294 SqlUnion = 0,
2295 SqlUnionAll = 1,
2296}
2297impl SqlSupportedUnions {
2298 /// String value of the enum field names used in the ProtoBuf definition.
2299 ///
2300 /// The values are not transformed in any way and thus are considered stable
2301 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2302 pub fn as_str_name(&self) -> &'static str {
2303 match self {
2304 Self::SqlUnion => "SQL_UNION",
2305 Self::SqlUnionAll => "SQL_UNION_ALL",
2306 }
2307 }
2308 /// Creates an enum from field names used in the ProtoBuf definition.
2309 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2310 match value {
2311 "SQL_UNION" => Some(Self::SqlUnion),
2312 "SQL_UNION_ALL" => Some(Self::SqlUnionAll),
2313 _ => None,
2314 }
2315 }
2316}
2317#[allow(clippy::all)]
2318#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2319#[repr(i32)]
2320pub enum SqlTransactionIsolationLevel {
2321 SqlTransactionNone = 0,
2322 SqlTransactionReadUncommitted = 1,
2323 SqlTransactionReadCommitted = 2,
2324 SqlTransactionRepeatableRead = 3,
2325 SqlTransactionSerializable = 4,
2326}
2327impl SqlTransactionIsolationLevel {
2328 /// String value of the enum field names used in the ProtoBuf definition.
2329 ///
2330 /// The values are not transformed in any way and thus are considered stable
2331 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2332 pub fn as_str_name(&self) -> &'static str {
2333 match self {
2334 Self::SqlTransactionNone => "SQL_TRANSACTION_NONE",
2335 Self::SqlTransactionReadUncommitted => "SQL_TRANSACTION_READ_UNCOMMITTED",
2336 Self::SqlTransactionReadCommitted => "SQL_TRANSACTION_READ_COMMITTED",
2337 Self::SqlTransactionRepeatableRead => "SQL_TRANSACTION_REPEATABLE_READ",
2338 Self::SqlTransactionSerializable => "SQL_TRANSACTION_SERIALIZABLE",
2339 }
2340 }
2341 /// Creates an enum from field names used in the ProtoBuf definition.
2342 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2343 match value {
2344 "SQL_TRANSACTION_NONE" => Some(Self::SqlTransactionNone),
2345 "SQL_TRANSACTION_READ_UNCOMMITTED" => {
2346 Some(Self::SqlTransactionReadUncommitted)
2347 }
2348 "SQL_TRANSACTION_READ_COMMITTED" => Some(Self::SqlTransactionReadCommitted),
2349 "SQL_TRANSACTION_REPEATABLE_READ" => Some(Self::SqlTransactionRepeatableRead),
2350 "SQL_TRANSACTION_SERIALIZABLE" => Some(Self::SqlTransactionSerializable),
2351 _ => None,
2352 }
2353 }
2354}
2355#[allow(clippy::all)]
2356#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2357#[repr(i32)]
2358pub enum SqlSupportedTransactions {
2359 SqlTransactionUnspecified = 0,
2360 SqlDataDefinitionTransactions = 1,
2361 SqlDataManipulationTransactions = 2,
2362}
2363impl SqlSupportedTransactions {
2364 /// String value of the enum field names used in the ProtoBuf definition.
2365 ///
2366 /// The values are not transformed in any way and thus are considered stable
2367 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2368 pub fn as_str_name(&self) -> &'static str {
2369 match self {
2370 Self::SqlTransactionUnspecified => "SQL_TRANSACTION_UNSPECIFIED",
2371 Self::SqlDataDefinitionTransactions => "SQL_DATA_DEFINITION_TRANSACTIONS",
2372 Self::SqlDataManipulationTransactions => "SQL_DATA_MANIPULATION_TRANSACTIONS",
2373 }
2374 }
2375 /// Creates an enum from field names used in the ProtoBuf definition.
2376 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2377 match value {
2378 "SQL_TRANSACTION_UNSPECIFIED" => Some(Self::SqlTransactionUnspecified),
2379 "SQL_DATA_DEFINITION_TRANSACTIONS" => {
2380 Some(Self::SqlDataDefinitionTransactions)
2381 }
2382 "SQL_DATA_MANIPULATION_TRANSACTIONS" => {
2383 Some(Self::SqlDataManipulationTransactions)
2384 }
2385 _ => None,
2386 }
2387 }
2388}
2389#[allow(clippy::all)]
2390#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2391#[repr(i32)]
2392pub enum SqlSupportedResultSetType {
2393 SqlResultSetTypeUnspecified = 0,
2394 SqlResultSetTypeForwardOnly = 1,
2395 SqlResultSetTypeScrollInsensitive = 2,
2396 SqlResultSetTypeScrollSensitive = 3,
2397}
2398impl SqlSupportedResultSetType {
2399 /// String value of the enum field names used in the ProtoBuf definition.
2400 ///
2401 /// The values are not transformed in any way and thus are considered stable
2402 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2403 pub fn as_str_name(&self) -> &'static str {
2404 match self {
2405 Self::SqlResultSetTypeUnspecified => "SQL_RESULT_SET_TYPE_UNSPECIFIED",
2406 Self::SqlResultSetTypeForwardOnly => "SQL_RESULT_SET_TYPE_FORWARD_ONLY",
2407 Self::SqlResultSetTypeScrollInsensitive => {
2408 "SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE"
2409 }
2410 Self::SqlResultSetTypeScrollSensitive => {
2411 "SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE"
2412 }
2413 }
2414 }
2415 /// Creates an enum from field names used in the ProtoBuf definition.
2416 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2417 match value {
2418 "SQL_RESULT_SET_TYPE_UNSPECIFIED" => Some(Self::SqlResultSetTypeUnspecified),
2419 "SQL_RESULT_SET_TYPE_FORWARD_ONLY" => Some(Self::SqlResultSetTypeForwardOnly),
2420 "SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE" => {
2421 Some(Self::SqlResultSetTypeScrollInsensitive)
2422 }
2423 "SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE" => {
2424 Some(Self::SqlResultSetTypeScrollSensitive)
2425 }
2426 _ => None,
2427 }
2428 }
2429}
2430#[allow(clippy::all)]
2431#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2432#[repr(i32)]
2433pub enum SqlSupportedResultSetConcurrency {
2434 SqlResultSetConcurrencyUnspecified = 0,
2435 SqlResultSetConcurrencyReadOnly = 1,
2436 SqlResultSetConcurrencyUpdatable = 2,
2437}
2438impl SqlSupportedResultSetConcurrency {
2439 /// String value of the enum field names used in the ProtoBuf definition.
2440 ///
2441 /// The values are not transformed in any way and thus are considered stable
2442 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2443 pub fn as_str_name(&self) -> &'static str {
2444 match self {
2445 Self::SqlResultSetConcurrencyUnspecified => {
2446 "SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED"
2447 }
2448 Self::SqlResultSetConcurrencyReadOnly => {
2449 "SQL_RESULT_SET_CONCURRENCY_READ_ONLY"
2450 }
2451 Self::SqlResultSetConcurrencyUpdatable => {
2452 "SQL_RESULT_SET_CONCURRENCY_UPDATABLE"
2453 }
2454 }
2455 }
2456 /// Creates an enum from field names used in the ProtoBuf definition.
2457 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2458 match value {
2459 "SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED" => {
2460 Some(Self::SqlResultSetConcurrencyUnspecified)
2461 }
2462 "SQL_RESULT_SET_CONCURRENCY_READ_ONLY" => {
2463 Some(Self::SqlResultSetConcurrencyReadOnly)
2464 }
2465 "SQL_RESULT_SET_CONCURRENCY_UPDATABLE" => {
2466 Some(Self::SqlResultSetConcurrencyUpdatable)
2467 }
2468 _ => None,
2469 }
2470 }
2471}
2472#[allow(clippy::all)]
2473#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2474#[repr(i32)]
2475pub enum SqlSupportsConvert {
2476 SqlConvertBigint = 0,
2477 SqlConvertBinary = 1,
2478 SqlConvertBit = 2,
2479 SqlConvertChar = 3,
2480 SqlConvertDate = 4,
2481 SqlConvertDecimal = 5,
2482 SqlConvertFloat = 6,
2483 SqlConvertInteger = 7,
2484 SqlConvertIntervalDayTime = 8,
2485 SqlConvertIntervalYearMonth = 9,
2486 SqlConvertLongvarbinary = 10,
2487 SqlConvertLongvarchar = 11,
2488 SqlConvertNumeric = 12,
2489 SqlConvertReal = 13,
2490 SqlConvertSmallint = 14,
2491 SqlConvertTime = 15,
2492 SqlConvertTimestamp = 16,
2493 SqlConvertTinyint = 17,
2494 SqlConvertVarbinary = 18,
2495 SqlConvertVarchar = 19,
2496}
2497impl SqlSupportsConvert {
2498 /// String value of the enum field names used in the ProtoBuf definition.
2499 ///
2500 /// The values are not transformed in any way and thus are considered stable
2501 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2502 pub fn as_str_name(&self) -> &'static str {
2503 match self {
2504 Self::SqlConvertBigint => "SQL_CONVERT_BIGINT",
2505 Self::SqlConvertBinary => "SQL_CONVERT_BINARY",
2506 Self::SqlConvertBit => "SQL_CONVERT_BIT",
2507 Self::SqlConvertChar => "SQL_CONVERT_CHAR",
2508 Self::SqlConvertDate => "SQL_CONVERT_DATE",
2509 Self::SqlConvertDecimal => "SQL_CONVERT_DECIMAL",
2510 Self::SqlConvertFloat => "SQL_CONVERT_FLOAT",
2511 Self::SqlConvertInteger => "SQL_CONVERT_INTEGER",
2512 Self::SqlConvertIntervalDayTime => "SQL_CONVERT_INTERVAL_DAY_TIME",
2513 Self::SqlConvertIntervalYearMonth => "SQL_CONVERT_INTERVAL_YEAR_MONTH",
2514 Self::SqlConvertLongvarbinary => "SQL_CONVERT_LONGVARBINARY",
2515 Self::SqlConvertLongvarchar => "SQL_CONVERT_LONGVARCHAR",
2516 Self::SqlConvertNumeric => "SQL_CONVERT_NUMERIC",
2517 Self::SqlConvertReal => "SQL_CONVERT_REAL",
2518 Self::SqlConvertSmallint => "SQL_CONVERT_SMALLINT",
2519 Self::SqlConvertTime => "SQL_CONVERT_TIME",
2520 Self::SqlConvertTimestamp => "SQL_CONVERT_TIMESTAMP",
2521 Self::SqlConvertTinyint => "SQL_CONVERT_TINYINT",
2522 Self::SqlConvertVarbinary => "SQL_CONVERT_VARBINARY",
2523 Self::SqlConvertVarchar => "SQL_CONVERT_VARCHAR",
2524 }
2525 }
2526 /// Creates an enum from field names used in the ProtoBuf definition.
2527 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2528 match value {
2529 "SQL_CONVERT_BIGINT" => Some(Self::SqlConvertBigint),
2530 "SQL_CONVERT_BINARY" => Some(Self::SqlConvertBinary),
2531 "SQL_CONVERT_BIT" => Some(Self::SqlConvertBit),
2532 "SQL_CONVERT_CHAR" => Some(Self::SqlConvertChar),
2533 "SQL_CONVERT_DATE" => Some(Self::SqlConvertDate),
2534 "SQL_CONVERT_DECIMAL" => Some(Self::SqlConvertDecimal),
2535 "SQL_CONVERT_FLOAT" => Some(Self::SqlConvertFloat),
2536 "SQL_CONVERT_INTEGER" => Some(Self::SqlConvertInteger),
2537 "SQL_CONVERT_INTERVAL_DAY_TIME" => Some(Self::SqlConvertIntervalDayTime),
2538 "SQL_CONVERT_INTERVAL_YEAR_MONTH" => Some(Self::SqlConvertIntervalYearMonth),
2539 "SQL_CONVERT_LONGVARBINARY" => Some(Self::SqlConvertLongvarbinary),
2540 "SQL_CONVERT_LONGVARCHAR" => Some(Self::SqlConvertLongvarchar),
2541 "SQL_CONVERT_NUMERIC" => Some(Self::SqlConvertNumeric),
2542 "SQL_CONVERT_REAL" => Some(Self::SqlConvertReal),
2543 "SQL_CONVERT_SMALLINT" => Some(Self::SqlConvertSmallint),
2544 "SQL_CONVERT_TIME" => Some(Self::SqlConvertTime),
2545 "SQL_CONVERT_TIMESTAMP" => Some(Self::SqlConvertTimestamp),
2546 "SQL_CONVERT_TINYINT" => Some(Self::SqlConvertTinyint),
2547 "SQL_CONVERT_VARBINARY" => Some(Self::SqlConvertVarbinary),
2548 "SQL_CONVERT_VARCHAR" => Some(Self::SqlConvertVarchar),
2549 _ => None,
2550 }
2551 }
2552}
2553/// *
2554/// The JDBC/ODBC-defined type of any object.
2555/// All the values here are the same as in the JDBC and ODBC specs.
2556#[allow(clippy::all)]
2557#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2558#[repr(i32)]
2559pub enum XdbcDataType {
2560 XdbcUnknownType = 0,
2561 XdbcChar = 1,
2562 XdbcNumeric = 2,
2563 XdbcDecimal = 3,
2564 XdbcInteger = 4,
2565 XdbcSmallint = 5,
2566 XdbcFloat = 6,
2567 XdbcReal = 7,
2568 XdbcDouble = 8,
2569 XdbcDatetime = 9,
2570 XdbcInterval = 10,
2571 XdbcVarchar = 12,
2572 XdbcDate = 91,
2573 XdbcTime = 92,
2574 XdbcTimestamp = 93,
2575 XdbcLongvarchar = -1,
2576 XdbcBinary = -2,
2577 XdbcVarbinary = -3,
2578 XdbcLongvarbinary = -4,
2579 XdbcBigint = -5,
2580 XdbcTinyint = -6,
2581 XdbcBit = -7,
2582 XdbcWchar = -8,
2583 XdbcWvarchar = -9,
2584}
2585impl XdbcDataType {
2586 /// String value of the enum field names used in the ProtoBuf definition.
2587 ///
2588 /// The values are not transformed in any way and thus are considered stable
2589 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2590 pub fn as_str_name(&self) -> &'static str {
2591 match self {
2592 Self::XdbcUnknownType => "XDBC_UNKNOWN_TYPE",
2593 Self::XdbcChar => "XDBC_CHAR",
2594 Self::XdbcNumeric => "XDBC_NUMERIC",
2595 Self::XdbcDecimal => "XDBC_DECIMAL",
2596 Self::XdbcInteger => "XDBC_INTEGER",
2597 Self::XdbcSmallint => "XDBC_SMALLINT",
2598 Self::XdbcFloat => "XDBC_FLOAT",
2599 Self::XdbcReal => "XDBC_REAL",
2600 Self::XdbcDouble => "XDBC_DOUBLE",
2601 Self::XdbcDatetime => "XDBC_DATETIME",
2602 Self::XdbcInterval => "XDBC_INTERVAL",
2603 Self::XdbcVarchar => "XDBC_VARCHAR",
2604 Self::XdbcDate => "XDBC_DATE",
2605 Self::XdbcTime => "XDBC_TIME",
2606 Self::XdbcTimestamp => "XDBC_TIMESTAMP",
2607 Self::XdbcLongvarchar => "XDBC_LONGVARCHAR",
2608 Self::XdbcBinary => "XDBC_BINARY",
2609 Self::XdbcVarbinary => "XDBC_VARBINARY",
2610 Self::XdbcLongvarbinary => "XDBC_LONGVARBINARY",
2611 Self::XdbcBigint => "XDBC_BIGINT",
2612 Self::XdbcTinyint => "XDBC_TINYINT",
2613 Self::XdbcBit => "XDBC_BIT",
2614 Self::XdbcWchar => "XDBC_WCHAR",
2615 Self::XdbcWvarchar => "XDBC_WVARCHAR",
2616 }
2617 }
2618 /// Creates an enum from field names used in the ProtoBuf definition.
2619 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2620 match value {
2621 "XDBC_UNKNOWN_TYPE" => Some(Self::XdbcUnknownType),
2622 "XDBC_CHAR" => Some(Self::XdbcChar),
2623 "XDBC_NUMERIC" => Some(Self::XdbcNumeric),
2624 "XDBC_DECIMAL" => Some(Self::XdbcDecimal),
2625 "XDBC_INTEGER" => Some(Self::XdbcInteger),
2626 "XDBC_SMALLINT" => Some(Self::XdbcSmallint),
2627 "XDBC_FLOAT" => Some(Self::XdbcFloat),
2628 "XDBC_REAL" => Some(Self::XdbcReal),
2629 "XDBC_DOUBLE" => Some(Self::XdbcDouble),
2630 "XDBC_DATETIME" => Some(Self::XdbcDatetime),
2631 "XDBC_INTERVAL" => Some(Self::XdbcInterval),
2632 "XDBC_VARCHAR" => Some(Self::XdbcVarchar),
2633 "XDBC_DATE" => Some(Self::XdbcDate),
2634 "XDBC_TIME" => Some(Self::XdbcTime),
2635 "XDBC_TIMESTAMP" => Some(Self::XdbcTimestamp),
2636 "XDBC_LONGVARCHAR" => Some(Self::XdbcLongvarchar),
2637 "XDBC_BINARY" => Some(Self::XdbcBinary),
2638 "XDBC_VARBINARY" => Some(Self::XdbcVarbinary),
2639 "XDBC_LONGVARBINARY" => Some(Self::XdbcLongvarbinary),
2640 "XDBC_BIGINT" => Some(Self::XdbcBigint),
2641 "XDBC_TINYINT" => Some(Self::XdbcTinyint),
2642 "XDBC_BIT" => Some(Self::XdbcBit),
2643 "XDBC_WCHAR" => Some(Self::XdbcWchar),
2644 "XDBC_WVARCHAR" => Some(Self::XdbcWvarchar),
2645 _ => None,
2646 }
2647 }
2648}
2649/// *
2650/// Detailed subtype information for XDBC_TYPE_DATETIME and XDBC_TYPE_INTERVAL.
2651#[allow(clippy::all)]
2652#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2653#[repr(i32)]
2654pub enum XdbcDatetimeSubcode {
2655 XdbcSubcodeUnknown = 0,
2656 XdbcSubcodeYear = 1,
2657 XdbcSubcodeTime = 2,
2658 XdbcSubcodeTimestamp = 3,
2659 XdbcSubcodeTimeWithTimezone = 4,
2660 XdbcSubcodeTimestampWithTimezone = 5,
2661 XdbcSubcodeSecond = 6,
2662 XdbcSubcodeYearToMonth = 7,
2663 XdbcSubcodeDayToHour = 8,
2664 XdbcSubcodeDayToMinute = 9,
2665 XdbcSubcodeDayToSecond = 10,
2666 XdbcSubcodeHourToMinute = 11,
2667 XdbcSubcodeHourToSecond = 12,
2668 XdbcSubcodeMinuteToSecond = 13,
2669 XdbcSubcodeIntervalYear = 101,
2670 XdbcSubcodeIntervalMonth = 102,
2671 XdbcSubcodeIntervalDay = 103,
2672 XdbcSubcodeIntervalHour = 104,
2673 XdbcSubcodeIntervalMinute = 105,
2674 XdbcSubcodeIntervalSecond = 106,
2675 XdbcSubcodeIntervalYearToMonth = 107,
2676 XdbcSubcodeIntervalDayToHour = 108,
2677 XdbcSubcodeIntervalDayToMinute = 109,
2678 XdbcSubcodeIntervalDayToSecond = 110,
2679 XdbcSubcodeIntervalHourToMinute = 111,
2680 XdbcSubcodeIntervalHourToSecond = 112,
2681 XdbcSubcodeIntervalMinuteToSecond = 113,
2682}
2683impl XdbcDatetimeSubcode {
2684 /// String value of the enum field names used in the ProtoBuf definition.
2685 ///
2686 /// The values are not transformed in any way and thus are considered stable
2687 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2688 pub fn as_str_name(&self) -> &'static str {
2689 match self {
2690 Self::XdbcSubcodeUnknown => "XDBC_SUBCODE_UNKNOWN",
2691 Self::XdbcSubcodeYear => "XDBC_SUBCODE_YEAR",
2692 Self::XdbcSubcodeTime => "XDBC_SUBCODE_TIME",
2693 Self::XdbcSubcodeTimestamp => "XDBC_SUBCODE_TIMESTAMP",
2694 Self::XdbcSubcodeTimeWithTimezone => "XDBC_SUBCODE_TIME_WITH_TIMEZONE",
2695 Self::XdbcSubcodeTimestampWithTimezone => {
2696 "XDBC_SUBCODE_TIMESTAMP_WITH_TIMEZONE"
2697 }
2698 Self::XdbcSubcodeSecond => "XDBC_SUBCODE_SECOND",
2699 Self::XdbcSubcodeYearToMonth => "XDBC_SUBCODE_YEAR_TO_MONTH",
2700 Self::XdbcSubcodeDayToHour => "XDBC_SUBCODE_DAY_TO_HOUR",
2701 Self::XdbcSubcodeDayToMinute => "XDBC_SUBCODE_DAY_TO_MINUTE",
2702 Self::XdbcSubcodeDayToSecond => "XDBC_SUBCODE_DAY_TO_SECOND",
2703 Self::XdbcSubcodeHourToMinute => "XDBC_SUBCODE_HOUR_TO_MINUTE",
2704 Self::XdbcSubcodeHourToSecond => "XDBC_SUBCODE_HOUR_TO_SECOND",
2705 Self::XdbcSubcodeMinuteToSecond => "XDBC_SUBCODE_MINUTE_TO_SECOND",
2706 Self::XdbcSubcodeIntervalYear => "XDBC_SUBCODE_INTERVAL_YEAR",
2707 Self::XdbcSubcodeIntervalMonth => "XDBC_SUBCODE_INTERVAL_MONTH",
2708 Self::XdbcSubcodeIntervalDay => "XDBC_SUBCODE_INTERVAL_DAY",
2709 Self::XdbcSubcodeIntervalHour => "XDBC_SUBCODE_INTERVAL_HOUR",
2710 Self::XdbcSubcodeIntervalMinute => "XDBC_SUBCODE_INTERVAL_MINUTE",
2711 Self::XdbcSubcodeIntervalSecond => "XDBC_SUBCODE_INTERVAL_SECOND",
2712 Self::XdbcSubcodeIntervalYearToMonth => "XDBC_SUBCODE_INTERVAL_YEAR_TO_MONTH",
2713 Self::XdbcSubcodeIntervalDayToHour => "XDBC_SUBCODE_INTERVAL_DAY_TO_HOUR",
2714 Self::XdbcSubcodeIntervalDayToMinute => "XDBC_SUBCODE_INTERVAL_DAY_TO_MINUTE",
2715 Self::XdbcSubcodeIntervalDayToSecond => "XDBC_SUBCODE_INTERVAL_DAY_TO_SECOND",
2716 Self::XdbcSubcodeIntervalHourToMinute => {
2717 "XDBC_SUBCODE_INTERVAL_HOUR_TO_MINUTE"
2718 }
2719 Self::XdbcSubcodeIntervalHourToSecond => {
2720 "XDBC_SUBCODE_INTERVAL_HOUR_TO_SECOND"
2721 }
2722 Self::XdbcSubcodeIntervalMinuteToSecond => {
2723 "XDBC_SUBCODE_INTERVAL_MINUTE_TO_SECOND"
2724 }
2725 }
2726 }
2727 /// Creates an enum from field names used in the ProtoBuf definition.
2728 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2729 match value {
2730 "XDBC_SUBCODE_UNKNOWN" => Some(Self::XdbcSubcodeUnknown),
2731 "XDBC_SUBCODE_YEAR" => Some(Self::XdbcSubcodeYear),
2732 "XDBC_SUBCODE_TIME" => Some(Self::XdbcSubcodeTime),
2733 "XDBC_SUBCODE_TIMESTAMP" => Some(Self::XdbcSubcodeTimestamp),
2734 "XDBC_SUBCODE_TIME_WITH_TIMEZONE" => Some(Self::XdbcSubcodeTimeWithTimezone),
2735 "XDBC_SUBCODE_TIMESTAMP_WITH_TIMEZONE" => {
2736 Some(Self::XdbcSubcodeTimestampWithTimezone)
2737 }
2738 "XDBC_SUBCODE_SECOND" => Some(Self::XdbcSubcodeSecond),
2739 "XDBC_SUBCODE_YEAR_TO_MONTH" => Some(Self::XdbcSubcodeYearToMonth),
2740 "XDBC_SUBCODE_DAY_TO_HOUR" => Some(Self::XdbcSubcodeDayToHour),
2741 "XDBC_SUBCODE_DAY_TO_MINUTE" => Some(Self::XdbcSubcodeDayToMinute),
2742 "XDBC_SUBCODE_DAY_TO_SECOND" => Some(Self::XdbcSubcodeDayToSecond),
2743 "XDBC_SUBCODE_HOUR_TO_MINUTE" => Some(Self::XdbcSubcodeHourToMinute),
2744 "XDBC_SUBCODE_HOUR_TO_SECOND" => Some(Self::XdbcSubcodeHourToSecond),
2745 "XDBC_SUBCODE_MINUTE_TO_SECOND" => Some(Self::XdbcSubcodeMinuteToSecond),
2746 "XDBC_SUBCODE_INTERVAL_YEAR" => Some(Self::XdbcSubcodeIntervalYear),
2747 "XDBC_SUBCODE_INTERVAL_MONTH" => Some(Self::XdbcSubcodeIntervalMonth),
2748 "XDBC_SUBCODE_INTERVAL_DAY" => Some(Self::XdbcSubcodeIntervalDay),
2749 "XDBC_SUBCODE_INTERVAL_HOUR" => Some(Self::XdbcSubcodeIntervalHour),
2750 "XDBC_SUBCODE_INTERVAL_MINUTE" => Some(Self::XdbcSubcodeIntervalMinute),
2751 "XDBC_SUBCODE_INTERVAL_SECOND" => Some(Self::XdbcSubcodeIntervalSecond),
2752 "XDBC_SUBCODE_INTERVAL_YEAR_TO_MONTH" => {
2753 Some(Self::XdbcSubcodeIntervalYearToMonth)
2754 }
2755 "XDBC_SUBCODE_INTERVAL_DAY_TO_HOUR" => {
2756 Some(Self::XdbcSubcodeIntervalDayToHour)
2757 }
2758 "XDBC_SUBCODE_INTERVAL_DAY_TO_MINUTE" => {
2759 Some(Self::XdbcSubcodeIntervalDayToMinute)
2760 }
2761 "XDBC_SUBCODE_INTERVAL_DAY_TO_SECOND" => {
2762 Some(Self::XdbcSubcodeIntervalDayToSecond)
2763 }
2764 "XDBC_SUBCODE_INTERVAL_HOUR_TO_MINUTE" => {
2765 Some(Self::XdbcSubcodeIntervalHourToMinute)
2766 }
2767 "XDBC_SUBCODE_INTERVAL_HOUR_TO_SECOND" => {
2768 Some(Self::XdbcSubcodeIntervalHourToSecond)
2769 }
2770 "XDBC_SUBCODE_INTERVAL_MINUTE_TO_SECOND" => {
2771 Some(Self::XdbcSubcodeIntervalMinuteToSecond)
2772 }
2773 _ => None,
2774 }
2775 }
2776}
2777#[allow(clippy::all)]
2778#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2779#[repr(i32)]
2780pub enum Nullable {
2781 /// *
2782 /// Indicates that the field does not allow the use of null values.
2783 NullabilityNoNulls = 0,
2784 /// *
2785 /// Indicates that the fields allow the use of null values.
2786 NullabilityNullable = 1,
2787 /// *
2788 /// Indicates that nullability of the fields cannot be determined.
2789 NullabilityUnknown = 2,
2790}
2791impl Nullable {
2792 /// String value of the enum field names used in the ProtoBuf definition.
2793 ///
2794 /// The values are not transformed in any way and thus are considered stable
2795 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2796 pub fn as_str_name(&self) -> &'static str {
2797 match self {
2798 Self::NullabilityNoNulls => "NULLABILITY_NO_NULLS",
2799 Self::NullabilityNullable => "NULLABILITY_NULLABLE",
2800 Self::NullabilityUnknown => "NULLABILITY_UNKNOWN",
2801 }
2802 }
2803 /// Creates an enum from field names used in the ProtoBuf definition.
2804 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2805 match value {
2806 "NULLABILITY_NO_NULLS" => Some(Self::NullabilityNoNulls),
2807 "NULLABILITY_NULLABLE" => Some(Self::NullabilityNullable),
2808 "NULLABILITY_UNKNOWN" => Some(Self::NullabilityUnknown),
2809 _ => None,
2810 }
2811 }
2812}
2813#[allow(clippy::all)]
2814#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2815#[repr(i32)]
2816pub enum Searchable {
2817 /// *
2818 /// Indicates that column cannot be used in a WHERE clause.
2819 None = 0,
2820 /// *
2821 /// Indicates that the column can be used in a WHERE clause if it is using a
2822 /// LIKE operator.
2823 Char = 1,
2824 /// *
2825 /// Indicates that the column can be used In a WHERE clause with any
2826 /// operator other than LIKE.
2827 ///
2828 /// - Allowed operators: comparison, quantified comparison, BETWEEN,
2829 /// DISTINCT, IN, MATCH, and UNIQUE.
2830 Basic = 2,
2831 /// *
2832 /// Indicates that the column can be used in a WHERE clause using any operator.
2833 Full = 3,
2834}
2835impl Searchable {
2836 /// String value of the enum field names used in the ProtoBuf definition.
2837 ///
2838 /// The values are not transformed in any way and thus are considered stable
2839 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2840 pub fn as_str_name(&self) -> &'static str {
2841 match self {
2842 Self::None => "SEARCHABLE_NONE",
2843 Self::Char => "SEARCHABLE_CHAR",
2844 Self::Basic => "SEARCHABLE_BASIC",
2845 Self::Full => "SEARCHABLE_FULL",
2846 }
2847 }
2848 /// Creates an enum from field names used in the ProtoBuf definition.
2849 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2850 match value {
2851 "SEARCHABLE_NONE" => Some(Self::None),
2852 "SEARCHABLE_CHAR" => Some(Self::Char),
2853 "SEARCHABLE_BASIC" => Some(Self::Basic),
2854 "SEARCHABLE_FULL" => Some(Self::Full),
2855 _ => None,
2856 }
2857 }
2858}
2859#[allow(clippy::all)]
2860#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2861#[repr(i32)]
2862pub enum UpdateDeleteRules {
2863 Cascade = 0,
2864 Restrict = 1,
2865 SetNull = 2,
2866 NoAction = 3,
2867 SetDefault = 4,
2868}
2869impl UpdateDeleteRules {
2870 /// String value of the enum field names used in the ProtoBuf definition.
2871 ///
2872 /// The values are not transformed in any way and thus are considered stable
2873 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2874 pub fn as_str_name(&self) -> &'static str {
2875 match self {
2876 Self::Cascade => "CASCADE",
2877 Self::Restrict => "RESTRICT",
2878 Self::SetNull => "SET_NULL",
2879 Self::NoAction => "NO_ACTION",
2880 Self::SetDefault => "SET_DEFAULT",
2881 }
2882 }
2883 /// Creates an enum from field names used in the ProtoBuf definition.
2884 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2885 match value {
2886 "CASCADE" => Some(Self::Cascade),
2887 "RESTRICT" => Some(Self::Restrict),
2888 "SET_NULL" => Some(Self::SetNull),
2889 "NO_ACTION" => Some(Self::NoAction),
2890 "SET_DEFAULT" => Some(Self::SetDefault),
2891 _ => None,
2892 }
2893 }
2894}