lance_namespace_reqwest_client/apis/
table_api.rs

1/*
2 * Lance Namespace Specification
3 *
4 * This OpenAPI specification is a part of the Lance namespace specification. It contains 2 parts:  The `components/schemas`, `components/responses`, `components/examples`, `tags` sections define the request and response shape for each operation in a Lance Namespace across all implementations. See https://lance.org/format/namespace/operations for more details.  The `servers`, `security`, `paths`, `components/parameters` sections are for the Lance REST Namespace implementation, which defines a complete REST server that can work with Lance datasets. See https://lance.org/format/namespace/rest for more details. 
5 *
6 * The version of the OpenAPI document: 1.0.0
7 * 
8 * Generated by: https://openapi-generator.tech
9 */
10
11
12use reqwest;
13use serde::{Deserialize, Serialize, de::Error as _};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration, ContentType};
16
17
18/// struct for typed errors of method [`alter_table_add_columns`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum AlterTableAddColumnsError {
22    Status400(models::ErrorResponse),
23    Status401(models::ErrorResponse),
24    Status403(models::ErrorResponse),
25    Status404(models::ErrorResponse),
26    Status503(models::ErrorResponse),
27    Status5XX(models::ErrorResponse),
28    UnknownValue(serde_json::Value),
29}
30
31/// struct for typed errors of method [`alter_table_alter_columns`]
32#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum AlterTableAlterColumnsError {
35    Status400(models::ErrorResponse),
36    Status401(models::ErrorResponse),
37    Status403(models::ErrorResponse),
38    Status404(models::ErrorResponse),
39    Status503(models::ErrorResponse),
40    Status5XX(models::ErrorResponse),
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`alter_table_backfill_columns`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum AlterTableBackfillColumnsError {
48    Status400(models::ErrorResponse),
49    Status401(models::ErrorResponse),
50    Status403(models::ErrorResponse),
51    Status404(models::ErrorResponse),
52    Status503(models::ErrorResponse),
53    Status5XX(models::ErrorResponse),
54    UnknownValue(serde_json::Value),
55}
56
57/// struct for typed errors of method [`alter_table_drop_columns`]
58#[derive(Debug, Clone, Serialize, Deserialize)]
59#[serde(untagged)]
60pub enum AlterTableDropColumnsError {
61    Status400(models::ErrorResponse),
62    Status401(models::ErrorResponse),
63    Status403(models::ErrorResponse),
64    Status404(models::ErrorResponse),
65    Status503(models::ErrorResponse),
66    Status5XX(models::ErrorResponse),
67    UnknownValue(serde_json::Value),
68}
69
70/// struct for typed errors of method [`analyze_table_query_plan`]
71#[derive(Debug, Clone, Serialize, Deserialize)]
72#[serde(untagged)]
73pub enum AnalyzeTableQueryPlanError {
74    Status400(models::ErrorResponse),
75    Status401(models::ErrorResponse),
76    Status403(models::ErrorResponse),
77    Status404(models::ErrorResponse),
78    Status503(models::ErrorResponse),
79    Status5XX(models::ErrorResponse),
80    UnknownValue(serde_json::Value),
81}
82
83/// struct for typed errors of method [`batch_commit_tables`]
84#[derive(Debug, Clone, Serialize, Deserialize)]
85#[serde(untagged)]
86pub enum BatchCommitTablesError {
87    Status400(models::ErrorResponse),
88    Status401(models::ErrorResponse),
89    Status403(models::ErrorResponse),
90    Status404(models::ErrorResponse),
91    Status409(models::ErrorResponse),
92    Status503(models::ErrorResponse),
93    Status5XX(models::ErrorResponse),
94    UnknownValue(serde_json::Value),
95}
96
97/// struct for typed errors of method [`batch_create_table_versions`]
98#[derive(Debug, Clone, Serialize, Deserialize)]
99#[serde(untagged)]
100pub enum BatchCreateTableVersionsError {
101    Status400(models::ErrorResponse),
102    Status401(models::ErrorResponse),
103    Status403(models::ErrorResponse),
104    Status404(models::ErrorResponse),
105    Status409(models::ErrorResponse),
106    Status503(models::ErrorResponse),
107    Status5XX(models::ErrorResponse),
108    UnknownValue(serde_json::Value),
109}
110
111/// struct for typed errors of method [`batch_delete_table_versions`]
112#[derive(Debug, Clone, Serialize, Deserialize)]
113#[serde(untagged)]
114pub enum BatchDeleteTableVersionsError {
115    Status400(models::ErrorResponse),
116    Status401(models::ErrorResponse),
117    Status403(models::ErrorResponse),
118    Status404(models::ErrorResponse),
119    Status503(models::ErrorResponse),
120    Status5XX(models::ErrorResponse),
121    UnknownValue(serde_json::Value),
122}
123
124/// struct for typed errors of method [`count_table_rows`]
125#[derive(Debug, Clone, Serialize, Deserialize)]
126#[serde(untagged)]
127pub enum CountTableRowsError {
128    Status400(models::ErrorResponse),
129    Status401(models::ErrorResponse),
130    Status403(models::ErrorResponse),
131    Status404(models::ErrorResponse),
132    Status503(models::ErrorResponse),
133    Status5XX(models::ErrorResponse),
134    UnknownValue(serde_json::Value),
135}
136
137/// struct for typed errors of method [`create_table`]
138#[derive(Debug, Clone, Serialize, Deserialize)]
139#[serde(untagged)]
140pub enum CreateTableError {
141    Status400(models::ErrorResponse),
142    Status401(models::ErrorResponse),
143    Status403(models::ErrorResponse),
144    Status404(models::ErrorResponse),
145    Status409(models::ErrorResponse),
146    Status503(models::ErrorResponse),
147    Status5XX(models::ErrorResponse),
148    UnknownValue(serde_json::Value),
149}
150
151/// struct for typed errors of method [`create_table_branch`]
152#[derive(Debug, Clone, Serialize, Deserialize)]
153#[serde(untagged)]
154pub enum CreateTableBranchError {
155    Status400(models::ErrorResponse),
156    Status401(models::ErrorResponse),
157    Status403(models::ErrorResponse),
158    Status404(models::ErrorResponse),
159    Status409(models::ErrorResponse),
160    Status503(models::ErrorResponse),
161    Status5XX(models::ErrorResponse),
162    UnknownValue(serde_json::Value),
163}
164
165/// struct for typed errors of method [`create_table_index`]
166#[derive(Debug, Clone, Serialize, Deserialize)]
167#[serde(untagged)]
168pub enum CreateTableIndexError {
169    Status400(models::ErrorResponse),
170    Status401(models::ErrorResponse),
171    Status403(models::ErrorResponse),
172    Status404(models::ErrorResponse),
173    Status503(models::ErrorResponse),
174    Status5XX(models::ErrorResponse),
175    UnknownValue(serde_json::Value),
176}
177
178/// struct for typed errors of method [`create_table_scalar_index`]
179#[derive(Debug, Clone, Serialize, Deserialize)]
180#[serde(untagged)]
181pub enum CreateTableScalarIndexError {
182    Status400(models::ErrorResponse),
183    Status401(models::ErrorResponse),
184    Status403(models::ErrorResponse),
185    Status404(models::ErrorResponse),
186    Status503(models::ErrorResponse),
187    Status5XX(models::ErrorResponse),
188    UnknownValue(serde_json::Value),
189}
190
191/// struct for typed errors of method [`create_table_tag`]
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(untagged)]
194pub enum CreateTableTagError {
195    Status400(models::ErrorResponse),
196    Status401(models::ErrorResponse),
197    Status403(models::ErrorResponse),
198    Status404(models::ErrorResponse),
199    Status409(models::ErrorResponse),
200    Status503(models::ErrorResponse),
201    Status5XX(models::ErrorResponse),
202    UnknownValue(serde_json::Value),
203}
204
205/// struct for typed errors of method [`create_table_version`]
206#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(untagged)]
208pub enum CreateTableVersionError {
209    Status400(models::ErrorResponse),
210    Status401(models::ErrorResponse),
211    Status403(models::ErrorResponse),
212    Status404(models::ErrorResponse),
213    Status409(models::ErrorResponse),
214    Status503(models::ErrorResponse),
215    Status5XX(models::ErrorResponse),
216    UnknownValue(serde_json::Value),
217}
218
219/// struct for typed errors of method [`declare_table`]
220#[derive(Debug, Clone, Serialize, Deserialize)]
221#[serde(untagged)]
222pub enum DeclareTableError {
223    Status400(models::ErrorResponse),
224    Status401(models::ErrorResponse),
225    Status403(models::ErrorResponse),
226    Status404(models::ErrorResponse),
227    Status409(models::ErrorResponse),
228    Status503(models::ErrorResponse),
229    Status5XX(models::ErrorResponse),
230    UnknownValue(serde_json::Value),
231}
232
233/// struct for typed errors of method [`delete_from_table`]
234#[derive(Debug, Clone, Serialize, Deserialize)]
235#[serde(untagged)]
236pub enum DeleteFromTableError {
237    Status400(models::ErrorResponse),
238    Status401(models::ErrorResponse),
239    Status403(models::ErrorResponse),
240    Status404(models::ErrorResponse),
241    Status503(models::ErrorResponse),
242    Status5XX(models::ErrorResponse),
243    UnknownValue(serde_json::Value),
244}
245
246/// struct for typed errors of method [`delete_table_branch`]
247#[derive(Debug, Clone, Serialize, Deserialize)]
248#[serde(untagged)]
249pub enum DeleteTableBranchError {
250    Status400(models::ErrorResponse),
251    Status401(models::ErrorResponse),
252    Status403(models::ErrorResponse),
253    Status404(models::ErrorResponse),
254    Status503(models::ErrorResponse),
255    Status5XX(models::ErrorResponse),
256    UnknownValue(serde_json::Value),
257}
258
259/// struct for typed errors of method [`delete_table_tag`]
260#[derive(Debug, Clone, Serialize, Deserialize)]
261#[serde(untagged)]
262pub enum DeleteTableTagError {
263    Status400(models::ErrorResponse),
264    Status401(models::ErrorResponse),
265    Status403(models::ErrorResponse),
266    Status404(models::ErrorResponse),
267    Status503(models::ErrorResponse),
268    Status5XX(models::ErrorResponse),
269    UnknownValue(serde_json::Value),
270}
271
272/// struct for typed errors of method [`deregister_table`]
273#[derive(Debug, Clone, Serialize, Deserialize)]
274#[serde(untagged)]
275pub enum DeregisterTableError {
276    Status400(models::ErrorResponse),
277    Status401(models::ErrorResponse),
278    Status403(models::ErrorResponse),
279    Status404(models::ErrorResponse),
280    Status503(models::ErrorResponse),
281    Status5XX(models::ErrorResponse),
282    UnknownValue(serde_json::Value),
283}
284
285/// struct for typed errors of method [`describe_table`]
286#[derive(Debug, Clone, Serialize, Deserialize)]
287#[serde(untagged)]
288pub enum DescribeTableError {
289    Status400(models::ErrorResponse),
290    Status401(models::ErrorResponse),
291    Status403(models::ErrorResponse),
292    Status404(models::ErrorResponse),
293    Status503(models::ErrorResponse),
294    Status5XX(models::ErrorResponse),
295    UnknownValue(serde_json::Value),
296}
297
298/// struct for typed errors of method [`describe_table_index_stats`]
299#[derive(Debug, Clone, Serialize, Deserialize)]
300#[serde(untagged)]
301pub enum DescribeTableIndexStatsError {
302    Status400(models::ErrorResponse),
303    Status401(models::ErrorResponse),
304    Status403(models::ErrorResponse),
305    Status404(models::ErrorResponse),
306    Status503(models::ErrorResponse),
307    Status5XX(models::ErrorResponse),
308    UnknownValue(serde_json::Value),
309}
310
311/// struct for typed errors of method [`describe_table_version`]
312#[derive(Debug, Clone, Serialize, Deserialize)]
313#[serde(untagged)]
314pub enum DescribeTableVersionError {
315    Status400(models::ErrorResponse),
316    Status401(models::ErrorResponse),
317    Status403(models::ErrorResponse),
318    Status404(models::ErrorResponse),
319    Status503(models::ErrorResponse),
320    Status5XX(models::ErrorResponse),
321    UnknownValue(serde_json::Value),
322}
323
324/// struct for typed errors of method [`drop_table`]
325#[derive(Debug, Clone, Serialize, Deserialize)]
326#[serde(untagged)]
327pub enum DropTableError {
328    Status400(models::ErrorResponse),
329    Status401(models::ErrorResponse),
330    Status403(models::ErrorResponse),
331    Status404(models::ErrorResponse),
332    Status503(models::ErrorResponse),
333    Status5XX(models::ErrorResponse),
334    UnknownValue(serde_json::Value),
335}
336
337/// struct for typed errors of method [`drop_table_index`]
338#[derive(Debug, Clone, Serialize, Deserialize)]
339#[serde(untagged)]
340pub enum DropTableIndexError {
341    Status400(models::ErrorResponse),
342    Status401(models::ErrorResponse),
343    Status403(models::ErrorResponse),
344    Status404(models::ErrorResponse),
345    Status503(models::ErrorResponse),
346    Status5XX(models::ErrorResponse),
347    UnknownValue(serde_json::Value),
348}
349
350/// struct for typed errors of method [`explain_table_query_plan`]
351#[derive(Debug, Clone, Serialize, Deserialize)]
352#[serde(untagged)]
353pub enum ExplainTableQueryPlanError {
354    Status400(models::ErrorResponse),
355    Status401(models::ErrorResponse),
356    Status403(models::ErrorResponse),
357    Status404(models::ErrorResponse),
358    Status503(models::ErrorResponse),
359    Status5XX(models::ErrorResponse),
360    UnknownValue(serde_json::Value),
361}
362
363/// struct for typed errors of method [`get_table_stats`]
364#[derive(Debug, Clone, Serialize, Deserialize)]
365#[serde(untagged)]
366pub enum GetTableStatsError {
367    Status400(models::ErrorResponse),
368    Status401(models::ErrorResponse),
369    Status403(models::ErrorResponse),
370    Status404(models::ErrorResponse),
371    Status503(models::ErrorResponse),
372    Status5XX(models::ErrorResponse),
373    UnknownValue(serde_json::Value),
374}
375
376/// struct for typed errors of method [`get_table_tag_version`]
377#[derive(Debug, Clone, Serialize, Deserialize)]
378#[serde(untagged)]
379pub enum GetTableTagVersionError {
380    Status400(models::ErrorResponse),
381    Status401(models::ErrorResponse),
382    Status403(models::ErrorResponse),
383    Status404(models::ErrorResponse),
384    Status503(models::ErrorResponse),
385    Status5XX(models::ErrorResponse),
386    UnknownValue(serde_json::Value),
387}
388
389/// struct for typed errors of method [`insert_into_table`]
390#[derive(Debug, Clone, Serialize, Deserialize)]
391#[serde(untagged)]
392pub enum InsertIntoTableError {
393    Status400(models::ErrorResponse),
394    Status401(models::ErrorResponse),
395    Status403(models::ErrorResponse),
396    Status404(models::ErrorResponse),
397    Status503(models::ErrorResponse),
398    Status5XX(models::ErrorResponse),
399    UnknownValue(serde_json::Value),
400}
401
402/// struct for typed errors of method [`list_all_tables`]
403#[derive(Debug, Clone, Serialize, Deserialize)]
404#[serde(untagged)]
405pub enum ListAllTablesError {
406    Status400(models::ErrorResponse),
407    Status401(models::ErrorResponse),
408    Status403(models::ErrorResponse),
409    Status503(models::ErrorResponse),
410    Status5XX(models::ErrorResponse),
411    UnknownValue(serde_json::Value),
412}
413
414/// struct for typed errors of method [`list_table_branches`]
415#[derive(Debug, Clone, Serialize, Deserialize)]
416#[serde(untagged)]
417pub enum ListTableBranchesError {
418    Status400(models::ErrorResponse),
419    Status401(models::ErrorResponse),
420    Status403(models::ErrorResponse),
421    Status404(models::ErrorResponse),
422    Status503(models::ErrorResponse),
423    Status5XX(models::ErrorResponse),
424    UnknownValue(serde_json::Value),
425}
426
427/// struct for typed errors of method [`list_table_indices`]
428#[derive(Debug, Clone, Serialize, Deserialize)]
429#[serde(untagged)]
430pub enum ListTableIndicesError {
431    Status400(models::ErrorResponse),
432    Status401(models::ErrorResponse),
433    Status403(models::ErrorResponse),
434    Status404(models::ErrorResponse),
435    Status503(models::ErrorResponse),
436    Status5XX(models::ErrorResponse),
437    UnknownValue(serde_json::Value),
438}
439
440/// struct for typed errors of method [`list_table_tags`]
441#[derive(Debug, Clone, Serialize, Deserialize)]
442#[serde(untagged)]
443pub enum ListTableTagsError {
444    Status400(models::ErrorResponse),
445    Status401(models::ErrorResponse),
446    Status403(models::ErrorResponse),
447    Status404(models::ErrorResponse),
448    Status503(models::ErrorResponse),
449    Status5XX(models::ErrorResponse),
450    UnknownValue(serde_json::Value),
451}
452
453/// struct for typed errors of method [`list_table_versions`]
454#[derive(Debug, Clone, Serialize, Deserialize)]
455#[serde(untagged)]
456pub enum ListTableVersionsError {
457    Status400(models::ErrorResponse),
458    Status401(models::ErrorResponse),
459    Status403(models::ErrorResponse),
460    Status404(models::ErrorResponse),
461    Status503(models::ErrorResponse),
462    Status5XX(models::ErrorResponse),
463    UnknownValue(serde_json::Value),
464}
465
466/// struct for typed errors of method [`list_tables`]
467#[derive(Debug, Clone, Serialize, Deserialize)]
468#[serde(untagged)]
469pub enum ListTablesError {
470    Status400(models::ErrorResponse),
471    Status401(models::ErrorResponse),
472    Status403(models::ErrorResponse),
473    Status404(models::ErrorResponse),
474    Status406(models::ErrorResponse),
475    Status503(models::ErrorResponse),
476    Status5XX(models::ErrorResponse),
477    UnknownValue(serde_json::Value),
478}
479
480/// struct for typed errors of method [`merge_insert_into_table`]
481#[derive(Debug, Clone, Serialize, Deserialize)]
482#[serde(untagged)]
483pub enum MergeInsertIntoTableError {
484    Status400(models::ErrorResponse),
485    Status401(models::ErrorResponse),
486    Status403(models::ErrorResponse),
487    Status404(models::ErrorResponse),
488    Status503(models::ErrorResponse),
489    Status5XX(models::ErrorResponse),
490    UnknownValue(serde_json::Value),
491}
492
493/// struct for typed errors of method [`query_table`]
494#[derive(Debug, Clone, Serialize, Deserialize)]
495#[serde(untagged)]
496pub enum QueryTableError {
497    Status400(models::ErrorResponse),
498    Status401(models::ErrorResponse),
499    Status403(models::ErrorResponse),
500    Status404(models::ErrorResponse),
501    Status503(models::ErrorResponse),
502    Status5XX(models::ErrorResponse),
503    UnknownValue(serde_json::Value),
504}
505
506/// struct for typed errors of method [`register_table`]
507#[derive(Debug, Clone, Serialize, Deserialize)]
508#[serde(untagged)]
509pub enum RegisterTableError {
510    Status400(models::ErrorResponse),
511    Status401(models::ErrorResponse),
512    Status403(models::ErrorResponse),
513    Status404(models::ErrorResponse),
514    Status406(models::ErrorResponse),
515    Status409(models::ErrorResponse),
516    Status503(models::ErrorResponse),
517    Status5XX(models::ErrorResponse),
518    UnknownValue(serde_json::Value),
519}
520
521/// struct for typed errors of method [`rename_table`]
522#[derive(Debug, Clone, Serialize, Deserialize)]
523#[serde(untagged)]
524pub enum RenameTableError {
525    Status400(models::ErrorResponse),
526    Status401(models::ErrorResponse),
527    Status403(models::ErrorResponse),
528    Status404(models::ErrorResponse),
529    Status409(models::ErrorResponse),
530    Status503(models::ErrorResponse),
531    Status5XX(models::ErrorResponse),
532    UnknownValue(serde_json::Value),
533}
534
535/// struct for typed errors of method [`restore_table`]
536#[derive(Debug, Clone, Serialize, Deserialize)]
537#[serde(untagged)]
538pub enum RestoreTableError {
539    Status400(models::ErrorResponse),
540    Status401(models::ErrorResponse),
541    Status403(models::ErrorResponse),
542    Status404(models::ErrorResponse),
543    Status503(models::ErrorResponse),
544    Status5XX(models::ErrorResponse),
545    UnknownValue(serde_json::Value),
546}
547
548/// struct for typed errors of method [`table_exists`]
549#[derive(Debug, Clone, Serialize, Deserialize)]
550#[serde(untagged)]
551pub enum TableExistsError {
552    Status400(models::ErrorResponse),
553    Status401(models::ErrorResponse),
554    Status403(models::ErrorResponse),
555    Status404(models::ErrorResponse),
556    Status503(models::ErrorResponse),
557    Status5XX(models::ErrorResponse),
558    UnknownValue(serde_json::Value),
559}
560
561/// struct for typed errors of method [`update_field_metadata`]
562#[derive(Debug, Clone, Serialize, Deserialize)]
563#[serde(untagged)]
564pub enum UpdateFieldMetadataError {
565    Status400(models::ErrorResponse),
566    Status401(models::ErrorResponse),
567    Status403(models::ErrorResponse),
568    Status404(models::ErrorResponse),
569    Status503(models::ErrorResponse),
570    Status5XX(models::ErrorResponse),
571    UnknownValue(serde_json::Value),
572}
573
574/// struct for typed errors of method [`update_table`]
575#[derive(Debug, Clone, Serialize, Deserialize)]
576#[serde(untagged)]
577pub enum UpdateTableError {
578    Status400(models::ErrorResponse),
579    Status401(models::ErrorResponse),
580    Status403(models::ErrorResponse),
581    Status404(models::ErrorResponse),
582    Status503(models::ErrorResponse),
583    Status5XX(models::ErrorResponse),
584    UnknownValue(serde_json::Value),
585}
586
587/// struct for typed errors of method [`update_table_schema_metadata`]
588#[derive(Debug, Clone, Serialize, Deserialize)]
589#[serde(untagged)]
590pub enum UpdateTableSchemaMetadataError {
591    Status400(models::ErrorResponse),
592    Status401(models::ErrorResponse),
593    Status403(models::ErrorResponse),
594    Status404(models::ErrorResponse),
595    Status503(models::ErrorResponse),
596    Status5XX(models::ErrorResponse),
597    UnknownValue(serde_json::Value),
598}
599
600/// struct for typed errors of method [`update_table_tag`]
601#[derive(Debug, Clone, Serialize, Deserialize)]
602#[serde(untagged)]
603pub enum UpdateTableTagError {
604    Status400(models::ErrorResponse),
605    Status401(models::ErrorResponse),
606    Status403(models::ErrorResponse),
607    Status404(models::ErrorResponse),
608    Status503(models::ErrorResponse),
609    Status5XX(models::ErrorResponse),
610    UnknownValue(serde_json::Value),
611}
612
613
614/// Add new columns to table `id` using SQL expressions or default values. 
615pub async fn alter_table_add_columns(configuration: &configuration::Configuration, id: &str, alter_table_add_columns_request: models::AlterTableAddColumnsRequest, delimiter: Option<&str>) -> Result<models::AlterTableAddColumnsResponse, Error<AlterTableAddColumnsError>> {
616    // add a prefix to parameters to efficiently prevent name collisions
617    let p_id = id;
618    let p_alter_table_add_columns_request = alter_table_add_columns_request;
619    let p_delimiter = delimiter;
620
621    let uri_str = format!("{}/v1/table/{id}/add_columns", configuration.base_path, id=crate::apis::urlencode(p_id));
622    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
623
624    if let Some(ref param_value) = p_delimiter {
625        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
626    }
627    if let Some(ref user_agent) = configuration.user_agent {
628        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
629    }
630    if let Some(ref token) = configuration.oauth_access_token {
631        req_builder = req_builder.bearer_auth(token.to_owned());
632    };
633    if let Some(ref apikey) = configuration.api_key {
634        let key = apikey.key.clone();
635        let value = match apikey.prefix {
636            Some(ref prefix) => format!("{} {}", prefix, key),
637            None => key,
638        };
639        req_builder = req_builder.header("x-api-key", value);
640    };
641    if let Some(ref token) = configuration.bearer_access_token {
642        req_builder = req_builder.bearer_auth(token.to_owned());
643    };
644    req_builder = req_builder.json(&p_alter_table_add_columns_request);
645
646    let req = req_builder.build()?;
647    let resp = configuration.client.execute(req).await?;
648
649    let status = resp.status();
650    let content_type = resp
651        .headers()
652        .get("content-type")
653        .and_then(|v| v.to_str().ok())
654        .unwrap_or("application/octet-stream");
655    let content_type = super::ContentType::from(content_type);
656
657    if !status.is_client_error() && !status.is_server_error() {
658        let content = resp.text().await?;
659        match content_type {
660            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
661            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AlterTableAddColumnsResponse`"))),
662            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AlterTableAddColumnsResponse`")))),
663        }
664    } else {
665        let content = resp.text().await?;
666        let entity: Option<AlterTableAddColumnsError> = serde_json::from_str(&content).ok();
667        Err(Error::ResponseError(ResponseContent { status, content, entity }))
668    }
669}
670
671/// Modify existing columns in table `id`, such as renaming or changing data types. 
672pub async fn alter_table_alter_columns(configuration: &configuration::Configuration, id: &str, alter_table_alter_columns_request: models::AlterTableAlterColumnsRequest, delimiter: Option<&str>) -> Result<models::AlterTableAlterColumnsResponse, Error<AlterTableAlterColumnsError>> {
673    // add a prefix to parameters to efficiently prevent name collisions
674    let p_id = id;
675    let p_alter_table_alter_columns_request = alter_table_alter_columns_request;
676    let p_delimiter = delimiter;
677
678    let uri_str = format!("{}/v1/table/{id}/alter_columns", configuration.base_path, id=crate::apis::urlencode(p_id));
679    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
680
681    if let Some(ref param_value) = p_delimiter {
682        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
683    }
684    if let Some(ref user_agent) = configuration.user_agent {
685        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
686    }
687    if let Some(ref token) = configuration.oauth_access_token {
688        req_builder = req_builder.bearer_auth(token.to_owned());
689    };
690    if let Some(ref apikey) = configuration.api_key {
691        let key = apikey.key.clone();
692        let value = match apikey.prefix {
693            Some(ref prefix) => format!("{} {}", prefix, key),
694            None => key,
695        };
696        req_builder = req_builder.header("x-api-key", value);
697    };
698    if let Some(ref token) = configuration.bearer_access_token {
699        req_builder = req_builder.bearer_auth(token.to_owned());
700    };
701    req_builder = req_builder.json(&p_alter_table_alter_columns_request);
702
703    let req = req_builder.build()?;
704    let resp = configuration.client.execute(req).await?;
705
706    let status = resp.status();
707    let content_type = resp
708        .headers()
709        .get("content-type")
710        .and_then(|v| v.to_str().ok())
711        .unwrap_or("application/octet-stream");
712    let content_type = super::ContentType::from(content_type);
713
714    if !status.is_client_error() && !status.is_server_error() {
715        let content = resp.text().await?;
716        match content_type {
717            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
718            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AlterTableAlterColumnsResponse`"))),
719            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AlterTableAlterColumnsResponse`")))),
720        }
721    } else {
722        let content = resp.text().await?;
723        let entity: Option<AlterTableAlterColumnsError> = serde_json::from_str(&content).ok();
724        Err(Error::ResponseError(ResponseContent { status, content, entity }))
725    }
726}
727
728/// Trigger an asynchronous backfill job for a computed column on table `id`. The column must be a virtual (UDF-backed) column. Returns a job ID for tracking. 
729pub async fn alter_table_backfill_columns(configuration: &configuration::Configuration, id: &str, alter_table_backfill_columns_request: models::AlterTableBackfillColumnsRequest, delimiter: Option<&str>) -> Result<models::AlterTableBackfillColumnsResponse, Error<AlterTableBackfillColumnsError>> {
730    // add a prefix to parameters to efficiently prevent name collisions
731    let p_id = id;
732    let p_alter_table_backfill_columns_request = alter_table_backfill_columns_request;
733    let p_delimiter = delimiter;
734
735    let uri_str = format!("{}/v1/table/{id}/backfill_column", configuration.base_path, id=crate::apis::urlencode(p_id));
736    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
737
738    if let Some(ref param_value) = p_delimiter {
739        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
740    }
741    if let Some(ref user_agent) = configuration.user_agent {
742        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
743    }
744    if let Some(ref token) = configuration.oauth_access_token {
745        req_builder = req_builder.bearer_auth(token.to_owned());
746    };
747    if let Some(ref apikey) = configuration.api_key {
748        let key = apikey.key.clone();
749        let value = match apikey.prefix {
750            Some(ref prefix) => format!("{} {}", prefix, key),
751            None => key,
752        };
753        req_builder = req_builder.header("x-api-key", value);
754    };
755    if let Some(ref token) = configuration.bearer_access_token {
756        req_builder = req_builder.bearer_auth(token.to_owned());
757    };
758    req_builder = req_builder.json(&p_alter_table_backfill_columns_request);
759
760    let req = req_builder.build()?;
761    let resp = configuration.client.execute(req).await?;
762
763    let status = resp.status();
764    let content_type = resp
765        .headers()
766        .get("content-type")
767        .and_then(|v| v.to_str().ok())
768        .unwrap_or("application/octet-stream");
769    let content_type = super::ContentType::from(content_type);
770
771    if !status.is_client_error() && !status.is_server_error() {
772        let content = resp.text().await?;
773        match content_type {
774            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
775            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AlterTableBackfillColumnsResponse`"))),
776            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AlterTableBackfillColumnsResponse`")))),
777        }
778    } else {
779        let content = resp.text().await?;
780        let entity: Option<AlterTableBackfillColumnsError> = serde_json::from_str(&content).ok();
781        Err(Error::ResponseError(ResponseContent { status, content, entity }))
782    }
783}
784
785/// Remove specified columns from table `id`. 
786pub async fn alter_table_drop_columns(configuration: &configuration::Configuration, id: &str, alter_table_drop_columns_request: models::AlterTableDropColumnsRequest, delimiter: Option<&str>) -> Result<models::AlterTableDropColumnsResponse, Error<AlterTableDropColumnsError>> {
787    // add a prefix to parameters to efficiently prevent name collisions
788    let p_id = id;
789    let p_alter_table_drop_columns_request = alter_table_drop_columns_request;
790    let p_delimiter = delimiter;
791
792    let uri_str = format!("{}/v1/table/{id}/drop_columns", configuration.base_path, id=crate::apis::urlencode(p_id));
793    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
794
795    if let Some(ref param_value) = p_delimiter {
796        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
797    }
798    if let Some(ref user_agent) = configuration.user_agent {
799        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
800    }
801    if let Some(ref token) = configuration.oauth_access_token {
802        req_builder = req_builder.bearer_auth(token.to_owned());
803    };
804    if let Some(ref apikey) = configuration.api_key {
805        let key = apikey.key.clone();
806        let value = match apikey.prefix {
807            Some(ref prefix) => format!("{} {}", prefix, key),
808            None => key,
809        };
810        req_builder = req_builder.header("x-api-key", value);
811    };
812    if let Some(ref token) = configuration.bearer_access_token {
813        req_builder = req_builder.bearer_auth(token.to_owned());
814    };
815    req_builder = req_builder.json(&p_alter_table_drop_columns_request);
816
817    let req = req_builder.build()?;
818    let resp = configuration.client.execute(req).await?;
819
820    let status = resp.status();
821    let content_type = resp
822        .headers()
823        .get("content-type")
824        .and_then(|v| v.to_str().ok())
825        .unwrap_or("application/octet-stream");
826    let content_type = super::ContentType::from(content_type);
827
828    if !status.is_client_error() && !status.is_server_error() {
829        let content = resp.text().await?;
830        match content_type {
831            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
832            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AlterTableDropColumnsResponse`"))),
833            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AlterTableDropColumnsResponse`")))),
834        }
835    } else {
836        let content = resp.text().await?;
837        let entity: Option<AlterTableDropColumnsError> = serde_json::from_str(&content).ok();
838        Err(Error::ResponseError(ResponseContent { status, content, entity }))
839    }
840}
841
842/// Analyze the query execution plan for a query against table `id`. Returns detailed statistics and analysis of the query execution plan.  REST NAMESPACE ONLY REST namespace returns the response as a plain string instead of the `AnalyzeTableQueryPlanResponse` JSON object. 
843pub async fn analyze_table_query_plan(configuration: &configuration::Configuration, id: &str, analyze_table_query_plan_request: models::AnalyzeTableQueryPlanRequest, delimiter: Option<&str>) -> Result<String, Error<AnalyzeTableQueryPlanError>> {
844    // add a prefix to parameters to efficiently prevent name collisions
845    let p_id = id;
846    let p_analyze_table_query_plan_request = analyze_table_query_plan_request;
847    let p_delimiter = delimiter;
848
849    let uri_str = format!("{}/v1/table/{id}/analyze_plan", configuration.base_path, id=crate::apis::urlencode(p_id));
850    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
851
852    if let Some(ref param_value) = p_delimiter {
853        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
854    }
855    if let Some(ref user_agent) = configuration.user_agent {
856        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
857    }
858    if let Some(ref token) = configuration.oauth_access_token {
859        req_builder = req_builder.bearer_auth(token.to_owned());
860    };
861    if let Some(ref apikey) = configuration.api_key {
862        let key = apikey.key.clone();
863        let value = match apikey.prefix {
864            Some(ref prefix) => format!("{} {}", prefix, key),
865            None => key,
866        };
867        req_builder = req_builder.header("x-api-key", value);
868    };
869    if let Some(ref token) = configuration.bearer_access_token {
870        req_builder = req_builder.bearer_auth(token.to_owned());
871    };
872    req_builder = req_builder.json(&p_analyze_table_query_plan_request);
873
874    let req = req_builder.build()?;
875    let resp = configuration.client.execute(req).await?;
876
877    let status = resp.status();
878    let content_type = resp
879        .headers()
880        .get("content-type")
881        .and_then(|v| v.to_str().ok())
882        .unwrap_or("application/octet-stream");
883    let content_type = super::ContentType::from(content_type);
884
885    if !status.is_client_error() && !status.is_server_error() {
886        let content = resp.text().await?;
887        match content_type {
888            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
889            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `String`"))),
890            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `String`")))),
891        }
892    } else {
893        let content = resp.text().await?;
894        let entity: Option<AnalyzeTableQueryPlanError> = serde_json::from_str(&content).ok();
895        Err(Error::ResponseError(ResponseContent { status, content, entity }))
896    }
897}
898
899/// Atomically commit a batch of table operations. This is a generalized version of `BatchCreateTableVersions` that supports mixed operation types within a single atomic transaction at the metadata layer.  Supported operation types: - `DeclareTable`: Declare (reserve) a new table - `CreateTableVersion`: Create a new version entry for a table - `DeleteTableVersions`: Delete version ranges from a table - `DeregisterTable`: Deregister (soft-delete) a table  All operations are committed atomically: either all succeed or none are applied. 
900pub async fn batch_commit_tables(configuration: &configuration::Configuration, batch_commit_tables_request: models::BatchCommitTablesRequest, delimiter: Option<&str>) -> Result<models::BatchCommitTablesResponse, Error<BatchCommitTablesError>> {
901    // add a prefix to parameters to efficiently prevent name collisions
902    let p_batch_commit_tables_request = batch_commit_tables_request;
903    let p_delimiter = delimiter;
904
905    let uri_str = format!("{}/v1/table/batch-commit", configuration.base_path);
906    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
907
908    if let Some(ref param_value) = p_delimiter {
909        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
910    }
911    if let Some(ref user_agent) = configuration.user_agent {
912        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
913    }
914    if let Some(ref token) = configuration.oauth_access_token {
915        req_builder = req_builder.bearer_auth(token.to_owned());
916    };
917    if let Some(ref apikey) = configuration.api_key {
918        let key = apikey.key.clone();
919        let value = match apikey.prefix {
920            Some(ref prefix) => format!("{} {}", prefix, key),
921            None => key,
922        };
923        req_builder = req_builder.header("x-api-key", value);
924    };
925    if let Some(ref token) = configuration.bearer_access_token {
926        req_builder = req_builder.bearer_auth(token.to_owned());
927    };
928    req_builder = req_builder.json(&p_batch_commit_tables_request);
929
930    let req = req_builder.build()?;
931    let resp = configuration.client.execute(req).await?;
932
933    let status = resp.status();
934    let content_type = resp
935        .headers()
936        .get("content-type")
937        .and_then(|v| v.to_str().ok())
938        .unwrap_or("application/octet-stream");
939    let content_type = super::ContentType::from(content_type);
940
941    if !status.is_client_error() && !status.is_server_error() {
942        let content = resp.text().await?;
943        match content_type {
944            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
945            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::BatchCommitTablesResponse`"))),
946            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::BatchCommitTablesResponse`")))),
947        }
948    } else {
949        let content = resp.text().await?;
950        let entity: Option<BatchCommitTablesError> = serde_json::from_str(&content).ok();
951        Err(Error::ResponseError(ResponseContent { status, content, entity }))
952    }
953}
954
955/// Atomically create new version entries for multiple tables.  This operation is atomic: either all table versions are created successfully, or none are created. If any version creation fails (e.g., due to conflict), the entire batch operation fails.  Each entry in the request specifies the table identifier and version details. This supports `put_if_not_exists` semantics for each version entry. 
956pub async fn batch_create_table_versions(configuration: &configuration::Configuration, batch_create_table_versions_request: models::BatchCreateTableVersionsRequest, delimiter: Option<&str>) -> Result<models::BatchCreateTableVersionsResponse, Error<BatchCreateTableVersionsError>> {
957    // add a prefix to parameters to efficiently prevent name collisions
958    let p_batch_create_table_versions_request = batch_create_table_versions_request;
959    let p_delimiter = delimiter;
960
961    let uri_str = format!("{}/v1/table/version/batch-create", configuration.base_path);
962    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
963
964    if let Some(ref param_value) = p_delimiter {
965        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
966    }
967    if let Some(ref user_agent) = configuration.user_agent {
968        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
969    }
970    if let Some(ref token) = configuration.oauth_access_token {
971        req_builder = req_builder.bearer_auth(token.to_owned());
972    };
973    if let Some(ref apikey) = configuration.api_key {
974        let key = apikey.key.clone();
975        let value = match apikey.prefix {
976            Some(ref prefix) => format!("{} {}", prefix, key),
977            None => key,
978        };
979        req_builder = req_builder.header("x-api-key", value);
980    };
981    if let Some(ref token) = configuration.bearer_access_token {
982        req_builder = req_builder.bearer_auth(token.to_owned());
983    };
984    req_builder = req_builder.json(&p_batch_create_table_versions_request);
985
986    let req = req_builder.build()?;
987    let resp = configuration.client.execute(req).await?;
988
989    let status = resp.status();
990    let content_type = resp
991        .headers()
992        .get("content-type")
993        .and_then(|v| v.to_str().ok())
994        .unwrap_or("application/octet-stream");
995    let content_type = super::ContentType::from(content_type);
996
997    if !status.is_client_error() && !status.is_server_error() {
998        let content = resp.text().await?;
999        match content_type {
1000            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1001            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::BatchCreateTableVersionsResponse`"))),
1002            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::BatchCreateTableVersionsResponse`")))),
1003        }
1004    } else {
1005        let content = resp.text().await?;
1006        let entity: Option<BatchCreateTableVersionsError> = serde_json::from_str(&content).ok();
1007        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1008    }
1009}
1010
1011/// Delete version metadata records for table `id`.  This operation deletes version tracking records, NOT the actual table data. It supports deleting ranges of versions for efficient bulk cleanup.  Special range values: - `start_version: 0` with `end_version: -1` means delete ALL version records 
1012pub async fn batch_delete_table_versions(configuration: &configuration::Configuration, id: &str, batch_delete_table_versions_request: models::BatchDeleteTableVersionsRequest, delimiter: Option<&str>) -> Result<models::BatchDeleteTableVersionsResponse, Error<BatchDeleteTableVersionsError>> {
1013    // add a prefix to parameters to efficiently prevent name collisions
1014    let p_id = id;
1015    let p_batch_delete_table_versions_request = batch_delete_table_versions_request;
1016    let p_delimiter = delimiter;
1017
1018    let uri_str = format!("{}/v1/table/{id}/version/delete", configuration.base_path, id=crate::apis::urlencode(p_id));
1019    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1020
1021    if let Some(ref param_value) = p_delimiter {
1022        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1023    }
1024    if let Some(ref user_agent) = configuration.user_agent {
1025        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1026    }
1027    if let Some(ref token) = configuration.oauth_access_token {
1028        req_builder = req_builder.bearer_auth(token.to_owned());
1029    };
1030    if let Some(ref apikey) = configuration.api_key {
1031        let key = apikey.key.clone();
1032        let value = match apikey.prefix {
1033            Some(ref prefix) => format!("{} {}", prefix, key),
1034            None => key,
1035        };
1036        req_builder = req_builder.header("x-api-key", value);
1037    };
1038    if let Some(ref token) = configuration.bearer_access_token {
1039        req_builder = req_builder.bearer_auth(token.to_owned());
1040    };
1041    req_builder = req_builder.json(&p_batch_delete_table_versions_request);
1042
1043    let req = req_builder.build()?;
1044    let resp = configuration.client.execute(req).await?;
1045
1046    let status = resp.status();
1047    let content_type = resp
1048        .headers()
1049        .get("content-type")
1050        .and_then(|v| v.to_str().ok())
1051        .unwrap_or("application/octet-stream");
1052    let content_type = super::ContentType::from(content_type);
1053
1054    if !status.is_client_error() && !status.is_server_error() {
1055        let content = resp.text().await?;
1056        match content_type {
1057            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1058            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::BatchDeleteTableVersionsResponse`"))),
1059            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::BatchDeleteTableVersionsResponse`")))),
1060        }
1061    } else {
1062        let content = resp.text().await?;
1063        let entity: Option<BatchDeleteTableVersionsError> = serde_json::from_str(&content).ok();
1064        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1065    }
1066}
1067
1068/// Count the number of rows in table `id`  REST NAMESPACE ONLY REST namespace returns the response as a plain integer instead of the `CountTableRowsResponse` JSON object. 
1069pub async fn count_table_rows(configuration: &configuration::Configuration, id: &str, count_table_rows_request: models::CountTableRowsRequest, delimiter: Option<&str>) -> Result<i64, Error<CountTableRowsError>> {
1070    // add a prefix to parameters to efficiently prevent name collisions
1071    let p_id = id;
1072    let p_count_table_rows_request = count_table_rows_request;
1073    let p_delimiter = delimiter;
1074
1075    let uri_str = format!("{}/v1/table/{id}/count_rows", configuration.base_path, id=crate::apis::urlencode(p_id));
1076    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1077
1078    if let Some(ref param_value) = p_delimiter {
1079        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1080    }
1081    if let Some(ref user_agent) = configuration.user_agent {
1082        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1083    }
1084    if let Some(ref token) = configuration.oauth_access_token {
1085        req_builder = req_builder.bearer_auth(token.to_owned());
1086    };
1087    if let Some(ref apikey) = configuration.api_key {
1088        let key = apikey.key.clone();
1089        let value = match apikey.prefix {
1090            Some(ref prefix) => format!("{} {}", prefix, key),
1091            None => key,
1092        };
1093        req_builder = req_builder.header("x-api-key", value);
1094    };
1095    if let Some(ref token) = configuration.bearer_access_token {
1096        req_builder = req_builder.bearer_auth(token.to_owned());
1097    };
1098    req_builder = req_builder.json(&p_count_table_rows_request);
1099
1100    let req = req_builder.build()?;
1101    let resp = configuration.client.execute(req).await?;
1102
1103    let status = resp.status();
1104    let content_type = resp
1105        .headers()
1106        .get("content-type")
1107        .and_then(|v| v.to_str().ok())
1108        .unwrap_or("application/octet-stream");
1109    let content_type = super::ContentType::from(content_type);
1110
1111    if !status.is_client_error() && !status.is_server_error() {
1112        let content = resp.text().await?;
1113        match content_type {
1114            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1115            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `i64`"))),
1116            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `i64`")))),
1117        }
1118    } else {
1119        let content = resp.text().await?;
1120        let entity: Option<CountTableRowsError> = serde_json::from_str(&content).ok();
1121        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1122    }
1123}
1124
1125/// Create table `id` in the namespace with the given data in Arrow IPC stream.  The schema of the Arrow IPC stream is used as the table schema. If the stream is empty, the API creates a new empty table.  REST NAMESPACE ONLY REST namespace uses Arrow IPC stream as the request body. It passes in the `CreateTableRequest` information in the following way: - `id`: pass through path parameter of the same name - `mode`: pass through query parameter of the same name - `properties`: serialize as a single JSON-encoded query parameter such as   `properties={\"user\":\"alice\",\"team\":\"eng\"}`; these are business logic properties   managed by the namespace implementation outside Lance context - `storage_options`: serialize as a single JSON-encoded query parameter such as   `storage_options={\"aws_region\":\"us-east-1\",\"timeout\":\"30s\"}`; these configure   write-time overrides for data and metadata written during table creation 
1126pub async fn create_table(configuration: &configuration::Configuration, id: &str, body: Vec<u8>, delimiter: Option<&str>, mode: Option<&str>, properties: Option<&str>, storage_options: Option<&str>) -> Result<models::CreateTableResponse, Error<CreateTableError>> {
1127    // add a prefix to parameters to efficiently prevent name collisions
1128    let p_id = id;
1129    let p_body = body;
1130    let p_delimiter = delimiter;
1131    let p_mode = mode;
1132    let p_properties = properties;
1133    let p_storage_options = storage_options;
1134
1135    let uri_str = format!("{}/v1/table/{id}/create", configuration.base_path, id=crate::apis::urlencode(p_id));
1136    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1137
1138    if let Some(ref param_value) = p_delimiter {
1139        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1140    }
1141    if let Some(ref param_value) = p_mode {
1142        req_builder = req_builder.query(&[("mode", &param_value.to_string())]);
1143    }
1144    if let Some(ref param_value) = p_properties {
1145        req_builder = req_builder.query(&[("properties", &param_value.to_string())]);
1146    }
1147    if let Some(ref param_value) = p_storage_options {
1148        req_builder = req_builder.query(&[("storage_options", &param_value.to_string())]);
1149    }
1150    if let Some(ref user_agent) = configuration.user_agent {
1151        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1152    }
1153    if let Some(ref token) = configuration.oauth_access_token {
1154        req_builder = req_builder.bearer_auth(token.to_owned());
1155    };
1156    if let Some(ref apikey) = configuration.api_key {
1157        let key = apikey.key.clone();
1158        let value = match apikey.prefix {
1159            Some(ref prefix) => format!("{} {}", prefix, key),
1160            None => key,
1161        };
1162        req_builder = req_builder.header("x-api-key", value);
1163    };
1164    if let Some(ref token) = configuration.bearer_access_token {
1165        req_builder = req_builder.bearer_auth(token.to_owned());
1166    };
1167    req_builder = req_builder.body(p_body);
1168
1169    let req = req_builder.build()?;
1170    let resp = configuration.client.execute(req).await?;
1171
1172    let status = resp.status();
1173    let content_type = resp
1174        .headers()
1175        .get("content-type")
1176        .and_then(|v| v.to_str().ok())
1177        .unwrap_or("application/octet-stream");
1178    let content_type = super::ContentType::from(content_type);
1179
1180    if !status.is_client_error() && !status.is_server_error() {
1181        let content = resp.text().await?;
1182        match content_type {
1183            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1184            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableResponse`"))),
1185            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateTableResponse`")))),
1186        }
1187    } else {
1188        let content = resp.text().await?;
1189        let entity: Option<CreateTableError> = serde_json::from_str(&content).ok();
1190        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1191    }
1192}
1193
1194/// Create a new branch for table `id` starting from a source ref (another branch and/or version), defaulting to the latest version of the main branch. 
1195pub async fn create_table_branch(configuration: &configuration::Configuration, id: &str, create_table_branch_request: models::CreateTableBranchRequest, delimiter: Option<&str>) -> Result<models::CreateTableBranchResponse, Error<CreateTableBranchError>> {
1196    // add a prefix to parameters to efficiently prevent name collisions
1197    let p_id = id;
1198    let p_create_table_branch_request = create_table_branch_request;
1199    let p_delimiter = delimiter;
1200
1201    let uri_str = format!("{}/v1/table/{id}/branches/create", configuration.base_path, id=crate::apis::urlencode(p_id));
1202    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1203
1204    if let Some(ref param_value) = p_delimiter {
1205        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1206    }
1207    if let Some(ref user_agent) = configuration.user_agent {
1208        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1209    }
1210    if let Some(ref token) = configuration.oauth_access_token {
1211        req_builder = req_builder.bearer_auth(token.to_owned());
1212    };
1213    if let Some(ref apikey) = configuration.api_key {
1214        let key = apikey.key.clone();
1215        let value = match apikey.prefix {
1216            Some(ref prefix) => format!("{} {}", prefix, key),
1217            None => key,
1218        };
1219        req_builder = req_builder.header("x-api-key", value);
1220    };
1221    if let Some(ref token) = configuration.bearer_access_token {
1222        req_builder = req_builder.bearer_auth(token.to_owned());
1223    };
1224    req_builder = req_builder.json(&p_create_table_branch_request);
1225
1226    let req = req_builder.build()?;
1227    let resp = configuration.client.execute(req).await?;
1228
1229    let status = resp.status();
1230    let content_type = resp
1231        .headers()
1232        .get("content-type")
1233        .and_then(|v| v.to_str().ok())
1234        .unwrap_or("application/octet-stream");
1235    let content_type = super::ContentType::from(content_type);
1236
1237    if !status.is_client_error() && !status.is_server_error() {
1238        let content = resp.text().await?;
1239        match content_type {
1240            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1241            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableBranchResponse`"))),
1242            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateTableBranchResponse`")))),
1243        }
1244    } else {
1245        let content = resp.text().await?;
1246        let entity: Option<CreateTableBranchError> = serde_json::from_str(&content).ok();
1247        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1248    }
1249}
1250
1251/// Create an index on a table field for faster search operations. Supports vector indexes (IVF_FLAT, IVF_HNSW_SQ, IVF_PQ, etc.) and scalar indexes (BTREE, BITMAP, FTS, etc.). Index creation is handled asynchronously. Use the `ListTableIndices` and `DescribeTableIndexStats` operations to monitor index creation progress. 
1252pub async fn create_table_index(configuration: &configuration::Configuration, id: &str, create_table_index_request: models::CreateTableIndexRequest, delimiter: Option<&str>) -> Result<models::CreateTableIndexResponse, Error<CreateTableIndexError>> {
1253    // add a prefix to parameters to efficiently prevent name collisions
1254    let p_id = id;
1255    let p_create_table_index_request = create_table_index_request;
1256    let p_delimiter = delimiter;
1257
1258    let uri_str = format!("{}/v1/table/{id}/create_index", configuration.base_path, id=crate::apis::urlencode(p_id));
1259    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1260
1261    if let Some(ref param_value) = p_delimiter {
1262        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1263    }
1264    if let Some(ref user_agent) = configuration.user_agent {
1265        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1266    }
1267    if let Some(ref token) = configuration.oauth_access_token {
1268        req_builder = req_builder.bearer_auth(token.to_owned());
1269    };
1270    if let Some(ref apikey) = configuration.api_key {
1271        let key = apikey.key.clone();
1272        let value = match apikey.prefix {
1273            Some(ref prefix) => format!("{} {}", prefix, key),
1274            None => key,
1275        };
1276        req_builder = req_builder.header("x-api-key", value);
1277    };
1278    if let Some(ref token) = configuration.bearer_access_token {
1279        req_builder = req_builder.bearer_auth(token.to_owned());
1280    };
1281    req_builder = req_builder.json(&p_create_table_index_request);
1282
1283    let req = req_builder.build()?;
1284    let resp = configuration.client.execute(req).await?;
1285
1286    let status = resp.status();
1287    let content_type = resp
1288        .headers()
1289        .get("content-type")
1290        .and_then(|v| v.to_str().ok())
1291        .unwrap_or("application/octet-stream");
1292    let content_type = super::ContentType::from(content_type);
1293
1294    if !status.is_client_error() && !status.is_server_error() {
1295        let content = resp.text().await?;
1296        match content_type {
1297            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1298            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableIndexResponse`"))),
1299            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateTableIndexResponse`")))),
1300        }
1301    } else {
1302        let content = resp.text().await?;
1303        let entity: Option<CreateTableIndexError> = serde_json::from_str(&content).ok();
1304        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1305    }
1306}
1307
1308/// Create a scalar index on a table field for faster filtering operations. Supports scalar indexes (BTREE, BITMAP, LABEL_LIST, FTS, etc.). This is an alias for CreateTableIndex specifically for scalar indexes. Index creation is handled asynchronously. Use the `ListTableIndices` and `DescribeTableIndexStats` operations to monitor index creation progress. 
1309pub async fn create_table_scalar_index(configuration: &configuration::Configuration, id: &str, create_table_index_request: models::CreateTableIndexRequest, delimiter: Option<&str>) -> Result<models::CreateTableScalarIndexResponse, Error<CreateTableScalarIndexError>> {
1310    // add a prefix to parameters to efficiently prevent name collisions
1311    let p_id = id;
1312    let p_create_table_index_request = create_table_index_request;
1313    let p_delimiter = delimiter;
1314
1315    let uri_str = format!("{}/v1/table/{id}/create_scalar_index", configuration.base_path, id=crate::apis::urlencode(p_id));
1316    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1317
1318    if let Some(ref param_value) = p_delimiter {
1319        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1320    }
1321    if let Some(ref user_agent) = configuration.user_agent {
1322        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1323    }
1324    if let Some(ref token) = configuration.oauth_access_token {
1325        req_builder = req_builder.bearer_auth(token.to_owned());
1326    };
1327    if let Some(ref apikey) = configuration.api_key {
1328        let key = apikey.key.clone();
1329        let value = match apikey.prefix {
1330            Some(ref prefix) => format!("{} {}", prefix, key),
1331            None => key,
1332        };
1333        req_builder = req_builder.header("x-api-key", value);
1334    };
1335    if let Some(ref token) = configuration.bearer_access_token {
1336        req_builder = req_builder.bearer_auth(token.to_owned());
1337    };
1338    req_builder = req_builder.json(&p_create_table_index_request);
1339
1340    let req = req_builder.build()?;
1341    let resp = configuration.client.execute(req).await?;
1342
1343    let status = resp.status();
1344    let content_type = resp
1345        .headers()
1346        .get("content-type")
1347        .and_then(|v| v.to_str().ok())
1348        .unwrap_or("application/octet-stream");
1349    let content_type = super::ContentType::from(content_type);
1350
1351    if !status.is_client_error() && !status.is_server_error() {
1352        let content = resp.text().await?;
1353        match content_type {
1354            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1355            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableScalarIndexResponse`"))),
1356            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateTableScalarIndexResponse`")))),
1357        }
1358    } else {
1359        let content = resp.text().await?;
1360        let entity: Option<CreateTableScalarIndexError> = serde_json::from_str(&content).ok();
1361        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1362    }
1363}
1364
1365/// Create a new tag for table `id` that points to a specific version. 
1366pub async fn create_table_tag(configuration: &configuration::Configuration, id: &str, create_table_tag_request: models::CreateTableTagRequest, delimiter: Option<&str>) -> Result<models::CreateTableTagResponse, Error<CreateTableTagError>> {
1367    // add a prefix to parameters to efficiently prevent name collisions
1368    let p_id = id;
1369    let p_create_table_tag_request = create_table_tag_request;
1370    let p_delimiter = delimiter;
1371
1372    let uri_str = format!("{}/v1/table/{id}/tags/create", configuration.base_path, id=crate::apis::urlencode(p_id));
1373    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1374
1375    if let Some(ref param_value) = p_delimiter {
1376        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1377    }
1378    if let Some(ref user_agent) = configuration.user_agent {
1379        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1380    }
1381    if let Some(ref token) = configuration.oauth_access_token {
1382        req_builder = req_builder.bearer_auth(token.to_owned());
1383    };
1384    if let Some(ref apikey) = configuration.api_key {
1385        let key = apikey.key.clone();
1386        let value = match apikey.prefix {
1387            Some(ref prefix) => format!("{} {}", prefix, key),
1388            None => key,
1389        };
1390        req_builder = req_builder.header("x-api-key", value);
1391    };
1392    if let Some(ref token) = configuration.bearer_access_token {
1393        req_builder = req_builder.bearer_auth(token.to_owned());
1394    };
1395    req_builder = req_builder.json(&p_create_table_tag_request);
1396
1397    let req = req_builder.build()?;
1398    let resp = configuration.client.execute(req).await?;
1399
1400    let status = resp.status();
1401    let content_type = resp
1402        .headers()
1403        .get("content-type")
1404        .and_then(|v| v.to_str().ok())
1405        .unwrap_or("application/octet-stream");
1406    let content_type = super::ContentType::from(content_type);
1407
1408    if !status.is_client_error() && !status.is_server_error() {
1409        let content = resp.text().await?;
1410        match content_type {
1411            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1412            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableTagResponse`"))),
1413            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateTableTagResponse`")))),
1414        }
1415    } else {
1416        let content = resp.text().await?;
1417        let entity: Option<CreateTableTagError> = serde_json::from_str(&content).ok();
1418        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1419    }
1420}
1421
1422/// Create a new version entry for table `id`.  This operation supports `put_if_not_exists` semantics. The operation will fail with 409 Conflict if the version already exists. 
1423pub async fn create_table_version(configuration: &configuration::Configuration, id: &str, create_table_version_request: models::CreateTableVersionRequest, delimiter: Option<&str>) -> Result<models::CreateTableVersionResponse, Error<CreateTableVersionError>> {
1424    // add a prefix to parameters to efficiently prevent name collisions
1425    let p_id = id;
1426    let p_create_table_version_request = create_table_version_request;
1427    let p_delimiter = delimiter;
1428
1429    let uri_str = format!("{}/v1/table/{id}/version/create", configuration.base_path, id=crate::apis::urlencode(p_id));
1430    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1431
1432    if let Some(ref param_value) = p_delimiter {
1433        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1434    }
1435    if let Some(ref user_agent) = configuration.user_agent {
1436        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1437    }
1438    if let Some(ref token) = configuration.oauth_access_token {
1439        req_builder = req_builder.bearer_auth(token.to_owned());
1440    };
1441    if let Some(ref apikey) = configuration.api_key {
1442        let key = apikey.key.clone();
1443        let value = match apikey.prefix {
1444            Some(ref prefix) => format!("{} {}", prefix, key),
1445            None => key,
1446        };
1447        req_builder = req_builder.header("x-api-key", value);
1448    };
1449    if let Some(ref token) = configuration.bearer_access_token {
1450        req_builder = req_builder.bearer_auth(token.to_owned());
1451    };
1452    req_builder = req_builder.json(&p_create_table_version_request);
1453
1454    let req = req_builder.build()?;
1455    let resp = configuration.client.execute(req).await?;
1456
1457    let status = resp.status();
1458    let content_type = resp
1459        .headers()
1460        .get("content-type")
1461        .and_then(|v| v.to_str().ok())
1462        .unwrap_or("application/octet-stream");
1463    let content_type = super::ContentType::from(content_type);
1464
1465    if !status.is_client_error() && !status.is_server_error() {
1466        let content = resp.text().await?;
1467        match content_type {
1468            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1469            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableVersionResponse`"))),
1470            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateTableVersionResponse`")))),
1471        }
1472    } else {
1473        let content = resp.text().await?;
1474        let entity: Option<CreateTableVersionError> = serde_json::from_str(&content).ok();
1475        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1476    }
1477}
1478
1479/// Declare a table with the given name without touching storage. This is a metadata-only operation that records the table existence and sets up aspects like access control.  For DirectoryNamespace implementation, this creates a `.lance-reserved` file in the table directory to mark the table's existence without creating actual Lance data files. 
1480pub async fn declare_table(configuration: &configuration::Configuration, id: &str, declare_table_request: models::DeclareTableRequest, delimiter: Option<&str>) -> Result<models::DeclareTableResponse, Error<DeclareTableError>> {
1481    // add a prefix to parameters to efficiently prevent name collisions
1482    let p_id = id;
1483    let p_declare_table_request = declare_table_request;
1484    let p_delimiter = delimiter;
1485
1486    let uri_str = format!("{}/v1/table/{id}/declare", configuration.base_path, id=crate::apis::urlencode(p_id));
1487    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1488
1489    if let Some(ref param_value) = p_delimiter {
1490        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1491    }
1492    if let Some(ref user_agent) = configuration.user_agent {
1493        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1494    }
1495    if let Some(ref token) = configuration.oauth_access_token {
1496        req_builder = req_builder.bearer_auth(token.to_owned());
1497    };
1498    if let Some(ref apikey) = configuration.api_key {
1499        let key = apikey.key.clone();
1500        let value = match apikey.prefix {
1501            Some(ref prefix) => format!("{} {}", prefix, key),
1502            None => key,
1503        };
1504        req_builder = req_builder.header("x-api-key", value);
1505    };
1506    if let Some(ref token) = configuration.bearer_access_token {
1507        req_builder = req_builder.bearer_auth(token.to_owned());
1508    };
1509    req_builder = req_builder.json(&p_declare_table_request);
1510
1511    let req = req_builder.build()?;
1512    let resp = configuration.client.execute(req).await?;
1513
1514    let status = resp.status();
1515    let content_type = resp
1516        .headers()
1517        .get("content-type")
1518        .and_then(|v| v.to_str().ok())
1519        .unwrap_or("application/octet-stream");
1520    let content_type = super::ContentType::from(content_type);
1521
1522    if !status.is_client_error() && !status.is_server_error() {
1523        let content = resp.text().await?;
1524        match content_type {
1525            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1526            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeclareTableResponse`"))),
1527            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeclareTableResponse`")))),
1528        }
1529    } else {
1530        let content = resp.text().await?;
1531        let entity: Option<DeclareTableError> = serde_json::from_str(&content).ok();
1532        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1533    }
1534}
1535
1536/// Delete rows from table `id`. 
1537pub async fn delete_from_table(configuration: &configuration::Configuration, id: &str, delete_from_table_request: models::DeleteFromTableRequest, delimiter: Option<&str>) -> Result<models::DeleteFromTableResponse, Error<DeleteFromTableError>> {
1538    // add a prefix to parameters to efficiently prevent name collisions
1539    let p_id = id;
1540    let p_delete_from_table_request = delete_from_table_request;
1541    let p_delimiter = delimiter;
1542
1543    let uri_str = format!("{}/v1/table/{id}/delete", configuration.base_path, id=crate::apis::urlencode(p_id));
1544    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1545
1546    if let Some(ref param_value) = p_delimiter {
1547        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1548    }
1549    if let Some(ref user_agent) = configuration.user_agent {
1550        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1551    }
1552    if let Some(ref token) = configuration.oauth_access_token {
1553        req_builder = req_builder.bearer_auth(token.to_owned());
1554    };
1555    if let Some(ref apikey) = configuration.api_key {
1556        let key = apikey.key.clone();
1557        let value = match apikey.prefix {
1558            Some(ref prefix) => format!("{} {}", prefix, key),
1559            None => key,
1560        };
1561        req_builder = req_builder.header("x-api-key", value);
1562    };
1563    if let Some(ref token) = configuration.bearer_access_token {
1564        req_builder = req_builder.bearer_auth(token.to_owned());
1565    };
1566    req_builder = req_builder.json(&p_delete_from_table_request);
1567
1568    let req = req_builder.build()?;
1569    let resp = configuration.client.execute(req).await?;
1570
1571    let status = resp.status();
1572    let content_type = resp
1573        .headers()
1574        .get("content-type")
1575        .and_then(|v| v.to_str().ok())
1576        .unwrap_or("application/octet-stream");
1577    let content_type = super::ContentType::from(content_type);
1578
1579    if !status.is_client_error() && !status.is_server_error() {
1580        let content = resp.text().await?;
1581        match content_type {
1582            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1583            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteFromTableResponse`"))),
1584            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeleteFromTableResponse`")))),
1585        }
1586    } else {
1587        let content = resp.text().await?;
1588        let entity: Option<DeleteFromTableError> = serde_json::from_str(&content).ok();
1589        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1590    }
1591}
1592
1593/// Delete an existing branch from table `id`. 
1594pub async fn delete_table_branch(configuration: &configuration::Configuration, id: &str, delete_table_branch_request: models::DeleteTableBranchRequest, delimiter: Option<&str>) -> Result<models::DeleteTableBranchResponse, Error<DeleteTableBranchError>> {
1595    // add a prefix to parameters to efficiently prevent name collisions
1596    let p_id = id;
1597    let p_delete_table_branch_request = delete_table_branch_request;
1598    let p_delimiter = delimiter;
1599
1600    let uri_str = format!("{}/v1/table/{id}/branches/delete", configuration.base_path, id=crate::apis::urlencode(p_id));
1601    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1602
1603    if let Some(ref param_value) = p_delimiter {
1604        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1605    }
1606    if let Some(ref user_agent) = configuration.user_agent {
1607        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1608    }
1609    if let Some(ref token) = configuration.oauth_access_token {
1610        req_builder = req_builder.bearer_auth(token.to_owned());
1611    };
1612    if let Some(ref apikey) = configuration.api_key {
1613        let key = apikey.key.clone();
1614        let value = match apikey.prefix {
1615            Some(ref prefix) => format!("{} {}", prefix, key),
1616            None => key,
1617        };
1618        req_builder = req_builder.header("x-api-key", value);
1619    };
1620    if let Some(ref token) = configuration.bearer_access_token {
1621        req_builder = req_builder.bearer_auth(token.to_owned());
1622    };
1623    req_builder = req_builder.json(&p_delete_table_branch_request);
1624
1625    let req = req_builder.build()?;
1626    let resp = configuration.client.execute(req).await?;
1627
1628    let status = resp.status();
1629    let content_type = resp
1630        .headers()
1631        .get("content-type")
1632        .and_then(|v| v.to_str().ok())
1633        .unwrap_or("application/octet-stream");
1634    let content_type = super::ContentType::from(content_type);
1635
1636    if !status.is_client_error() && !status.is_server_error() {
1637        let content = resp.text().await?;
1638        match content_type {
1639            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1640            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteTableBranchResponse`"))),
1641            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeleteTableBranchResponse`")))),
1642        }
1643    } else {
1644        let content = resp.text().await?;
1645        let entity: Option<DeleteTableBranchError> = serde_json::from_str(&content).ok();
1646        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1647    }
1648}
1649
1650/// Delete an existing tag from table `id`. 
1651pub async fn delete_table_tag(configuration: &configuration::Configuration, id: &str, delete_table_tag_request: models::DeleteTableTagRequest, delimiter: Option<&str>) -> Result<models::DeleteTableTagResponse, Error<DeleteTableTagError>> {
1652    // add a prefix to parameters to efficiently prevent name collisions
1653    let p_id = id;
1654    let p_delete_table_tag_request = delete_table_tag_request;
1655    let p_delimiter = delimiter;
1656
1657    let uri_str = format!("{}/v1/table/{id}/tags/delete", configuration.base_path, id=crate::apis::urlencode(p_id));
1658    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1659
1660    if let Some(ref param_value) = p_delimiter {
1661        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1662    }
1663    if let Some(ref user_agent) = configuration.user_agent {
1664        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1665    }
1666    if let Some(ref token) = configuration.oauth_access_token {
1667        req_builder = req_builder.bearer_auth(token.to_owned());
1668    };
1669    if let Some(ref apikey) = configuration.api_key {
1670        let key = apikey.key.clone();
1671        let value = match apikey.prefix {
1672            Some(ref prefix) => format!("{} {}", prefix, key),
1673            None => key,
1674        };
1675        req_builder = req_builder.header("x-api-key", value);
1676    };
1677    if let Some(ref token) = configuration.bearer_access_token {
1678        req_builder = req_builder.bearer_auth(token.to_owned());
1679    };
1680    req_builder = req_builder.json(&p_delete_table_tag_request);
1681
1682    let req = req_builder.build()?;
1683    let resp = configuration.client.execute(req).await?;
1684
1685    let status = resp.status();
1686    let content_type = resp
1687        .headers()
1688        .get("content-type")
1689        .and_then(|v| v.to_str().ok())
1690        .unwrap_or("application/octet-stream");
1691    let content_type = super::ContentType::from(content_type);
1692
1693    if !status.is_client_error() && !status.is_server_error() {
1694        let content = resp.text().await?;
1695        match content_type {
1696            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1697            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteTableTagResponse`"))),
1698            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeleteTableTagResponse`")))),
1699        }
1700    } else {
1701        let content = resp.text().await?;
1702        let entity: Option<DeleteTableTagError> = serde_json::from_str(&content).ok();
1703        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1704    }
1705}
1706
1707/// Deregister table `id` from its namespace. 
1708pub async fn deregister_table(configuration: &configuration::Configuration, id: &str, deregister_table_request: models::DeregisterTableRequest, delimiter: Option<&str>) -> Result<models::DeregisterTableResponse, Error<DeregisterTableError>> {
1709    // add a prefix to parameters to efficiently prevent name collisions
1710    let p_id = id;
1711    let p_deregister_table_request = deregister_table_request;
1712    let p_delimiter = delimiter;
1713
1714    let uri_str = format!("{}/v1/table/{id}/deregister", configuration.base_path, id=crate::apis::urlencode(p_id));
1715    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1716
1717    if let Some(ref param_value) = p_delimiter {
1718        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1719    }
1720    if let Some(ref user_agent) = configuration.user_agent {
1721        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1722    }
1723    if let Some(ref token) = configuration.oauth_access_token {
1724        req_builder = req_builder.bearer_auth(token.to_owned());
1725    };
1726    if let Some(ref apikey) = configuration.api_key {
1727        let key = apikey.key.clone();
1728        let value = match apikey.prefix {
1729            Some(ref prefix) => format!("{} {}", prefix, key),
1730            None => key,
1731        };
1732        req_builder = req_builder.header("x-api-key", value);
1733    };
1734    if let Some(ref token) = configuration.bearer_access_token {
1735        req_builder = req_builder.bearer_auth(token.to_owned());
1736    };
1737    req_builder = req_builder.json(&p_deregister_table_request);
1738
1739    let req = req_builder.build()?;
1740    let resp = configuration.client.execute(req).await?;
1741
1742    let status = resp.status();
1743    let content_type = resp
1744        .headers()
1745        .get("content-type")
1746        .and_then(|v| v.to_str().ok())
1747        .unwrap_or("application/octet-stream");
1748    let content_type = super::ContentType::from(content_type);
1749
1750    if !status.is_client_error() && !status.is_server_error() {
1751        let content = resp.text().await?;
1752        match content_type {
1753            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1754            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeregisterTableResponse`"))),
1755            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeregisterTableResponse`")))),
1756        }
1757    } else {
1758        let content = resp.text().await?;
1759        let entity: Option<DeregisterTableError> = serde_json::from_str(&content).ok();
1760        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1761    }
1762}
1763
1764/// Describe the detailed information for table `id`.  REST NAMESPACE ONLY REST namespace passes `with_table_uri`, `load_detailed_metadata`, and `check_declared` as query parameters instead of in the request body. 
1765pub async fn describe_table(configuration: &configuration::Configuration, id: &str, describe_table_request: models::DescribeTableRequest, delimiter: Option<&str>, with_table_uri: Option<bool>, load_detailed_metadata: Option<bool>, check_declared: Option<bool>) -> Result<models::DescribeTableResponse, Error<DescribeTableError>> {
1766    // add a prefix to parameters to efficiently prevent name collisions
1767    let p_id = id;
1768    let p_describe_table_request = describe_table_request;
1769    let p_delimiter = delimiter;
1770    let p_with_table_uri = with_table_uri;
1771    let p_load_detailed_metadata = load_detailed_metadata;
1772    let p_check_declared = check_declared;
1773
1774    let uri_str = format!("{}/v1/table/{id}/describe", configuration.base_path, id=crate::apis::urlencode(p_id));
1775    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1776
1777    if let Some(ref param_value) = p_delimiter {
1778        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1779    }
1780    if let Some(ref param_value) = p_with_table_uri {
1781        req_builder = req_builder.query(&[("with_table_uri", &param_value.to_string())]);
1782    }
1783    if let Some(ref param_value) = p_load_detailed_metadata {
1784        req_builder = req_builder.query(&[("load_detailed_metadata", &param_value.to_string())]);
1785    }
1786    if let Some(ref param_value) = p_check_declared {
1787        req_builder = req_builder.query(&[("check_declared", &param_value.to_string())]);
1788    }
1789    if let Some(ref user_agent) = configuration.user_agent {
1790        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1791    }
1792    if let Some(ref token) = configuration.oauth_access_token {
1793        req_builder = req_builder.bearer_auth(token.to_owned());
1794    };
1795    if let Some(ref apikey) = configuration.api_key {
1796        let key = apikey.key.clone();
1797        let value = match apikey.prefix {
1798            Some(ref prefix) => format!("{} {}", prefix, key),
1799            None => key,
1800        };
1801        req_builder = req_builder.header("x-api-key", value);
1802    };
1803    if let Some(ref token) = configuration.bearer_access_token {
1804        req_builder = req_builder.bearer_auth(token.to_owned());
1805    };
1806    req_builder = req_builder.json(&p_describe_table_request);
1807
1808    let req = req_builder.build()?;
1809    let resp = configuration.client.execute(req).await?;
1810
1811    let status = resp.status();
1812    let content_type = resp
1813        .headers()
1814        .get("content-type")
1815        .and_then(|v| v.to_str().ok())
1816        .unwrap_or("application/octet-stream");
1817    let content_type = super::ContentType::from(content_type);
1818
1819    if !status.is_client_error() && !status.is_server_error() {
1820        let content = resp.text().await?;
1821        match content_type {
1822            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1823            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DescribeTableResponse`"))),
1824            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DescribeTableResponse`")))),
1825        }
1826    } else {
1827        let content = resp.text().await?;
1828        let entity: Option<DescribeTableError> = serde_json::from_str(&content).ok();
1829        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1830    }
1831}
1832
1833/// Get statistics for a specific index on a table. Returns information about the index type, distance type (for vector indices), and row counts. 
1834pub async fn describe_table_index_stats(configuration: &configuration::Configuration, id: &str, index_name: &str, describe_table_index_stats_request: models::DescribeTableIndexStatsRequest, delimiter: Option<&str>) -> Result<models::DescribeTableIndexStatsResponse, Error<DescribeTableIndexStatsError>> {
1835    // add a prefix to parameters to efficiently prevent name collisions
1836    let p_id = id;
1837    let p_index_name = index_name;
1838    let p_describe_table_index_stats_request = describe_table_index_stats_request;
1839    let p_delimiter = delimiter;
1840
1841    let uri_str = format!("{}/v1/table/{id}/index/{index_name}/stats", configuration.base_path, id=crate::apis::urlencode(p_id), index_name=crate::apis::urlencode(p_index_name));
1842    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1843
1844    if let Some(ref param_value) = p_delimiter {
1845        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1846    }
1847    if let Some(ref user_agent) = configuration.user_agent {
1848        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1849    }
1850    if let Some(ref token) = configuration.oauth_access_token {
1851        req_builder = req_builder.bearer_auth(token.to_owned());
1852    };
1853    if let Some(ref apikey) = configuration.api_key {
1854        let key = apikey.key.clone();
1855        let value = match apikey.prefix {
1856            Some(ref prefix) => format!("{} {}", prefix, key),
1857            None => key,
1858        };
1859        req_builder = req_builder.header("x-api-key", value);
1860    };
1861    if let Some(ref token) = configuration.bearer_access_token {
1862        req_builder = req_builder.bearer_auth(token.to_owned());
1863    };
1864    req_builder = req_builder.json(&p_describe_table_index_stats_request);
1865
1866    let req = req_builder.build()?;
1867    let resp = configuration.client.execute(req).await?;
1868
1869    let status = resp.status();
1870    let content_type = resp
1871        .headers()
1872        .get("content-type")
1873        .and_then(|v| v.to_str().ok())
1874        .unwrap_or("application/octet-stream");
1875    let content_type = super::ContentType::from(content_type);
1876
1877    if !status.is_client_error() && !status.is_server_error() {
1878        let content = resp.text().await?;
1879        match content_type {
1880            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1881            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DescribeTableIndexStatsResponse`"))),
1882            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DescribeTableIndexStatsResponse`")))),
1883        }
1884    } else {
1885        let content = resp.text().await?;
1886        let entity: Option<DescribeTableIndexStatsError> = serde_json::from_str(&content).ok();
1887        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1888    }
1889}
1890
1891/// Describe the detailed information for a specific version of table `id`.  Returns the manifest path and metadata for the specified version. 
1892pub async fn describe_table_version(configuration: &configuration::Configuration, id: &str, describe_table_version_request: models::DescribeTableVersionRequest, delimiter: Option<&str>) -> Result<models::DescribeTableVersionResponse, Error<DescribeTableVersionError>> {
1893    // add a prefix to parameters to efficiently prevent name collisions
1894    let p_id = id;
1895    let p_describe_table_version_request = describe_table_version_request;
1896    let p_delimiter = delimiter;
1897
1898    let uri_str = format!("{}/v1/table/{id}/version/describe", configuration.base_path, id=crate::apis::urlencode(p_id));
1899    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1900
1901    if let Some(ref param_value) = p_delimiter {
1902        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1903    }
1904    if let Some(ref user_agent) = configuration.user_agent {
1905        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1906    }
1907    if let Some(ref token) = configuration.oauth_access_token {
1908        req_builder = req_builder.bearer_auth(token.to_owned());
1909    };
1910    if let Some(ref apikey) = configuration.api_key {
1911        let key = apikey.key.clone();
1912        let value = match apikey.prefix {
1913            Some(ref prefix) => format!("{} {}", prefix, key),
1914            None => key,
1915        };
1916        req_builder = req_builder.header("x-api-key", value);
1917    };
1918    if let Some(ref token) = configuration.bearer_access_token {
1919        req_builder = req_builder.bearer_auth(token.to_owned());
1920    };
1921    req_builder = req_builder.json(&p_describe_table_version_request);
1922
1923    let req = req_builder.build()?;
1924    let resp = configuration.client.execute(req).await?;
1925
1926    let status = resp.status();
1927    let content_type = resp
1928        .headers()
1929        .get("content-type")
1930        .and_then(|v| v.to_str().ok())
1931        .unwrap_or("application/octet-stream");
1932    let content_type = super::ContentType::from(content_type);
1933
1934    if !status.is_client_error() && !status.is_server_error() {
1935        let content = resp.text().await?;
1936        match content_type {
1937            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1938            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DescribeTableVersionResponse`"))),
1939            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DescribeTableVersionResponse`")))),
1940        }
1941    } else {
1942        let content = resp.text().await?;
1943        let entity: Option<DescribeTableVersionError> = serde_json::from_str(&content).ok();
1944        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1945    }
1946}
1947
1948/// Drop table `id` and delete its data.  REST NAMESPACE ONLY REST namespace does not use a request body for this operation. The `DropTableRequest` information is passed in the following way: - `id`: pass through path parameter of the same name 
1949pub async fn drop_table(configuration: &configuration::Configuration, id: &str, delimiter: Option<&str>) -> Result<models::DropTableResponse, Error<DropTableError>> {
1950    // add a prefix to parameters to efficiently prevent name collisions
1951    let p_id = id;
1952    let p_delimiter = delimiter;
1953
1954    let uri_str = format!("{}/v1/table/{id}/drop", configuration.base_path, id=crate::apis::urlencode(p_id));
1955    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1956
1957    if let Some(ref param_value) = p_delimiter {
1958        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1959    }
1960    if let Some(ref user_agent) = configuration.user_agent {
1961        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1962    }
1963    if let Some(ref token) = configuration.oauth_access_token {
1964        req_builder = req_builder.bearer_auth(token.to_owned());
1965    };
1966    if let Some(ref apikey) = configuration.api_key {
1967        let key = apikey.key.clone();
1968        let value = match apikey.prefix {
1969            Some(ref prefix) => format!("{} {}", prefix, key),
1970            None => key,
1971        };
1972        req_builder = req_builder.header("x-api-key", value);
1973    };
1974    if let Some(ref token) = configuration.bearer_access_token {
1975        req_builder = req_builder.bearer_auth(token.to_owned());
1976    };
1977
1978    let req = req_builder.build()?;
1979    let resp = configuration.client.execute(req).await?;
1980
1981    let status = resp.status();
1982    let content_type = resp
1983        .headers()
1984        .get("content-type")
1985        .and_then(|v| v.to_str().ok())
1986        .unwrap_or("application/octet-stream");
1987    let content_type = super::ContentType::from(content_type);
1988
1989    if !status.is_client_error() && !status.is_server_error() {
1990        let content = resp.text().await?;
1991        match content_type {
1992            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1993            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DropTableResponse`"))),
1994            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DropTableResponse`")))),
1995        }
1996    } else {
1997        let content = resp.text().await?;
1998        let entity: Option<DropTableError> = serde_json::from_str(&content).ok();
1999        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2000    }
2001}
2002
2003/// Drop the specified index from table `id`.  REST NAMESPACE ONLY REST namespace does not use a request body for this operation. The `DropTableIndexRequest` information is passed in the following way: - `id`: pass through path parameter of the same name - `index_name`: pass through path parameter of the same name 
2004pub async fn drop_table_index(configuration: &configuration::Configuration, id: &str, index_name: &str, delimiter: Option<&str>, branch: Option<&str>) -> Result<models::DropTableIndexResponse, Error<DropTableIndexError>> {
2005    // add a prefix to parameters to efficiently prevent name collisions
2006    let p_id = id;
2007    let p_index_name = index_name;
2008    let p_delimiter = delimiter;
2009    let p_branch = branch;
2010
2011    let uri_str = format!("{}/v1/table/{id}/index/{index_name}/drop", configuration.base_path, id=crate::apis::urlencode(p_id), index_name=crate::apis::urlencode(p_index_name));
2012    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2013
2014    if let Some(ref param_value) = p_delimiter {
2015        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2016    }
2017    if let Some(ref param_value) = p_branch {
2018        req_builder = req_builder.query(&[("branch", &param_value.to_string())]);
2019    }
2020    if let Some(ref user_agent) = configuration.user_agent {
2021        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2022    }
2023    if let Some(ref token) = configuration.oauth_access_token {
2024        req_builder = req_builder.bearer_auth(token.to_owned());
2025    };
2026    if let Some(ref apikey) = configuration.api_key {
2027        let key = apikey.key.clone();
2028        let value = match apikey.prefix {
2029            Some(ref prefix) => format!("{} {}", prefix, key),
2030            None => key,
2031        };
2032        req_builder = req_builder.header("x-api-key", value);
2033    };
2034    if let Some(ref token) = configuration.bearer_access_token {
2035        req_builder = req_builder.bearer_auth(token.to_owned());
2036    };
2037
2038    let req = req_builder.build()?;
2039    let resp = configuration.client.execute(req).await?;
2040
2041    let status = resp.status();
2042    let content_type = resp
2043        .headers()
2044        .get("content-type")
2045        .and_then(|v| v.to_str().ok())
2046        .unwrap_or("application/octet-stream");
2047    let content_type = super::ContentType::from(content_type);
2048
2049    if !status.is_client_error() && !status.is_server_error() {
2050        let content = resp.text().await?;
2051        match content_type {
2052            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2053            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DropTableIndexResponse`"))),
2054            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DropTableIndexResponse`")))),
2055        }
2056    } else {
2057        let content = resp.text().await?;
2058        let entity: Option<DropTableIndexError> = serde_json::from_str(&content).ok();
2059        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2060    }
2061}
2062
2063/// Get the query execution plan for a query against table `id`. Returns a human-readable explanation of how the query will be executed.  REST NAMESPACE ONLY REST namespace returns the response as a plain string instead of the `ExplainTableQueryPlanResponse` JSON object. 
2064pub async fn explain_table_query_plan(configuration: &configuration::Configuration, id: &str, explain_table_query_plan_request: models::ExplainTableQueryPlanRequest, delimiter: Option<&str>) -> Result<String, Error<ExplainTableQueryPlanError>> {
2065    // add a prefix to parameters to efficiently prevent name collisions
2066    let p_id = id;
2067    let p_explain_table_query_plan_request = explain_table_query_plan_request;
2068    let p_delimiter = delimiter;
2069
2070    let uri_str = format!("{}/v1/table/{id}/explain_plan", configuration.base_path, id=crate::apis::urlencode(p_id));
2071    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2072
2073    if let Some(ref param_value) = p_delimiter {
2074        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2075    }
2076    if let Some(ref user_agent) = configuration.user_agent {
2077        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2078    }
2079    if let Some(ref token) = configuration.oauth_access_token {
2080        req_builder = req_builder.bearer_auth(token.to_owned());
2081    };
2082    if let Some(ref apikey) = configuration.api_key {
2083        let key = apikey.key.clone();
2084        let value = match apikey.prefix {
2085            Some(ref prefix) => format!("{} {}", prefix, key),
2086            None => key,
2087        };
2088        req_builder = req_builder.header("x-api-key", value);
2089    };
2090    if let Some(ref token) = configuration.bearer_access_token {
2091        req_builder = req_builder.bearer_auth(token.to_owned());
2092    };
2093    req_builder = req_builder.json(&p_explain_table_query_plan_request);
2094
2095    let req = req_builder.build()?;
2096    let resp = configuration.client.execute(req).await?;
2097
2098    let status = resp.status();
2099    let content_type = resp
2100        .headers()
2101        .get("content-type")
2102        .and_then(|v| v.to_str().ok())
2103        .unwrap_or("application/octet-stream");
2104    let content_type = super::ContentType::from(content_type);
2105
2106    if !status.is_client_error() && !status.is_server_error() {
2107        let content = resp.text().await?;
2108        match content_type {
2109            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2110            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `String`"))),
2111            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `String`")))),
2112        }
2113    } else {
2114        let content = resp.text().await?;
2115        let entity: Option<ExplainTableQueryPlanError> = serde_json::from_str(&content).ok();
2116        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2117    }
2118}
2119
2120/// Get statistics for table `id`, including row counts, data sizes, and column statistics. 
2121pub async fn get_table_stats(configuration: &configuration::Configuration, id: &str, get_table_stats_request: models::GetTableStatsRequest, delimiter: Option<&str>) -> Result<models::GetTableStatsResponse, Error<GetTableStatsError>> {
2122    // add a prefix to parameters to efficiently prevent name collisions
2123    let p_id = id;
2124    let p_get_table_stats_request = get_table_stats_request;
2125    let p_delimiter = delimiter;
2126
2127    let uri_str = format!("{}/v1/table/{id}/stats", configuration.base_path, id=crate::apis::urlencode(p_id));
2128    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2129
2130    if let Some(ref param_value) = p_delimiter {
2131        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2132    }
2133    if let Some(ref user_agent) = configuration.user_agent {
2134        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2135    }
2136    if let Some(ref token) = configuration.oauth_access_token {
2137        req_builder = req_builder.bearer_auth(token.to_owned());
2138    };
2139    if let Some(ref apikey) = configuration.api_key {
2140        let key = apikey.key.clone();
2141        let value = match apikey.prefix {
2142            Some(ref prefix) => format!("{} {}", prefix, key),
2143            None => key,
2144        };
2145        req_builder = req_builder.header("x-api-key", value);
2146    };
2147    if let Some(ref token) = configuration.bearer_access_token {
2148        req_builder = req_builder.bearer_auth(token.to_owned());
2149    };
2150    req_builder = req_builder.json(&p_get_table_stats_request);
2151
2152    let req = req_builder.build()?;
2153    let resp = configuration.client.execute(req).await?;
2154
2155    let status = resp.status();
2156    let content_type = resp
2157        .headers()
2158        .get("content-type")
2159        .and_then(|v| v.to_str().ok())
2160        .unwrap_or("application/octet-stream");
2161    let content_type = super::ContentType::from(content_type);
2162
2163    if !status.is_client_error() && !status.is_server_error() {
2164        let content = resp.text().await?;
2165        match content_type {
2166            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2167            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetTableStatsResponse`"))),
2168            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetTableStatsResponse`")))),
2169        }
2170    } else {
2171        let content = resp.text().await?;
2172        let entity: Option<GetTableStatsError> = serde_json::from_str(&content).ok();
2173        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2174    }
2175}
2176
2177/// Get the version number that a specific tag points to for table `id`. 
2178pub async fn get_table_tag_version(configuration: &configuration::Configuration, id: &str, get_table_tag_version_request: models::GetTableTagVersionRequest, delimiter: Option<&str>) -> Result<models::GetTableTagVersionResponse, Error<GetTableTagVersionError>> {
2179    // add a prefix to parameters to efficiently prevent name collisions
2180    let p_id = id;
2181    let p_get_table_tag_version_request = get_table_tag_version_request;
2182    let p_delimiter = delimiter;
2183
2184    let uri_str = format!("{}/v1/table/{id}/tags/version", configuration.base_path, id=crate::apis::urlencode(p_id));
2185    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2186
2187    if let Some(ref param_value) = p_delimiter {
2188        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2189    }
2190    if let Some(ref user_agent) = configuration.user_agent {
2191        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2192    }
2193    if let Some(ref token) = configuration.oauth_access_token {
2194        req_builder = req_builder.bearer_auth(token.to_owned());
2195    };
2196    if let Some(ref apikey) = configuration.api_key {
2197        let key = apikey.key.clone();
2198        let value = match apikey.prefix {
2199            Some(ref prefix) => format!("{} {}", prefix, key),
2200            None => key,
2201        };
2202        req_builder = req_builder.header("x-api-key", value);
2203    };
2204    if let Some(ref token) = configuration.bearer_access_token {
2205        req_builder = req_builder.bearer_auth(token.to_owned());
2206    };
2207    req_builder = req_builder.json(&p_get_table_tag_version_request);
2208
2209    let req = req_builder.build()?;
2210    let resp = configuration.client.execute(req).await?;
2211
2212    let status = resp.status();
2213    let content_type = resp
2214        .headers()
2215        .get("content-type")
2216        .and_then(|v| v.to_str().ok())
2217        .unwrap_or("application/octet-stream");
2218    let content_type = super::ContentType::from(content_type);
2219
2220    if !status.is_client_error() && !status.is_server_error() {
2221        let content = resp.text().await?;
2222        match content_type {
2223            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2224            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetTableTagVersionResponse`"))),
2225            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetTableTagVersionResponse`")))),
2226        }
2227    } else {
2228        let content = resp.text().await?;
2229        let entity: Option<GetTableTagVersionError> = serde_json::from_str(&content).ok();
2230        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2231    }
2232}
2233
2234/// Insert new records into table `id`.  For tables that have been declared but not yet created on storage (is_only_declared=true), this operation will create the table with the provided data.  REST NAMESPACE ONLY REST namespace uses Arrow IPC stream as the request body. It passes in the `InsertIntoTableRequest` information in the following way: - `id`: pass through path parameter of the same name - `mode`: pass through query parameter of the same name 
2235pub async fn insert_into_table(configuration: &configuration::Configuration, id: &str, body: Vec<u8>, delimiter: Option<&str>, branch: Option<&str>, mode: Option<&str>) -> Result<models::InsertIntoTableResponse, Error<InsertIntoTableError>> {
2236    // add a prefix to parameters to efficiently prevent name collisions
2237    let p_id = id;
2238    let p_body = body;
2239    let p_delimiter = delimiter;
2240    let p_branch = branch;
2241    let p_mode = mode;
2242
2243    let uri_str = format!("{}/v1/table/{id}/insert", configuration.base_path, id=crate::apis::urlencode(p_id));
2244    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2245
2246    if let Some(ref param_value) = p_delimiter {
2247        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2248    }
2249    if let Some(ref param_value) = p_branch {
2250        req_builder = req_builder.query(&[("branch", &param_value.to_string())]);
2251    }
2252    if let Some(ref param_value) = p_mode {
2253        req_builder = req_builder.query(&[("mode", &param_value.to_string())]);
2254    }
2255    if let Some(ref user_agent) = configuration.user_agent {
2256        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2257    }
2258    if let Some(ref token) = configuration.oauth_access_token {
2259        req_builder = req_builder.bearer_auth(token.to_owned());
2260    };
2261    if let Some(ref apikey) = configuration.api_key {
2262        let key = apikey.key.clone();
2263        let value = match apikey.prefix {
2264            Some(ref prefix) => format!("{} {}", prefix, key),
2265            None => key,
2266        };
2267        req_builder = req_builder.header("x-api-key", value);
2268    };
2269    if let Some(ref token) = configuration.bearer_access_token {
2270        req_builder = req_builder.bearer_auth(token.to_owned());
2271    };
2272    req_builder = req_builder.body(p_body);
2273
2274    let req = req_builder.build()?;
2275    let resp = configuration.client.execute(req).await?;
2276
2277    let status = resp.status();
2278    let content_type = resp
2279        .headers()
2280        .get("content-type")
2281        .and_then(|v| v.to_str().ok())
2282        .unwrap_or("application/octet-stream");
2283    let content_type = super::ContentType::from(content_type);
2284
2285    if !status.is_client_error() && !status.is_server_error() {
2286        let content = resp.text().await?;
2287        match content_type {
2288            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2289            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::InsertIntoTableResponse`"))),
2290            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::InsertIntoTableResponse`")))),
2291        }
2292    } else {
2293        let content = resp.text().await?;
2294        let entity: Option<InsertIntoTableError> = serde_json::from_str(&content).ok();
2295        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2296    }
2297}
2298
2299/// List all tables across all namespaces.  REST NAMESPACE ONLY REST namespace uses GET to perform this operation without a request body. It passes in the `ListAllTablesRequest` information in the following way: - `page_token`: pass through query parameter of the same name - `limit`: pass through query parameter of the same name - `delimiter`: pass through query parameter of the same name - `include_declared`: pass through query parameter of the same name 
2300pub async fn list_all_tables(configuration: &configuration::Configuration, delimiter: Option<&str>, page_token: Option<&str>, limit: Option<i32>, include_declared: Option<bool>) -> Result<models::ListTablesResponse, Error<ListAllTablesError>> {
2301    // add a prefix to parameters to efficiently prevent name collisions
2302    let p_delimiter = delimiter;
2303    let p_page_token = page_token;
2304    let p_limit = limit;
2305    let p_include_declared = include_declared;
2306
2307    let uri_str = format!("{}/v1/table", configuration.base_path);
2308    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2309
2310    if let Some(ref param_value) = p_delimiter {
2311        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2312    }
2313    if let Some(ref param_value) = p_page_token {
2314        req_builder = req_builder.query(&[("page_token", &param_value.to_string())]);
2315    }
2316    if let Some(ref param_value) = p_limit {
2317        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
2318    }
2319    if let Some(ref param_value) = p_include_declared {
2320        req_builder = req_builder.query(&[("include_declared", &param_value.to_string())]);
2321    }
2322    if let Some(ref user_agent) = configuration.user_agent {
2323        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2324    }
2325    if let Some(ref token) = configuration.oauth_access_token {
2326        req_builder = req_builder.bearer_auth(token.to_owned());
2327    };
2328    if let Some(ref apikey) = configuration.api_key {
2329        let key = apikey.key.clone();
2330        let value = match apikey.prefix {
2331            Some(ref prefix) => format!("{} {}", prefix, key),
2332            None => key,
2333        };
2334        req_builder = req_builder.header("x-api-key", value);
2335    };
2336    if let Some(ref token) = configuration.bearer_access_token {
2337        req_builder = req_builder.bearer_auth(token.to_owned());
2338    };
2339
2340    let req = req_builder.build()?;
2341    let resp = configuration.client.execute(req).await?;
2342
2343    let status = resp.status();
2344    let content_type = resp
2345        .headers()
2346        .get("content-type")
2347        .and_then(|v| v.to_str().ok())
2348        .unwrap_or("application/octet-stream");
2349    let content_type = super::ContentType::from(content_type);
2350
2351    if !status.is_client_error() && !status.is_server_error() {
2352        let content = resp.text().await?;
2353        match content_type {
2354            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2355            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTablesResponse`"))),
2356            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListTablesResponse`")))),
2357        }
2358    } else {
2359        let content = resp.text().await?;
2360        let entity: Option<ListAllTablesError> = serde_json::from_str(&content).ok();
2361        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2362    }
2363}
2364
2365/// List all branches that have been created for table `id`. Returns a map of branch names to their contents.  REST NAMESPACE ONLY REST namespace does not use a request body for this operation. The `ListTableBranchesRequest` information is passed in the following way: - `id`: pass through path parameter of the same name - `page_token`: pass through query parameter of the same name - `limit`: pass through query parameter of the same name 
2366pub async fn list_table_branches(configuration: &configuration::Configuration, id: &str, delimiter: Option<&str>, page_token: Option<&str>, limit: Option<i32>) -> Result<models::ListTableBranchesResponse, Error<ListTableBranchesError>> {
2367    // add a prefix to parameters to efficiently prevent name collisions
2368    let p_id = id;
2369    let p_delimiter = delimiter;
2370    let p_page_token = page_token;
2371    let p_limit = limit;
2372
2373    let uri_str = format!("{}/v1/table/{id}/branches/list", configuration.base_path, id=crate::apis::urlencode(p_id));
2374    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2375
2376    if let Some(ref param_value) = p_delimiter {
2377        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2378    }
2379    if let Some(ref param_value) = p_page_token {
2380        req_builder = req_builder.query(&[("page_token", &param_value.to_string())]);
2381    }
2382    if let Some(ref param_value) = p_limit {
2383        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
2384    }
2385    if let Some(ref user_agent) = configuration.user_agent {
2386        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2387    }
2388    if let Some(ref token) = configuration.oauth_access_token {
2389        req_builder = req_builder.bearer_auth(token.to_owned());
2390    };
2391    if let Some(ref apikey) = configuration.api_key {
2392        let key = apikey.key.clone();
2393        let value = match apikey.prefix {
2394            Some(ref prefix) => format!("{} {}", prefix, key),
2395            None => key,
2396        };
2397        req_builder = req_builder.header("x-api-key", value);
2398    };
2399    if let Some(ref token) = configuration.bearer_access_token {
2400        req_builder = req_builder.bearer_auth(token.to_owned());
2401    };
2402
2403    let req = req_builder.build()?;
2404    let resp = configuration.client.execute(req).await?;
2405
2406    let status = resp.status();
2407    let content_type = resp
2408        .headers()
2409        .get("content-type")
2410        .and_then(|v| v.to_str().ok())
2411        .unwrap_or("application/octet-stream");
2412    let content_type = super::ContentType::from(content_type);
2413
2414    if !status.is_client_error() && !status.is_server_error() {
2415        let content = resp.text().await?;
2416        match content_type {
2417            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2418            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTableBranchesResponse`"))),
2419            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListTableBranchesResponse`")))),
2420        }
2421    } else {
2422        let content = resp.text().await?;
2423        let entity: Option<ListTableBranchesError> = serde_json::from_str(&content).ok();
2424        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2425    }
2426}
2427
2428/// List all indices created on a table. Returns information about each index including name, columns, status, and UUID. 
2429pub async fn list_table_indices(configuration: &configuration::Configuration, id: &str, list_table_indices_request: models::ListTableIndicesRequest, delimiter: Option<&str>) -> Result<models::ListTableIndicesResponse, Error<ListTableIndicesError>> {
2430    // add a prefix to parameters to efficiently prevent name collisions
2431    let p_id = id;
2432    let p_list_table_indices_request = list_table_indices_request;
2433    let p_delimiter = delimiter;
2434
2435    let uri_str = format!("{}/v1/table/{id}/index/list", configuration.base_path, id=crate::apis::urlencode(p_id));
2436    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2437
2438    if let Some(ref param_value) = p_delimiter {
2439        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2440    }
2441    if let Some(ref user_agent) = configuration.user_agent {
2442        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2443    }
2444    if let Some(ref token) = configuration.oauth_access_token {
2445        req_builder = req_builder.bearer_auth(token.to_owned());
2446    };
2447    if let Some(ref apikey) = configuration.api_key {
2448        let key = apikey.key.clone();
2449        let value = match apikey.prefix {
2450            Some(ref prefix) => format!("{} {}", prefix, key),
2451            None => key,
2452        };
2453        req_builder = req_builder.header("x-api-key", value);
2454    };
2455    if let Some(ref token) = configuration.bearer_access_token {
2456        req_builder = req_builder.bearer_auth(token.to_owned());
2457    };
2458    req_builder = req_builder.json(&p_list_table_indices_request);
2459
2460    let req = req_builder.build()?;
2461    let resp = configuration.client.execute(req).await?;
2462
2463    let status = resp.status();
2464    let content_type = resp
2465        .headers()
2466        .get("content-type")
2467        .and_then(|v| v.to_str().ok())
2468        .unwrap_or("application/octet-stream");
2469    let content_type = super::ContentType::from(content_type);
2470
2471    if !status.is_client_error() && !status.is_server_error() {
2472        let content = resp.text().await?;
2473        match content_type {
2474            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2475            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTableIndicesResponse`"))),
2476            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListTableIndicesResponse`")))),
2477        }
2478    } else {
2479        let content = resp.text().await?;
2480        let entity: Option<ListTableIndicesError> = serde_json::from_str(&content).ok();
2481        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2482    }
2483}
2484
2485/// List all tags that have been created for table `id`. Returns a map of tag names to their corresponding version numbers and metadata.  REST NAMESPACE ONLY REST namespace does not use a request body for this operation. The `ListTableTagsRequest` information is passed in the following way: - `id`: pass through path parameter of the same name - `page_token`: pass through query parameter of the same name - `limit`: pass through query parameter of the same name 
2486pub async fn list_table_tags(configuration: &configuration::Configuration, id: &str, delimiter: Option<&str>, page_token: Option<&str>, limit: Option<i32>) -> Result<models::ListTableTagsResponse, Error<ListTableTagsError>> {
2487    // add a prefix to parameters to efficiently prevent name collisions
2488    let p_id = id;
2489    let p_delimiter = delimiter;
2490    let p_page_token = page_token;
2491    let p_limit = limit;
2492
2493    let uri_str = format!("{}/v1/table/{id}/tags/list", configuration.base_path, id=crate::apis::urlencode(p_id));
2494    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2495
2496    if let Some(ref param_value) = p_delimiter {
2497        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2498    }
2499    if let Some(ref param_value) = p_page_token {
2500        req_builder = req_builder.query(&[("page_token", &param_value.to_string())]);
2501    }
2502    if let Some(ref param_value) = p_limit {
2503        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
2504    }
2505    if let Some(ref user_agent) = configuration.user_agent {
2506        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2507    }
2508    if let Some(ref token) = configuration.oauth_access_token {
2509        req_builder = req_builder.bearer_auth(token.to_owned());
2510    };
2511    if let Some(ref apikey) = configuration.api_key {
2512        let key = apikey.key.clone();
2513        let value = match apikey.prefix {
2514            Some(ref prefix) => format!("{} {}", prefix, key),
2515            None => key,
2516        };
2517        req_builder = req_builder.header("x-api-key", value);
2518    };
2519    if let Some(ref token) = configuration.bearer_access_token {
2520        req_builder = req_builder.bearer_auth(token.to_owned());
2521    };
2522
2523    let req = req_builder.build()?;
2524    let resp = configuration.client.execute(req).await?;
2525
2526    let status = resp.status();
2527    let content_type = resp
2528        .headers()
2529        .get("content-type")
2530        .and_then(|v| v.to_str().ok())
2531        .unwrap_or("application/octet-stream");
2532    let content_type = super::ContentType::from(content_type);
2533
2534    if !status.is_client_error() && !status.is_server_error() {
2535        let content = resp.text().await?;
2536        match content_type {
2537            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2538            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTableTagsResponse`"))),
2539            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListTableTagsResponse`")))),
2540        }
2541    } else {
2542        let content = resp.text().await?;
2543        let entity: Option<ListTableTagsError> = serde_json::from_str(&content).ok();
2544        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2545    }
2546}
2547
2548/// List all versions (commits) of table `id` with their metadata.  Use `descending=true` to guarantee versions are returned in descending order (latest to oldest). Otherwise, the ordering is implementation-defined.  REST NAMESPACE ONLY REST namespace does not use a request body for this operation. The `ListTableVersionsRequest` information is passed in the following way: - `id`: pass through path parameter of the same name - `page_token`: pass through query parameter of the same name - `limit`: pass through query parameter of the same name - `descending`: pass through query parameter of the same name 
2549pub async fn list_table_versions(configuration: &configuration::Configuration, id: &str, delimiter: Option<&str>, branch: Option<&str>, page_token: Option<&str>, limit: Option<i32>, descending: Option<bool>) -> Result<models::ListTableVersionsResponse, Error<ListTableVersionsError>> {
2550    // add a prefix to parameters to efficiently prevent name collisions
2551    let p_id = id;
2552    let p_delimiter = delimiter;
2553    let p_branch = branch;
2554    let p_page_token = page_token;
2555    let p_limit = limit;
2556    let p_descending = descending;
2557
2558    let uri_str = format!("{}/v1/table/{id}/version/list", configuration.base_path, id=crate::apis::urlencode(p_id));
2559    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2560
2561    if let Some(ref param_value) = p_delimiter {
2562        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2563    }
2564    if let Some(ref param_value) = p_branch {
2565        req_builder = req_builder.query(&[("branch", &param_value.to_string())]);
2566    }
2567    if let Some(ref param_value) = p_page_token {
2568        req_builder = req_builder.query(&[("page_token", &param_value.to_string())]);
2569    }
2570    if let Some(ref param_value) = p_limit {
2571        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
2572    }
2573    if let Some(ref param_value) = p_descending {
2574        req_builder = req_builder.query(&[("descending", &param_value.to_string())]);
2575    }
2576    if let Some(ref user_agent) = configuration.user_agent {
2577        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2578    }
2579    if let Some(ref token) = configuration.oauth_access_token {
2580        req_builder = req_builder.bearer_auth(token.to_owned());
2581    };
2582    if let Some(ref apikey) = configuration.api_key {
2583        let key = apikey.key.clone();
2584        let value = match apikey.prefix {
2585            Some(ref prefix) => format!("{} {}", prefix, key),
2586            None => key,
2587        };
2588        req_builder = req_builder.header("x-api-key", value);
2589    };
2590    if let Some(ref token) = configuration.bearer_access_token {
2591        req_builder = req_builder.bearer_auth(token.to_owned());
2592    };
2593
2594    let req = req_builder.build()?;
2595    let resp = configuration.client.execute(req).await?;
2596
2597    let status = resp.status();
2598    let content_type = resp
2599        .headers()
2600        .get("content-type")
2601        .and_then(|v| v.to_str().ok())
2602        .unwrap_or("application/octet-stream");
2603    let content_type = super::ContentType::from(content_type);
2604
2605    if !status.is_client_error() && !status.is_server_error() {
2606        let content = resp.text().await?;
2607        match content_type {
2608            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2609            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTableVersionsResponse`"))),
2610            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListTableVersionsResponse`")))),
2611        }
2612    } else {
2613        let content = resp.text().await?;
2614        let entity: Option<ListTableVersionsError> = serde_json::from_str(&content).ok();
2615        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2616    }
2617}
2618
2619/// List all child table names of the parent namespace `id`.  REST NAMESPACE ONLY REST namespace uses GET to perform this operation without a request body. It passes in the `ListTablesRequest` information in the following way: - `id`: pass through path parameter of the same name - `page_token`: pass through query parameter of the same name - `limit`: pass through query parameter of the same name - `include_declared`: pass through query parameter of the same name 
2620pub async fn list_tables(configuration: &configuration::Configuration, id: &str, delimiter: Option<&str>, page_token: Option<&str>, limit: Option<i32>, include_declared: Option<bool>) -> Result<models::ListTablesResponse, Error<ListTablesError>> {
2621    // add a prefix to parameters to efficiently prevent name collisions
2622    let p_id = id;
2623    let p_delimiter = delimiter;
2624    let p_page_token = page_token;
2625    let p_limit = limit;
2626    let p_include_declared = include_declared;
2627
2628    let uri_str = format!("{}/v1/namespace/{id}/table/list", configuration.base_path, id=crate::apis::urlencode(p_id));
2629    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2630
2631    if let Some(ref param_value) = p_delimiter {
2632        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2633    }
2634    if let Some(ref param_value) = p_page_token {
2635        req_builder = req_builder.query(&[("page_token", &param_value.to_string())]);
2636    }
2637    if let Some(ref param_value) = p_limit {
2638        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
2639    }
2640    if let Some(ref param_value) = p_include_declared {
2641        req_builder = req_builder.query(&[("include_declared", &param_value.to_string())]);
2642    }
2643    if let Some(ref user_agent) = configuration.user_agent {
2644        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2645    }
2646    if let Some(ref token) = configuration.oauth_access_token {
2647        req_builder = req_builder.bearer_auth(token.to_owned());
2648    };
2649    if let Some(ref apikey) = configuration.api_key {
2650        let key = apikey.key.clone();
2651        let value = match apikey.prefix {
2652            Some(ref prefix) => format!("{} {}", prefix, key),
2653            None => key,
2654        };
2655        req_builder = req_builder.header("x-api-key", value);
2656    };
2657    if let Some(ref token) = configuration.bearer_access_token {
2658        req_builder = req_builder.bearer_auth(token.to_owned());
2659    };
2660
2661    let req = req_builder.build()?;
2662    let resp = configuration.client.execute(req).await?;
2663
2664    let status = resp.status();
2665    let content_type = resp
2666        .headers()
2667        .get("content-type")
2668        .and_then(|v| v.to_str().ok())
2669        .unwrap_or("application/octet-stream");
2670    let content_type = super::ContentType::from(content_type);
2671
2672    if !status.is_client_error() && !status.is_server_error() {
2673        let content = resp.text().await?;
2674        match content_type {
2675            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2676            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTablesResponse`"))),
2677            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListTablesResponse`")))),
2678        }
2679    } else {
2680        let content = resp.text().await?;
2681        let entity: Option<ListTablesError> = serde_json::from_str(&content).ok();
2682        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2683    }
2684}
2685
2686/// Performs a merge insert (upsert) operation on table `id`. This operation updates existing rows based on a matching column and inserts new rows that don't match. It returns the number of rows inserted and updated.  For tables that have been declared but not yet created on storage (is_only_declared=true), this operation will create the table with the provided data (since there are no existing rows to merge with).  REST NAMESPACE ONLY REST namespace uses Arrow IPC stream as the request body. It passes in the `MergeInsertIntoTableRequest` information in the following way: - `id`: pass through path parameter of the same name - `on`: pass through query parameter of the same name - `when_matched_update_all`: pass through query parameter of the same name - `when_matched_update_all_filt`: pass through query parameter of the same name - `when_not_matched_insert_all`: pass through query parameter of the same name - `when_not_matched_by_source_delete`: pass through query parameter of the same name - `when_not_matched_by_source_delete_filt`: pass through query parameter of the same name 
2687pub async fn merge_insert_into_table(configuration: &configuration::Configuration, id: &str, on: &str, body: Vec<u8>, delimiter: Option<&str>, branch: Option<&str>, when_matched_update_all: Option<bool>, when_matched_update_all_filt: Option<&str>, when_not_matched_insert_all: Option<bool>, when_not_matched_by_source_delete: Option<bool>, when_not_matched_by_source_delete_filt: Option<&str>, timeout: Option<&str>, use_index: Option<bool>) -> Result<models::MergeInsertIntoTableResponse, Error<MergeInsertIntoTableError>> {
2688    // add a prefix to parameters to efficiently prevent name collisions
2689    let p_id = id;
2690    let p_on = on;
2691    let p_body = body;
2692    let p_delimiter = delimiter;
2693    let p_branch = branch;
2694    let p_when_matched_update_all = when_matched_update_all;
2695    let p_when_matched_update_all_filt = when_matched_update_all_filt;
2696    let p_when_not_matched_insert_all = when_not_matched_insert_all;
2697    let p_when_not_matched_by_source_delete = when_not_matched_by_source_delete;
2698    let p_when_not_matched_by_source_delete_filt = when_not_matched_by_source_delete_filt;
2699    let p_timeout = timeout;
2700    let p_use_index = use_index;
2701
2702    let uri_str = format!("{}/v1/table/{id}/merge_insert", configuration.base_path, id=crate::apis::urlencode(p_id));
2703    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2704
2705    if let Some(ref param_value) = p_delimiter {
2706        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2707    }
2708    if let Some(ref param_value) = p_branch {
2709        req_builder = req_builder.query(&[("branch", &param_value.to_string())]);
2710    }
2711    req_builder = req_builder.query(&[("on", &p_on.to_string())]);
2712    if let Some(ref param_value) = p_when_matched_update_all {
2713        req_builder = req_builder.query(&[("when_matched_update_all", &param_value.to_string())]);
2714    }
2715    if let Some(ref param_value) = p_when_matched_update_all_filt {
2716        req_builder = req_builder.query(&[("when_matched_update_all_filt", &param_value.to_string())]);
2717    }
2718    if let Some(ref param_value) = p_when_not_matched_insert_all {
2719        req_builder = req_builder.query(&[("when_not_matched_insert_all", &param_value.to_string())]);
2720    }
2721    if let Some(ref param_value) = p_when_not_matched_by_source_delete {
2722        req_builder = req_builder.query(&[("when_not_matched_by_source_delete", &param_value.to_string())]);
2723    }
2724    if let Some(ref param_value) = p_when_not_matched_by_source_delete_filt {
2725        req_builder = req_builder.query(&[("when_not_matched_by_source_delete_filt", &param_value.to_string())]);
2726    }
2727    if let Some(ref param_value) = p_timeout {
2728        req_builder = req_builder.query(&[("timeout", &param_value.to_string())]);
2729    }
2730    if let Some(ref param_value) = p_use_index {
2731        req_builder = req_builder.query(&[("use_index", &param_value.to_string())]);
2732    }
2733    if let Some(ref user_agent) = configuration.user_agent {
2734        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2735    }
2736    if let Some(ref token) = configuration.oauth_access_token {
2737        req_builder = req_builder.bearer_auth(token.to_owned());
2738    };
2739    if let Some(ref apikey) = configuration.api_key {
2740        let key = apikey.key.clone();
2741        let value = match apikey.prefix {
2742            Some(ref prefix) => format!("{} {}", prefix, key),
2743            None => key,
2744        };
2745        req_builder = req_builder.header("x-api-key", value);
2746    };
2747    if let Some(ref token) = configuration.bearer_access_token {
2748        req_builder = req_builder.bearer_auth(token.to_owned());
2749    };
2750    req_builder = req_builder.body(p_body);
2751
2752    let req = req_builder.build()?;
2753    let resp = configuration.client.execute(req).await?;
2754
2755    let status = resp.status();
2756    let content_type = resp
2757        .headers()
2758        .get("content-type")
2759        .and_then(|v| v.to_str().ok())
2760        .unwrap_or("application/octet-stream");
2761    let content_type = super::ContentType::from(content_type);
2762
2763    if !status.is_client_error() && !status.is_server_error() {
2764        let content = resp.text().await?;
2765        match content_type {
2766            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2767            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::MergeInsertIntoTableResponse`"))),
2768            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::MergeInsertIntoTableResponse`")))),
2769        }
2770    } else {
2771        let content = resp.text().await?;
2772        let entity: Option<MergeInsertIntoTableError> = serde_json::from_str(&content).ok();
2773        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2774    }
2775}
2776
2777/// Query table `id` with vector search, full text search and optional SQL filtering. Returns results in Arrow IPC file or stream format.  REST NAMESPACE ONLY REST namespace returns the response as Arrow IPC file binary data instead of the `QueryTableResponse` JSON object. 
2778pub async fn query_table(configuration: &configuration::Configuration, id: &str, query_table_request: models::QueryTableRequest, delimiter: Option<&str>) -> Result<reqwest::Response, Error<QueryTableError>> {
2779    // add a prefix to parameters to efficiently prevent name collisions
2780    let p_id = id;
2781    let p_query_table_request = query_table_request;
2782    let p_delimiter = delimiter;
2783
2784    let uri_str = format!("{}/v1/table/{id}/query", configuration.base_path, id=crate::apis::urlencode(p_id));
2785    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2786
2787    if let Some(ref param_value) = p_delimiter {
2788        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2789    }
2790    if let Some(ref user_agent) = configuration.user_agent {
2791        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2792    }
2793    if let Some(ref token) = configuration.oauth_access_token {
2794        req_builder = req_builder.bearer_auth(token.to_owned());
2795    };
2796    if let Some(ref apikey) = configuration.api_key {
2797        let key = apikey.key.clone();
2798        let value = match apikey.prefix {
2799            Some(ref prefix) => format!("{} {}", prefix, key),
2800            None => key,
2801        };
2802        req_builder = req_builder.header("x-api-key", value);
2803    };
2804    if let Some(ref token) = configuration.bearer_access_token {
2805        req_builder = req_builder.bearer_auth(token.to_owned());
2806    };
2807    req_builder = req_builder.json(&p_query_table_request);
2808
2809    let req = req_builder.build()?;
2810    let resp = configuration.client.execute(req).await?;
2811
2812    let status = resp.status();
2813
2814    if !status.is_client_error() && !status.is_server_error() {
2815        Ok(resp)
2816    } else {
2817        let content = resp.text().await?;
2818        let entity: Option<QueryTableError> = serde_json::from_str(&content).ok();
2819        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2820    }
2821}
2822
2823/// Register an existing table at a given storage location as `id`. 
2824pub async fn register_table(configuration: &configuration::Configuration, id: &str, register_table_request: models::RegisterTableRequest, delimiter: Option<&str>) -> Result<models::RegisterTableResponse, Error<RegisterTableError>> {
2825    // add a prefix to parameters to efficiently prevent name collisions
2826    let p_id = id;
2827    let p_register_table_request = register_table_request;
2828    let p_delimiter = delimiter;
2829
2830    let uri_str = format!("{}/v1/table/{id}/register", configuration.base_path, id=crate::apis::urlencode(p_id));
2831    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2832
2833    if let Some(ref param_value) = p_delimiter {
2834        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2835    }
2836    if let Some(ref user_agent) = configuration.user_agent {
2837        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2838    }
2839    if let Some(ref token) = configuration.oauth_access_token {
2840        req_builder = req_builder.bearer_auth(token.to_owned());
2841    };
2842    if let Some(ref apikey) = configuration.api_key {
2843        let key = apikey.key.clone();
2844        let value = match apikey.prefix {
2845            Some(ref prefix) => format!("{} {}", prefix, key),
2846            None => key,
2847        };
2848        req_builder = req_builder.header("x-api-key", value);
2849    };
2850    if let Some(ref token) = configuration.bearer_access_token {
2851        req_builder = req_builder.bearer_auth(token.to_owned());
2852    };
2853    req_builder = req_builder.json(&p_register_table_request);
2854
2855    let req = req_builder.build()?;
2856    let resp = configuration.client.execute(req).await?;
2857
2858    let status = resp.status();
2859    let content_type = resp
2860        .headers()
2861        .get("content-type")
2862        .and_then(|v| v.to_str().ok())
2863        .unwrap_or("application/octet-stream");
2864    let content_type = super::ContentType::from(content_type);
2865
2866    if !status.is_client_error() && !status.is_server_error() {
2867        let content = resp.text().await?;
2868        match content_type {
2869            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2870            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RegisterTableResponse`"))),
2871            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RegisterTableResponse`")))),
2872        }
2873    } else {
2874        let content = resp.text().await?;
2875        let entity: Option<RegisterTableError> = serde_json::from_str(&content).ok();
2876        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2877    }
2878}
2879
2880/// Rename table `id` to a new name. 
2881pub async fn rename_table(configuration: &configuration::Configuration, id: &str, rename_table_request: models::RenameTableRequest, delimiter: Option<&str>) -> Result<models::RenameTableResponse, Error<RenameTableError>> {
2882    // add a prefix to parameters to efficiently prevent name collisions
2883    let p_id = id;
2884    let p_rename_table_request = rename_table_request;
2885    let p_delimiter = delimiter;
2886
2887    let uri_str = format!("{}/v1/table/{id}/rename", configuration.base_path, id=crate::apis::urlencode(p_id));
2888    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2889
2890    if let Some(ref param_value) = p_delimiter {
2891        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2892    }
2893    if let Some(ref user_agent) = configuration.user_agent {
2894        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2895    }
2896    if let Some(ref token) = configuration.oauth_access_token {
2897        req_builder = req_builder.bearer_auth(token.to_owned());
2898    };
2899    if let Some(ref apikey) = configuration.api_key {
2900        let key = apikey.key.clone();
2901        let value = match apikey.prefix {
2902            Some(ref prefix) => format!("{} {}", prefix, key),
2903            None => key,
2904        };
2905        req_builder = req_builder.header("x-api-key", value);
2906    };
2907    if let Some(ref token) = configuration.bearer_access_token {
2908        req_builder = req_builder.bearer_auth(token.to_owned());
2909    };
2910    req_builder = req_builder.json(&p_rename_table_request);
2911
2912    let req = req_builder.build()?;
2913    let resp = configuration.client.execute(req).await?;
2914
2915    let status = resp.status();
2916    let content_type = resp
2917        .headers()
2918        .get("content-type")
2919        .and_then(|v| v.to_str().ok())
2920        .unwrap_or("application/octet-stream");
2921    let content_type = super::ContentType::from(content_type);
2922
2923    if !status.is_client_error() && !status.is_server_error() {
2924        let content = resp.text().await?;
2925        match content_type {
2926            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2927            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RenameTableResponse`"))),
2928            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RenameTableResponse`")))),
2929        }
2930    } else {
2931        let content = resp.text().await?;
2932        let entity: Option<RenameTableError> = serde_json::from_str(&content).ok();
2933        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2934    }
2935}
2936
2937/// Restore table `id` to a specific version. 
2938pub async fn restore_table(configuration: &configuration::Configuration, id: &str, restore_table_request: models::RestoreTableRequest, delimiter: Option<&str>) -> Result<models::RestoreTableResponse, Error<RestoreTableError>> {
2939    // add a prefix to parameters to efficiently prevent name collisions
2940    let p_id = id;
2941    let p_restore_table_request = restore_table_request;
2942    let p_delimiter = delimiter;
2943
2944    let uri_str = format!("{}/v1/table/{id}/restore", configuration.base_path, id=crate::apis::urlencode(p_id));
2945    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2946
2947    if let Some(ref param_value) = p_delimiter {
2948        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2949    }
2950    if let Some(ref user_agent) = configuration.user_agent {
2951        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2952    }
2953    if let Some(ref token) = configuration.oauth_access_token {
2954        req_builder = req_builder.bearer_auth(token.to_owned());
2955    };
2956    if let Some(ref apikey) = configuration.api_key {
2957        let key = apikey.key.clone();
2958        let value = match apikey.prefix {
2959            Some(ref prefix) => format!("{} {}", prefix, key),
2960            None => key,
2961        };
2962        req_builder = req_builder.header("x-api-key", value);
2963    };
2964    if let Some(ref token) = configuration.bearer_access_token {
2965        req_builder = req_builder.bearer_auth(token.to_owned());
2966    };
2967    req_builder = req_builder.json(&p_restore_table_request);
2968
2969    let req = req_builder.build()?;
2970    let resp = configuration.client.execute(req).await?;
2971
2972    let status = resp.status();
2973    let content_type = resp
2974        .headers()
2975        .get("content-type")
2976        .and_then(|v| v.to_str().ok())
2977        .unwrap_or("application/octet-stream");
2978    let content_type = super::ContentType::from(content_type);
2979
2980    if !status.is_client_error() && !status.is_server_error() {
2981        let content = resp.text().await?;
2982        match content_type {
2983            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2984            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RestoreTableResponse`"))),
2985            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RestoreTableResponse`")))),
2986        }
2987    } else {
2988        let content = resp.text().await?;
2989        let entity: Option<RestoreTableError> = serde_json::from_str(&content).ok();
2990        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2991    }
2992}
2993
2994/// Check if table `id` exists.  This operation should behave exactly like DescribeTable, except it does not contain a response body.  For DirectoryNamespace implementation, a table exists if either: - The table has Lance data versions (regular table created with CreateTable) - A `.lance-reserved` file exists in the table directory (declared table created with DeclareTable) 
2995pub async fn table_exists(configuration: &configuration::Configuration, id: &str, table_exists_request: models::TableExistsRequest, delimiter: Option<&str>) -> Result<(), Error<TableExistsError>> {
2996    // add a prefix to parameters to efficiently prevent name collisions
2997    let p_id = id;
2998    let p_table_exists_request = table_exists_request;
2999    let p_delimiter = delimiter;
3000
3001    let uri_str = format!("{}/v1/table/{id}/exists", configuration.base_path, id=crate::apis::urlencode(p_id));
3002    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
3003
3004    if let Some(ref param_value) = p_delimiter {
3005        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
3006    }
3007    if let Some(ref user_agent) = configuration.user_agent {
3008        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
3009    }
3010    if let Some(ref token) = configuration.oauth_access_token {
3011        req_builder = req_builder.bearer_auth(token.to_owned());
3012    };
3013    if let Some(ref apikey) = configuration.api_key {
3014        let key = apikey.key.clone();
3015        let value = match apikey.prefix {
3016            Some(ref prefix) => format!("{} {}", prefix, key),
3017            None => key,
3018        };
3019        req_builder = req_builder.header("x-api-key", value);
3020    };
3021    if let Some(ref token) = configuration.bearer_access_token {
3022        req_builder = req_builder.bearer_auth(token.to_owned());
3023    };
3024    req_builder = req_builder.json(&p_table_exists_request);
3025
3026    let req = req_builder.build()?;
3027    let resp = configuration.client.execute(req).await?;
3028
3029    let status = resp.status();
3030
3031    if !status.is_client_error() && !status.is_server_error() {
3032        Ok(())
3033    } else {
3034        let content = resp.text().await?;
3035        let entity: Option<TableExistsError> = serde_json::from_str(&content).ok();
3036        Err(Error::ResponseError(ResponseContent { status, content, entity }))
3037    }
3038}
3039
3040/// Update the Arrow field (column) metadata for table `id`.  Each entry targets a field by `path` and merges the provided key-value pairs into that field's existing metadata, or replaces it when `replace` is true. A null metadata value deletes that key. 
3041pub async fn update_field_metadata(configuration: &configuration::Configuration, id: &str, update_field_metadata_request: models::UpdateFieldMetadataRequest, delimiter: Option<&str>) -> Result<models::UpdateFieldMetadataResponse, Error<UpdateFieldMetadataError>> {
3042    // add a prefix to parameters to efficiently prevent name collisions
3043    let p_id = id;
3044    let p_update_field_metadata_request = update_field_metadata_request;
3045    let p_delimiter = delimiter;
3046
3047    let uri_str = format!("{}/v1/table/{id}/update_field_metadata", configuration.base_path, id=crate::apis::urlencode(p_id));
3048    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
3049
3050    if let Some(ref param_value) = p_delimiter {
3051        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
3052    }
3053    if let Some(ref user_agent) = configuration.user_agent {
3054        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
3055    }
3056    if let Some(ref token) = configuration.oauth_access_token {
3057        req_builder = req_builder.bearer_auth(token.to_owned());
3058    };
3059    if let Some(ref apikey) = configuration.api_key {
3060        let key = apikey.key.clone();
3061        let value = match apikey.prefix {
3062            Some(ref prefix) => format!("{} {}", prefix, key),
3063            None => key,
3064        };
3065        req_builder = req_builder.header("x-api-key", value);
3066    };
3067    if let Some(ref token) = configuration.bearer_access_token {
3068        req_builder = req_builder.bearer_auth(token.to_owned());
3069    };
3070    req_builder = req_builder.json(&p_update_field_metadata_request);
3071
3072    let req = req_builder.build()?;
3073    let resp = configuration.client.execute(req).await?;
3074
3075    let status = resp.status();
3076    let content_type = resp
3077        .headers()
3078        .get("content-type")
3079        .and_then(|v| v.to_str().ok())
3080        .unwrap_or("application/octet-stream");
3081    let content_type = super::ContentType::from(content_type);
3082
3083    if !status.is_client_error() && !status.is_server_error() {
3084        let content = resp.text().await?;
3085        match content_type {
3086            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
3087            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateFieldMetadataResponse`"))),
3088            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateFieldMetadataResponse`")))),
3089        }
3090    } else {
3091        let content = resp.text().await?;
3092        let entity: Option<UpdateFieldMetadataError> = serde_json::from_str(&content).ok();
3093        Err(Error::ResponseError(ResponseContent { status, content, entity }))
3094    }
3095}
3096
3097/// Update existing rows in table `id`. 
3098pub async fn update_table(configuration: &configuration::Configuration, id: &str, update_table_request: models::UpdateTableRequest, delimiter: Option<&str>) -> Result<models::UpdateTableResponse, Error<UpdateTableError>> {
3099    // add a prefix to parameters to efficiently prevent name collisions
3100    let p_id = id;
3101    let p_update_table_request = update_table_request;
3102    let p_delimiter = delimiter;
3103
3104    let uri_str = format!("{}/v1/table/{id}/update", configuration.base_path, id=crate::apis::urlencode(p_id));
3105    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
3106
3107    if let Some(ref param_value) = p_delimiter {
3108        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
3109    }
3110    if let Some(ref user_agent) = configuration.user_agent {
3111        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
3112    }
3113    if let Some(ref token) = configuration.oauth_access_token {
3114        req_builder = req_builder.bearer_auth(token.to_owned());
3115    };
3116    if let Some(ref apikey) = configuration.api_key {
3117        let key = apikey.key.clone();
3118        let value = match apikey.prefix {
3119            Some(ref prefix) => format!("{} {}", prefix, key),
3120            None => key,
3121        };
3122        req_builder = req_builder.header("x-api-key", value);
3123    };
3124    if let Some(ref token) = configuration.bearer_access_token {
3125        req_builder = req_builder.bearer_auth(token.to_owned());
3126    };
3127    req_builder = req_builder.json(&p_update_table_request);
3128
3129    let req = req_builder.build()?;
3130    let resp = configuration.client.execute(req).await?;
3131
3132    let status = resp.status();
3133    let content_type = resp
3134        .headers()
3135        .get("content-type")
3136        .and_then(|v| v.to_str().ok())
3137        .unwrap_or("application/octet-stream");
3138    let content_type = super::ContentType::from(content_type);
3139
3140    if !status.is_client_error() && !status.is_server_error() {
3141        let content = resp.text().await?;
3142        match content_type {
3143            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
3144            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTableResponse`"))),
3145            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateTableResponse`")))),
3146        }
3147    } else {
3148        let content = resp.text().await?;
3149        let entity: Option<UpdateTableError> = serde_json::from_str(&content).ok();
3150        Err(Error::ResponseError(ResponseContent { status, content, entity }))
3151    }
3152}
3153
3154/// Replace the schema metadata for table `id` with the provided key-value pairs.  REST NAMESPACE ONLY REST namespace uses a direct object (map of string to string) as both request and response body instead of the wrapped `UpdateTableSchemaMetadataRequest` and `UpdateTableSchemaMetadataResponse`. 
3155pub async fn update_table_schema_metadata(configuration: &configuration::Configuration, id: &str, request_body: std::collections::HashMap<String, String>, delimiter: Option<&str>, branch: Option<&str>) -> Result<std::collections::HashMap<String, String>, Error<UpdateTableSchemaMetadataError>> {
3156    // add a prefix to parameters to efficiently prevent name collisions
3157    let p_id = id;
3158    let p_request_body = request_body;
3159    let p_delimiter = delimiter;
3160    let p_branch = branch;
3161
3162    let uri_str = format!("{}/v1/table/{id}/schema_metadata/update", configuration.base_path, id=crate::apis::urlencode(p_id));
3163    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
3164
3165    if let Some(ref param_value) = p_delimiter {
3166        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
3167    }
3168    if let Some(ref param_value) = p_branch {
3169        req_builder = req_builder.query(&[("branch", &param_value.to_string())]);
3170    }
3171    if let Some(ref user_agent) = configuration.user_agent {
3172        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
3173    }
3174    if let Some(ref token) = configuration.oauth_access_token {
3175        req_builder = req_builder.bearer_auth(token.to_owned());
3176    };
3177    if let Some(ref apikey) = configuration.api_key {
3178        let key = apikey.key.clone();
3179        let value = match apikey.prefix {
3180            Some(ref prefix) => format!("{} {}", prefix, key),
3181            None => key,
3182        };
3183        req_builder = req_builder.header("x-api-key", value);
3184    };
3185    if let Some(ref token) = configuration.bearer_access_token {
3186        req_builder = req_builder.bearer_auth(token.to_owned());
3187    };
3188    req_builder = req_builder.json(&p_request_body);
3189
3190    let req = req_builder.build()?;
3191    let resp = configuration.client.execute(req).await?;
3192
3193    let status = resp.status();
3194    let content_type = resp
3195        .headers()
3196        .get("content-type")
3197        .and_then(|v| v.to_str().ok())
3198        .unwrap_or("application/octet-stream");
3199    let content_type = super::ContentType::from(content_type);
3200
3201    if !status.is_client_error() && !status.is_server_error() {
3202        let content = resp.text().await?;
3203        match content_type {
3204            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
3205            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `std::collections::HashMap&lt;String, String&gt;`"))),
3206            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap&lt;String, String&gt;`")))),
3207        }
3208    } else {
3209        let content = resp.text().await?;
3210        let entity: Option<UpdateTableSchemaMetadataError> = serde_json::from_str(&content).ok();
3211        Err(Error::ResponseError(ResponseContent { status, content, entity }))
3212    }
3213}
3214
3215/// Update an existing tag for table `id` to point to a different version. 
3216pub async fn update_table_tag(configuration: &configuration::Configuration, id: &str, update_table_tag_request: models::UpdateTableTagRequest, delimiter: Option<&str>) -> Result<models::UpdateTableTagResponse, Error<UpdateTableTagError>> {
3217    // add a prefix to parameters to efficiently prevent name collisions
3218    let p_id = id;
3219    let p_update_table_tag_request = update_table_tag_request;
3220    let p_delimiter = delimiter;
3221
3222    let uri_str = format!("{}/v1/table/{id}/tags/update", configuration.base_path, id=crate::apis::urlencode(p_id));
3223    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
3224
3225    if let Some(ref param_value) = p_delimiter {
3226        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
3227    }
3228    if let Some(ref user_agent) = configuration.user_agent {
3229        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
3230    }
3231    if let Some(ref token) = configuration.oauth_access_token {
3232        req_builder = req_builder.bearer_auth(token.to_owned());
3233    };
3234    if let Some(ref apikey) = configuration.api_key {
3235        let key = apikey.key.clone();
3236        let value = match apikey.prefix {
3237            Some(ref prefix) => format!("{} {}", prefix, key),
3238            None => key,
3239        };
3240        req_builder = req_builder.header("x-api-key", value);
3241    };
3242    if let Some(ref token) = configuration.bearer_access_token {
3243        req_builder = req_builder.bearer_auth(token.to_owned());
3244    };
3245    req_builder = req_builder.json(&p_update_table_tag_request);
3246
3247    let req = req_builder.build()?;
3248    let resp = configuration.client.execute(req).await?;
3249
3250    let status = resp.status();
3251    let content_type = resp
3252        .headers()
3253        .get("content-type")
3254        .and_then(|v| v.to_str().ok())
3255        .unwrap_or("application/octet-stream");
3256    let content_type = super::ContentType::from(content_type);
3257
3258    if !status.is_client_error() && !status.is_server_error() {
3259        let content = resp.text().await?;
3260        match content_type {
3261            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
3262            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTableTagResponse`"))),
3263            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateTableTagResponse`")))),
3264        }
3265    } else {
3266        let content = resp.text().await?;
3267        let entity: Option<UpdateTableTagError> = serde_json::from_str(&content).ok();
3268        Err(Error::ResponseError(ResponseContent { status, content, entity }))
3269    }
3270}
3271
lance_namespace_reqwest_client/apis/table_api.rs

lance_namespace_reqwest_client/apis/
table_api.rs
