lance_namespace_reqwest_client/apis/
data_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_backfill_columns`]
32#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum AlterTableBackfillColumnsError {
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 [`analyze_table_query_plan`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum AnalyzeTableQueryPlanError {
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 [`count_table_rows`]
58#[derive(Debug, Clone, Serialize, Deserialize)]
59#[serde(untagged)]
60pub enum CountTableRowsError {
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 [`create_materialized_view`]
71#[derive(Debug, Clone, Serialize, Deserialize)]
72#[serde(untagged)]
73pub enum CreateMaterializedViewError {
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 [`create_table`]
85#[derive(Debug, Clone, Serialize, Deserialize)]
86#[serde(untagged)]
87pub enum CreateTableError {
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 [`delete_from_table`]
99#[derive(Debug, Clone, Serialize, Deserialize)]
100#[serde(untagged)]
101pub enum DeleteFromTableError {
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 [`explain_table_query_plan`]
112#[derive(Debug, Clone, Serialize, Deserialize)]
113#[serde(untagged)]
114pub enum ExplainTableQueryPlanError {
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 [`insert_into_table`]
125#[derive(Debug, Clone, Serialize, Deserialize)]
126#[serde(untagged)]
127pub enum InsertIntoTableError {
128    Status400(models::ErrorResponse),
129    Status401(models::ErrorResponse),
130    Status403(models::ErrorResponse),
131    Status404(models::ErrorResponse),
132    Status503(models::ErrorResponse),
133    Status5XX(models::ErrorResponse),
134    UnknownValue(serde_json::Value),
135}
136
137/// struct for typed errors of method [`merge_insert_into_table`]
138#[derive(Debug, Clone, Serialize, Deserialize)]
139#[serde(untagged)]
140pub enum MergeInsertIntoTableError {
141    Status400(models::ErrorResponse),
142    Status401(models::ErrorResponse),
143    Status403(models::ErrorResponse),
144    Status404(models::ErrorResponse),
145    Status503(models::ErrorResponse),
146    Status5XX(models::ErrorResponse),
147    UnknownValue(serde_json::Value),
148}
149
150/// struct for typed errors of method [`query_table`]
151#[derive(Debug, Clone, Serialize, Deserialize)]
152#[serde(untagged)]
153pub enum QueryTableError {
154    Status400(models::ErrorResponse),
155    Status401(models::ErrorResponse),
156    Status403(models::ErrorResponse),
157    Status404(models::ErrorResponse),
158    Status503(models::ErrorResponse),
159    Status5XX(models::ErrorResponse),
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`refresh_materialized_view`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum RefreshMaterializedViewError {
167    Status400(models::ErrorResponse),
168    Status401(models::ErrorResponse),
169    Status403(models::ErrorResponse),
170    Status404(models::ErrorResponse),
171    Status503(models::ErrorResponse),
172    Status5XX(models::ErrorResponse),
173    UnknownValue(serde_json::Value),
174}
175
176/// struct for typed errors of method [`update_table`]
177#[derive(Debug, Clone, Serialize, Deserialize)]
178#[serde(untagged)]
179pub enum UpdateTableError {
180    Status400(models::ErrorResponse),
181    Status401(models::ErrorResponse),
182    Status403(models::ErrorResponse),
183    Status404(models::ErrorResponse),
184    Status503(models::ErrorResponse),
185    Status5XX(models::ErrorResponse),
186    UnknownValue(serde_json::Value),
187}
188
189
190/// Add new columns to table `id` using SQL expressions or default values. 
191pub 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>> {
192    // add a prefix to parameters to efficiently prevent name collisions
193    let p_id = id;
194    let p_alter_table_add_columns_request = alter_table_add_columns_request;
195    let p_delimiter = delimiter;
196
197    let uri_str = format!("{}/v1/table/{id}/add_columns", configuration.base_path, id=crate::apis::urlencode(p_id));
198    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
199
200    if let Some(ref param_value) = p_delimiter {
201        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
202    }
203    if let Some(ref user_agent) = configuration.user_agent {
204        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
205    }
206    if let Some(ref token) = configuration.oauth_access_token {
207        req_builder = req_builder.bearer_auth(token.to_owned());
208    };
209    if let Some(ref apikey) = configuration.api_key {
210        let key = apikey.key.clone();
211        let value = match apikey.prefix {
212            Some(ref prefix) => format!("{} {}", prefix, key),
213            None => key,
214        };
215        req_builder = req_builder.header("x-api-key", value);
216    };
217    if let Some(ref token) = configuration.bearer_access_token {
218        req_builder = req_builder.bearer_auth(token.to_owned());
219    };
220    req_builder = req_builder.json(&p_alter_table_add_columns_request);
221
222    let req = req_builder.build()?;
223    let resp = configuration.client.execute(req).await?;
224
225    let status = resp.status();
226    let content_type = resp
227        .headers()
228        .get("content-type")
229        .and_then(|v| v.to_str().ok())
230        .unwrap_or("application/octet-stream");
231    let content_type = super::ContentType::from(content_type);
232
233    if !status.is_client_error() && !status.is_server_error() {
234        let content = resp.text().await?;
235        match content_type {
236            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
237            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AlterTableAddColumnsResponse`"))),
238            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`")))),
239        }
240    } else {
241        let content = resp.text().await?;
242        let entity: Option<AlterTableAddColumnsError> = serde_json::from_str(&content).ok();
243        Err(Error::ResponseError(ResponseContent { status, content, entity }))
244    }
245}
246
247/// Trigger an asynchronous backfill job for a computed column on table `id`. The column must be a virtual (UDF-backed) column. Returns a job ID for tracking. 
248pub async fn alter_table_backfill_columns(configuration: &configuration::Configuration, id: &str, alter_table_backfill_columns_request: models::AlterTableBackfillColumnsRequest, delimiter: Option<&str>) -> Result<models::AlterTableBackfillColumnsResponse, Error<AlterTableBackfillColumnsError>> {
249    // add a prefix to parameters to efficiently prevent name collisions
250    let p_id = id;
251    let p_alter_table_backfill_columns_request = alter_table_backfill_columns_request;
252    let p_delimiter = delimiter;
253
254    let uri_str = format!("{}/v1/table/{id}/backfill_column", configuration.base_path, id=crate::apis::urlencode(p_id));
255    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
256
257    if let Some(ref param_value) = p_delimiter {
258        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
259    }
260    if let Some(ref user_agent) = configuration.user_agent {
261        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
262    }
263    if let Some(ref token) = configuration.oauth_access_token {
264        req_builder = req_builder.bearer_auth(token.to_owned());
265    };
266    if let Some(ref apikey) = configuration.api_key {
267        let key = apikey.key.clone();
268        let value = match apikey.prefix {
269            Some(ref prefix) => format!("{} {}", prefix, key),
270            None => key,
271        };
272        req_builder = req_builder.header("x-api-key", value);
273    };
274    if let Some(ref token) = configuration.bearer_access_token {
275        req_builder = req_builder.bearer_auth(token.to_owned());
276    };
277    req_builder = req_builder.json(&p_alter_table_backfill_columns_request);
278
279    let req = req_builder.build()?;
280    let resp = configuration.client.execute(req).await?;
281
282    let status = resp.status();
283    let content_type = resp
284        .headers()
285        .get("content-type")
286        .and_then(|v| v.to_str().ok())
287        .unwrap_or("application/octet-stream");
288    let content_type = super::ContentType::from(content_type);
289
290    if !status.is_client_error() && !status.is_server_error() {
291        let content = resp.text().await?;
292        match content_type {
293            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
294            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AlterTableBackfillColumnsResponse`"))),
295            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AlterTableBackfillColumnsResponse`")))),
296        }
297    } else {
298        let content = resp.text().await?;
299        let entity: Option<AlterTableBackfillColumnsError> = serde_json::from_str(&content).ok();
300        Err(Error::ResponseError(ResponseContent { status, content, entity }))
301    }
302}
303
304/// 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. 
305pub 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>> {
306    // add a prefix to parameters to efficiently prevent name collisions
307    let p_id = id;
308    let p_analyze_table_query_plan_request = analyze_table_query_plan_request;
309    let p_delimiter = delimiter;
310
311    let uri_str = format!("{}/v1/table/{id}/analyze_plan", configuration.base_path, id=crate::apis::urlencode(p_id));
312    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
313
314    if let Some(ref param_value) = p_delimiter {
315        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
316    }
317    if let Some(ref user_agent) = configuration.user_agent {
318        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
319    }
320    if let Some(ref token) = configuration.oauth_access_token {
321        req_builder = req_builder.bearer_auth(token.to_owned());
322    };
323    if let Some(ref apikey) = configuration.api_key {
324        let key = apikey.key.clone();
325        let value = match apikey.prefix {
326            Some(ref prefix) => format!("{} {}", prefix, key),
327            None => key,
328        };
329        req_builder = req_builder.header("x-api-key", value);
330    };
331    if let Some(ref token) = configuration.bearer_access_token {
332        req_builder = req_builder.bearer_auth(token.to_owned());
333    };
334    req_builder = req_builder.json(&p_analyze_table_query_plan_request);
335
336    let req = req_builder.build()?;
337    let resp = configuration.client.execute(req).await?;
338
339    let status = resp.status();
340    let content_type = resp
341        .headers()
342        .get("content-type")
343        .and_then(|v| v.to_str().ok())
344        .unwrap_or("application/octet-stream");
345    let content_type = super::ContentType::from(content_type);
346
347    if !status.is_client_error() && !status.is_server_error() {
348        let content = resp.text().await?;
349        match content_type {
350            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
351            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `String`"))),
352            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`")))),
353        }
354    } else {
355        let content = resp.text().await?;
356        let entity: Option<AnalyzeTableQueryPlanError> = serde_json::from_str(&content).ok();
357        Err(Error::ResponseError(ResponseContent { status, content, entity }))
358    }
359}
360
361/// 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. 
362pub async fn count_table_rows(configuration: &configuration::Configuration, id: &str, count_table_rows_request: models::CountTableRowsRequest, delimiter: Option<&str>) -> Result<i64, Error<CountTableRowsError>> {
363    // add a prefix to parameters to efficiently prevent name collisions
364    let p_id = id;
365    let p_count_table_rows_request = count_table_rows_request;
366    let p_delimiter = delimiter;
367
368    let uri_str = format!("{}/v1/table/{id}/count_rows", configuration.base_path, id=crate::apis::urlencode(p_id));
369    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
370
371    if let Some(ref param_value) = p_delimiter {
372        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
373    }
374    if let Some(ref user_agent) = configuration.user_agent {
375        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
376    }
377    if let Some(ref token) = configuration.oauth_access_token {
378        req_builder = req_builder.bearer_auth(token.to_owned());
379    };
380    if let Some(ref apikey) = configuration.api_key {
381        let key = apikey.key.clone();
382        let value = match apikey.prefix {
383            Some(ref prefix) => format!("{} {}", prefix, key),
384            None => key,
385        };
386        req_builder = req_builder.header("x-api-key", value);
387    };
388    if let Some(ref token) = configuration.bearer_access_token {
389        req_builder = req_builder.bearer_auth(token.to_owned());
390    };
391    req_builder = req_builder.json(&p_count_table_rows_request);
392
393    let req = req_builder.build()?;
394    let resp = configuration.client.execute(req).await?;
395
396    let status = resp.status();
397    let content_type = resp
398        .headers()
399        .get("content-type")
400        .and_then(|v| v.to_str().ok())
401        .unwrap_or("application/octet-stream");
402    let content_type = super::ContentType::from(content_type);
403
404    if !status.is_client_error() && !status.is_server_error() {
405        let content = resp.text().await?;
406        match content_type {
407            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
408            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `i64`"))),
409            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`")))),
410        }
411    } else {
412        let content = resp.text().await?;
413        let entity: Option<CountTableRowsError> = serde_json::from_str(&content).ok();
414        Err(Error::ResponseError(ResponseContent { status, content, entity }))
415    }
416}
417
418/// Create a materialized view at identifier `id`. The view may be query-backed, UDTF-backed, or chunker-backed, controlled by the `kind` discriminator. 
419pub async fn create_materialized_view(configuration: &configuration::Configuration, id: &str, create_materialized_view_request: models::CreateMaterializedViewRequest, delimiter: Option<&str>) -> Result<models::CreateMaterializedViewResponse, Error<CreateMaterializedViewError>> {
420    // add a prefix to parameters to efficiently prevent name collisions
421    let p_id = id;
422    let p_create_materialized_view_request = create_materialized_view_request;
423    let p_delimiter = delimiter;
424
425    let uri_str = format!("{}/v1/materialized_view/{id}/create", configuration.base_path, id=crate::apis::urlencode(p_id));
426    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
427
428    if let Some(ref param_value) = p_delimiter {
429        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
430    }
431    if let Some(ref user_agent) = configuration.user_agent {
432        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
433    }
434    if let Some(ref token) = configuration.oauth_access_token {
435        req_builder = req_builder.bearer_auth(token.to_owned());
436    };
437    if let Some(ref apikey) = configuration.api_key {
438        let key = apikey.key.clone();
439        let value = match apikey.prefix {
440            Some(ref prefix) => format!("{} {}", prefix, key),
441            None => key,
442        };
443        req_builder = req_builder.header("x-api-key", value);
444    };
445    if let Some(ref token) = configuration.bearer_access_token {
446        req_builder = req_builder.bearer_auth(token.to_owned());
447    };
448    req_builder = req_builder.json(&p_create_materialized_view_request);
449
450    let req = req_builder.build()?;
451    let resp = configuration.client.execute(req).await?;
452
453    let status = resp.status();
454    let content_type = resp
455        .headers()
456        .get("content-type")
457        .and_then(|v| v.to_str().ok())
458        .unwrap_or("application/octet-stream");
459    let content_type = super::ContentType::from(content_type);
460
461    if !status.is_client_error() && !status.is_server_error() {
462        let content = resp.text().await?;
463        match content_type {
464            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
465            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateMaterializedViewResponse`"))),
466            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::CreateMaterializedViewResponse`")))),
467        }
468    } else {
469        let content = resp.text().await?;
470        let entity: Option<CreateMaterializedViewError> = serde_json::from_str(&content).ok();
471        Err(Error::ResponseError(ResponseContent { status, content, entity }))
472    }
473}
474
475/// Create table `id` in the namespace with the given data in Arrow IPC stream.  The schema of the Arrow IPC stream is used as the table schema. If the stream is empty, the API creates a new empty table.  REST NAMESPACE ONLY REST namespace uses Arrow IPC stream as the request body. It passes in the `CreateTableRequest` information in the following way: - `id`: pass through path parameter of the same name - `mode`: pass through query parameter of the same name - `properties`: serialize as a single JSON-encoded query parameter such as   `properties={\"user\":\"alice\",\"team\":\"eng\"}`; these are business logic properties   managed by the namespace implementation outside Lance context - `storage_options`: serialize as a single JSON-encoded query parameter such as   `storage_options={\"aws_region\":\"us-east-1\",\"timeout\":\"30s\"}`; these configure   write-time overrides for data and metadata written during table creation 
476pub async fn create_table(configuration: &configuration::Configuration, id: &str, body: Vec<u8>, delimiter: Option<&str>, mode: Option<&str>, properties: Option<&str>, storage_options: Option<&str>) -> Result<models::CreateTableResponse, Error<CreateTableError>> {
477    // add a prefix to parameters to efficiently prevent name collisions
478    let p_id = id;
479    let p_body = body;
480    let p_delimiter = delimiter;
481    let p_mode = mode;
482    let p_properties = properties;
483    let p_storage_options = storage_options;
484
485    let uri_str = format!("{}/v1/table/{id}/create", configuration.base_path, id=crate::apis::urlencode(p_id));
486    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
487
488    if let Some(ref param_value) = p_delimiter {
489        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
490    }
491    if let Some(ref param_value) = p_mode {
492        req_builder = req_builder.query(&[("mode", &param_value.to_string())]);
493    }
494    if let Some(ref param_value) = p_properties {
495        req_builder = req_builder.query(&[("properties", &param_value.to_string())]);
496    }
497    if let Some(ref param_value) = p_storage_options {
498        req_builder = req_builder.query(&[("storage_options", &param_value.to_string())]);
499    }
500    if let Some(ref user_agent) = configuration.user_agent {
501        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
502    }
503    if let Some(ref token) = configuration.oauth_access_token {
504        req_builder = req_builder.bearer_auth(token.to_owned());
505    };
506    if let Some(ref apikey) = configuration.api_key {
507        let key = apikey.key.clone();
508        let value = match apikey.prefix {
509            Some(ref prefix) => format!("{} {}", prefix, key),
510            None => key,
511        };
512        req_builder = req_builder.header("x-api-key", value);
513    };
514    if let Some(ref token) = configuration.bearer_access_token {
515        req_builder = req_builder.bearer_auth(token.to_owned());
516    };
517    req_builder = req_builder.body(p_body);
518
519    let req = req_builder.build()?;
520    let resp = configuration.client.execute(req).await?;
521
522    let status = resp.status();
523    let content_type = resp
524        .headers()
525        .get("content-type")
526        .and_then(|v| v.to_str().ok())
527        .unwrap_or("application/octet-stream");
528    let content_type = super::ContentType::from(content_type);
529
530    if !status.is_client_error() && !status.is_server_error() {
531        let content = resp.text().await?;
532        match content_type {
533            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
534            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableResponse`"))),
535            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`")))),
536        }
537    } else {
538        let content = resp.text().await?;
539        let entity: Option<CreateTableError> = serde_json::from_str(&content).ok();
540        Err(Error::ResponseError(ResponseContent { status, content, entity }))
541    }
542}
543
544/// Delete rows from table `id`. 
545pub async fn delete_from_table(configuration: &configuration::Configuration, id: &str, delete_from_table_request: models::DeleteFromTableRequest, delimiter: Option<&str>) -> Result<models::DeleteFromTableResponse, Error<DeleteFromTableError>> {
546    // add a prefix to parameters to efficiently prevent name collisions
547    let p_id = id;
548    let p_delete_from_table_request = delete_from_table_request;
549    let p_delimiter = delimiter;
550
551    let uri_str = format!("{}/v1/table/{id}/delete", configuration.base_path, id=crate::apis::urlencode(p_id));
552    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
553
554    if let Some(ref param_value) = p_delimiter {
555        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
556    }
557    if let Some(ref user_agent) = configuration.user_agent {
558        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
559    }
560    if let Some(ref token) = configuration.oauth_access_token {
561        req_builder = req_builder.bearer_auth(token.to_owned());
562    };
563    if let Some(ref apikey) = configuration.api_key {
564        let key = apikey.key.clone();
565        let value = match apikey.prefix {
566            Some(ref prefix) => format!("{} {}", prefix, key),
567            None => key,
568        };
569        req_builder = req_builder.header("x-api-key", value);
570    };
571    if let Some(ref token) = configuration.bearer_access_token {
572        req_builder = req_builder.bearer_auth(token.to_owned());
573    };
574    req_builder = req_builder.json(&p_delete_from_table_request);
575
576    let req = req_builder.build()?;
577    let resp = configuration.client.execute(req).await?;
578
579    let status = resp.status();
580    let content_type = resp
581        .headers()
582        .get("content-type")
583        .and_then(|v| v.to_str().ok())
584        .unwrap_or("application/octet-stream");
585    let content_type = super::ContentType::from(content_type);
586
587    if !status.is_client_error() && !status.is_server_error() {
588        let content = resp.text().await?;
589        match content_type {
590            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
591            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteFromTableResponse`"))),
592            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`")))),
593        }
594    } else {
595        let content = resp.text().await?;
596        let entity: Option<DeleteFromTableError> = serde_json::from_str(&content).ok();
597        Err(Error::ResponseError(ResponseContent { status, content, entity }))
598    }
599}
600
601/// 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. 
602pub 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>> {
603    // add a prefix to parameters to efficiently prevent name collisions
604    let p_id = id;
605    let p_explain_table_query_plan_request = explain_table_query_plan_request;
606    let p_delimiter = delimiter;
607
608    let uri_str = format!("{}/v1/table/{id}/explain_plan", configuration.base_path, id=crate::apis::urlencode(p_id));
609    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
610
611    if let Some(ref param_value) = p_delimiter {
612        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
613    }
614    if let Some(ref user_agent) = configuration.user_agent {
615        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
616    }
617    if let Some(ref token) = configuration.oauth_access_token {
618        req_builder = req_builder.bearer_auth(token.to_owned());
619    };
620    if let Some(ref apikey) = configuration.api_key {
621        let key = apikey.key.clone();
622        let value = match apikey.prefix {
623            Some(ref prefix) => format!("{} {}", prefix, key),
624            None => key,
625        };
626        req_builder = req_builder.header("x-api-key", value);
627    };
628    if let Some(ref token) = configuration.bearer_access_token {
629        req_builder = req_builder.bearer_auth(token.to_owned());
630    };
631    req_builder = req_builder.json(&p_explain_table_query_plan_request);
632
633    let req = req_builder.build()?;
634    let resp = configuration.client.execute(req).await?;
635
636    let status = resp.status();
637    let content_type = resp
638        .headers()
639        .get("content-type")
640        .and_then(|v| v.to_str().ok())
641        .unwrap_or("application/octet-stream");
642    let content_type = super::ContentType::from(content_type);
643
644    if !status.is_client_error() && !status.is_server_error() {
645        let content = resp.text().await?;
646        match content_type {
647            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
648            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `String`"))),
649            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`")))),
650        }
651    } else {
652        let content = resp.text().await?;
653        let entity: Option<ExplainTableQueryPlanError> = serde_json::from_str(&content).ok();
654        Err(Error::ResponseError(ResponseContent { status, content, entity }))
655    }
656}
657
658/// Insert new records into table `id`.  For tables that have been declared but not yet created on storage (is_only_declared=true), this operation will create the table with the provided data.  REST NAMESPACE ONLY REST namespace uses Arrow IPC stream as the request body. It passes in the `InsertIntoTableRequest` information in the following way: - `id`: pass through path parameter of the same name - `mode`: pass through query parameter of the same name 
659pub async fn insert_into_table(configuration: &configuration::Configuration, id: &str, body: Vec<u8>, delimiter: Option<&str>, branch: Option<&str>, mode: Option<&str>) -> Result<models::InsertIntoTableResponse, Error<InsertIntoTableError>> {
660    // add a prefix to parameters to efficiently prevent name collisions
661    let p_id = id;
662    let p_body = body;
663    let p_delimiter = delimiter;
664    let p_branch = branch;
665    let p_mode = mode;
666
667    let uri_str = format!("{}/v1/table/{id}/insert", configuration.base_path, id=crate::apis::urlencode(p_id));
668    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
669
670    if let Some(ref param_value) = p_delimiter {
671        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
672    }
673    if let Some(ref param_value) = p_branch {
674        req_builder = req_builder.query(&[("branch", &param_value.to_string())]);
675    }
676    if let Some(ref param_value) = p_mode {
677        req_builder = req_builder.query(&[("mode", &param_value.to_string())]);
678    }
679    if let Some(ref user_agent) = configuration.user_agent {
680        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
681    }
682    if let Some(ref token) = configuration.oauth_access_token {
683        req_builder = req_builder.bearer_auth(token.to_owned());
684    };
685    if let Some(ref apikey) = configuration.api_key {
686        let key = apikey.key.clone();
687        let value = match apikey.prefix {
688            Some(ref prefix) => format!("{} {}", prefix, key),
689            None => key,
690        };
691        req_builder = req_builder.header("x-api-key", value);
692    };
693    if let Some(ref token) = configuration.bearer_access_token {
694        req_builder = req_builder.bearer_auth(token.to_owned());
695    };
696    req_builder = req_builder.body(p_body);
697
698    let req = req_builder.build()?;
699    let resp = configuration.client.execute(req).await?;
700
701    let status = resp.status();
702    let content_type = resp
703        .headers()
704        .get("content-type")
705        .and_then(|v| v.to_str().ok())
706        .unwrap_or("application/octet-stream");
707    let content_type = super::ContentType::from(content_type);
708
709    if !status.is_client_error() && !status.is_server_error() {
710        let content = resp.text().await?;
711        match content_type {
712            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
713            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::InsertIntoTableResponse`"))),
714            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`")))),
715        }
716    } else {
717        let content = resp.text().await?;
718        let entity: Option<InsertIntoTableError> = serde_json::from_str(&content).ok();
719        Err(Error::ResponseError(ResponseContent { status, content, entity }))
720    }
721}
722
723/// Performs a merge insert (upsert) operation on table `id`. This operation updates existing rows based on a matching column and inserts new rows that don't match. It returns the number of rows inserted and updated.  For tables that have been declared but not yet created on storage (is_only_declared=true), this operation will create the table with the provided data (since there are no existing rows to merge with).  REST NAMESPACE ONLY REST namespace uses Arrow IPC stream as the request body. It passes in the `MergeInsertIntoTableRequest` information in the following way: - `id`: pass through path parameter of the same name - `on`: pass through query parameter of the same name - `when_matched_update_all`: pass through query parameter of the same name - `when_matched_update_all_filt`: pass through query parameter of the same name - `when_not_matched_insert_all`: pass through query parameter of the same name - `when_not_matched_by_source_delete`: pass through query parameter of the same name - `when_not_matched_by_source_delete_filt`: pass through query parameter of the same name 
724pub async fn merge_insert_into_table(configuration: &configuration::Configuration, id: &str, on: &str, body: Vec<u8>, delimiter: Option<&str>, branch: Option<&str>, when_matched_update_all: Option<bool>, when_matched_update_all_filt: Option<&str>, when_not_matched_insert_all: Option<bool>, when_not_matched_by_source_delete: Option<bool>, when_not_matched_by_source_delete_filt: Option<&str>, timeout: Option<&str>, use_index: Option<bool>) -> Result<models::MergeInsertIntoTableResponse, Error<MergeInsertIntoTableError>> {
725    // add a prefix to parameters to efficiently prevent name collisions
726    let p_id = id;
727    let p_on = on;
728    let p_body = body;
729    let p_delimiter = delimiter;
730    let p_branch = branch;
731    let p_when_matched_update_all = when_matched_update_all;
732    let p_when_matched_update_all_filt = when_matched_update_all_filt;
733    let p_when_not_matched_insert_all = when_not_matched_insert_all;
734    let p_when_not_matched_by_source_delete = when_not_matched_by_source_delete;
735    let p_when_not_matched_by_source_delete_filt = when_not_matched_by_source_delete_filt;
736    let p_timeout = timeout;
737    let p_use_index = use_index;
738
739    let uri_str = format!("{}/v1/table/{id}/merge_insert", 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 param_value) = p_branch {
746        req_builder = req_builder.query(&[("branch", &param_value.to_string())]);
747    }
748    req_builder = req_builder.query(&[("on", &p_on.to_string())]);
749    if let Some(ref param_value) = p_when_matched_update_all {
750        req_builder = req_builder.query(&[("when_matched_update_all", &param_value.to_string())]);
751    }
752    if let Some(ref param_value) = p_when_matched_update_all_filt {
753        req_builder = req_builder.query(&[("when_matched_update_all_filt", &param_value.to_string())]);
754    }
755    if let Some(ref param_value) = p_when_not_matched_insert_all {
756        req_builder = req_builder.query(&[("when_not_matched_insert_all", &param_value.to_string())]);
757    }
758    if let Some(ref param_value) = p_when_not_matched_by_source_delete {
759        req_builder = req_builder.query(&[("when_not_matched_by_source_delete", &param_value.to_string())]);
760    }
761    if let Some(ref param_value) = p_when_not_matched_by_source_delete_filt {
762        req_builder = req_builder.query(&[("when_not_matched_by_source_delete_filt", &param_value.to_string())]);
763    }
764    if let Some(ref param_value) = p_timeout {
765        req_builder = req_builder.query(&[("timeout", &param_value.to_string())]);
766    }
767    if let Some(ref param_value) = p_use_index {
768        req_builder = req_builder.query(&[("use_index", &param_value.to_string())]);
769    }
770    if let Some(ref user_agent) = configuration.user_agent {
771        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
772    }
773    if let Some(ref token) = configuration.oauth_access_token {
774        req_builder = req_builder.bearer_auth(token.to_owned());
775    };
776    if let Some(ref apikey) = configuration.api_key {
777        let key = apikey.key.clone();
778        let value = match apikey.prefix {
779            Some(ref prefix) => format!("{} {}", prefix, key),
780            None => key,
781        };
782        req_builder = req_builder.header("x-api-key", value);
783    };
784    if let Some(ref token) = configuration.bearer_access_token {
785        req_builder = req_builder.bearer_auth(token.to_owned());
786    };
787    req_builder = req_builder.body(p_body);
788
789    let req = req_builder.build()?;
790    let resp = configuration.client.execute(req).await?;
791
792    let status = resp.status();
793    let content_type = resp
794        .headers()
795        .get("content-type")
796        .and_then(|v| v.to_str().ok())
797        .unwrap_or("application/octet-stream");
798    let content_type = super::ContentType::from(content_type);
799
800    if !status.is_client_error() && !status.is_server_error() {
801        let content = resp.text().await?;
802        match content_type {
803            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
804            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::MergeInsertIntoTableResponse`"))),
805            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`")))),
806        }
807    } else {
808        let content = resp.text().await?;
809        let entity: Option<MergeInsertIntoTableError> = serde_json::from_str(&content).ok();
810        Err(Error::ResponseError(ResponseContent { status, content, entity }))
811    }
812}
813
814/// 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. 
815pub async fn query_table(configuration: &configuration::Configuration, id: &str, query_table_request: models::QueryTableRequest, delimiter: Option<&str>) -> Result<reqwest::Response, Error<QueryTableError>> {
816    // add a prefix to parameters to efficiently prevent name collisions
817    let p_id = id;
818    let p_query_table_request = query_table_request;
819    let p_delimiter = delimiter;
820
821    let uri_str = format!("{}/v1/table/{id}/query", configuration.base_path, id=crate::apis::urlencode(p_id));
822    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
823
824    if let Some(ref param_value) = p_delimiter {
825        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
826    }
827    if let Some(ref user_agent) = configuration.user_agent {
828        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
829    }
830    if let Some(ref token) = configuration.oauth_access_token {
831        req_builder = req_builder.bearer_auth(token.to_owned());
832    };
833    if let Some(ref apikey) = configuration.api_key {
834        let key = apikey.key.clone();
835        let value = match apikey.prefix {
836            Some(ref prefix) => format!("{} {}", prefix, key),
837            None => key,
838        };
839        req_builder = req_builder.header("x-api-key", value);
840    };
841    if let Some(ref token) = configuration.bearer_access_token {
842        req_builder = req_builder.bearer_auth(token.to_owned());
843    };
844    req_builder = req_builder.json(&p_query_table_request);
845
846    let req = req_builder.build()?;
847    let resp = configuration.client.execute(req).await?;
848
849    let status = resp.status();
850
851    if !status.is_client_error() && !status.is_server_error() {
852        Ok(resp)
853    } else {
854        let content = resp.text().await?;
855        let entity: Option<QueryTableError> = serde_json::from_str(&content).ok();
856        Err(Error::ResponseError(ResponseContent { status, content, entity }))
857    }
858}
859
860/// Trigger an asynchronous refresh job for materialized view `id`. Returns a job ID for tracking. 
861pub async fn refresh_materialized_view(configuration: &configuration::Configuration, id: &str, delimiter: Option<&str>, refresh_materialized_view_request: Option<models::RefreshMaterializedViewRequest>) -> Result<models::RefreshMaterializedViewResponse, Error<RefreshMaterializedViewError>> {
862    // add a prefix to parameters to efficiently prevent name collisions
863    let p_id = id;
864    let p_delimiter = delimiter;
865    let p_refresh_materialized_view_request = refresh_materialized_view_request;
866
867    let uri_str = format!("{}/v1/materialized_view/{id}/refresh", configuration.base_path, id=crate::apis::urlencode(p_id));
868    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
869
870    if let Some(ref param_value) = p_delimiter {
871        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
872    }
873    if let Some(ref user_agent) = configuration.user_agent {
874        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
875    }
876    if let Some(ref token) = configuration.oauth_access_token {
877        req_builder = req_builder.bearer_auth(token.to_owned());
878    };
879    if let Some(ref apikey) = configuration.api_key {
880        let key = apikey.key.clone();
881        let value = match apikey.prefix {
882            Some(ref prefix) => format!("{} {}", prefix, key),
883            None => key,
884        };
885        req_builder = req_builder.header("x-api-key", value);
886    };
887    if let Some(ref token) = configuration.bearer_access_token {
888        req_builder = req_builder.bearer_auth(token.to_owned());
889    };
890    req_builder = req_builder.json(&p_refresh_materialized_view_request);
891
892    let req = req_builder.build()?;
893    let resp = configuration.client.execute(req).await?;
894
895    let status = resp.status();
896    let content_type = resp
897        .headers()
898        .get("content-type")
899        .and_then(|v| v.to_str().ok())
900        .unwrap_or("application/octet-stream");
901    let content_type = super::ContentType::from(content_type);
902
903    if !status.is_client_error() && !status.is_server_error() {
904        let content = resp.text().await?;
905        match content_type {
906            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
907            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RefreshMaterializedViewResponse`"))),
908            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::RefreshMaterializedViewResponse`")))),
909        }
910    } else {
911        let content = resp.text().await?;
912        let entity: Option<RefreshMaterializedViewError> = serde_json::from_str(&content).ok();
913        Err(Error::ResponseError(ResponseContent { status, content, entity }))
914    }
915}
916
917/// Update existing rows in table `id`. 
918pub async fn update_table(configuration: &configuration::Configuration, id: &str, update_table_request: models::UpdateTableRequest, delimiter: Option<&str>) -> Result<models::UpdateTableResponse, Error<UpdateTableError>> {
919    // add a prefix to parameters to efficiently prevent name collisions
920    let p_id = id;
921    let p_update_table_request = update_table_request;
922    let p_delimiter = delimiter;
923
924    let uri_str = format!("{}/v1/table/{id}/update", configuration.base_path, id=crate::apis::urlencode(p_id));
925    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
926
927    if let Some(ref param_value) = p_delimiter {
928        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
929    }
930    if let Some(ref user_agent) = configuration.user_agent {
931        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
932    }
933    if let Some(ref token) = configuration.oauth_access_token {
934        req_builder = req_builder.bearer_auth(token.to_owned());
935    };
936    if let Some(ref apikey) = configuration.api_key {
937        let key = apikey.key.clone();
938        let value = match apikey.prefix {
939            Some(ref prefix) => format!("{} {}", prefix, key),
940            None => key,
941        };
942        req_builder = req_builder.header("x-api-key", value);
943    };
944    if let Some(ref token) = configuration.bearer_access_token {
945        req_builder = req_builder.bearer_auth(token.to_owned());
946    };
947    req_builder = req_builder.json(&p_update_table_request);
948
949    let req = req_builder.build()?;
950    let resp = configuration.client.execute(req).await?;
951
952    let status = resp.status();
953    let content_type = resp
954        .headers()
955        .get("content-type")
956        .and_then(|v| v.to_str().ok())
957        .unwrap_or("application/octet-stream");
958    let content_type = super::ContentType::from(content_type);
959
960    if !status.is_client_error() && !status.is_server_error() {
961        let content = resp.text().await?;
962        match content_type {
963            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
964            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTableResponse`"))),
965            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`")))),
966        }
967    } else {
968        let content = resp.text().await?;
969        let entity: Option<UpdateTableError> = serde_json::from_str(&content).ok();
970        Err(Error::ResponseError(ResponseContent { status, content, entity }))
971    }
972}
973
lance_namespace_reqwest_client/apis/data_api.rs

lance_namespace_reqwest_client/apis/
data_api.rs
