Skip to content

Commit 53e3010

Browse files
penbergpenberg
authored
Merge 'Kill unwrap() in vector module' from Pekka Enberg
In preparation for #3992, which bans unwrap() altogether, remove unwrap() calls from vector module. Reviewed-by: Nikita Sivukhin (@sivukhin) Closes #4021
2 parents 6c74c53 + d8db724 commit 53e3010

File tree

3 files changed

+72
-113
lines changed

3 files changed

+72
-113
lines changed

‎core/vdbe/execute.rs‎

Lines changed: 15 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,10 @@ use crate::vdbe::affinity::{apply_numeric_affinity, try_for_float, Affinity, Par
2424
use crate::vdbe::insn::InsertFlags;
2525
use crate::vdbe::value::ComparisonOp;
2626
use crate::vdbe::{registers_to_ref_values, EndStatement, StepResult, TxnCleanup};
27-
use crate::vector::{vector32_sparse, vector_concat, vector_distance_jaccard, vector_slice};
27+
use crate::vector::{
28+
vector32, vector32_sparse, vector64, vector_concat, vector_distance_cos,
29+
vector_distance_jaccard, vector_distance_l2, vector_extract, vector_slice,
30+
};
2831
use crate::{
2932
error::{
3033
LimboError, SQLITE_CONSTRAINT, SQLITE_CONSTRAINT_NOTNULL, SQLITE_CONSTRAINT_PRIMARYKEY,
@@ -66,7 +69,6 @@ use crate::{
6669
builder::CursorType,
6770
insn::{IdxInsertFlags, Insn},
6871
},
69-
vector::{vector32, vector64, vector_distance_cos, vector_distance_l2, vector_extract},
7072
};
7173

7274
use crate::{info, turso_assert, OpenFlags, Row, TransactionState, ValueRef};
@@ -5526,47 +5528,46 @@ pub fn op_function(
55265528
}
55275529
},
55285530
crate::function::Func::Vector(vector_func) => {
5529-
let values =
5530-
registers_to_ref_values(&state.registers[*start_reg..*start_reg + arg_count]);
5531+
let args = &state.registers[*start_reg..*start_reg + arg_count];
55315532
match vector_func {
55325533
VectorFunc::Vector => {
5533-
let result = vector32(values)?;
5534+
let result = vector32(args)?;
55345535
state.registers[*dest] = Register::Value(result);
55355536
}
55365537
VectorFunc::Vector32 => {
5537-
let result = vector32(values)?;
5538+
let result = vector32(args)?;
55385539
state.registers[*dest] = Register::Value(result);
55395540
}
55405541
VectorFunc::Vector32Sparse => {
5541-
let result = vector32_sparse(values)?;
5542+
let result = vector32_sparse(args)?;
55425543
state.registers[*dest] = Register::Value(result);
55435544
}
55445545
VectorFunc::Vector64 => {
5545-
let result = vector64(values)?;
5546+
let result = vector64(args)?;
55465547
state.registers[*dest] = Register::Value(result);
55475548
}
55485549
VectorFunc::VectorExtract => {
5549-
let result = vector_extract(values)?;
5550+
let result = vector_extract(args)?;
55505551
state.registers[*dest] = Register::Value(result);
55515552
}
55525553
VectorFunc::VectorDistanceCos => {
5553-
let result = vector_distance_cos(values)?;
5554+
let result = vector_distance_cos(args)?;
55545555
state.registers[*dest] = Register::Value(result);
55555556
}
55565557
VectorFunc::VectorDistanceL2 => {
5557-
let result = vector_distance_l2(values)?;
5558+
let result = vector_distance_l2(args)?;
55585559
state.registers[*dest] = Register::Value(result);
55595560
}
55605561
VectorFunc::VectorDistanceJaccard => {
5561-
let result = vector_distance_jaccard(values)?;
5562+
let result = vector_distance_jaccard(args)?;
55625563
state.registers[*dest] = Register::Value(result);
55635564
}
55645565
VectorFunc::VectorConcat => {
5565-
let result = vector_concat(values)?;
5566+
let result = vector_concat(args)?;
55665567
state.registers[*dest] = Register::Value(result);
55675568
}
55685569
VectorFunc::VectorSlice => {
5569-
let result = vector_slice(values)?;
5570+
let result = vector_slice(args)?;
55705571
state.registers[*dest] = Register::Value(result)
55715572
}
55725573
}

‎core/vector/mod.rs‎

Lines changed: 37 additions & 94 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
use crate::types::AsValueRef;
22
use crate::types::Value;
33
use crate::types::ValueType;
4+
use crate::vdbe::Register;
45
use crate::LimboError;
56
use crate::Result;
67
use crate::ValueRef;
@@ -33,75 +34,50 @@ pub fn parse_vector<'a>(
3334
}
3435
}
3536

36-
pub fn vector32<I, E, V>(args: I) -> Result<Value>
37-
where
38-
V: AsValueRef,
39-
E: ExactSizeIterator<Item = V>,
40-
I: IntoIterator<IntoIter = E, Item = V>,
41-
{
42-
let mut args = args.into_iter();
37+
pub fn vector32(args: &[Register]) -> Result<Value> {
4338
if args.len() != 1 {
4439
return Err(LimboError::ConversionError(
4540
"vector32 requires exactly one argument".to_string(),
4641
));
4742
}
48-
let value = args.next().unwrap();
49-
let vector = parse_vector(&value, Some(VectorType::Float32Dense))?;
43+
let value = args[0].get_value();
44+
let vector = parse_vector(value, Some(VectorType::Float32Dense))?;
5045
let vector = operations::convert::vector_convert(vector, VectorType::Float32Dense)?;
5146
Ok(operations::serialize::vector_serialize(vector))
5247
}
5348

54-
pub fn vector32_sparse<I, E, V>(args: I) -> Result<Value>
55-
where
56-
V: AsValueRef,
57-
E: ExactSizeIterator<Item = V>,
58-
I: IntoIterator<IntoIter = E, Item = V>,
59-
{
60-
let mut args = args.into_iter();
49+
pub fn vector32_sparse(args: &[Register]) -> Result<Value> {
6150
if args.len() != 1 {
6251
return Err(LimboError::ConversionError(
6352
"vector32_sparse requires exactly one argument".to_string(),
6453
));
6554
}
66-
let value = args.next().unwrap();
67-
let vector = parse_vector(&value, Some(VectorType::Float32Sparse))?;
55+
let value = args[0].get_value();
56+
let vector = parse_vector(value, Some(VectorType::Float32Sparse))?;
6857
let vector = operations::convert::vector_convert(vector, VectorType::Float32Sparse)?;
6958
Ok(operations::serialize::vector_serialize(vector))
7059
}
7160

72-
pub fn vector64<I, E, V>(args: I) -> Result<Value>
73-
where
74-
V: AsValueRef,
75-
E: ExactSizeIterator<Item = V>,
76-
I: IntoIterator<IntoIter = E, Item = V>,
77-
{
78-
let mut args = args.into_iter();
61+
pub fn vector64(args: &[Register]) -> Result<Value> {
7962
if args.len() != 1 {
8063
return Err(LimboError::ConversionError(
8164
"vector64 requires exactly one argument".to_string(),
8265
));
8366
}
84-
let value = args.next().unwrap();
85-
let vector = parse_vector(&value, Some(VectorType::Float64Dense))?;
67+
let value = args[0].get_value();
68+
let vector = parse_vector(value, Some(VectorType::Float64Dense))?;
8669
let vector = operations::convert::vector_convert(vector, VectorType::Float64Dense)?;
8770
Ok(operations::serialize::vector_serialize(vector))
8871
}
8972

90-
pub fn vector_extract<I, E, V>(args: I) -> Result<Value>
91-
where
92-
V: AsValueRef,
93-
E: ExactSizeIterator<Item = V>,
94-
I: IntoIterator<IntoIter = E, Item = V>,
95-
{
96-
let mut args = args.into_iter();
73+
pub fn vector_extract(args: &[Register]) -> Result<Value> {
9774
if args.len() != 1 {
9875
return Err(LimboError::ConversionError(
9976
"vector_extract requires exactly one argument".to_string(),
10077
));
10178
}
10279

103-
let value = args.next().unwrap();
104-
let value = value.as_value_ref();
80+
let value = args[0].get_value().as_value_ref();
10581
let blob = match value {
10682
ValueRef::Blob(b) => b,
10783
_ => {
@@ -119,110 +95,77 @@ where
11995
Ok(Value::build_text(operations::text::vector_to_text(&vector)))
12096
}
12197

122-
pub fn vector_distance_cos<I, E, V>(args: I) -> Result<Value>
123-
where
124-
V: AsValueRef,
125-
E: ExactSizeIterator<Item = V>,
126-
I: IntoIterator<IntoIter = E, Item = V>,
127-
{
128-
let mut args = args.into_iter();
98+
pub fn vector_distance_cos(args: &[Register]) -> Result<Value> {
12999
if args.len() != 2 {
130100
return Err(LimboError::ConversionError(
131101
"vector_distance_cos requires exactly two arguments".to_string(),
132102
));
133103
}
134104

135-
let value_0 = args.next().unwrap();
136-
let value_1 = args.next().unwrap();
137-
let x = parse_vector(&value_0, None)?;
138-
let y = parse_vector(&value_1, None)?;
105+
let value_0 = args[0].get_value();
106+
let value_1 = args[1].get_value();
107+
let x = parse_vector(value_0, None)?;
108+
let y = parse_vector(value_1, None)?;
139109
let dist = operations::distance_cos::vector_distance_cos(&x, &y)?;
140110
Ok(Value::Float(dist))
141111
}
142112

143-
pub fn vector_distance_l2<I, E, V>(args: I) -> Result<Value>
144-
where
145-
V: AsValueRef,
146-
E: ExactSizeIterator<Item = V>,
147-
I: IntoIterator<IntoIter = E, Item = V>,
148-
{
149-
let mut args = args.into_iter();
113+
pub fn vector_distance_l2(args: &[Register]) -> Result<Value> {
150114
if args.len() != 2 {
151115
return Err(LimboError::ConversionError(
152116
"distance_l2 requires exactly two arguments".to_string(),
153117
));
154118
}
155119

156-
let value_0 = args.next().unwrap();
157-
let value_1 = args.next().unwrap();
158-
let x = parse_vector(&value_0, None)?;
159-
let y = parse_vector(&value_1, None)?;
120+
let value_0 = args[0].get_value();
121+
let value_1 = args[1].get_value();
122+
let x = parse_vector(value_0, None)?;
123+
let y = parse_vector(value_1, None)?;
160124
let dist = operations::distance_l2::vector_distance_l2(&x, &y)?;
161125
Ok(Value::Float(dist))
162126
}
163127

164-
pub fn vector_distance_jaccard<I, E, V>(args: I) -> Result<Value>
165-
where
166-
V: AsValueRef,
167-
E: ExactSizeIterator<Item = V>,
168-
I: IntoIterator<IntoIter = E, Item = V>,
169-
{
170-
let mut args = args.into_iter();
128+
pub fn vector_distance_jaccard(args: &[Register]) -> Result<Value> {
171129
if args.len() != 2 {
172130
return Err(LimboError::ConversionError(
173131
"distance_jaccard requires exactly two arguments".to_string(),
174132
));
175133
}
176134

177-
let value_0 = args.next().unwrap();
178-
let value_1 = args.next().unwrap();
179-
let x = parse_vector(&value_0, None)?;
180-
let y = parse_vector(&value_1, None)?;
135+
let value_0 = args[0].get_value();
136+
let value_1 = args[1].get_value();
137+
let x = parse_vector(value_0, None)?;
138+
let y = parse_vector(value_1, None)?;
181139
let dist = operations::jaccard::vector_distance_jaccard(&x, &y)?;
182140
Ok(Value::Float(dist))
183141
}
184142

185-
pub fn vector_concat<I, E, V>(args: I) -> Result<Value>
186-
where
187-
V: AsValueRef,
188-
E: ExactSizeIterator<Item = V>,
189-
I: IntoIterator<IntoIter = E, Item = V>,
190-
{
191-
let mut args = args.into_iter();
143+
pub fn vector_concat(args: &[Register]) -> Result<Value> {
192144
if args.len() != 2 {
193145
return Err(LimboError::InvalidArgument(
194146
"concat requires exactly two arguments".into(),
195147
));
196148
}
197149

198-
let value_0 = args.next().unwrap();
199-
let value_1 = args.next().unwrap();
200-
let x = parse_vector(&value_0, None)?;
201-
let y = parse_vector(&value_1, None)?;
150+
let value_0 = args[0].get_value();
151+
let value_1 = args[1].get_value();
152+
let x = parse_vector(value_0, None)?;
153+
let y = parse_vector(value_1, None)?;
202154
let vector = operations::concat::vector_concat(&x, &y)?;
203155
Ok(operations::serialize::vector_serialize(vector))
204156
}
205157

206-
pub fn vector_slice<I, E, V>(args: I) -> Result<Value>
207-
where
208-
V: AsValueRef,
209-
E: ExactSizeIterator<Item = V>,
210-
I: IntoIterator<IntoIter = E, Item = V>,
211-
{
212-
let mut args = args.into_iter();
158+
pub fn vector_slice(args: &[Register]) -> Result<Value> {
213159
if args.len() != 3 {
214160
return Err(LimboError::InvalidArgument(
215161
"vector_slice requires exactly three arguments".into(),
216162
));
217163
}
218-
let value_0 = args.next().unwrap();
219-
let value_1 = args.next().unwrap();
220-
let value_1 = value_1.as_value_ref();
221-
222-
let value_2 = args.next().unwrap();
223-
let value_2 = value_2.as_value_ref();
164+
let value_0 = args[0].get_value();
165+
let value_1 = args[1].get_value().as_value_ref();
166+
let value_2 = args[2].get_value().as_value_ref();
224167

225-
let vector = parse_vector(&value_0, None)?;
168+
let vector = parse_vector(value_0, None)?;
226169

227170
let start_index = value_1
228171
.as_int()

‎core/vector/vector_types.rs‎

Lines changed: 20 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -128,7 +128,9 @@ impl<'a> Vector<'a> {
128128
) -> Result<Self> {
129129
let owned_slice = owned.as_deref();
130130
let refer_slice = refer.as_ref().map(|&x| x);
131-
let data = owned_slice.unwrap_or_else(|| refer_slice.unwrap());
131+
let data = owned_slice.or(refer_slice).ok_or_else(|| {
132+
LimboError::InternalError("Vector must have either owned or refer data".to_string())
133+
})?;
132134
match vector_type {
133135
VectorType::Float32Dense => {
134136
if data.len() % 4 != 0 {
@@ -167,7 +169,12 @@ impl<'a> Vector<'a> {
167169
}
168170
let original_len = data.len();
169171
let dims_bytes = &data[original_len - 4..];
170-
let dims = u32::from_le_bytes(dims_bytes.try_into().unwrap()) as usize;
172+
let dims = u32::from_le_bytes([
173+
dims_bytes[0],
174+
dims_bytes[1],
175+
dims_bytes[2],
176+
dims_bytes[3],
177+
]) as usize;
171178
let owned = owned.map(|mut x| {
172179
x.truncate(original_len - 4);
173180
x
@@ -187,17 +194,25 @@ impl<'a> Vector<'a> {
187194
pub fn bin_len(&self) -> usize {
188195
let owned = self.owned.as_ref().map(|x| x.len());
189196
let refer = self.refer.as_ref().map(|x| x.len());
190-
owned.unwrap_or_else(|| refer.unwrap())
197+
owned
198+
.or(refer)
199+
.expect("Vector invariant: exactly one of owned or refer must be Some")
191200
}
192201

193202
pub fn bin_data(&'a self) -> &'a [u8] {
194203
let owned = self.owned.as_deref();
195204
let refer = self.refer.as_ref().map(|&x| x);
196-
owned.unwrap_or_else(|| refer.unwrap())
205+
owned
206+
.or(refer)
207+
.expect("Vector invariant: exactly one of owned or refer must be Some")
197208
}
198209

199210
pub fn bin_eject(self) -> Vec<u8> {
200-
self.owned.unwrap_or_else(|| self.refer.unwrap().to_vec())
211+
self.owned.unwrap_or_else(|| {
212+
self.refer
213+
.expect("Vector invariant: exactly one of owned or refer must be Some")
214+
.to_vec()
215+
})
201216
}
202217

203218
/// # Safety

0 commit comments

Comments
 (0)