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://lancedb.github.io/lance-namespace/spec/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://lancedb.github.io/lance-namespace/spec/impls/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 [`analyze_table_query_plan`]
32#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum AnalyzeTableQueryPlanError {
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 [`count_table_rows`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum CountTableRowsError {
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 [`create_table`]
58#[derive(Debug, Clone, Serialize, Deserialize)]
59#[serde(untagged)]
60pub enum CreateTableError {
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 [`delete_from_table`]
71#[derive(Debug, Clone, Serialize, Deserialize)]
72#[serde(untagged)]
73pub enum DeleteFromTableError {
74    Status400(models::ErrorResponse),
75    Status401(models::ErrorResponse),
76    Status403(models::ErrorResponse),
77    Status404(models::ErrorResponse),
78    Status503(models::ErrorResponse),
79    Status5XX(models::ErrorResponse),
80    UnknownValue(serde_json::Value),
81}
82
83/// struct for typed errors of method [`explain_table_query_plan`]
84#[derive(Debug, Clone, Serialize, Deserialize)]
85#[serde(untagged)]
86pub enum ExplainTableQueryPlanError {
87    Status400(models::ErrorResponse),
88    Status401(models::ErrorResponse),
89    Status403(models::ErrorResponse),
90    Status404(models::ErrorResponse),
91    Status503(models::ErrorResponse),
92    Status5XX(models::ErrorResponse),
93    UnknownValue(serde_json::Value),
94}
95
96/// struct for typed errors of method [`insert_into_table`]
97#[derive(Debug, Clone, Serialize, Deserialize)]
98#[serde(untagged)]
99pub enum InsertIntoTableError {
100    Status400(models::ErrorResponse),
101    Status401(models::ErrorResponse),
102    Status403(models::ErrorResponse),
103    Status404(models::ErrorResponse),
104    Status503(models::ErrorResponse),
105    Status5XX(models::ErrorResponse),
106    UnknownValue(serde_json::Value),
107}
108
109/// struct for typed errors of method [`merge_insert_into_table`]
110#[derive(Debug, Clone, Serialize, Deserialize)]
111#[serde(untagged)]
112pub enum MergeInsertIntoTableError {
113    Status400(models::ErrorResponse),
114    Status401(models::ErrorResponse),
115    Status403(models::ErrorResponse),
116    Status404(models::ErrorResponse),
117    Status503(models::ErrorResponse),
118    Status5XX(models::ErrorResponse),
119    UnknownValue(serde_json::Value),
120}
121
122/// struct for typed errors of method [`query_table`]
123#[derive(Debug, Clone, Serialize, Deserialize)]
124#[serde(untagged)]
125pub enum QueryTableError {
126    Status400(models::ErrorResponse),
127    Status401(models::ErrorResponse),
128    Status403(models::ErrorResponse),
129    Status404(models::ErrorResponse),
130    Status503(models::ErrorResponse),
131    Status5XX(models::ErrorResponse),
132    UnknownValue(serde_json::Value),
133}
134
135/// struct for typed errors of method [`update_table`]
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum UpdateTableError {
139    Status400(models::ErrorResponse),
140    Status401(models::ErrorResponse),
141    Status403(models::ErrorResponse),
142    Status404(models::ErrorResponse),
143    Status503(models::ErrorResponse),
144    Status5XX(models::ErrorResponse),
145    UnknownValue(serde_json::Value),
146}
147
148
149/// Add new columns to table `id` using SQL expressions or default values. 
150pub 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>> {
151    // add a prefix to parameters to efficiently prevent name collisions
152    let p_id = id;
153    let p_alter_table_add_columns_request = alter_table_add_columns_request;
154    let p_delimiter = delimiter;
155
156    let uri_str = format!("{}/v1/table/{id}/add_columns", configuration.base_path, id=crate::apis::urlencode(p_id));
157    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
158
159    if let Some(ref param_value) = p_delimiter {
160        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
161    }
162    if let Some(ref user_agent) = configuration.user_agent {
163        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
164    }
165    req_builder = req_builder.json(&p_alter_table_add_columns_request);
166
167    let req = req_builder.build()?;
168    let resp = configuration.client.execute(req).await?;
169
170    let status = resp.status();
171    let content_type = resp
172        .headers()
173        .get("content-type")
174        .and_then(|v| v.to_str().ok())
175        .unwrap_or("application/octet-stream");
176    let content_type = super::ContentType::from(content_type);
177
178    if !status.is_client_error() && !status.is_server_error() {
179        let content = resp.text().await?;
180        match content_type {
181            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
182            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AlterTableAddColumnsResponse`"))),
183            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`")))),
184        }
185    } else {
186        let content = resp.text().await?;
187        let entity: Option<AlterTableAddColumnsError> = serde_json::from_str(&content).ok();
188        Err(Error::ResponseError(ResponseContent { status, content, entity }))
189    }
190}
191
192/// Analyze the query execution plan for a query against table `id`. Returns detailed statistics and analysis of the query execution plan. 
193pub async fn analyze_table_query_plan(configuration: &configuration::Configuration, id: &str, analyze_table_query_plan_request: models::AnalyzeTableQueryPlanRequest, delimiter: Option<&str>) -> Result<models::AnalyzeTableQueryPlanResponse, Error<AnalyzeTableQueryPlanError>> {
194    // add a prefix to parameters to efficiently prevent name collisions
195    let p_id = id;
196    let p_analyze_table_query_plan_request = analyze_table_query_plan_request;
197    let p_delimiter = delimiter;
198
199    let uri_str = format!("{}/v1/table/{id}/analyze_plan", configuration.base_path, id=crate::apis::urlencode(p_id));
200    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
201
202    if let Some(ref param_value) = p_delimiter {
203        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
204    }
205    if let Some(ref user_agent) = configuration.user_agent {
206        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
207    }
208    req_builder = req_builder.json(&p_analyze_table_query_plan_request);
209
210    let req = req_builder.build()?;
211    let resp = configuration.client.execute(req).await?;
212
213    let status = resp.status();
214    let content_type = resp
215        .headers()
216        .get("content-type")
217        .and_then(|v| v.to_str().ok())
218        .unwrap_or("application/octet-stream");
219    let content_type = super::ContentType::from(content_type);
220
221    if !status.is_client_error() && !status.is_server_error() {
222        let content = resp.text().await?;
223        match content_type {
224            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
225            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AnalyzeTableQueryPlanResponse`"))),
226            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::AnalyzeTableQueryPlanResponse`")))),
227        }
228    } else {
229        let content = resp.text().await?;
230        let entity: Option<AnalyzeTableQueryPlanError> = serde_json::from_str(&content).ok();
231        Err(Error::ResponseError(ResponseContent { status, content, entity }))
232    }
233}
234
235/// Count the number of rows in table `id` 
236pub async fn count_table_rows(configuration: &configuration::Configuration, id: &str, count_table_rows_request: models::CountTableRowsRequest, delimiter: Option<&str>) -> Result<i64, Error<CountTableRowsError>> {
237    // add a prefix to parameters to efficiently prevent name collisions
238    let p_id = id;
239    let p_count_table_rows_request = count_table_rows_request;
240    let p_delimiter = delimiter;
241
242    let uri_str = format!("{}/v1/table/{id}/count_rows", configuration.base_path, id=crate::apis::urlencode(p_id));
243    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
244
245    if let Some(ref param_value) = p_delimiter {
246        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
247    }
248    if let Some(ref user_agent) = configuration.user_agent {
249        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
250    }
251    req_builder = req_builder.json(&p_count_table_rows_request);
252
253    let req = req_builder.build()?;
254    let resp = configuration.client.execute(req).await?;
255
256    let status = resp.status();
257    let content_type = resp
258        .headers()
259        .get("content-type")
260        .and_then(|v| v.to_str().ok())
261        .unwrap_or("application/octet-stream");
262    let content_type = super::ContentType::from(content_type);
263
264    if !status.is_client_error() && !status.is_server_error() {
265        let content = resp.text().await?;
266        match content_type {
267            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
268            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `i64`"))),
269            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`")))),
270        }
271    } else {
272        let content = resp.text().await?;
273        let entity: Option<CountTableRowsError> = serde_json::from_str(&content).ok();
274        Err(Error::ResponseError(ResponseContent { status, content, entity }))
275    }
276}
277
278/// 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 - `location`: pass through header `x-lance-table-location` - `properties`: pass through header `x-lance-table-properties` 
279pub async fn create_table(configuration: &configuration::Configuration, id: &str, body: Vec<u8>, delimiter: Option<&str>, mode: Option<&str>, x_lance_table_location: Option<&str>, x_lance_table_properties: Option<&str>) -> Result<models::CreateTableResponse, Error<CreateTableError>> {
280    // add a prefix to parameters to efficiently prevent name collisions
281    let p_id = id;
282    let p_body = body;
283    let p_delimiter = delimiter;
284    let p_mode = mode;
285    let p_x_lance_table_location = x_lance_table_location;
286    let p_x_lance_table_properties = x_lance_table_properties;
287
288    let uri_str = format!("{}/v1/table/{id}/create", configuration.base_path, id=crate::apis::urlencode(p_id));
289    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
290
291    if let Some(ref param_value) = p_delimiter {
292        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
293    }
294    if let Some(ref param_value) = p_mode {
295        req_builder = req_builder.query(&[("mode", &param_value.to_string())]);
296    }
297    if let Some(ref user_agent) = configuration.user_agent {
298        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
299    }
300    if let Some(param_value) = p_x_lance_table_location {
301        req_builder = req_builder.header("x-lance-table-location", param_value.to_string());
302    }
303    if let Some(param_value) = p_x_lance_table_properties {
304        req_builder = req_builder.header("x-lance-table-properties", param_value.to_string());
305    }
306    req_builder = req_builder.body(p_body);
307
308    let req = req_builder.build()?;
309    let resp = configuration.client.execute(req).await?;
310
311    let status = resp.status();
312    let content_type = resp
313        .headers()
314        .get("content-type")
315        .and_then(|v| v.to_str().ok())
316        .unwrap_or("application/octet-stream");
317    let content_type = super::ContentType::from(content_type);
318
319    if !status.is_client_error() && !status.is_server_error() {
320        let content = resp.text().await?;
321        match content_type {
322            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
323            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableResponse`"))),
324            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`")))),
325        }
326    } else {
327        let content = resp.text().await?;
328        let entity: Option<CreateTableError> = serde_json::from_str(&content).ok();
329        Err(Error::ResponseError(ResponseContent { status, content, entity }))
330    }
331}
332
333/// Delete rows from table `id`. 
334pub async fn delete_from_table(configuration: &configuration::Configuration, id: &str, delete_from_table_request: models::DeleteFromTableRequest, delimiter: Option<&str>) -> Result<models::DeleteFromTableResponse, Error<DeleteFromTableError>> {
335    // add a prefix to parameters to efficiently prevent name collisions
336    let p_id = id;
337    let p_delete_from_table_request = delete_from_table_request;
338    let p_delimiter = delimiter;
339
340    let uri_str = format!("{}/v1/table/{id}/delete", configuration.base_path, id=crate::apis::urlencode(p_id));
341    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
342
343    if let Some(ref param_value) = p_delimiter {
344        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
345    }
346    if let Some(ref user_agent) = configuration.user_agent {
347        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
348    }
349    req_builder = req_builder.json(&p_delete_from_table_request);
350
351    let req = req_builder.build()?;
352    let resp = configuration.client.execute(req).await?;
353
354    let status = resp.status();
355    let content_type = resp
356        .headers()
357        .get("content-type")
358        .and_then(|v| v.to_str().ok())
359        .unwrap_or("application/octet-stream");
360    let content_type = super::ContentType::from(content_type);
361
362    if !status.is_client_error() && !status.is_server_error() {
363        let content = resp.text().await?;
364        match content_type {
365            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
366            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteFromTableResponse`"))),
367            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`")))),
368        }
369    } else {
370        let content = resp.text().await?;
371        let entity: Option<DeleteFromTableError> = serde_json::from_str(&content).ok();
372        Err(Error::ResponseError(ResponseContent { status, content, entity }))
373    }
374}
375
376/// Get the query execution plan for a query against table `id`. Returns a human-readable explanation of how the query will be executed. 
377pub async fn explain_table_query_plan(configuration: &configuration::Configuration, id: &str, explain_table_query_plan_request: models::ExplainTableQueryPlanRequest, delimiter: Option<&str>) -> Result<models::ExplainTableQueryPlanResponse, Error<ExplainTableQueryPlanError>> {
378    // add a prefix to parameters to efficiently prevent name collisions
379    let p_id = id;
380    let p_explain_table_query_plan_request = explain_table_query_plan_request;
381    let p_delimiter = delimiter;
382
383    let uri_str = format!("{}/v1/table/{id}/explain_plan", configuration.base_path, id=crate::apis::urlencode(p_id));
384    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
385
386    if let Some(ref param_value) = p_delimiter {
387        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
388    }
389    if let Some(ref user_agent) = configuration.user_agent {
390        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
391    }
392    req_builder = req_builder.json(&p_explain_table_query_plan_request);
393
394    let req = req_builder.build()?;
395    let resp = configuration.client.execute(req).await?;
396
397    let status = resp.status();
398    let content_type = resp
399        .headers()
400        .get("content-type")
401        .and_then(|v| v.to_str().ok())
402        .unwrap_or("application/octet-stream");
403    let content_type = super::ContentType::from(content_type);
404
405    if !status.is_client_error() && !status.is_server_error() {
406        let content = resp.text().await?;
407        match content_type {
408            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
409            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ExplainTableQueryPlanResponse`"))),
410            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::ExplainTableQueryPlanResponse`")))),
411        }
412    } else {
413        let content = resp.text().await?;
414        let entity: Option<ExplainTableQueryPlanError> = serde_json::from_str(&content).ok();
415        Err(Error::ResponseError(ResponseContent { status, content, entity }))
416    }
417}
418
419/// 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 
420pub async fn insert_into_table(configuration: &configuration::Configuration, id: &str, body: Vec<u8>, delimiter: Option<&str>, mode: Option<&str>) -> Result<models::InsertIntoTableResponse, Error<InsertIntoTableError>> {
421    // add a prefix to parameters to efficiently prevent name collisions
422    let p_id = id;
423    let p_body = body;
424    let p_delimiter = delimiter;
425    let p_mode = mode;
426
427    let uri_str = format!("{}/v1/table/{id}/insert", configuration.base_path, id=crate::apis::urlencode(p_id));
428    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
429
430    if let Some(ref param_value) = p_delimiter {
431        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
432    }
433    if let Some(ref param_value) = p_mode {
434        req_builder = req_builder.query(&[("mode", &param_value.to_string())]);
435    }
436    if let Some(ref user_agent) = configuration.user_agent {
437        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
438    }
439    req_builder = req_builder.body(p_body);
440
441    let req = req_builder.build()?;
442    let resp = configuration.client.execute(req).await?;
443
444    let status = resp.status();
445    let content_type = resp
446        .headers()
447        .get("content-type")
448        .and_then(|v| v.to_str().ok())
449        .unwrap_or("application/octet-stream");
450    let content_type = super::ContentType::from(content_type);
451
452    if !status.is_client_error() && !status.is_server_error() {
453        let content = resp.text().await?;
454        match content_type {
455            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
456            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::InsertIntoTableResponse`"))),
457            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`")))),
458        }
459    } else {
460        let content = resp.text().await?;
461        let entity: Option<InsertIntoTableError> = serde_json::from_str(&content).ok();
462        Err(Error::ResponseError(ResponseContent { status, content, entity }))
463    }
464}
465
466/// 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 
467pub 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>) -> Result<models::MergeInsertIntoTableResponse, Error<MergeInsertIntoTableError>> {
468    // add a prefix to parameters to efficiently prevent name collisions
469    let p_id = id;
470    let p_on = on;
471    let p_body = body;
472    let p_delimiter = delimiter;
473    let p_when_matched_update_all = when_matched_update_all;
474    let p_when_matched_update_all_filt = when_matched_update_all_filt;
475    let p_when_not_matched_insert_all = when_not_matched_insert_all;
476    let p_when_not_matched_by_source_delete = when_not_matched_by_source_delete;
477    let p_when_not_matched_by_source_delete_filt = when_not_matched_by_source_delete_filt;
478
479    let uri_str = format!("{}/v1/table/{id}/merge_insert", configuration.base_path, id=crate::apis::urlencode(p_id));
480    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
481
482    if let Some(ref param_value) = p_delimiter {
483        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
484    }
485    req_builder = req_builder.query(&[("on", &p_on.to_string())]);
486    if let Some(ref param_value) = p_when_matched_update_all {
487        req_builder = req_builder.query(&[("when_matched_update_all", &param_value.to_string())]);
488    }
489    if let Some(ref param_value) = p_when_matched_update_all_filt {
490        req_builder = req_builder.query(&[("when_matched_update_all_filt", &param_value.to_string())]);
491    }
492    if let Some(ref param_value) = p_when_not_matched_insert_all {
493        req_builder = req_builder.query(&[("when_not_matched_insert_all", &param_value.to_string())]);
494    }
495    if let Some(ref param_value) = p_when_not_matched_by_source_delete {
496        req_builder = req_builder.query(&[("when_not_matched_by_source_delete", &param_value.to_string())]);
497    }
498    if let Some(ref param_value) = p_when_not_matched_by_source_delete_filt {
499        req_builder = req_builder.query(&[("when_not_matched_by_source_delete_filt", &param_value.to_string())]);
500    }
501    if let Some(ref user_agent) = configuration.user_agent {
502        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
503    }
504    req_builder = req_builder.body(p_body);
505
506    let req = req_builder.build()?;
507    let resp = configuration.client.execute(req).await?;
508
509    let status = resp.status();
510    let content_type = resp
511        .headers()
512        .get("content-type")
513        .and_then(|v| v.to_str().ok())
514        .unwrap_or("application/octet-stream");
515    let content_type = super::ContentType::from(content_type);
516
517    if !status.is_client_error() && !status.is_server_error() {
518        let content = resp.text().await?;
519        match content_type {
520            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
521            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::MergeInsertIntoTableResponse`"))),
522            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`")))),
523        }
524    } else {
525        let content = resp.text().await?;
526        let entity: Option<MergeInsertIntoTableError> = serde_json::from_str(&content).ok();
527        Err(Error::ResponseError(ResponseContent { status, content, entity }))
528    }
529}
530
531/// Query table `id` with vector search, full text search and optional SQL filtering. Returns results in Arrow IPC file or stream format. 
532pub async fn query_table(configuration: &configuration::Configuration, id: &str, query_table_request: models::QueryTableRequest, delimiter: Option<&str>) -> Result<reqwest::Response, Error<QueryTableError>> {
533    // add a prefix to parameters to efficiently prevent name collisions
534    let p_id = id;
535    let p_query_table_request = query_table_request;
536    let p_delimiter = delimiter;
537
538    let uri_str = format!("{}/v1/table/{id}/query", configuration.base_path, id=crate::apis::urlencode(p_id));
539    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
540
541    if let Some(ref param_value) = p_delimiter {
542        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
543    }
544    if let Some(ref user_agent) = configuration.user_agent {
545        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
546    }
547    req_builder = req_builder.json(&p_query_table_request);
548
549    let req = req_builder.build()?;
550    let resp = configuration.client.execute(req).await?;
551
552    let status = resp.status();
553
554    if !status.is_client_error() && !status.is_server_error() {
555        Ok(resp)
556    } else {
557        let content = resp.text().await?;
558        let entity: Option<QueryTableError> = serde_json::from_str(&content).ok();
559        Err(Error::ResponseError(ResponseContent { status, content, entity }))
560    }
561}
562
563/// Update existing rows in table `id`. 
564pub async fn update_table(configuration: &configuration::Configuration, id: &str, update_table_request: models::UpdateTableRequest, delimiter: Option<&str>) -> Result<models::UpdateTableResponse, Error<UpdateTableError>> {
565    // add a prefix to parameters to efficiently prevent name collisions
566    let p_id = id;
567    let p_update_table_request = update_table_request;
568    let p_delimiter = delimiter;
569
570    let uri_str = format!("{}/v1/table/{id}/update", configuration.base_path, id=crate::apis::urlencode(p_id));
571    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
572
573    if let Some(ref param_value) = p_delimiter {
574        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
575    }
576    if let Some(ref user_agent) = configuration.user_agent {
577        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
578    }
579    req_builder = req_builder.json(&p_update_table_request);
580
581    let req = req_builder.build()?;
582    let resp = configuration.client.execute(req).await?;
583
584    let status = resp.status();
585    let content_type = resp
586        .headers()
587        .get("content-type")
588        .and_then(|v| v.to_str().ok())
589        .unwrap_or("application/octet-stream");
590    let content_type = super::ContentType::from(content_type);
591
592    if !status.is_client_error() && !status.is_server_error() {
593        let content = resp.text().await?;
594        match content_type {
595            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
596            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTableResponse`"))),
597            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`")))),
598        }
599    } else {
600        let content = resp.text().await?;
601        let entity: Option<UpdateTableError> = serde_json::from_str(&content).ok();
602        Err(Error::ResponseError(ResponseContent { status, content, entity }))
603    }
604}
605
lance_namespace_reqwest_client/apis/data_api.rs

lance_namespace_reqwest_client/apis/
data_api.rs
