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

lance_namespace_reqwest_client/apis/
table_api.rs
