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_drop_columns`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum AlterTableDropColumnsError {
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 [`analyze_table_query_plan`]
58#[derive(Debug, Clone, Serialize, Deserialize)]
59#[serde(untagged)]
60pub enum AnalyzeTableQueryPlanError {
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 [`batch_delete_table_versions`]
71#[derive(Debug, Clone, Serialize, Deserialize)]
72#[serde(untagged)]
73pub enum BatchDeleteTableVersionsError {
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 [`count_table_rows`]
84#[derive(Debug, Clone, Serialize, Deserialize)]
85#[serde(untagged)]
86pub enum CountTableRowsError {
87    Status400(models::ErrorResponse),
88    Status401(models::ErrorResponse),
89    Status403(models::ErrorResponse),
90    Status404(models::ErrorResponse),
91    Status503(models::ErrorResponse),
92    Status5XX(models::ErrorResponse),
93    UnknownValue(serde_json::Value),
94}
95
96/// struct for typed errors of method [`create_empty_table`]
97#[derive(Debug, Clone, Serialize, Deserialize)]
98#[serde(untagged)]
99pub enum CreateEmptyTableError {
100    Status400(models::ErrorResponse),
101    Status401(models::ErrorResponse),
102    Status403(models::ErrorResponse),
103    Status404(models::ErrorResponse),
104    Status409(models::ErrorResponse),
105    Status503(models::ErrorResponse),
106    Status5XX(models::ErrorResponse),
107    UnknownValue(serde_json::Value),
108}
109
110/// struct for typed errors of method [`create_table`]
111#[derive(Debug, Clone, Serialize, Deserialize)]
112#[serde(untagged)]
113pub enum CreateTableError {
114    Status400(models::ErrorResponse),
115    Status401(models::ErrorResponse),
116    Status403(models::ErrorResponse),
117    Status404(models::ErrorResponse),
118    Status503(models::ErrorResponse),
119    Status5XX(models::ErrorResponse),
120    UnknownValue(serde_json::Value),
121}
122
123/// struct for typed errors of method [`create_table_index`]
124#[derive(Debug, Clone, Serialize, Deserialize)]
125#[serde(untagged)]
126pub enum CreateTableIndexError {
127    Status400(models::ErrorResponse),
128    Status401(models::ErrorResponse),
129    Status403(models::ErrorResponse),
130    Status404(models::ErrorResponse),
131    Status503(models::ErrorResponse),
132    Status5XX(models::ErrorResponse),
133    UnknownValue(serde_json::Value),
134}
135
136/// struct for typed errors of method [`create_table_scalar_index`]
137#[derive(Debug, Clone, Serialize, Deserialize)]
138#[serde(untagged)]
139pub enum CreateTableScalarIndexError {
140    Status400(models::ErrorResponse),
141    Status401(models::ErrorResponse),
142    Status403(models::ErrorResponse),
143    Status404(models::ErrorResponse),
144    Status503(models::ErrorResponse),
145    Status5XX(models::ErrorResponse),
146    UnknownValue(serde_json::Value),
147}
148
149/// struct for typed errors of method [`create_table_tag`]
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(untagged)]
152pub enum CreateTableTagError {
153    Status400(models::ErrorResponse),
154    Status401(models::ErrorResponse),
155    Status403(models::ErrorResponse),
156    Status404(models::ErrorResponse),
157    Status409(models::ErrorResponse),
158    Status503(models::ErrorResponse),
159    Status5XX(models::ErrorResponse),
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`create_table_version`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum CreateTableVersionError {
167    Status400(models::ErrorResponse),
168    Status401(models::ErrorResponse),
169    Status403(models::ErrorResponse),
170    Status404(models::ErrorResponse),
171    Status409(models::ErrorResponse),
172    Status503(models::ErrorResponse),
173    Status5XX(models::ErrorResponse),
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed errors of method [`declare_table`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum DeclareTableError {
181    Status400(models::ErrorResponse),
182    Status401(models::ErrorResponse),
183    Status403(models::ErrorResponse),
184    Status404(models::ErrorResponse),
185    Status409(models::ErrorResponse),
186    Status503(models::ErrorResponse),
187    Status5XX(models::ErrorResponse),
188    UnknownValue(serde_json::Value),
189}
190
191/// struct for typed errors of method [`delete_from_table`]
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(untagged)]
194pub enum DeleteFromTableError {
195    Status400(models::ErrorResponse),
196    Status401(models::ErrorResponse),
197    Status403(models::ErrorResponse),
198    Status404(models::ErrorResponse),
199    Status503(models::ErrorResponse),
200    Status5XX(models::ErrorResponse),
201    UnknownValue(serde_json::Value),
202}
203
204/// struct for typed errors of method [`delete_table_tag`]
205#[derive(Debug, Clone, Serialize, Deserialize)]
206#[serde(untagged)]
207pub enum DeleteTableTagError {
208    Status400(models::ErrorResponse),
209    Status401(models::ErrorResponse),
210    Status403(models::ErrorResponse),
211    Status404(models::ErrorResponse),
212    Status503(models::ErrorResponse),
213    Status5XX(models::ErrorResponse),
214    UnknownValue(serde_json::Value),
215}
216
217/// struct for typed errors of method [`deregister_table`]
218#[derive(Debug, Clone, Serialize, Deserialize)]
219#[serde(untagged)]
220pub enum DeregisterTableError {
221    Status400(models::ErrorResponse),
222    Status401(models::ErrorResponse),
223    Status403(models::ErrorResponse),
224    Status404(models::ErrorResponse),
225    Status503(models::ErrorResponse),
226    Status5XX(models::ErrorResponse),
227    UnknownValue(serde_json::Value),
228}
229
230/// struct for typed errors of method [`describe_table`]
231#[derive(Debug, Clone, Serialize, Deserialize)]
232#[serde(untagged)]
233pub enum DescribeTableError {
234    Status400(models::ErrorResponse),
235    Status401(models::ErrorResponse),
236    Status403(models::ErrorResponse),
237    Status404(models::ErrorResponse),
238    Status503(models::ErrorResponse),
239    Status5XX(models::ErrorResponse),
240    UnknownValue(serde_json::Value),
241}
242
243/// struct for typed errors of method [`describe_table_index_stats`]
244#[derive(Debug, Clone, Serialize, Deserialize)]
245#[serde(untagged)]
246pub enum DescribeTableIndexStatsError {
247    Status400(models::ErrorResponse),
248    Status401(models::ErrorResponse),
249    Status403(models::ErrorResponse),
250    Status404(models::ErrorResponse),
251    Status503(models::ErrorResponse),
252    Status5XX(models::ErrorResponse),
253    UnknownValue(serde_json::Value),
254}
255
256/// struct for typed errors of method [`describe_table_version`]
257#[derive(Debug, Clone, Serialize, Deserialize)]
258#[serde(untagged)]
259pub enum DescribeTableVersionError {
260    Status400(models::ErrorResponse),
261    Status401(models::ErrorResponse),
262    Status403(models::ErrorResponse),
263    Status404(models::ErrorResponse),
264    Status503(models::ErrorResponse),
265    Status5XX(models::ErrorResponse),
266    UnknownValue(serde_json::Value),
267}
268
269/// struct for typed errors of method [`drop_table`]
270#[derive(Debug, Clone, Serialize, Deserialize)]
271#[serde(untagged)]
272pub enum DropTableError {
273    Status400(models::ErrorResponse),
274    Status401(models::ErrorResponse),
275    Status403(models::ErrorResponse),
276    Status404(models::ErrorResponse),
277    Status503(models::ErrorResponse),
278    Status5XX(models::ErrorResponse),
279    UnknownValue(serde_json::Value),
280}
281
282/// struct for typed errors of method [`drop_table_index`]
283#[derive(Debug, Clone, Serialize, Deserialize)]
284#[serde(untagged)]
285pub enum DropTableIndexError {
286    Status400(models::ErrorResponse),
287    Status401(models::ErrorResponse),
288    Status403(models::ErrorResponse),
289    Status404(models::ErrorResponse),
290    Status503(models::ErrorResponse),
291    Status5XX(models::ErrorResponse),
292    UnknownValue(serde_json::Value),
293}
294
295/// struct for typed errors of method [`explain_table_query_plan`]
296#[derive(Debug, Clone, Serialize, Deserialize)]
297#[serde(untagged)]
298pub enum ExplainTableQueryPlanError {
299    Status400(models::ErrorResponse),
300    Status401(models::ErrorResponse),
301    Status403(models::ErrorResponse),
302    Status404(models::ErrorResponse),
303    Status503(models::ErrorResponse),
304    Status5XX(models::ErrorResponse),
305    UnknownValue(serde_json::Value),
306}
307
308/// struct for typed errors of method [`get_table_stats`]
309#[derive(Debug, Clone, Serialize, Deserialize)]
310#[serde(untagged)]
311pub enum GetTableStatsError {
312    Status400(models::ErrorResponse),
313    Status401(models::ErrorResponse),
314    Status403(models::ErrorResponse),
315    Status404(models::ErrorResponse),
316    Status503(models::ErrorResponse),
317    Status5XX(models::ErrorResponse),
318    UnknownValue(serde_json::Value),
319}
320
321/// struct for typed errors of method [`get_table_tag_version`]
322#[derive(Debug, Clone, Serialize, Deserialize)]
323#[serde(untagged)]
324pub enum GetTableTagVersionError {
325    Status400(models::ErrorResponse),
326    Status401(models::ErrorResponse),
327    Status403(models::ErrorResponse),
328    Status404(models::ErrorResponse),
329    Status503(models::ErrorResponse),
330    Status5XX(models::ErrorResponse),
331    UnknownValue(serde_json::Value),
332}
333
334/// struct for typed errors of method [`insert_into_table`]
335#[derive(Debug, Clone, Serialize, Deserialize)]
336#[serde(untagged)]
337pub enum InsertIntoTableError {
338    Status400(models::ErrorResponse),
339    Status401(models::ErrorResponse),
340    Status403(models::ErrorResponse),
341    Status404(models::ErrorResponse),
342    Status503(models::ErrorResponse),
343    Status5XX(models::ErrorResponse),
344    UnknownValue(serde_json::Value),
345}
346
347/// struct for typed errors of method [`list_all_tables`]
348#[derive(Debug, Clone, Serialize, Deserialize)]
349#[serde(untagged)]
350pub enum ListAllTablesError {
351    Status400(models::ErrorResponse),
352    Status401(models::ErrorResponse),
353    Status403(models::ErrorResponse),
354    Status503(models::ErrorResponse),
355    Status5XX(models::ErrorResponse),
356    UnknownValue(serde_json::Value),
357}
358
359/// struct for typed errors of method [`list_table_indices`]
360#[derive(Debug, Clone, Serialize, Deserialize)]
361#[serde(untagged)]
362pub enum ListTableIndicesError {
363    Status400(models::ErrorResponse),
364    Status401(models::ErrorResponse),
365    Status403(models::ErrorResponse),
366    Status404(models::ErrorResponse),
367    Status503(models::ErrorResponse),
368    Status5XX(models::ErrorResponse),
369    UnknownValue(serde_json::Value),
370}
371
372/// struct for typed errors of method [`list_table_tags`]
373#[derive(Debug, Clone, Serialize, Deserialize)]
374#[serde(untagged)]
375pub enum ListTableTagsError {
376    Status400(models::ErrorResponse),
377    Status401(models::ErrorResponse),
378    Status403(models::ErrorResponse),
379    Status404(models::ErrorResponse),
380    Status503(models::ErrorResponse),
381    Status5XX(models::ErrorResponse),
382    UnknownValue(serde_json::Value),
383}
384
385/// struct for typed errors of method [`list_table_versions`]
386#[derive(Debug, Clone, Serialize, Deserialize)]
387#[serde(untagged)]
388pub enum ListTableVersionsError {
389    Status400(models::ErrorResponse),
390    Status401(models::ErrorResponse),
391    Status403(models::ErrorResponse),
392    Status404(models::ErrorResponse),
393    Status503(models::ErrorResponse),
394    Status5XX(models::ErrorResponse),
395    UnknownValue(serde_json::Value),
396}
397
398/// struct for typed errors of method [`list_tables`]
399#[derive(Debug, Clone, Serialize, Deserialize)]
400#[serde(untagged)]
401pub enum ListTablesError {
402    Status400(models::ErrorResponse),
403    Status401(models::ErrorResponse),
404    Status403(models::ErrorResponse),
405    Status404(models::ErrorResponse),
406    Status406(models::ErrorResponse),
407    Status503(models::ErrorResponse),
408    Status5XX(models::ErrorResponse),
409    UnknownValue(serde_json::Value),
410}
411
412/// struct for typed errors of method [`merge_insert_into_table`]
413#[derive(Debug, Clone, Serialize, Deserialize)]
414#[serde(untagged)]
415pub enum MergeInsertIntoTableError {
416    Status400(models::ErrorResponse),
417    Status401(models::ErrorResponse),
418    Status403(models::ErrorResponse),
419    Status404(models::ErrorResponse),
420    Status503(models::ErrorResponse),
421    Status5XX(models::ErrorResponse),
422    UnknownValue(serde_json::Value),
423}
424
425/// struct for typed errors of method [`query_table`]
426#[derive(Debug, Clone, Serialize, Deserialize)]
427#[serde(untagged)]
428pub enum QueryTableError {
429    Status400(models::ErrorResponse),
430    Status401(models::ErrorResponse),
431    Status403(models::ErrorResponse),
432    Status404(models::ErrorResponse),
433    Status503(models::ErrorResponse),
434    Status5XX(models::ErrorResponse),
435    UnknownValue(serde_json::Value),
436}
437
438/// struct for typed errors of method [`register_table`]
439#[derive(Debug, Clone, Serialize, Deserialize)]
440#[serde(untagged)]
441pub enum RegisterTableError {
442    Status400(models::ErrorResponse),
443    Status401(models::ErrorResponse),
444    Status403(models::ErrorResponse),
445    Status404(models::ErrorResponse),
446    Status406(models::ErrorResponse),
447    Status409(models::ErrorResponse),
448    Status503(models::ErrorResponse),
449    Status5XX(models::ErrorResponse),
450    UnknownValue(serde_json::Value),
451}
452
453/// struct for typed errors of method [`rename_table`]
454#[derive(Debug, Clone, Serialize, Deserialize)]
455#[serde(untagged)]
456pub enum RenameTableError {
457    Status400(models::ErrorResponse),
458    Status401(models::ErrorResponse),
459    Status403(models::ErrorResponse),
460    Status404(models::ErrorResponse),
461    Status409(models::ErrorResponse),
462    Status503(models::ErrorResponse),
463    Status5XX(models::ErrorResponse),
464    UnknownValue(serde_json::Value),
465}
466
467/// struct for typed errors of method [`restore_table`]
468#[derive(Debug, Clone, Serialize, Deserialize)]
469#[serde(untagged)]
470pub enum RestoreTableError {
471    Status400(models::ErrorResponse),
472    Status401(models::ErrorResponse),
473    Status403(models::ErrorResponse),
474    Status404(models::ErrorResponse),
475    Status503(models::ErrorResponse),
476    Status5XX(models::ErrorResponse),
477    UnknownValue(serde_json::Value),
478}
479
480/// struct for typed errors of method [`table_exists`]
481#[derive(Debug, Clone, Serialize, Deserialize)]
482#[serde(untagged)]
483pub enum TableExistsError {
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 [`update_table`]
494#[derive(Debug, Clone, Serialize, Deserialize)]
495#[serde(untagged)]
496pub enum UpdateTableError {
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 [`update_table_schema_metadata`]
507#[derive(Debug, Clone, Serialize, Deserialize)]
508#[serde(untagged)]
509pub enum UpdateTableSchemaMetadataError {
510    Status400(models::ErrorResponse),
511    Status401(models::ErrorResponse),
512    Status403(models::ErrorResponse),
513    Status404(models::ErrorResponse),
514    Status503(models::ErrorResponse),
515    Status5XX(models::ErrorResponse),
516    UnknownValue(serde_json::Value),
517}
518
519/// struct for typed errors of method [`update_table_tag`]
520#[derive(Debug, Clone, Serialize, Deserialize)]
521#[serde(untagged)]
522pub enum UpdateTableTagError {
523    Status400(models::ErrorResponse),
524    Status401(models::ErrorResponse),
525    Status403(models::ErrorResponse),
526    Status404(models::ErrorResponse),
527    Status503(models::ErrorResponse),
528    Status5XX(models::ErrorResponse),
529    UnknownValue(serde_json::Value),
530}
531
532
533/// Add new columns to table `id` using SQL expressions or default values. 
534pub 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>> {
535    // add a prefix to parameters to efficiently prevent name collisions
536    let p_id = id;
537    let p_alter_table_add_columns_request = alter_table_add_columns_request;
538    let p_delimiter = delimiter;
539
540    let uri_str = format!("{}/v1/table/{id}/add_columns", configuration.base_path, id=crate::apis::urlencode(p_id));
541    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
542
543    if let Some(ref param_value) = p_delimiter {
544        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
545    }
546    if let Some(ref user_agent) = configuration.user_agent {
547        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
548    }
549    if let Some(ref token) = configuration.oauth_access_token {
550        req_builder = req_builder.bearer_auth(token.to_owned());
551    };
552    if let Some(ref apikey) = configuration.api_key {
553        let key = apikey.key.clone();
554        let value = match apikey.prefix {
555            Some(ref prefix) => format!("{} {}", prefix, key),
556            None => key,
557        };
558        req_builder = req_builder.header("x-api-key", value);
559    };
560    if let Some(ref token) = configuration.bearer_access_token {
561        req_builder = req_builder.bearer_auth(token.to_owned());
562    };
563    req_builder = req_builder.json(&p_alter_table_add_columns_request);
564
565    let req = req_builder.build()?;
566    let resp = configuration.client.execute(req).await?;
567
568    let status = resp.status();
569    let content_type = resp
570        .headers()
571        .get("content-type")
572        .and_then(|v| v.to_str().ok())
573        .unwrap_or("application/octet-stream");
574    let content_type = super::ContentType::from(content_type);
575
576    if !status.is_client_error() && !status.is_server_error() {
577        let content = resp.text().await?;
578        match content_type {
579            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
580            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AlterTableAddColumnsResponse`"))),
581            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`")))),
582        }
583    } else {
584        let content = resp.text().await?;
585        let entity: Option<AlterTableAddColumnsError> = serde_json::from_str(&content).ok();
586        Err(Error::ResponseError(ResponseContent { status, content, entity }))
587    }
588}
589
590/// Modify existing columns in table `id`, such as renaming or changing data types. 
591pub 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>> {
592    // add a prefix to parameters to efficiently prevent name collisions
593    let p_id = id;
594    let p_alter_table_alter_columns_request = alter_table_alter_columns_request;
595    let p_delimiter = delimiter;
596
597    let uri_str = format!("{}/v1/table/{id}/alter_columns", configuration.base_path, id=crate::apis::urlencode(p_id));
598    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
599
600    if let Some(ref param_value) = p_delimiter {
601        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
602    }
603    if let Some(ref user_agent) = configuration.user_agent {
604        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
605    }
606    if let Some(ref token) = configuration.oauth_access_token {
607        req_builder = req_builder.bearer_auth(token.to_owned());
608    };
609    if let Some(ref apikey) = configuration.api_key {
610        let key = apikey.key.clone();
611        let value = match apikey.prefix {
612            Some(ref prefix) => format!("{} {}", prefix, key),
613            None => key,
614        };
615        req_builder = req_builder.header("x-api-key", value);
616    };
617    if let Some(ref token) = configuration.bearer_access_token {
618        req_builder = req_builder.bearer_auth(token.to_owned());
619    };
620    req_builder = req_builder.json(&p_alter_table_alter_columns_request);
621
622    let req = req_builder.build()?;
623    let resp = configuration.client.execute(req).await?;
624
625    let status = resp.status();
626    let content_type = resp
627        .headers()
628        .get("content-type")
629        .and_then(|v| v.to_str().ok())
630        .unwrap_or("application/octet-stream");
631    let content_type = super::ContentType::from(content_type);
632
633    if !status.is_client_error() && !status.is_server_error() {
634        let content = resp.text().await?;
635        match content_type {
636            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
637            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AlterTableAlterColumnsResponse`"))),
638            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`")))),
639        }
640    } else {
641        let content = resp.text().await?;
642        let entity: Option<AlterTableAlterColumnsError> = serde_json::from_str(&content).ok();
643        Err(Error::ResponseError(ResponseContent { status, content, entity }))
644    }
645}
646
647/// Remove specified columns from table `id`. 
648pub 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>> {
649    // add a prefix to parameters to efficiently prevent name collisions
650    let p_id = id;
651    let p_alter_table_drop_columns_request = alter_table_drop_columns_request;
652    let p_delimiter = delimiter;
653
654    let uri_str = format!("{}/v1/table/{id}/drop_columns", configuration.base_path, id=crate::apis::urlencode(p_id));
655    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
656
657    if let Some(ref param_value) = p_delimiter {
658        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
659    }
660    if let Some(ref user_agent) = configuration.user_agent {
661        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
662    }
663    if let Some(ref token) = configuration.oauth_access_token {
664        req_builder = req_builder.bearer_auth(token.to_owned());
665    };
666    if let Some(ref apikey) = configuration.api_key {
667        let key = apikey.key.clone();
668        let value = match apikey.prefix {
669            Some(ref prefix) => format!("{} {}", prefix, key),
670            None => key,
671        };
672        req_builder = req_builder.header("x-api-key", value);
673    };
674    if let Some(ref token) = configuration.bearer_access_token {
675        req_builder = req_builder.bearer_auth(token.to_owned());
676    };
677    req_builder = req_builder.json(&p_alter_table_drop_columns_request);
678
679    let req = req_builder.build()?;
680    let resp = configuration.client.execute(req).await?;
681
682    let status = resp.status();
683    let content_type = resp
684        .headers()
685        .get("content-type")
686        .and_then(|v| v.to_str().ok())
687        .unwrap_or("application/octet-stream");
688    let content_type = super::ContentType::from(content_type);
689
690    if !status.is_client_error() && !status.is_server_error() {
691        let content = resp.text().await?;
692        match content_type {
693            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
694            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AlterTableDropColumnsResponse`"))),
695            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`")))),
696        }
697    } else {
698        let content = resp.text().await?;
699        let entity: Option<AlterTableDropColumnsError> = serde_json::from_str(&content).ok();
700        Err(Error::ResponseError(ResponseContent { status, content, entity }))
701    }
702}
703
704/// 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. 
705pub 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>> {
706    // add a prefix to parameters to efficiently prevent name collisions
707    let p_id = id;
708    let p_analyze_table_query_plan_request = analyze_table_query_plan_request;
709    let p_delimiter = delimiter;
710
711    let uri_str = format!("{}/v1/table/{id}/analyze_plan", configuration.base_path, id=crate::apis::urlencode(p_id));
712    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
713
714    if let Some(ref param_value) = p_delimiter {
715        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
716    }
717    if let Some(ref user_agent) = configuration.user_agent {
718        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
719    }
720    if let Some(ref token) = configuration.oauth_access_token {
721        req_builder = req_builder.bearer_auth(token.to_owned());
722    };
723    if let Some(ref apikey) = configuration.api_key {
724        let key = apikey.key.clone();
725        let value = match apikey.prefix {
726            Some(ref prefix) => format!("{} {}", prefix, key),
727            None => key,
728        };
729        req_builder = req_builder.header("x-api-key", value);
730    };
731    if let Some(ref token) = configuration.bearer_access_token {
732        req_builder = req_builder.bearer_auth(token.to_owned());
733    };
734    req_builder = req_builder.json(&p_analyze_table_query_plan_request);
735
736    let req = req_builder.build()?;
737    let resp = configuration.client.execute(req).await?;
738
739    let status = resp.status();
740    let content_type = resp
741        .headers()
742        .get("content-type")
743        .and_then(|v| v.to_str().ok())
744        .unwrap_or("application/octet-stream");
745    let content_type = super::ContentType::from(content_type);
746
747    if !status.is_client_error() && !status.is_server_error() {
748        let content = resp.text().await?;
749        match content_type {
750            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
751            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `String`"))),
752            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`")))),
753        }
754    } else {
755        let content = resp.text().await?;
756        let entity: Option<AnalyzeTableQueryPlanError> = serde_json::from_str(&content).ok();
757        Err(Error::ResponseError(ResponseContent { status, content, entity }))
758    }
759}
760
761/// 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 
762pub 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>> {
763    // add a prefix to parameters to efficiently prevent name collisions
764    let p_id = id;
765    let p_batch_delete_table_versions_request = batch_delete_table_versions_request;
766    let p_delimiter = delimiter;
767
768    let uri_str = format!("{}/v1/table/{id}/version/delete", configuration.base_path, id=crate::apis::urlencode(p_id));
769    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
770
771    if let Some(ref param_value) = p_delimiter {
772        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
773    }
774    if let Some(ref user_agent) = configuration.user_agent {
775        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
776    }
777    if let Some(ref token) = configuration.oauth_access_token {
778        req_builder = req_builder.bearer_auth(token.to_owned());
779    };
780    if let Some(ref apikey) = configuration.api_key {
781        let key = apikey.key.clone();
782        let value = match apikey.prefix {
783            Some(ref prefix) => format!("{} {}", prefix, key),
784            None => key,
785        };
786        req_builder = req_builder.header("x-api-key", value);
787    };
788    if let Some(ref token) = configuration.bearer_access_token {
789        req_builder = req_builder.bearer_auth(token.to_owned());
790    };
791    req_builder = req_builder.json(&p_batch_delete_table_versions_request);
792
793    let req = req_builder.build()?;
794    let resp = configuration.client.execute(req).await?;
795
796    let status = resp.status();
797    let content_type = resp
798        .headers()
799        .get("content-type")
800        .and_then(|v| v.to_str().ok())
801        .unwrap_or("application/octet-stream");
802    let content_type = super::ContentType::from(content_type);
803
804    if !status.is_client_error() && !status.is_server_error() {
805        let content = resp.text().await?;
806        match content_type {
807            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
808            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::BatchDeleteTableVersionsResponse`"))),
809            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`")))),
810        }
811    } else {
812        let content = resp.text().await?;
813        let entity: Option<BatchDeleteTableVersionsError> = serde_json::from_str(&content).ok();
814        Err(Error::ResponseError(ResponseContent { status, content, entity }))
815    }
816}
817
818/// 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. 
819pub async fn count_table_rows(configuration: &configuration::Configuration, id: &str, count_table_rows_request: models::CountTableRowsRequest, delimiter: Option<&str>) -> Result<i64, Error<CountTableRowsError>> {
820    // add a prefix to parameters to efficiently prevent name collisions
821    let p_id = id;
822    let p_count_table_rows_request = count_table_rows_request;
823    let p_delimiter = delimiter;
824
825    let uri_str = format!("{}/v1/table/{id}/count_rows", configuration.base_path, id=crate::apis::urlencode(p_id));
826    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
827
828    if let Some(ref param_value) = p_delimiter {
829        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
830    }
831    if let Some(ref user_agent) = configuration.user_agent {
832        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
833    }
834    if let Some(ref token) = configuration.oauth_access_token {
835        req_builder = req_builder.bearer_auth(token.to_owned());
836    };
837    if let Some(ref apikey) = configuration.api_key {
838        let key = apikey.key.clone();
839        let value = match apikey.prefix {
840            Some(ref prefix) => format!("{} {}", prefix, key),
841            None => key,
842        };
843        req_builder = req_builder.header("x-api-key", value);
844    };
845    if let Some(ref token) = configuration.bearer_access_token {
846        req_builder = req_builder.bearer_auth(token.to_owned());
847    };
848    req_builder = req_builder.json(&p_count_table_rows_request);
849
850    let req = req_builder.build()?;
851    let resp = configuration.client.execute(req).await?;
852
853    let status = resp.status();
854    let content_type = resp
855        .headers()
856        .get("content-type")
857        .and_then(|v| v.to_str().ok())
858        .unwrap_or("application/octet-stream");
859    let content_type = super::ContentType::from(content_type);
860
861    if !status.is_client_error() && !status.is_server_error() {
862        let content = resp.text().await?;
863        match content_type {
864            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
865            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `i64`"))),
866            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`")))),
867        }
868    } else {
869        let content = resp.text().await?;
870        let entity: Option<CountTableRowsError> = serde_json::from_str(&content).ok();
871        Err(Error::ResponseError(ResponseContent { status, content, entity }))
872    }
873}
874
875/// Create an empty 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.  **Deprecated**: Use `DeclareTable` instead. 
876pub async fn create_empty_table(configuration: &configuration::Configuration, id: &str, create_empty_table_request: models::CreateEmptyTableRequest, delimiter: Option<&str>) -> Result<models::CreateEmptyTableResponse, Error<CreateEmptyTableError>> {
877    // add a prefix to parameters to efficiently prevent name collisions
878    let p_id = id;
879    let p_create_empty_table_request = create_empty_table_request;
880    let p_delimiter = delimiter;
881
882    let uri_str = format!("{}/v1/table/{id}/create-empty", configuration.base_path, id=crate::apis::urlencode(p_id));
883    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
884
885    if let Some(ref param_value) = p_delimiter {
886        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
887    }
888    if let Some(ref user_agent) = configuration.user_agent {
889        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
890    }
891    if let Some(ref token) = configuration.oauth_access_token {
892        req_builder = req_builder.bearer_auth(token.to_owned());
893    };
894    if let Some(ref apikey) = configuration.api_key {
895        let key = apikey.key.clone();
896        let value = match apikey.prefix {
897            Some(ref prefix) => format!("{} {}", prefix, key),
898            None => key,
899        };
900        req_builder = req_builder.header("x-api-key", value);
901    };
902    if let Some(ref token) = configuration.bearer_access_token {
903        req_builder = req_builder.bearer_auth(token.to_owned());
904    };
905    req_builder = req_builder.json(&p_create_empty_table_request);
906
907    let req = req_builder.build()?;
908    let resp = configuration.client.execute(req).await?;
909
910    let status = resp.status();
911    let content_type = resp
912        .headers()
913        .get("content-type")
914        .and_then(|v| v.to_str().ok())
915        .unwrap_or("application/octet-stream");
916    let content_type = super::ContentType::from(content_type);
917
918    if !status.is_client_error() && !status.is_server_error() {
919        let content = resp.text().await?;
920        match content_type {
921            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
922            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateEmptyTableResponse`"))),
923            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::CreateEmptyTableResponse`")))),
924        }
925    } else {
926        let content = resp.text().await?;
927        let entity: Option<CreateEmptyTableError> = serde_json::from_str(&content).ok();
928        Err(Error::ResponseError(ResponseContent { status, content, entity }))
929    }
930}
931
932/// 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 
933pub async fn create_table(configuration: &configuration::Configuration, id: &str, body: Vec<u8>, delimiter: Option<&str>, mode: Option<&str>) -> Result<models::CreateTableResponse, Error<CreateTableError>> {
934    // add a prefix to parameters to efficiently prevent name collisions
935    let p_id = id;
936    let p_body = body;
937    let p_delimiter = delimiter;
938    let p_mode = mode;
939
940    let uri_str = format!("{}/v1/table/{id}/create", configuration.base_path, id=crate::apis::urlencode(p_id));
941    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
942
943    if let Some(ref param_value) = p_delimiter {
944        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
945    }
946    if let Some(ref param_value) = p_mode {
947        req_builder = req_builder.query(&[("mode", &param_value.to_string())]);
948    }
949    if let Some(ref user_agent) = configuration.user_agent {
950        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
951    }
952    if let Some(ref token) = configuration.oauth_access_token {
953        req_builder = req_builder.bearer_auth(token.to_owned());
954    };
955    if let Some(ref apikey) = configuration.api_key {
956        let key = apikey.key.clone();
957        let value = match apikey.prefix {
958            Some(ref prefix) => format!("{} {}", prefix, key),
959            None => key,
960        };
961        req_builder = req_builder.header("x-api-key", value);
962    };
963    if let Some(ref token) = configuration.bearer_access_token {
964        req_builder = req_builder.bearer_auth(token.to_owned());
965    };
966    req_builder = req_builder.body(p_body);
967
968    let req = req_builder.build()?;
969    let resp = configuration.client.execute(req).await?;
970
971    let status = resp.status();
972    let content_type = resp
973        .headers()
974        .get("content-type")
975        .and_then(|v| v.to_str().ok())
976        .unwrap_or("application/octet-stream");
977    let content_type = super::ContentType::from(content_type);
978
979    if !status.is_client_error() && !status.is_server_error() {
980        let content = resp.text().await?;
981        match content_type {
982            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
983            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableResponse`"))),
984            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`")))),
985        }
986    } else {
987        let content = resp.text().await?;
988        let entity: Option<CreateTableError> = serde_json::from_str(&content).ok();
989        Err(Error::ResponseError(ResponseContent { status, content, entity }))
990    }
991}
992
993/// Create an index on a table column 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. 
994pub async fn create_table_index(configuration: &configuration::Configuration, id: &str, create_table_index_request: models::CreateTableIndexRequest, delimiter: Option<&str>) -> Result<models::CreateTableIndexResponse, Error<CreateTableIndexError>> {
995    // add a prefix to parameters to efficiently prevent name collisions
996    let p_id = id;
997    let p_create_table_index_request = create_table_index_request;
998    let p_delimiter = delimiter;
999
1000    let uri_str = format!("{}/v1/table/{id}/create_index", configuration.base_path, id=crate::apis::urlencode(p_id));
1001    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1002
1003    if let Some(ref param_value) = p_delimiter {
1004        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1005    }
1006    if let Some(ref user_agent) = configuration.user_agent {
1007        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1008    }
1009    if let Some(ref token) = configuration.oauth_access_token {
1010        req_builder = req_builder.bearer_auth(token.to_owned());
1011    };
1012    if let Some(ref apikey) = configuration.api_key {
1013        let key = apikey.key.clone();
1014        let value = match apikey.prefix {
1015            Some(ref prefix) => format!("{} {}", prefix, key),
1016            None => key,
1017        };
1018        req_builder = req_builder.header("x-api-key", value);
1019    };
1020    if let Some(ref token) = configuration.bearer_access_token {
1021        req_builder = req_builder.bearer_auth(token.to_owned());
1022    };
1023    req_builder = req_builder.json(&p_create_table_index_request);
1024
1025    let req = req_builder.build()?;
1026    let resp = configuration.client.execute(req).await?;
1027
1028    let status = resp.status();
1029    let content_type = resp
1030        .headers()
1031        .get("content-type")
1032        .and_then(|v| v.to_str().ok())
1033        .unwrap_or("application/octet-stream");
1034    let content_type = super::ContentType::from(content_type);
1035
1036    if !status.is_client_error() && !status.is_server_error() {
1037        let content = resp.text().await?;
1038        match content_type {
1039            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1040            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableIndexResponse`"))),
1041            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`")))),
1042        }
1043    } else {
1044        let content = resp.text().await?;
1045        let entity: Option<CreateTableIndexError> = serde_json::from_str(&content).ok();
1046        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1047    }
1048}
1049
1050/// Create a scalar index on a table column 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. 
1051pub 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>> {
1052    // add a prefix to parameters to efficiently prevent name collisions
1053    let p_id = id;
1054    let p_create_table_index_request = create_table_index_request;
1055    let p_delimiter = delimiter;
1056
1057    let uri_str = format!("{}/v1/table/{id}/create_scalar_index", configuration.base_path, id=crate::apis::urlencode(p_id));
1058    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1059
1060    if let Some(ref param_value) = p_delimiter {
1061        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1062    }
1063    if let Some(ref user_agent) = configuration.user_agent {
1064        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1065    }
1066    if let Some(ref token) = configuration.oauth_access_token {
1067        req_builder = req_builder.bearer_auth(token.to_owned());
1068    };
1069    if let Some(ref apikey) = configuration.api_key {
1070        let key = apikey.key.clone();
1071        let value = match apikey.prefix {
1072            Some(ref prefix) => format!("{} {}", prefix, key),
1073            None => key,
1074        };
1075        req_builder = req_builder.header("x-api-key", value);
1076    };
1077    if let Some(ref token) = configuration.bearer_access_token {
1078        req_builder = req_builder.bearer_auth(token.to_owned());
1079    };
1080    req_builder = req_builder.json(&p_create_table_index_request);
1081
1082    let req = req_builder.build()?;
1083    let resp = configuration.client.execute(req).await?;
1084
1085    let status = resp.status();
1086    let content_type = resp
1087        .headers()
1088        .get("content-type")
1089        .and_then(|v| v.to_str().ok())
1090        .unwrap_or("application/octet-stream");
1091    let content_type = super::ContentType::from(content_type);
1092
1093    if !status.is_client_error() && !status.is_server_error() {
1094        let content = resp.text().await?;
1095        match content_type {
1096            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1097            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableScalarIndexResponse`"))),
1098            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`")))),
1099        }
1100    } else {
1101        let content = resp.text().await?;
1102        let entity: Option<CreateTableScalarIndexError> = serde_json::from_str(&content).ok();
1103        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1104    }
1105}
1106
1107/// Create a new tag for table `id` that points to a specific version. 
1108pub async fn create_table_tag(configuration: &configuration::Configuration, id: &str, create_table_tag_request: models::CreateTableTagRequest, delimiter: Option<&str>) -> Result<models::CreateTableTagResponse, Error<CreateTableTagError>> {
1109    // add a prefix to parameters to efficiently prevent name collisions
1110    let p_id = id;
1111    let p_create_table_tag_request = create_table_tag_request;
1112    let p_delimiter = delimiter;
1113
1114    let uri_str = format!("{}/v1/table/{id}/tags/create", configuration.base_path, id=crate::apis::urlencode(p_id));
1115    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1116
1117    if let Some(ref param_value) = p_delimiter {
1118        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1119    }
1120    if let Some(ref user_agent) = configuration.user_agent {
1121        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1122    }
1123    if let Some(ref token) = configuration.oauth_access_token {
1124        req_builder = req_builder.bearer_auth(token.to_owned());
1125    };
1126    if let Some(ref apikey) = configuration.api_key {
1127        let key = apikey.key.clone();
1128        let value = match apikey.prefix {
1129            Some(ref prefix) => format!("{} {}", prefix, key),
1130            None => key,
1131        };
1132        req_builder = req_builder.header("x-api-key", value);
1133    };
1134    if let Some(ref token) = configuration.bearer_access_token {
1135        req_builder = req_builder.bearer_auth(token.to_owned());
1136    };
1137    req_builder = req_builder.json(&p_create_table_tag_request);
1138
1139    let req = req_builder.build()?;
1140    let resp = configuration.client.execute(req).await?;
1141
1142    let status = resp.status();
1143    let content_type = resp
1144        .headers()
1145        .get("content-type")
1146        .and_then(|v| v.to_str().ok())
1147        .unwrap_or("application/octet-stream");
1148    let content_type = super::ContentType::from(content_type);
1149
1150    if !status.is_client_error() && !status.is_server_error() {
1151        let content = resp.text().await?;
1152        match content_type {
1153            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1154            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableTagResponse`"))),
1155            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`")))),
1156        }
1157    } else {
1158        let content = resp.text().await?;
1159        let entity: Option<CreateTableTagError> = serde_json::from_str(&content).ok();
1160        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1161    }
1162}
1163
1164/// 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. 
1165pub async fn create_table_version(configuration: &configuration::Configuration, id: &str, create_table_version_request: models::CreateTableVersionRequest, delimiter: Option<&str>) -> Result<models::CreateTableVersionResponse, Error<CreateTableVersionError>> {
1166    // add a prefix to parameters to efficiently prevent name collisions
1167    let p_id = id;
1168    let p_create_table_version_request = create_table_version_request;
1169    let p_delimiter = delimiter;
1170
1171    let uri_str = format!("{}/v1/table/{id}/version/create", configuration.base_path, id=crate::apis::urlencode(p_id));
1172    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1173
1174    if let Some(ref param_value) = p_delimiter {
1175        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1176    }
1177    if let Some(ref user_agent) = configuration.user_agent {
1178        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1179    }
1180    if let Some(ref token) = configuration.oauth_access_token {
1181        req_builder = req_builder.bearer_auth(token.to_owned());
1182    };
1183    if let Some(ref apikey) = configuration.api_key {
1184        let key = apikey.key.clone();
1185        let value = match apikey.prefix {
1186            Some(ref prefix) => format!("{} {}", prefix, key),
1187            None => key,
1188        };
1189        req_builder = req_builder.header("x-api-key", value);
1190    };
1191    if let Some(ref token) = configuration.bearer_access_token {
1192        req_builder = req_builder.bearer_auth(token.to_owned());
1193    };
1194    req_builder = req_builder.json(&p_create_table_version_request);
1195
1196    let req = req_builder.build()?;
1197    let resp = configuration.client.execute(req).await?;
1198
1199    let status = resp.status();
1200    let content_type = resp
1201        .headers()
1202        .get("content-type")
1203        .and_then(|v| v.to_str().ok())
1204        .unwrap_or("application/octet-stream");
1205    let content_type = super::ContentType::from(content_type);
1206
1207    if !status.is_client_error() && !status.is_server_error() {
1208        let content = resp.text().await?;
1209        match content_type {
1210            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1211            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableVersionResponse`"))),
1212            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`")))),
1213        }
1214    } else {
1215        let content = resp.text().await?;
1216        let entity: Option<CreateTableVersionError> = serde_json::from_str(&content).ok();
1217        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1218    }
1219}
1220
1221/// 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. 
1222pub async fn declare_table(configuration: &configuration::Configuration, id: &str, declare_table_request: models::DeclareTableRequest, delimiter: Option<&str>) -> Result<models::DeclareTableResponse, Error<DeclareTableError>> {
1223    // add a prefix to parameters to efficiently prevent name collisions
1224    let p_id = id;
1225    let p_declare_table_request = declare_table_request;
1226    let p_delimiter = delimiter;
1227
1228    let uri_str = format!("{}/v1/table/{id}/declare", configuration.base_path, id=crate::apis::urlencode(p_id));
1229    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1230
1231    if let Some(ref param_value) = p_delimiter {
1232        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1233    }
1234    if let Some(ref user_agent) = configuration.user_agent {
1235        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1236    }
1237    if let Some(ref token) = configuration.oauth_access_token {
1238        req_builder = req_builder.bearer_auth(token.to_owned());
1239    };
1240    if let Some(ref apikey) = configuration.api_key {
1241        let key = apikey.key.clone();
1242        let value = match apikey.prefix {
1243            Some(ref prefix) => format!("{} {}", prefix, key),
1244            None => key,
1245        };
1246        req_builder = req_builder.header("x-api-key", value);
1247    };
1248    if let Some(ref token) = configuration.bearer_access_token {
1249        req_builder = req_builder.bearer_auth(token.to_owned());
1250    };
1251    req_builder = req_builder.json(&p_declare_table_request);
1252
1253    let req = req_builder.build()?;
1254    let resp = configuration.client.execute(req).await?;
1255
1256    let status = resp.status();
1257    let content_type = resp
1258        .headers()
1259        .get("content-type")
1260        .and_then(|v| v.to_str().ok())
1261        .unwrap_or("application/octet-stream");
1262    let content_type = super::ContentType::from(content_type);
1263
1264    if !status.is_client_error() && !status.is_server_error() {
1265        let content = resp.text().await?;
1266        match content_type {
1267            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1268            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeclareTableResponse`"))),
1269            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`")))),
1270        }
1271    } else {
1272        let content = resp.text().await?;
1273        let entity: Option<DeclareTableError> = serde_json::from_str(&content).ok();
1274        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1275    }
1276}
1277
1278/// Delete rows from table `id`. 
1279pub async fn delete_from_table(configuration: &configuration::Configuration, id: &str, delete_from_table_request: models::DeleteFromTableRequest, delimiter: Option<&str>) -> Result<models::DeleteFromTableResponse, Error<DeleteFromTableError>> {
1280    // add a prefix to parameters to efficiently prevent name collisions
1281    let p_id = id;
1282    let p_delete_from_table_request = delete_from_table_request;
1283    let p_delimiter = delimiter;
1284
1285    let uri_str = format!("{}/v1/table/{id}/delete", configuration.base_path, id=crate::apis::urlencode(p_id));
1286    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1287
1288    if let Some(ref param_value) = p_delimiter {
1289        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1290    }
1291    if let Some(ref user_agent) = configuration.user_agent {
1292        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1293    }
1294    if let Some(ref token) = configuration.oauth_access_token {
1295        req_builder = req_builder.bearer_auth(token.to_owned());
1296    };
1297    if let Some(ref apikey) = configuration.api_key {
1298        let key = apikey.key.clone();
1299        let value = match apikey.prefix {
1300            Some(ref prefix) => format!("{} {}", prefix, key),
1301            None => key,
1302        };
1303        req_builder = req_builder.header("x-api-key", value);
1304    };
1305    if let Some(ref token) = configuration.bearer_access_token {
1306        req_builder = req_builder.bearer_auth(token.to_owned());
1307    };
1308    req_builder = req_builder.json(&p_delete_from_table_request);
1309
1310    let req = req_builder.build()?;
1311    let resp = configuration.client.execute(req).await?;
1312
1313    let status = resp.status();
1314    let content_type = resp
1315        .headers()
1316        .get("content-type")
1317        .and_then(|v| v.to_str().ok())
1318        .unwrap_or("application/octet-stream");
1319    let content_type = super::ContentType::from(content_type);
1320
1321    if !status.is_client_error() && !status.is_server_error() {
1322        let content = resp.text().await?;
1323        match content_type {
1324            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1325            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteFromTableResponse`"))),
1326            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`")))),
1327        }
1328    } else {
1329        let content = resp.text().await?;
1330        let entity: Option<DeleteFromTableError> = serde_json::from_str(&content).ok();
1331        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1332    }
1333}
1334
1335/// Delete an existing tag from table `id`. 
1336pub async fn delete_table_tag(configuration: &configuration::Configuration, id: &str, delete_table_tag_request: models::DeleteTableTagRequest, delimiter: Option<&str>) -> Result<models::DeleteTableTagResponse, Error<DeleteTableTagError>> {
1337    // add a prefix to parameters to efficiently prevent name collisions
1338    let p_id = id;
1339    let p_delete_table_tag_request = delete_table_tag_request;
1340    let p_delimiter = delimiter;
1341
1342    let uri_str = format!("{}/v1/table/{id}/tags/delete", configuration.base_path, id=crate::apis::urlencode(p_id));
1343    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1344
1345    if let Some(ref param_value) = p_delimiter {
1346        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1347    }
1348    if let Some(ref user_agent) = configuration.user_agent {
1349        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1350    }
1351    if let Some(ref token) = configuration.oauth_access_token {
1352        req_builder = req_builder.bearer_auth(token.to_owned());
1353    };
1354    if let Some(ref apikey) = configuration.api_key {
1355        let key = apikey.key.clone();
1356        let value = match apikey.prefix {
1357            Some(ref prefix) => format!("{} {}", prefix, key),
1358            None => key,
1359        };
1360        req_builder = req_builder.header("x-api-key", value);
1361    };
1362    if let Some(ref token) = configuration.bearer_access_token {
1363        req_builder = req_builder.bearer_auth(token.to_owned());
1364    };
1365    req_builder = req_builder.json(&p_delete_table_tag_request);
1366
1367    let req = req_builder.build()?;
1368    let resp = configuration.client.execute(req).await?;
1369
1370    let status = resp.status();
1371    let content_type = resp
1372        .headers()
1373        .get("content-type")
1374        .and_then(|v| v.to_str().ok())
1375        .unwrap_or("application/octet-stream");
1376    let content_type = super::ContentType::from(content_type);
1377
1378    if !status.is_client_error() && !status.is_server_error() {
1379        let content = resp.text().await?;
1380        match content_type {
1381            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1382            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteTableTagResponse`"))),
1383            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`")))),
1384        }
1385    } else {
1386        let content = resp.text().await?;
1387        let entity: Option<DeleteTableTagError> = serde_json::from_str(&content).ok();
1388        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1389    }
1390}
1391
1392/// Deregister table `id` from its namespace. 
1393pub async fn deregister_table(configuration: &configuration::Configuration, id: &str, deregister_table_request: models::DeregisterTableRequest, delimiter: Option<&str>) -> Result<models::DeregisterTableResponse, Error<DeregisterTableError>> {
1394    // add a prefix to parameters to efficiently prevent name collisions
1395    let p_id = id;
1396    let p_deregister_table_request = deregister_table_request;
1397    let p_delimiter = delimiter;
1398
1399    let uri_str = format!("{}/v1/table/{id}/deregister", configuration.base_path, id=crate::apis::urlencode(p_id));
1400    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1401
1402    if let Some(ref param_value) = p_delimiter {
1403        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1404    }
1405    if let Some(ref user_agent) = configuration.user_agent {
1406        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1407    }
1408    if let Some(ref token) = configuration.oauth_access_token {
1409        req_builder = req_builder.bearer_auth(token.to_owned());
1410    };
1411    if let Some(ref apikey) = configuration.api_key {
1412        let key = apikey.key.clone();
1413        let value = match apikey.prefix {
1414            Some(ref prefix) => format!("{} {}", prefix, key),
1415            None => key,
1416        };
1417        req_builder = req_builder.header("x-api-key", value);
1418    };
1419    if let Some(ref token) = configuration.bearer_access_token {
1420        req_builder = req_builder.bearer_auth(token.to_owned());
1421    };
1422    req_builder = req_builder.json(&p_deregister_table_request);
1423
1424    let req = req_builder.build()?;
1425    let resp = configuration.client.execute(req).await?;
1426
1427    let status = resp.status();
1428    let content_type = resp
1429        .headers()
1430        .get("content-type")
1431        .and_then(|v| v.to_str().ok())
1432        .unwrap_or("application/octet-stream");
1433    let content_type = super::ContentType::from(content_type);
1434
1435    if !status.is_client_error() && !status.is_server_error() {
1436        let content = resp.text().await?;
1437        match content_type {
1438            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1439            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeregisterTableResponse`"))),
1440            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`")))),
1441        }
1442    } else {
1443        let content = resp.text().await?;
1444        let entity: Option<DeregisterTableError> = serde_json::from_str(&content).ok();
1445        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1446    }
1447}
1448
1449/// Describe the detailed information for table `id`.  REST NAMESPACE ONLY REST namespace passes `with_table_uri` and `load_detailed_metadata` as query parameters instead of in the request body. 
1450pub 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>) -> Result<models::DescribeTableResponse, Error<DescribeTableError>> {
1451    // add a prefix to parameters to efficiently prevent name collisions
1452    let p_id = id;
1453    let p_describe_table_request = describe_table_request;
1454    let p_delimiter = delimiter;
1455    let p_with_table_uri = with_table_uri;
1456    let p_load_detailed_metadata = load_detailed_metadata;
1457
1458    let uri_str = format!("{}/v1/table/{id}/describe", configuration.base_path, id=crate::apis::urlencode(p_id));
1459    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1460
1461    if let Some(ref param_value) = p_delimiter {
1462        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1463    }
1464    if let Some(ref param_value) = p_with_table_uri {
1465        req_builder = req_builder.query(&[("with_table_uri", &param_value.to_string())]);
1466    }
1467    if let Some(ref param_value) = p_load_detailed_metadata {
1468        req_builder = req_builder.query(&[("load_detailed_metadata", &param_value.to_string())]);
1469    }
1470    if let Some(ref user_agent) = configuration.user_agent {
1471        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1472    }
1473    if let Some(ref token) = configuration.oauth_access_token {
1474        req_builder = req_builder.bearer_auth(token.to_owned());
1475    };
1476    if let Some(ref apikey) = configuration.api_key {
1477        let key = apikey.key.clone();
1478        let value = match apikey.prefix {
1479            Some(ref prefix) => format!("{} {}", prefix, key),
1480            None => key,
1481        };
1482        req_builder = req_builder.header("x-api-key", value);
1483    };
1484    if let Some(ref token) = configuration.bearer_access_token {
1485        req_builder = req_builder.bearer_auth(token.to_owned());
1486    };
1487    req_builder = req_builder.json(&p_describe_table_request);
1488
1489    let req = req_builder.build()?;
1490    let resp = configuration.client.execute(req).await?;
1491
1492    let status = resp.status();
1493    let content_type = resp
1494        .headers()
1495        .get("content-type")
1496        .and_then(|v| v.to_str().ok())
1497        .unwrap_or("application/octet-stream");
1498    let content_type = super::ContentType::from(content_type);
1499
1500    if !status.is_client_error() && !status.is_server_error() {
1501        let content = resp.text().await?;
1502        match content_type {
1503            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1504            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DescribeTableResponse`"))),
1505            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`")))),
1506        }
1507    } else {
1508        let content = resp.text().await?;
1509        let entity: Option<DescribeTableError> = serde_json::from_str(&content).ok();
1510        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1511    }
1512}
1513
1514/// Get statistics for a specific index on a table. Returns information about the index type, distance type (for vector indices), and row counts. 
1515pub 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>> {
1516    // add a prefix to parameters to efficiently prevent name collisions
1517    let p_id = id;
1518    let p_index_name = index_name;
1519    let p_describe_table_index_stats_request = describe_table_index_stats_request;
1520    let p_delimiter = delimiter;
1521
1522    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));
1523    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1524
1525    if let Some(ref param_value) = p_delimiter {
1526        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1527    }
1528    if let Some(ref user_agent) = configuration.user_agent {
1529        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1530    }
1531    if let Some(ref token) = configuration.oauth_access_token {
1532        req_builder = req_builder.bearer_auth(token.to_owned());
1533    };
1534    if let Some(ref apikey) = configuration.api_key {
1535        let key = apikey.key.clone();
1536        let value = match apikey.prefix {
1537            Some(ref prefix) => format!("{} {}", prefix, key),
1538            None => key,
1539        };
1540        req_builder = req_builder.header("x-api-key", value);
1541    };
1542    if let Some(ref token) = configuration.bearer_access_token {
1543        req_builder = req_builder.bearer_auth(token.to_owned());
1544    };
1545    req_builder = req_builder.json(&p_describe_table_index_stats_request);
1546
1547    let req = req_builder.build()?;
1548    let resp = configuration.client.execute(req).await?;
1549
1550    let status = resp.status();
1551    let content_type = resp
1552        .headers()
1553        .get("content-type")
1554        .and_then(|v| v.to_str().ok())
1555        .unwrap_or("application/octet-stream");
1556    let content_type = super::ContentType::from(content_type);
1557
1558    if !status.is_client_error() && !status.is_server_error() {
1559        let content = resp.text().await?;
1560        match content_type {
1561            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1562            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DescribeTableIndexStatsResponse`"))),
1563            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`")))),
1564        }
1565    } else {
1566        let content = resp.text().await?;
1567        let entity: Option<DescribeTableIndexStatsError> = serde_json::from_str(&content).ok();
1568        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1569    }
1570}
1571
1572/// Describe the detailed information for a specific version of table `id`.  Returns the manifest path and metadata for the specified version. 
1573pub async fn describe_table_version(configuration: &configuration::Configuration, id: &str, describe_table_version_request: models::DescribeTableVersionRequest, delimiter: Option<&str>) -> Result<models::DescribeTableVersionResponse, Error<DescribeTableVersionError>> {
1574    // add a prefix to parameters to efficiently prevent name collisions
1575    let p_id = id;
1576    let p_describe_table_version_request = describe_table_version_request;
1577    let p_delimiter = delimiter;
1578
1579    let uri_str = format!("{}/v1/table/{id}/version/describe", configuration.base_path, id=crate::apis::urlencode(p_id));
1580    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1581
1582    if let Some(ref param_value) = p_delimiter {
1583        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1584    }
1585    if let Some(ref user_agent) = configuration.user_agent {
1586        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1587    }
1588    if let Some(ref token) = configuration.oauth_access_token {
1589        req_builder = req_builder.bearer_auth(token.to_owned());
1590    };
1591    if let Some(ref apikey) = configuration.api_key {
1592        let key = apikey.key.clone();
1593        let value = match apikey.prefix {
1594            Some(ref prefix) => format!("{} {}", prefix, key),
1595            None => key,
1596        };
1597        req_builder = req_builder.header("x-api-key", value);
1598    };
1599    if let Some(ref token) = configuration.bearer_access_token {
1600        req_builder = req_builder.bearer_auth(token.to_owned());
1601    };
1602    req_builder = req_builder.json(&p_describe_table_version_request);
1603
1604    let req = req_builder.build()?;
1605    let resp = configuration.client.execute(req).await?;
1606
1607    let status = resp.status();
1608    let content_type = resp
1609        .headers()
1610        .get("content-type")
1611        .and_then(|v| v.to_str().ok())
1612        .unwrap_or("application/octet-stream");
1613    let content_type = super::ContentType::from(content_type);
1614
1615    if !status.is_client_error() && !status.is_server_error() {
1616        let content = resp.text().await?;
1617        match content_type {
1618            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1619            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DescribeTableVersionResponse`"))),
1620            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`")))),
1621        }
1622    } else {
1623        let content = resp.text().await?;
1624        let entity: Option<DescribeTableVersionError> = serde_json::from_str(&content).ok();
1625        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1626    }
1627}
1628
1629/// 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 
1630pub async fn drop_table(configuration: &configuration::Configuration, id: &str, delimiter: Option<&str>) -> Result<models::DropTableResponse, Error<DropTableError>> {
1631    // add a prefix to parameters to efficiently prevent name collisions
1632    let p_id = id;
1633    let p_delimiter = delimiter;
1634
1635    let uri_str = format!("{}/v1/table/{id}/drop", configuration.base_path, id=crate::apis::urlencode(p_id));
1636    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1637
1638    if let Some(ref param_value) = p_delimiter {
1639        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1640    }
1641    if let Some(ref user_agent) = configuration.user_agent {
1642        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1643    }
1644    if let Some(ref token) = configuration.oauth_access_token {
1645        req_builder = req_builder.bearer_auth(token.to_owned());
1646    };
1647    if let Some(ref apikey) = configuration.api_key {
1648        let key = apikey.key.clone();
1649        let value = match apikey.prefix {
1650            Some(ref prefix) => format!("{} {}", prefix, key),
1651            None => key,
1652        };
1653        req_builder = req_builder.header("x-api-key", value);
1654    };
1655    if let Some(ref token) = configuration.bearer_access_token {
1656        req_builder = req_builder.bearer_auth(token.to_owned());
1657    };
1658
1659    let req = req_builder.build()?;
1660    let resp = configuration.client.execute(req).await?;
1661
1662    let status = resp.status();
1663    let content_type = resp
1664        .headers()
1665        .get("content-type")
1666        .and_then(|v| v.to_str().ok())
1667        .unwrap_or("application/octet-stream");
1668    let content_type = super::ContentType::from(content_type);
1669
1670    if !status.is_client_error() && !status.is_server_error() {
1671        let content = resp.text().await?;
1672        match content_type {
1673            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1674            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DropTableResponse`"))),
1675            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`")))),
1676        }
1677    } else {
1678        let content = resp.text().await?;
1679        let entity: Option<DropTableError> = serde_json::from_str(&content).ok();
1680        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1681    }
1682}
1683
1684/// 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 
1685pub async fn drop_table_index(configuration: &configuration::Configuration, id: &str, index_name: &str, delimiter: Option<&str>) -> Result<models::DropTableIndexResponse, Error<DropTableIndexError>> {
1686    // add a prefix to parameters to efficiently prevent name collisions
1687    let p_id = id;
1688    let p_index_name = index_name;
1689    let p_delimiter = delimiter;
1690
1691    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));
1692    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1693
1694    if let Some(ref param_value) = p_delimiter {
1695        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1696    }
1697    if let Some(ref user_agent) = configuration.user_agent {
1698        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1699    }
1700    if let Some(ref token) = configuration.oauth_access_token {
1701        req_builder = req_builder.bearer_auth(token.to_owned());
1702    };
1703    if let Some(ref apikey) = configuration.api_key {
1704        let key = apikey.key.clone();
1705        let value = match apikey.prefix {
1706            Some(ref prefix) => format!("{} {}", prefix, key),
1707            None => key,
1708        };
1709        req_builder = req_builder.header("x-api-key", value);
1710    };
1711    if let Some(ref token) = configuration.bearer_access_token {
1712        req_builder = req_builder.bearer_auth(token.to_owned());
1713    };
1714
1715    let req = req_builder.build()?;
1716    let resp = configuration.client.execute(req).await?;
1717
1718    let status = resp.status();
1719    let content_type = resp
1720        .headers()
1721        .get("content-type")
1722        .and_then(|v| v.to_str().ok())
1723        .unwrap_or("application/octet-stream");
1724    let content_type = super::ContentType::from(content_type);
1725
1726    if !status.is_client_error() && !status.is_server_error() {
1727        let content = resp.text().await?;
1728        match content_type {
1729            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1730            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DropTableIndexResponse`"))),
1731            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`")))),
1732        }
1733    } else {
1734        let content = resp.text().await?;
1735        let entity: Option<DropTableIndexError> = serde_json::from_str(&content).ok();
1736        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1737    }
1738}
1739
1740/// 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. 
1741pub 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>> {
1742    // add a prefix to parameters to efficiently prevent name collisions
1743    let p_id = id;
1744    let p_explain_table_query_plan_request = explain_table_query_plan_request;
1745    let p_delimiter = delimiter;
1746
1747    let uri_str = format!("{}/v1/table/{id}/explain_plan", configuration.base_path, id=crate::apis::urlencode(p_id));
1748    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1749
1750    if let Some(ref param_value) = p_delimiter {
1751        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1752    }
1753    if let Some(ref user_agent) = configuration.user_agent {
1754        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1755    }
1756    if let Some(ref token) = configuration.oauth_access_token {
1757        req_builder = req_builder.bearer_auth(token.to_owned());
1758    };
1759    if let Some(ref apikey) = configuration.api_key {
1760        let key = apikey.key.clone();
1761        let value = match apikey.prefix {
1762            Some(ref prefix) => format!("{} {}", prefix, key),
1763            None => key,
1764        };
1765        req_builder = req_builder.header("x-api-key", value);
1766    };
1767    if let Some(ref token) = configuration.bearer_access_token {
1768        req_builder = req_builder.bearer_auth(token.to_owned());
1769    };
1770    req_builder = req_builder.json(&p_explain_table_query_plan_request);
1771
1772    let req = req_builder.build()?;
1773    let resp = configuration.client.execute(req).await?;
1774
1775    let status = resp.status();
1776    let content_type = resp
1777        .headers()
1778        .get("content-type")
1779        .and_then(|v| v.to_str().ok())
1780        .unwrap_or("application/octet-stream");
1781    let content_type = super::ContentType::from(content_type);
1782
1783    if !status.is_client_error() && !status.is_server_error() {
1784        let content = resp.text().await?;
1785        match content_type {
1786            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1787            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `String`"))),
1788            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`")))),
1789        }
1790    } else {
1791        let content = resp.text().await?;
1792        let entity: Option<ExplainTableQueryPlanError> = serde_json::from_str(&content).ok();
1793        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1794    }
1795}
1796
1797/// Get statistics for table `id`, including row counts, data sizes, and column statistics. 
1798pub async fn get_table_stats(configuration: &configuration::Configuration, id: &str, get_table_stats_request: models::GetTableStatsRequest, delimiter: Option<&str>) -> Result<models::GetTableStatsResponse, Error<GetTableStatsError>> {
1799    // add a prefix to parameters to efficiently prevent name collisions
1800    let p_id = id;
1801    let p_get_table_stats_request = get_table_stats_request;
1802    let p_delimiter = delimiter;
1803
1804    let uri_str = format!("{}/v1/table/{id}/stats", configuration.base_path, id=crate::apis::urlencode(p_id));
1805    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1806
1807    if let Some(ref param_value) = p_delimiter {
1808        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1809    }
1810    if let Some(ref user_agent) = configuration.user_agent {
1811        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1812    }
1813    if let Some(ref token) = configuration.oauth_access_token {
1814        req_builder = req_builder.bearer_auth(token.to_owned());
1815    };
1816    if let Some(ref apikey) = configuration.api_key {
1817        let key = apikey.key.clone();
1818        let value = match apikey.prefix {
1819            Some(ref prefix) => format!("{} {}", prefix, key),
1820            None => key,
1821        };
1822        req_builder = req_builder.header("x-api-key", value);
1823    };
1824    if let Some(ref token) = configuration.bearer_access_token {
1825        req_builder = req_builder.bearer_auth(token.to_owned());
1826    };
1827    req_builder = req_builder.json(&p_get_table_stats_request);
1828
1829    let req = req_builder.build()?;
1830    let resp = configuration.client.execute(req).await?;
1831
1832    let status = resp.status();
1833    let content_type = resp
1834        .headers()
1835        .get("content-type")
1836        .and_then(|v| v.to_str().ok())
1837        .unwrap_or("application/octet-stream");
1838    let content_type = super::ContentType::from(content_type);
1839
1840    if !status.is_client_error() && !status.is_server_error() {
1841        let content = resp.text().await?;
1842        match content_type {
1843            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1844            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetTableStatsResponse`"))),
1845            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`")))),
1846        }
1847    } else {
1848        let content = resp.text().await?;
1849        let entity: Option<GetTableStatsError> = serde_json::from_str(&content).ok();
1850        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1851    }
1852}
1853
1854/// Get the version number that a specific tag points to for table `id`. 
1855pub 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>> {
1856    // add a prefix to parameters to efficiently prevent name collisions
1857    let p_id = id;
1858    let p_get_table_tag_version_request = get_table_tag_version_request;
1859    let p_delimiter = delimiter;
1860
1861    let uri_str = format!("{}/v1/table/{id}/tags/version", configuration.base_path, id=crate::apis::urlencode(p_id));
1862    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1863
1864    if let Some(ref param_value) = p_delimiter {
1865        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1866    }
1867    if let Some(ref user_agent) = configuration.user_agent {
1868        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1869    }
1870    if let Some(ref token) = configuration.oauth_access_token {
1871        req_builder = req_builder.bearer_auth(token.to_owned());
1872    };
1873    if let Some(ref apikey) = configuration.api_key {
1874        let key = apikey.key.clone();
1875        let value = match apikey.prefix {
1876            Some(ref prefix) => format!("{} {}", prefix, key),
1877            None => key,
1878        };
1879        req_builder = req_builder.header("x-api-key", value);
1880    };
1881    if let Some(ref token) = configuration.bearer_access_token {
1882        req_builder = req_builder.bearer_auth(token.to_owned());
1883    };
1884    req_builder = req_builder.json(&p_get_table_tag_version_request);
1885
1886    let req = req_builder.build()?;
1887    let resp = configuration.client.execute(req).await?;
1888
1889    let status = resp.status();
1890    let content_type = resp
1891        .headers()
1892        .get("content-type")
1893        .and_then(|v| v.to_str().ok())
1894        .unwrap_or("application/octet-stream");
1895    let content_type = super::ContentType::from(content_type);
1896
1897    if !status.is_client_error() && !status.is_server_error() {
1898        let content = resp.text().await?;
1899        match content_type {
1900            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1901            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetTableTagVersionResponse`"))),
1902            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`")))),
1903        }
1904    } else {
1905        let content = resp.text().await?;
1906        let entity: Option<GetTableTagVersionError> = serde_json::from_str(&content).ok();
1907        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1908    }
1909}
1910
1911/// Insert new records into table `id`.  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 
1912pub async fn insert_into_table(configuration: &configuration::Configuration, id: &str, body: Vec<u8>, delimiter: Option<&str>, mode: Option<&str>) -> Result<models::InsertIntoTableResponse, Error<InsertIntoTableError>> {
1913    // add a prefix to parameters to efficiently prevent name collisions
1914    let p_id = id;
1915    let p_body = body;
1916    let p_delimiter = delimiter;
1917    let p_mode = mode;
1918
1919    let uri_str = format!("{}/v1/table/{id}/insert", configuration.base_path, id=crate::apis::urlencode(p_id));
1920    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1921
1922    if let Some(ref param_value) = p_delimiter {
1923        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1924    }
1925    if let Some(ref param_value) = p_mode {
1926        req_builder = req_builder.query(&[("mode", &param_value.to_string())]);
1927    }
1928    if let Some(ref user_agent) = configuration.user_agent {
1929        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1930    }
1931    if let Some(ref token) = configuration.oauth_access_token {
1932        req_builder = req_builder.bearer_auth(token.to_owned());
1933    };
1934    if let Some(ref apikey) = configuration.api_key {
1935        let key = apikey.key.clone();
1936        let value = match apikey.prefix {
1937            Some(ref prefix) => format!("{} {}", prefix, key),
1938            None => key,
1939        };
1940        req_builder = req_builder.header("x-api-key", value);
1941    };
1942    if let Some(ref token) = configuration.bearer_access_token {
1943        req_builder = req_builder.bearer_auth(token.to_owned());
1944    };
1945    req_builder = req_builder.body(p_body);
1946
1947    let req = req_builder.build()?;
1948    let resp = configuration.client.execute(req).await?;
1949
1950    let status = resp.status();
1951    let content_type = resp
1952        .headers()
1953        .get("content-type")
1954        .and_then(|v| v.to_str().ok())
1955        .unwrap_or("application/octet-stream");
1956    let content_type = super::ContentType::from(content_type);
1957
1958    if !status.is_client_error() && !status.is_server_error() {
1959        let content = resp.text().await?;
1960        match content_type {
1961            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1962            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::InsertIntoTableResponse`"))),
1963            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`")))),
1964        }
1965    } else {
1966        let content = resp.text().await?;
1967        let entity: Option<InsertIntoTableError> = serde_json::from_str(&content).ok();
1968        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1969    }
1970}
1971
1972/// 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 
1973pub async fn list_all_tables(configuration: &configuration::Configuration, delimiter: Option<&str>, page_token: Option<&str>, limit: Option<i32>) -> Result<models::ListTablesResponse, Error<ListAllTablesError>> {
1974    // add a prefix to parameters to efficiently prevent name collisions
1975    let p_delimiter = delimiter;
1976    let p_page_token = page_token;
1977    let p_limit = limit;
1978
1979    let uri_str = format!("{}/v1/table", configuration.base_path);
1980    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1981
1982    if let Some(ref param_value) = p_delimiter {
1983        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1984    }
1985    if let Some(ref param_value) = p_page_token {
1986        req_builder = req_builder.query(&[("page_token", &param_value.to_string())]);
1987    }
1988    if let Some(ref param_value) = p_limit {
1989        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
1990    }
1991    if let Some(ref user_agent) = configuration.user_agent {
1992        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1993    }
1994    if let Some(ref token) = configuration.oauth_access_token {
1995        req_builder = req_builder.bearer_auth(token.to_owned());
1996    };
1997    if let Some(ref apikey) = configuration.api_key {
1998        let key = apikey.key.clone();
1999        let value = match apikey.prefix {
2000            Some(ref prefix) => format!("{} {}", prefix, key),
2001            None => key,
2002        };
2003        req_builder = req_builder.header("x-api-key", value);
2004    };
2005    if let Some(ref token) = configuration.bearer_access_token {
2006        req_builder = req_builder.bearer_auth(token.to_owned());
2007    };
2008
2009    let req = req_builder.build()?;
2010    let resp = configuration.client.execute(req).await?;
2011
2012    let status = resp.status();
2013    let content_type = resp
2014        .headers()
2015        .get("content-type")
2016        .and_then(|v| v.to_str().ok())
2017        .unwrap_or("application/octet-stream");
2018    let content_type = super::ContentType::from(content_type);
2019
2020    if !status.is_client_error() && !status.is_server_error() {
2021        let content = resp.text().await?;
2022        match content_type {
2023            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2024            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTablesResponse`"))),
2025            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`")))),
2026        }
2027    } else {
2028        let content = resp.text().await?;
2029        let entity: Option<ListAllTablesError> = serde_json::from_str(&content).ok();
2030        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2031    }
2032}
2033
2034/// List all indices created on a table. Returns information about each index including name, columns, status, and UUID. 
2035pub async fn list_table_indices(configuration: &configuration::Configuration, id: &str, list_table_indices_request: models::ListTableIndicesRequest, delimiter: Option<&str>) -> Result<models::ListTableIndicesResponse, Error<ListTableIndicesError>> {
2036    // add a prefix to parameters to efficiently prevent name collisions
2037    let p_id = id;
2038    let p_list_table_indices_request = list_table_indices_request;
2039    let p_delimiter = delimiter;
2040
2041    let uri_str = format!("{}/v1/table/{id}/index/list", configuration.base_path, id=crate::apis::urlencode(p_id));
2042    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2043
2044    if let Some(ref param_value) = p_delimiter {
2045        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2046    }
2047    if let Some(ref user_agent) = configuration.user_agent {
2048        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2049    }
2050    if let Some(ref token) = configuration.oauth_access_token {
2051        req_builder = req_builder.bearer_auth(token.to_owned());
2052    };
2053    if let Some(ref apikey) = configuration.api_key {
2054        let key = apikey.key.clone();
2055        let value = match apikey.prefix {
2056            Some(ref prefix) => format!("{} {}", prefix, key),
2057            None => key,
2058        };
2059        req_builder = req_builder.header("x-api-key", value);
2060    };
2061    if let Some(ref token) = configuration.bearer_access_token {
2062        req_builder = req_builder.bearer_auth(token.to_owned());
2063    };
2064    req_builder = req_builder.json(&p_list_table_indices_request);
2065
2066    let req = req_builder.build()?;
2067    let resp = configuration.client.execute(req).await?;
2068
2069    let status = resp.status();
2070    let content_type = resp
2071        .headers()
2072        .get("content-type")
2073        .and_then(|v| v.to_str().ok())
2074        .unwrap_or("application/octet-stream");
2075    let content_type = super::ContentType::from(content_type);
2076
2077    if !status.is_client_error() && !status.is_server_error() {
2078        let content = resp.text().await?;
2079        match content_type {
2080            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2081            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTableIndicesResponse`"))),
2082            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`")))),
2083        }
2084    } else {
2085        let content = resp.text().await?;
2086        let entity: Option<ListTableIndicesError> = serde_json::from_str(&content).ok();
2087        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2088    }
2089}
2090
2091/// 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 
2092pub 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>> {
2093    // add a prefix to parameters to efficiently prevent name collisions
2094    let p_id = id;
2095    let p_delimiter = delimiter;
2096    let p_page_token = page_token;
2097    let p_limit = limit;
2098
2099    let uri_str = format!("{}/v1/table/{id}/tags/list", configuration.base_path, id=crate::apis::urlencode(p_id));
2100    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2101
2102    if let Some(ref param_value) = p_delimiter {
2103        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2104    }
2105    if let Some(ref param_value) = p_page_token {
2106        req_builder = req_builder.query(&[("page_token", &param_value.to_string())]);
2107    }
2108    if let Some(ref param_value) = p_limit {
2109        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
2110    }
2111    if let Some(ref user_agent) = configuration.user_agent {
2112        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2113    }
2114    if let Some(ref token) = configuration.oauth_access_token {
2115        req_builder = req_builder.bearer_auth(token.to_owned());
2116    };
2117    if let Some(ref apikey) = configuration.api_key {
2118        let key = apikey.key.clone();
2119        let value = match apikey.prefix {
2120            Some(ref prefix) => format!("{} {}", prefix, key),
2121            None => key,
2122        };
2123        req_builder = req_builder.header("x-api-key", value);
2124    };
2125    if let Some(ref token) = configuration.bearer_access_token {
2126        req_builder = req_builder.bearer_auth(token.to_owned());
2127    };
2128
2129    let req = req_builder.build()?;
2130    let resp = configuration.client.execute(req).await?;
2131
2132    let status = resp.status();
2133    let content_type = resp
2134        .headers()
2135        .get("content-type")
2136        .and_then(|v| v.to_str().ok())
2137        .unwrap_or("application/octet-stream");
2138    let content_type = super::ContentType::from(content_type);
2139
2140    if !status.is_client_error() && !status.is_server_error() {
2141        let content = resp.text().await?;
2142        match content_type {
2143            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2144            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTableTagsResponse`"))),
2145            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`")))),
2146        }
2147    } else {
2148        let content = resp.text().await?;
2149        let entity: Option<ListTableTagsError> = serde_json::from_str(&content).ok();
2150        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2151    }
2152}
2153
2154/// 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 
2155pub async fn list_table_versions(configuration: &configuration::Configuration, id: &str, delimiter: Option<&str>, page_token: Option<&str>, limit: Option<i32>, descending: Option<bool>) -> Result<models::ListTableVersionsResponse, Error<ListTableVersionsError>> {
2156    // add a prefix to parameters to efficiently prevent name collisions
2157    let p_id = id;
2158    let p_delimiter = delimiter;
2159    let p_page_token = page_token;
2160    let p_limit = limit;
2161    let p_descending = descending;
2162
2163    let uri_str = format!("{}/v1/table/{id}/version/list", configuration.base_path, id=crate::apis::urlencode(p_id));
2164    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2165
2166    if let Some(ref param_value) = p_delimiter {
2167        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2168    }
2169    if let Some(ref param_value) = p_page_token {
2170        req_builder = req_builder.query(&[("page_token", &param_value.to_string())]);
2171    }
2172    if let Some(ref param_value) = p_limit {
2173        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
2174    }
2175    if let Some(ref param_value) = p_descending {
2176        req_builder = req_builder.query(&[("descending", &param_value.to_string())]);
2177    }
2178    if let Some(ref user_agent) = configuration.user_agent {
2179        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2180    }
2181    if let Some(ref token) = configuration.oauth_access_token {
2182        req_builder = req_builder.bearer_auth(token.to_owned());
2183    };
2184    if let Some(ref apikey) = configuration.api_key {
2185        let key = apikey.key.clone();
2186        let value = match apikey.prefix {
2187            Some(ref prefix) => format!("{} {}", prefix, key),
2188            None => key,
2189        };
2190        req_builder = req_builder.header("x-api-key", value);
2191    };
2192    if let Some(ref token) = configuration.bearer_access_token {
2193        req_builder = req_builder.bearer_auth(token.to_owned());
2194    };
2195
2196    let req = req_builder.build()?;
2197    let resp = configuration.client.execute(req).await?;
2198
2199    let status = resp.status();
2200    let content_type = resp
2201        .headers()
2202        .get("content-type")
2203        .and_then(|v| v.to_str().ok())
2204        .unwrap_or("application/octet-stream");
2205    let content_type = super::ContentType::from(content_type);
2206
2207    if !status.is_client_error() && !status.is_server_error() {
2208        let content = resp.text().await?;
2209        match content_type {
2210            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2211            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTableVersionsResponse`"))),
2212            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`")))),
2213        }
2214    } else {
2215        let content = resp.text().await?;
2216        let entity: Option<ListTableVersionsError> = serde_json::from_str(&content).ok();
2217        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2218    }
2219}
2220
2221/// 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 
2222pub async fn list_tables(configuration: &configuration::Configuration, id: &str, delimiter: Option<&str>, page_token: Option<&str>, limit: Option<i32>) -> Result<models::ListTablesResponse, Error<ListTablesError>> {
2223    // add a prefix to parameters to efficiently prevent name collisions
2224    let p_id = id;
2225    let p_delimiter = delimiter;
2226    let p_page_token = page_token;
2227    let p_limit = limit;
2228
2229    let uri_str = format!("{}/v1/namespace/{id}/table/list", configuration.base_path, id=crate::apis::urlencode(p_id));
2230    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2231
2232    if let Some(ref param_value) = p_delimiter {
2233        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2234    }
2235    if let Some(ref param_value) = p_page_token {
2236        req_builder = req_builder.query(&[("page_token", &param_value.to_string())]);
2237    }
2238    if let Some(ref param_value) = p_limit {
2239        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
2240    }
2241    if let Some(ref user_agent) = configuration.user_agent {
2242        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2243    }
2244    if let Some(ref token) = configuration.oauth_access_token {
2245        req_builder = req_builder.bearer_auth(token.to_owned());
2246    };
2247    if let Some(ref apikey) = configuration.api_key {
2248        let key = apikey.key.clone();
2249        let value = match apikey.prefix {
2250            Some(ref prefix) => format!("{} {}", prefix, key),
2251            None => key,
2252        };
2253        req_builder = req_builder.header("x-api-key", value);
2254    };
2255    if let Some(ref token) = configuration.bearer_access_token {
2256        req_builder = req_builder.bearer_auth(token.to_owned());
2257    };
2258
2259    let req = req_builder.build()?;
2260    let resp = configuration.client.execute(req).await?;
2261
2262    let status = resp.status();
2263    let content_type = resp
2264        .headers()
2265        .get("content-type")
2266        .and_then(|v| v.to_str().ok())
2267        .unwrap_or("application/octet-stream");
2268    let content_type = super::ContentType::from(content_type);
2269
2270    if !status.is_client_error() && !status.is_server_error() {
2271        let content = resp.text().await?;
2272        match content_type {
2273            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2274            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTablesResponse`"))),
2275            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`")))),
2276        }
2277    } else {
2278        let content = resp.text().await?;
2279        let entity: Option<ListTablesError> = serde_json::from_str(&content).ok();
2280        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2281    }
2282}
2283
2284/// 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.  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 
2285pub async fn merge_insert_into_table(configuration: &configuration::Configuration, id: &str, on: &str, body: Vec<u8>, delimiter: 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>> {
2286    // add a prefix to parameters to efficiently prevent name collisions
2287    let p_id = id;
2288    let p_on = on;
2289    let p_body = body;
2290    let p_delimiter = delimiter;
2291    let p_when_matched_update_all = when_matched_update_all;
2292    let p_when_matched_update_all_filt = when_matched_update_all_filt;
2293    let p_when_not_matched_insert_all = when_not_matched_insert_all;
2294    let p_when_not_matched_by_source_delete = when_not_matched_by_source_delete;
2295    let p_when_not_matched_by_source_delete_filt = when_not_matched_by_source_delete_filt;
2296    let p_timeout = timeout;
2297    let p_use_index = use_index;
2298
2299    let uri_str = format!("{}/v1/table/{id}/merge_insert", configuration.base_path, id=crate::apis::urlencode(p_id));
2300    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2301
2302    if let Some(ref param_value) = p_delimiter {
2303        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2304    }
2305    req_builder = req_builder.query(&[("on", &p_on.to_string())]);
2306    if let Some(ref param_value) = p_when_matched_update_all {
2307        req_builder = req_builder.query(&[("when_matched_update_all", &param_value.to_string())]);
2308    }
2309    if let Some(ref param_value) = p_when_matched_update_all_filt {
2310        req_builder = req_builder.query(&[("when_matched_update_all_filt", &param_value.to_string())]);
2311    }
2312    if let Some(ref param_value) = p_when_not_matched_insert_all {
2313        req_builder = req_builder.query(&[("when_not_matched_insert_all", &param_value.to_string())]);
2314    }
2315    if let Some(ref param_value) = p_when_not_matched_by_source_delete {
2316        req_builder = req_builder.query(&[("when_not_matched_by_source_delete", &param_value.to_string())]);
2317    }
2318    if let Some(ref param_value) = p_when_not_matched_by_source_delete_filt {
2319        req_builder = req_builder.query(&[("when_not_matched_by_source_delete_filt", &param_value.to_string())]);
2320    }
2321    if let Some(ref param_value) = p_timeout {
2322        req_builder = req_builder.query(&[("timeout", &param_value.to_string())]);
2323    }
2324    if let Some(ref param_value) = p_use_index {
2325        req_builder = req_builder.query(&[("use_index", &param_value.to_string())]);
2326    }
2327    if let Some(ref user_agent) = configuration.user_agent {
2328        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2329    }
2330    if let Some(ref token) = configuration.oauth_access_token {
2331        req_builder = req_builder.bearer_auth(token.to_owned());
2332    };
2333    if let Some(ref apikey) = configuration.api_key {
2334        let key = apikey.key.clone();
2335        let value = match apikey.prefix {
2336            Some(ref prefix) => format!("{} {}", prefix, key),
2337            None => key,
2338        };
2339        req_builder = req_builder.header("x-api-key", value);
2340    };
2341    if let Some(ref token) = configuration.bearer_access_token {
2342        req_builder = req_builder.bearer_auth(token.to_owned());
2343    };
2344    req_builder = req_builder.body(p_body);
2345
2346    let req = req_builder.build()?;
2347    let resp = configuration.client.execute(req).await?;
2348
2349    let status = resp.status();
2350    let content_type = resp
2351        .headers()
2352        .get("content-type")
2353        .and_then(|v| v.to_str().ok())
2354        .unwrap_or("application/octet-stream");
2355    let content_type = super::ContentType::from(content_type);
2356
2357    if !status.is_client_error() && !status.is_server_error() {
2358        let content = resp.text().await?;
2359        match content_type {
2360            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2361            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::MergeInsertIntoTableResponse`"))),
2362            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`")))),
2363        }
2364    } else {
2365        let content = resp.text().await?;
2366        let entity: Option<MergeInsertIntoTableError> = serde_json::from_str(&content).ok();
2367        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2368    }
2369}
2370
2371/// 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. 
2372pub async fn query_table(configuration: &configuration::Configuration, id: &str, query_table_request: models::QueryTableRequest, delimiter: Option<&str>) -> Result<reqwest::Response, Error<QueryTableError>> {
2373    // add a prefix to parameters to efficiently prevent name collisions
2374    let p_id = id;
2375    let p_query_table_request = query_table_request;
2376    let p_delimiter = delimiter;
2377
2378    let uri_str = format!("{}/v1/table/{id}/query", configuration.base_path, id=crate::apis::urlencode(p_id));
2379    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2380
2381    if let Some(ref param_value) = p_delimiter {
2382        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2383    }
2384    if let Some(ref user_agent) = configuration.user_agent {
2385        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2386    }
2387    if let Some(ref token) = configuration.oauth_access_token {
2388        req_builder = req_builder.bearer_auth(token.to_owned());
2389    };
2390    if let Some(ref apikey) = configuration.api_key {
2391        let key = apikey.key.clone();
2392        let value = match apikey.prefix {
2393            Some(ref prefix) => format!("{} {}", prefix, key),
2394            None => key,
2395        };
2396        req_builder = req_builder.header("x-api-key", value);
2397    };
2398    if let Some(ref token) = configuration.bearer_access_token {
2399        req_builder = req_builder.bearer_auth(token.to_owned());
2400    };
2401    req_builder = req_builder.json(&p_query_table_request);
2402
2403    let req = req_builder.build()?;
2404    let resp = configuration.client.execute(req).await?;
2405
2406    let status = resp.status();
2407
2408    if !status.is_client_error() && !status.is_server_error() {
2409        Ok(resp)
2410    } else {
2411        let content = resp.text().await?;
2412        let entity: Option<QueryTableError> = serde_json::from_str(&content).ok();
2413        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2414    }
2415}
2416
2417/// Register an existing table at a given storage location as `id`. 
2418pub async fn register_table(configuration: &configuration::Configuration, id: &str, register_table_request: models::RegisterTableRequest, delimiter: Option<&str>) -> Result<models::RegisterTableResponse, Error<RegisterTableError>> {
2419    // add a prefix to parameters to efficiently prevent name collisions
2420    let p_id = id;
2421    let p_register_table_request = register_table_request;
2422    let p_delimiter = delimiter;
2423
2424    let uri_str = format!("{}/v1/table/{id}/register", configuration.base_path, id=crate::apis::urlencode(p_id));
2425    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2426
2427    if let Some(ref param_value) = p_delimiter {
2428        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2429    }
2430    if let Some(ref user_agent) = configuration.user_agent {
2431        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2432    }
2433    if let Some(ref token) = configuration.oauth_access_token {
2434        req_builder = req_builder.bearer_auth(token.to_owned());
2435    };
2436    if let Some(ref apikey) = configuration.api_key {
2437        let key = apikey.key.clone();
2438        let value = match apikey.prefix {
2439            Some(ref prefix) => format!("{} {}", prefix, key),
2440            None => key,
2441        };
2442        req_builder = req_builder.header("x-api-key", value);
2443    };
2444    if let Some(ref token) = configuration.bearer_access_token {
2445        req_builder = req_builder.bearer_auth(token.to_owned());
2446    };
2447    req_builder = req_builder.json(&p_register_table_request);
2448
2449    let req = req_builder.build()?;
2450    let resp = configuration.client.execute(req).await?;
2451
2452    let status = resp.status();
2453    let content_type = resp
2454        .headers()
2455        .get("content-type")
2456        .and_then(|v| v.to_str().ok())
2457        .unwrap_or("application/octet-stream");
2458    let content_type = super::ContentType::from(content_type);
2459
2460    if !status.is_client_error() && !status.is_server_error() {
2461        let content = resp.text().await?;
2462        match content_type {
2463            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2464            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RegisterTableResponse`"))),
2465            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`")))),
2466        }
2467    } else {
2468        let content = resp.text().await?;
2469        let entity: Option<RegisterTableError> = serde_json::from_str(&content).ok();
2470        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2471    }
2472}
2473
2474/// Rename table `id` to a new name. 
2475pub async fn rename_table(configuration: &configuration::Configuration, id: &str, rename_table_request: models::RenameTableRequest, delimiter: Option<&str>) -> Result<models::RenameTableResponse, Error<RenameTableError>> {
2476    // add a prefix to parameters to efficiently prevent name collisions
2477    let p_id = id;
2478    let p_rename_table_request = rename_table_request;
2479    let p_delimiter = delimiter;
2480
2481    let uri_str = format!("{}/v1/table/{id}/rename", configuration.base_path, id=crate::apis::urlencode(p_id));
2482    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2483
2484    if let Some(ref param_value) = p_delimiter {
2485        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2486    }
2487    if let Some(ref user_agent) = configuration.user_agent {
2488        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2489    }
2490    if let Some(ref token) = configuration.oauth_access_token {
2491        req_builder = req_builder.bearer_auth(token.to_owned());
2492    };
2493    if let Some(ref apikey) = configuration.api_key {
2494        let key = apikey.key.clone();
2495        let value = match apikey.prefix {
2496            Some(ref prefix) => format!("{} {}", prefix, key),
2497            None => key,
2498        };
2499        req_builder = req_builder.header("x-api-key", value);
2500    };
2501    if let Some(ref token) = configuration.bearer_access_token {
2502        req_builder = req_builder.bearer_auth(token.to_owned());
2503    };
2504    req_builder = req_builder.json(&p_rename_table_request);
2505
2506    let req = req_builder.build()?;
2507    let resp = configuration.client.execute(req).await?;
2508
2509    let status = resp.status();
2510    let content_type = resp
2511        .headers()
2512        .get("content-type")
2513        .and_then(|v| v.to_str().ok())
2514        .unwrap_or("application/octet-stream");
2515    let content_type = super::ContentType::from(content_type);
2516
2517    if !status.is_client_error() && !status.is_server_error() {
2518        let content = resp.text().await?;
2519        match content_type {
2520            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2521            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RenameTableResponse`"))),
2522            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`")))),
2523        }
2524    } else {
2525        let content = resp.text().await?;
2526        let entity: Option<RenameTableError> = serde_json::from_str(&content).ok();
2527        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2528    }
2529}
2530
2531/// Restore table `id` to a specific version. 
2532pub async fn restore_table(configuration: &configuration::Configuration, id: &str, restore_table_request: models::RestoreTableRequest, delimiter: Option<&str>) -> Result<models::RestoreTableResponse, Error<RestoreTableError>> {
2533    // add a prefix to parameters to efficiently prevent name collisions
2534    let p_id = id;
2535    let p_restore_table_request = restore_table_request;
2536    let p_delimiter = delimiter;
2537
2538    let uri_str = format!("{}/v1/table/{id}/restore", configuration.base_path, id=crate::apis::urlencode(p_id));
2539    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2540
2541    if let Some(ref param_value) = p_delimiter {
2542        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2543    }
2544    if let Some(ref user_agent) = configuration.user_agent {
2545        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2546    }
2547    if let Some(ref token) = configuration.oauth_access_token {
2548        req_builder = req_builder.bearer_auth(token.to_owned());
2549    };
2550    if let Some(ref apikey) = configuration.api_key {
2551        let key = apikey.key.clone();
2552        let value = match apikey.prefix {
2553            Some(ref prefix) => format!("{} {}", prefix, key),
2554            None => key,
2555        };
2556        req_builder = req_builder.header("x-api-key", value);
2557    };
2558    if let Some(ref token) = configuration.bearer_access_token {
2559        req_builder = req_builder.bearer_auth(token.to_owned());
2560    };
2561    req_builder = req_builder.json(&p_restore_table_request);
2562
2563    let req = req_builder.build()?;
2564    let resp = configuration.client.execute(req).await?;
2565
2566    let status = resp.status();
2567    let content_type = resp
2568        .headers()
2569        .get("content-type")
2570        .and_then(|v| v.to_str().ok())
2571        .unwrap_or("application/octet-stream");
2572    let content_type = super::ContentType::from(content_type);
2573
2574    if !status.is_client_error() && !status.is_server_error() {
2575        let content = resp.text().await?;
2576        match content_type {
2577            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2578            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RestoreTableResponse`"))),
2579            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`")))),
2580        }
2581    } else {
2582        let content = resp.text().await?;
2583        let entity: Option<RestoreTableError> = serde_json::from_str(&content).ok();
2584        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2585    }
2586}
2587
2588/// 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) 
2589pub async fn table_exists(configuration: &configuration::Configuration, id: &str, table_exists_request: models::TableExistsRequest, delimiter: Option<&str>) -> Result<(), Error<TableExistsError>> {
2590    // add a prefix to parameters to efficiently prevent name collisions
2591    let p_id = id;
2592    let p_table_exists_request = table_exists_request;
2593    let p_delimiter = delimiter;
2594
2595    let uri_str = format!("{}/v1/table/{id}/exists", configuration.base_path, id=crate::apis::urlencode(p_id));
2596    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2597
2598    if let Some(ref param_value) = p_delimiter {
2599        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2600    }
2601    if let Some(ref user_agent) = configuration.user_agent {
2602        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2603    }
2604    if let Some(ref token) = configuration.oauth_access_token {
2605        req_builder = req_builder.bearer_auth(token.to_owned());
2606    };
2607    if let Some(ref apikey) = configuration.api_key {
2608        let key = apikey.key.clone();
2609        let value = match apikey.prefix {
2610            Some(ref prefix) => format!("{} {}", prefix, key),
2611            None => key,
2612        };
2613        req_builder = req_builder.header("x-api-key", value);
2614    };
2615    if let Some(ref token) = configuration.bearer_access_token {
2616        req_builder = req_builder.bearer_auth(token.to_owned());
2617    };
2618    req_builder = req_builder.json(&p_table_exists_request);
2619
2620    let req = req_builder.build()?;
2621    let resp = configuration.client.execute(req).await?;
2622
2623    let status = resp.status();
2624
2625    if !status.is_client_error() && !status.is_server_error() {
2626        Ok(())
2627    } else {
2628        let content = resp.text().await?;
2629        let entity: Option<TableExistsError> = serde_json::from_str(&content).ok();
2630        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2631    }
2632}
2633
2634/// Update existing rows in table `id`. 
2635pub async fn update_table(configuration: &configuration::Configuration, id: &str, update_table_request: models::UpdateTableRequest, delimiter: Option<&str>) -> Result<models::UpdateTableResponse, Error<UpdateTableError>> {
2636    // add a prefix to parameters to efficiently prevent name collisions
2637    let p_id = id;
2638    let p_update_table_request = update_table_request;
2639    let p_delimiter = delimiter;
2640
2641    let uri_str = format!("{}/v1/table/{id}/update", configuration.base_path, id=crate::apis::urlencode(p_id));
2642    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2643
2644    if let Some(ref param_value) = p_delimiter {
2645        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2646    }
2647    if let Some(ref user_agent) = configuration.user_agent {
2648        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2649    }
2650    if let Some(ref token) = configuration.oauth_access_token {
2651        req_builder = req_builder.bearer_auth(token.to_owned());
2652    };
2653    if let Some(ref apikey) = configuration.api_key {
2654        let key = apikey.key.clone();
2655        let value = match apikey.prefix {
2656            Some(ref prefix) => format!("{} {}", prefix, key),
2657            None => key,
2658        };
2659        req_builder = req_builder.header("x-api-key", value);
2660    };
2661    if let Some(ref token) = configuration.bearer_access_token {
2662        req_builder = req_builder.bearer_auth(token.to_owned());
2663    };
2664    req_builder = req_builder.json(&p_update_table_request);
2665
2666    let req = req_builder.build()?;
2667    let resp = configuration.client.execute(req).await?;
2668
2669    let status = resp.status();
2670    let content_type = resp
2671        .headers()
2672        .get("content-type")
2673        .and_then(|v| v.to_str().ok())
2674        .unwrap_or("application/octet-stream");
2675    let content_type = super::ContentType::from(content_type);
2676
2677    if !status.is_client_error() && !status.is_server_error() {
2678        let content = resp.text().await?;
2679        match content_type {
2680            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2681            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTableResponse`"))),
2682            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`")))),
2683        }
2684    } else {
2685        let content = resp.text().await?;
2686        let entity: Option<UpdateTableError> = serde_json::from_str(&content).ok();
2687        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2688    }
2689}
2690
2691/// 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`. 
2692pub async fn update_table_schema_metadata(configuration: &configuration::Configuration, id: &str, request_body: std::collections::HashMap<String, String>, delimiter: Option<&str>) -> Result<std::collections::HashMap<String, String>, Error<UpdateTableSchemaMetadataError>> {
2693    // add a prefix to parameters to efficiently prevent name collisions
2694    let p_id = id;
2695    let p_request_body = request_body;
2696    let p_delimiter = delimiter;
2697
2698    let uri_str = format!("{}/v1/table/{id}/schema_metadata/update", configuration.base_path, id=crate::apis::urlencode(p_id));
2699    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2700
2701    if let Some(ref param_value) = p_delimiter {
2702        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2703    }
2704    if let Some(ref user_agent) = configuration.user_agent {
2705        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2706    }
2707    if let Some(ref token) = configuration.oauth_access_token {
2708        req_builder = req_builder.bearer_auth(token.to_owned());
2709    };
2710    if let Some(ref apikey) = configuration.api_key {
2711        let key = apikey.key.clone();
2712        let value = match apikey.prefix {
2713            Some(ref prefix) => format!("{} {}", prefix, key),
2714            None => key,
2715        };
2716        req_builder = req_builder.header("x-api-key", value);
2717    };
2718    if let Some(ref token) = configuration.bearer_access_token {
2719        req_builder = req_builder.bearer_auth(token.to_owned());
2720    };
2721    req_builder = req_builder.json(&p_request_body);
2722
2723    let req = req_builder.build()?;
2724    let resp = configuration.client.execute(req).await?;
2725
2726    let status = resp.status();
2727    let content_type = resp
2728        .headers()
2729        .get("content-type")
2730        .and_then(|v| v.to_str().ok())
2731        .unwrap_or("application/octet-stream");
2732    let content_type = super::ContentType::from(content_type);
2733
2734    if !status.is_client_error() && !status.is_server_error() {
2735        let content = resp.text().await?;
2736        match content_type {
2737            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2738            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;`"))),
2739            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;`")))),
2740        }
2741    } else {
2742        let content = resp.text().await?;
2743        let entity: Option<UpdateTableSchemaMetadataError> = serde_json::from_str(&content).ok();
2744        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2745    }
2746}
2747
2748/// Update an existing tag for table `id` to point to a different version. 
2749pub async fn update_table_tag(configuration: &configuration::Configuration, id: &str, update_table_tag_request: models::UpdateTableTagRequest, delimiter: Option<&str>) -> Result<models::UpdateTableTagResponse, Error<UpdateTableTagError>> {
2750    // add a prefix to parameters to efficiently prevent name collisions
2751    let p_id = id;
2752    let p_update_table_tag_request = update_table_tag_request;
2753    let p_delimiter = delimiter;
2754
2755    let uri_str = format!("{}/v1/table/{id}/tags/update", configuration.base_path, id=crate::apis::urlencode(p_id));
2756    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2757
2758    if let Some(ref param_value) = p_delimiter {
2759        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2760    }
2761    if let Some(ref user_agent) = configuration.user_agent {
2762        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2763    }
2764    if let Some(ref token) = configuration.oauth_access_token {
2765        req_builder = req_builder.bearer_auth(token.to_owned());
2766    };
2767    if let Some(ref apikey) = configuration.api_key {
2768        let key = apikey.key.clone();
2769        let value = match apikey.prefix {
2770            Some(ref prefix) => format!("{} {}", prefix, key),
2771            None => key,
2772        };
2773        req_builder = req_builder.header("x-api-key", value);
2774    };
2775    if let Some(ref token) = configuration.bearer_access_token {
2776        req_builder = req_builder.bearer_auth(token.to_owned());
2777    };
2778    req_builder = req_builder.json(&p_update_table_tag_request);
2779
2780    let req = req_builder.build()?;
2781    let resp = configuration.client.execute(req).await?;
2782
2783    let status = resp.status();
2784    let content_type = resp
2785        .headers()
2786        .get("content-type")
2787        .and_then(|v| v.to_str().ok())
2788        .unwrap_or("application/octet-stream");
2789    let content_type = super::ContentType::from(content_type);
2790
2791    if !status.is_client_error() && !status.is_server_error() {
2792        let content = resp.text().await?;
2793        match content_type {
2794            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2795            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTableTagResponse`"))),
2796            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`")))),
2797        }
2798    } else {
2799        let content = resp.text().await?;
2800        let entity: Option<UpdateTableTagError> = serde_json::from_str(&content).ok();
2801        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2802    }
2803}
2804
lance_namespace_reqwest_client/apis/table_api.rs

lance_namespace_reqwest_client/apis/
table_api.rs
