qdrant_client/builders/
delete_payload_points_builder.rs

1use crate::grpc_macros::convert_option;
2use crate::qdrant::*;
3
4#[derive(Clone)]
5pub struct DeletePayloadPointsBuilder {
6    /// name of the collection
7    pub(crate) collection_name: Option<String>,
8    /// Wait until the changes have been applied?
9    pub(crate) wait: Option<Option<bool>>,
10    /// List of keys to delete
11    pub(crate) keys: Option<Vec<String>>,
12    /// Affected points
13    points_selector: Option<points_selector::PointsSelectorOneOf>,
14    /// Write ordering guarantees
15    pub(crate) ordering: Option<Option<WriteOrdering>>,
16    /// Option for custom sharding to specify used shard keys
17    pub(crate) shard_key_selector: Option<Option<ShardKeySelector>>,
18}
19
20impl DeletePayloadPointsBuilder {
21    /// name of the collection
22    #[allow(unused_mut)]
23    pub fn collection_name(self, value: String) -> Self {
24        let mut new = self;
25        new.collection_name = Option::Some(value);
26        new
27    }
28    /// Wait until the changes have been applied?
29    #[allow(unused_mut)]
30    pub fn wait(self, value: bool) -> Self {
31        let mut new = self;
32        new.wait = Option::Some(Option::Some(value));
33        new
34    }
35    /// List of keys to delete
36    #[allow(unused_mut)]
37    pub fn keys(self, value: Vec<String>) -> Self {
38        let mut new = self;
39        new.keys = Option::Some(value);
40        new
41    }
42    /// Affected points
43    #[allow(unused_mut)]
44    pub fn points_selector<VALUE: core::convert::Into<points_selector::PointsSelectorOneOf>>(
45        self,
46        value: VALUE,
47    ) -> Self {
48        let mut new = self;
49        new.points_selector = Option::Some(value.into());
50        new
51    }
52    /// Write ordering guarantees
53    #[allow(unused_mut)]
54    pub fn ordering<VALUE: core::convert::Into<WriteOrdering>>(self, value: VALUE) -> Self {
55        let mut new = self;
56        new.ordering = Option::Some(Option::Some(value.into()));
57        new
58    }
59    /// Option for custom sharding to specify used shard keys
60    #[allow(unused_mut)]
61    pub fn shard_key_selector<VALUE: core::convert::Into<ShardKeySelector>>(
62        self,
63        value: VALUE,
64    ) -> Self {
65        let mut new = self;
66        new.shard_key_selector = Option::Some(Option::Some(value.into()));
67        new
68    }
69
70    fn build_inner(self) -> Result<DeletePayloadPoints, DeletePayloadPointsBuilderError> {
71        Ok(DeletePayloadPoints {
72            collection_name: match self.collection_name {
73                Some(value) => value,
74                None => {
75                    return Result::Err(core::convert::Into::into(
76                        ::derive_builder::UninitializedFieldError::from("collection_name"),
77                    ));
78                }
79            },
80            wait: self.wait.unwrap_or_default(),
81            keys: match self.keys {
82                Some(value) => value,
83                None => {
84                    return Result::Err(core::convert::Into::into(
85                        ::derive_builder::UninitializedFieldError::from("keys"),
86                    ));
87                }
88            },
89            points_selector: { convert_option(&self.points_selector) },
90            ordering: self.ordering.unwrap_or_default(),
91            shard_key_selector: self.shard_key_selector.unwrap_or_default(),
92        })
93    }
94    /// Create an empty builder, with all fields set to `None` or `PhantomData`.
95    fn create_empty() -> Self {
96        Self {
97            collection_name: core::default::Default::default(),
98            wait: core::default::Default::default(),
99            keys: core::default::Default::default(),
100            points_selector: core::default::Default::default(),
101            ordering: core::default::Default::default(),
102            shard_key_selector: core::default::Default::default(),
103        }
104    }
105}
106
107impl From<DeletePayloadPointsBuilder> for DeletePayloadPoints {
108    fn from(value: DeletePayloadPointsBuilder) -> Self {
109        value.build_inner().unwrap_or_else(|_| {
110            panic!(
111                "Failed to convert {0} to {1}",
112                "DeletePayloadPointsBuilder", "DeletePayloadPoints"
113            )
114        })
115    }
116}
117
118impl DeletePayloadPointsBuilder {
119    /// Builds the desired type. Can often be omitted.
120    pub fn build(self) -> DeletePayloadPoints {
121        self.build_inner().unwrap_or_else(|_| {
122            panic!(
123                "Failed to build {0} into {1}",
124                "DeletePayloadPointsBuilder", "DeletePayloadPoints"
125            )
126        })
127    }
128}
129
130impl DeletePayloadPointsBuilder {
131    pub(crate) fn empty() -> Self {
132        Self::create_empty()
133    }
134}
135
136/// Error type for DeletePayloadPointsBuilder
137#[non_exhaustive]
138#[derive(Debug)]
139pub enum DeletePayloadPointsBuilderError {
140    /// Uninitialized field
141    UninitializedField(&'static str),
142    /// Custom validation error
143    ValidationError(String),
144}
145
146// Implementing the Display trait for better error messages
147impl std::fmt::Display for DeletePayloadPointsBuilderError {
148    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
149        match self {
150            Self::UninitializedField(field) => {
151                write!(f, "`{field}` must be initialized")
152            }
153            Self::ValidationError(error) => write!(f, "{error}"),
154        }
155    }
156}
157
158// Implementing the Error trait
159impl std::error::Error for DeletePayloadPointsBuilderError {}
160
161// Implementing From trait for conversion from UninitializedFieldError
162impl From<derive_builder::UninitializedFieldError> for DeletePayloadPointsBuilderError {
163    fn from(error: derive_builder::UninitializedFieldError) -> Self {
164        Self::UninitializedField(error.field_name())
165    }
166}
167
168// Implementing From trait for conversion from String
169impl From<String> for DeletePayloadPointsBuilderError {
170    fn from(error: String) -> Self {
171        Self::ValidationError(error)
172    }
173}