milvus-io
/
milvus
mirror of https://github.com/milvus-io/milvus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix: fix misleading name *_add_multi_* (#39997) 

fix: #39995

Signed-off-by: SpadeA <tangchenjie1210@gmail.com>
pull/40096/head
Spade A 2025-02-21 16:45:55 +08:00 committed by GitHub
parent 0d873719d3
commit d34d70582d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 95 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
internal/core/src/index/InvertedIndexTantivy.cpp
View File

@ -402,7 +402,7 @@ InvertedIndexTantivy<T>::BuildWithRawDataForUT(size_t n,
// only used in ut.
auto arr = static_cast<const boost::container::vector<T>*>(values);
for (size_t i = 0; i < n; i++) {
wrapper_->template add_multi_data(
wrapper_->template add_array_data(
arr[i].data(), arr[i].size(), i);
}
} else {
@ -413,7 +413,7 @@ InvertedIndexTantivy<T>::BuildWithRawDataForUT(size_t n,
// only used in ut.
auto arr = static_cast<const boost::container::vector<T>*>(values);
for (size_t i = 0; i < n; i++) {
wrapper_->template add_multi_data_by_single_segment_writer(
wrapper_->template add_array_data_by_single_segment_writer(
arr[i].data(), arr[i].size());
}
} else {
@ -458,7 +458,7 @@ InvertedIndexTantivy<T>::BuildWithFieldData(
if (!data->is_valid(i)) {
null_offset.push_back(i);
}
wrapper_->add_multi_data<T>(
wrapper_->add_array_data<T>(
static_cast<const T*>(data->RawValue(i)),
data->is_valid(i),
offset++);
@ -481,7 +481,7 @@ InvertedIndexTantivy<T>::BuildWithFieldData(
null_offset.push_back(i);
}
wrapper_
->add_multi_data_by_single_segment_writer<T>(
->add_array_data_by_single_segment_writer<T>(
static_cast<const T*>(data->RawValue(i)),
data->is_valid(i));
}
@ -525,12 +525,12 @@ InvertedIndexTantivy<T>::build_index_for_array(
}
auto length = data->is_valid(i) ? array_column[i].length() : 0;
if (!inverted_index_single_segment_) {
wrapper_->template add_multi_data(
wrapper_->template add_array_data(
reinterpret_cast<const T*>(array_column[i].data()),
length,
offset++);
} else {
wrapper_->template add_multi_data_by_single_segment_writer(
wrapper_->template add_array_data_by_single_segment_writer(
reinterpret_cast<const T*>(array_column[i].data()), length);
}
}
@ -559,10 +559,10 @@ InvertedIndexTantivy<std::string>::build_index_for_array(
}
auto length = data->is_valid(i) ? output.size() : 0;
if (!inverted_index_single_segment_) {
wrapper_->template add_multi_data(
wrapper_->template add_array_data(
output.data(), length, offset++);
} else {
wrapper_->template add_multi_data_by_single_segment_writer(
wrapper_->template add_array_data_by_single_segment_writer(
output.data(), length);
}
}

2
internal/core/src/index/TextMatchIndex.cpp
View File

@ -180,7 +180,7 @@ TextMatchIndex::AddNull(int64_t offset) {
null_offset.push_back(offset);
// still need to add null to make offset is correct
std::string empty = "";
wrapper_->add_multi_data(&empty, 0, offset);
wrapper_->add_array_data(&empty, 0, offset);
}
void

32
internal/core/thirdparty/tantivy/tantivy-binding/include/tantivy-binding.h vendored
View File

@ -252,75 +252,75 @@ RustResult tantivy_index_add_string(void *ptr, const char *s, int64_t offset);
RustResult tantivy_index_add_string_by_single_segment_writer(void *ptr, const char *s);
RustResult tantivy_index_add_multi_int8s(void *ptr,
RustResult tantivy_index_add_array_int8s(void *ptr,
const int8_t *array,
uintptr_t len,
int64_t offset);
RustResult tantivy_index_add_multi_int8s_by_single_segment_writer(void *ptr,
RustResult tantivy_index_add_array_int8s_by_single_segment_writer(void *ptr,
const int8_t *array,
uintptr_t len);
RustResult tantivy_index_add_multi_int16s(void *ptr,
RustResult tantivy_index_add_array_int16s(void *ptr,
const int16_t *array,
uintptr_t len,
int64_t offset);
RustResult tantivy_index_add_multi_int16s_by_single_segment_writer(void *ptr,
RustResult tantivy_index_add_array_int16s_by_single_segment_writer(void *ptr,
const int16_t *array,
uintptr_t len);
RustResult tantivy_index_add_multi_int32s(void *ptr,
RustResult tantivy_index_add_array_int32s(void *ptr,
const int32_t *array,
uintptr_t len,
int64_t offset);
RustResult tantivy_index_add_multi_int32s_by_single_segment_writer(void *ptr,
RustResult tantivy_index_add_array_int32s_by_single_segment_writer(void *ptr,
const int32_t *array,
uintptr_t len);
RustResult tantivy_index_add_multi_int64s(void *ptr,
RustResult tantivy_index_add_array_int64s(void *ptr,
const int64_t *array,
uintptr_t len,
int64_t offset);
RustResult tantivy_index_add_multi_int64s_by_single_segment_writer(void *ptr,
RustResult tantivy_index_add_array_int64s_by_single_segment_writer(void *ptr,
const int64_t *array,
uintptr_t len);
RustResult tantivy_index_add_multi_f32s(void *ptr,
RustResult tantivy_index_add_array_f32s(void *ptr,
const float *array,
uintptr_t len,
int64_t offset);
RustResult tantivy_index_add_multi_f32s_by_single_segment_writer(void *ptr,
RustResult tantivy_index_add_array_f32s_by_single_segment_writer(void *ptr,
const float *array,
uintptr_t len);
RustResult tantivy_index_add_multi_f64s(void *ptr,
RustResult tantivy_index_add_array_f64s(void *ptr,
const double *array,
uintptr_t len,
int64_t offset);
RustResult tantivy_index_add_multi_f64s_by_single_segment_writer(void *ptr,
RustResult tantivy_index_add_array_f64s_by_single_segment_writer(void *ptr,
const double *array,
uintptr_t len);
RustResult tantivy_index_add_multi_bools(void *ptr,
RustResult tantivy_index_add_array_bools(void *ptr,
const bool *array,
uintptr_t len,
int64_t offset);
RustResult tantivy_index_add_multi_bools_by_single_segment_writer(void *ptr,
RustResult tantivy_index_add_array_bools_by_single_segment_writer(void *ptr,
const bool *array,
uintptr_t len);
RustResult tantivy_index_add_multi_keywords(void *ptr,
RustResult tantivy_index_add_array_keywords(void *ptr,
const char *const *array,
uintptr_t len,
int64_t offset);
RustResult tantivy_index_add_multi_keywords_by_single_segment_writer(void *ptr,
RustResult tantivy_index_add_array_keywords_by_single_segment_writer(void *ptr,
const char *const *array,
uintptr_t len);

32
internal/core/thirdparty/tantivy/tantivy-binding/src/index_writer.rs vendored
View File

@ -176,7 +176,7 @@ impl IndexWriterWrapper {
))
}
pub fn add_multi_i8s(&mut self, datas: &[i8], offset: i64) -> Result<()> {
pub fn add_array_i8s(&mut self, datas: &[i8], offset: i64) -> Result<()> {
let mut document = TantivyDocument::default();
for data in datas {
document.add_field_value(self.field, &(*data as i64));
@ -185,7 +185,7 @@ impl IndexWriterWrapper {
self.index_writer_add_document(document)
}
pub fn add_multi_i16s(&mut self, datas: &[i16], offset: i64) -> Result<()> {
pub fn add_array_i16s(&mut self, datas: &[i16], offset: i64) -> Result<()> {
let mut document = TantivyDocument::default();
for data in datas {
document.add_field_value(self.field, &(*data as i64));
@ -194,7 +194,7 @@ impl IndexWriterWrapper {
self.index_writer_add_document(document)
}
pub fn add_multi_i32s(&mut self, datas: &[i32], offset: i64) -> Result<()> {
pub fn add_array_i32s(&mut self, datas: &[i32], offset: i64) -> Result<()> {
let mut document = TantivyDocument::default();
for data in datas {
document.add_field_value(self.field, &(*data as i64));
@ -203,7 +203,7 @@ impl IndexWriterWrapper {
self.index_writer_add_document(document)
}
pub fn add_multi_i64s(&mut self, datas: &[i64], offset: i64) -> Result<()> {
pub fn add_array_i64s(&mut self, datas: &[i64], offset: i64) -> Result<()> {
let mut document = TantivyDocument::default();
for data in datas {
document.add_field_value(self.field, data);
@ -212,7 +212,7 @@ impl IndexWriterWrapper {
self.index_writer_add_document(document)
}
pub fn add_multi_f32s(&mut self, datas: &[f32], offset: i64) -> Result<()> {
pub fn add_array_f32s(&mut self, datas: &[f32], offset: i64) -> Result<()> {
let mut document = TantivyDocument::default();
for data in datas {
document.add_field_value(self.field, &(*data as f64));
@ -221,7 +221,7 @@ impl IndexWriterWrapper {
self.index_writer_add_document(document)
}
pub fn add_multi_f64s(&mut self, datas: &[f64], offset: i64) -> Result<()> {
pub fn add_array_f64s(&mut self, datas: &[f64], offset: i64) -> Result<()> {
let mut document = TantivyDocument::default();
for data in datas {
document.add_field_value(self.field, data);
@ -230,7 +230,7 @@ impl IndexWriterWrapper {
self.index_writer_add_document(document)
}
pub fn add_multi_bools(&mut self, datas: &[bool], offset: i64) -> Result<()> {
pub fn add_array_bools(&mut self, datas: &[bool], offset: i64) -> Result<()> {
let mut document = TantivyDocument::default();
for data in datas {
document.add_field_value(self.field, data);
@ -239,7 +239,7 @@ impl IndexWriterWrapper {
self.index_writer_add_document(document)
}
pub fn add_multi_keywords(&mut self, datas: &[*const c_char], offset: i64) -> Result<()> {
pub fn add_array_keywords(&mut self, datas: &[*const c_char], offset: i64) -> Result<()> {
let mut document = TantivyDocument::default();
for element in datas {
let data = unsafe { CStr::from_ptr(*element) };
@ -289,7 +289,7 @@ impl IndexWriterWrapper {
))
}
pub fn add_multi_i8s_by_single_segment_writer(&mut self, datas: &[i8]) -> Result<()> {
pub fn add_array_i8s_by_single_segment_writer(&mut self, datas: &[i8]) -> Result<()> {
let mut document = TantivyDocument::default();
for data in datas {
document.add_field_value(self.field, &(*data as i64));
@ -297,7 +297,7 @@ impl IndexWriterWrapper {
self.single_segment_index_writer_add_document(document)
}
pub fn add_multi_i16s_by_single_segment_writer(&mut self, datas: &[i16]) -> Result<()> {
pub fn add_array_i16s_by_single_segment_writer(&mut self, datas: &[i16]) -> Result<()> {
let mut document = TantivyDocument::default();
for data in datas {
document.add_field_value(self.field, &(*data as i64));
@ -305,7 +305,7 @@ impl IndexWriterWrapper {
self.single_segment_index_writer_add_document(document)
}
pub fn add_multi_i32s_by_single_segment_writer(&mut self, datas: &[i32]) -> Result<()> {
pub fn add_array_i32s_by_single_segment_writer(&mut self, datas: &[i32]) -> Result<()> {
let mut document = TantivyDocument::default();
for data in datas {
document.add_field_value(self.field, &(*data as i64));
@ -313,7 +313,7 @@ impl IndexWriterWrapper {
self.single_segment_index_writer_add_document(document)
}
pub fn add_multi_i64s_by_single_segment_writer(&mut self, datas: &[i64]) -> Result<()> {
pub fn add_array_i64s_by_single_segment_writer(&mut self, datas: &[i64]) -> Result<()> {
let mut document = TantivyDocument::default();
for data in datas {
document.add_field_value(self.field, data);
@ -321,7 +321,7 @@ impl IndexWriterWrapper {
self.single_segment_index_writer_add_document(document)
}
pub fn add_multi_f32s_by_single_segment_writer(&mut self, datas: &[f32]) -> Result<()> {
pub fn add_array_f32s_by_single_segment_writer(&mut self, datas: &[f32]) -> Result<()> {
let mut document = TantivyDocument::default();
for data in datas {
document.add_field_value(self.field, &(*data as f64));
@ -329,7 +329,7 @@ impl IndexWriterWrapper {
self.single_segment_index_writer_add_document(document)
}
pub fn add_multi_f64s_by_single_segment_writer(&mut self, datas: &[f64]) -> Result<()> {
pub fn add_array_f64s_by_single_segment_writer(&mut self, datas: &[f64]) -> Result<()> {
let mut document = TantivyDocument::default();
for data in datas {
document.add_field_value(self.field, data);
@ -337,7 +337,7 @@ impl IndexWriterWrapper {
self.single_segment_index_writer_add_document(document)
}
pub fn add_multi_bools_by_single_segment_writer(&mut self, datas: &[bool]) -> Result<()> {
pub fn add_array_bools_by_single_segment_writer(&mut self, datas: &[bool]) -> Result<()> {
let mut document = TantivyDocument::default();
for data in datas {
document.add_field_value(self.field, data);
@ -345,7 +345,7 @@ impl IndexWriterWrapper {
self.single_segment_index_writer_add_document(document)
}
pub fn add_multi_keywords_by_single_segment_writer(
pub fn add_array_keywords_by_single_segment_writer(
&mut self,
datas: &[*const c_char],
) -> Result<()> {

64
internal/core/thirdparty/tantivy/tantivy-binding/src/index_writer_c.rs vendored
View File

@ -359,7 +359,7 @@ pub extern "C" fn tantivy_index_add_string_by_single_segment_writer(
// --------------------------------------------- array ------------------------------------------
#[no_mangle]
pub extern "C" fn tantivy_index_add_multi_int8s(
pub extern "C" fn tantivy_index_add_array_int8s(
ptr: *mut c_void,
array: *const i8,
len: usize,
@ -368,12 +368,12 @@ pub extern "C" fn tantivy_index_add_multi_int8s(
let real = ptr as *mut IndexWriterWrapper;
unsafe {
let arr = convert_to_rust_slice!(array, len);
(*real).add_multi_i8s(arr, offset).into()
(*real).add_array_i8s(arr, offset).into()
}
}
#[no_mangle]
pub extern "C" fn tantivy_index_add_multi_int8s_by_single_segment_writer(
pub extern "C" fn tantivy_index_add_array_int8s_by_single_segment_writer(
ptr: *mut c_void,
array: *const i8,
len: usize,
@ -381,12 +381,12 @@ pub extern "C" fn tantivy_index_add_multi_int8s_by_single_segment_writer(
let real = ptr as *mut IndexWriterWrapper;
unsafe {
let arr = convert_to_rust_slice!(array, len);
(*real).add_multi_i8s_by_single_segment_writer(arr).into()
(*real).add_array_i8s_by_single_segment_writer(arr).into()
}
}
#[no_mangle]
pub extern "C" fn tantivy_index_add_multi_int16s(
pub extern "C" fn tantivy_index_add_array_int16s(
ptr: *mut c_void,
array: *const i16,
len: usize,
@ -395,12 +395,12 @@ pub extern "C" fn tantivy_index_add_multi_int16s(
let real = ptr as *mut IndexWriterWrapper;
unsafe {
let arr = convert_to_rust_slice!(array, len);
(*real).add_multi_i16s(arr, offset).into()
(*real).add_array_i16s(arr, offset).into()
}
}
#[no_mangle]
pub extern "C" fn tantivy_index_add_multi_int16s_by_single_segment_writer(
pub extern "C" fn tantivy_index_add_array_int16s_by_single_segment_writer(
ptr: *mut c_void,
array: *const i16,
len: usize,
@ -408,12 +408,12 @@ pub extern "C" fn tantivy_index_add_multi_int16s_by_single_segment_writer(
let real = ptr as *mut IndexWriterWrapper;
unsafe {
let arr = convert_to_rust_slice!(array, len);
(*real).add_multi_i16s_by_single_segment_writer(arr).into()
(*real).add_array_i16s_by_single_segment_writer(arr).into()
}
}
#[no_mangle]
pub extern "C" fn tantivy_index_add_multi_int32s(
pub extern "C" fn tantivy_index_add_array_int32s(
ptr: *mut c_void,
array: *const i32,
len: usize,
@ -422,12 +422,12 @@ pub extern "C" fn tantivy_index_add_multi_int32s(
let real = ptr as *mut IndexWriterWrapper;
unsafe {
let arr = convert_to_rust_slice!(array, len);
(*real).add_multi_i32s(arr, offset).into()
(*real).add_array_i32s(arr, offset).into()
}
}
#[no_mangle]
pub extern "C" fn tantivy_index_add_multi_int32s_by_single_segment_writer(
pub extern "C" fn tantivy_index_add_array_int32s_by_single_segment_writer(
ptr: *mut c_void,
array: *const i32,
len: usize,
@ -435,12 +435,12 @@ pub extern "C" fn tantivy_index_add_multi_int32s_by_single_segment_writer(
let real = ptr as *mut IndexWriterWrapper;
unsafe {
let arr = convert_to_rust_slice!(array, len);
(*real).add_multi_i32s_by_single_segment_writer(arr).into()
(*real).add_array_i32s_by_single_segment_writer(arr).into()
}
}
#[no_mangle]
pub extern "C" fn tantivy_index_add_multi_int64s(
pub extern "C" fn tantivy_index_add_array_int64s(
ptr: *mut c_void,
array: *const i64,
len: usize,
@ -449,12 +449,12 @@ pub extern "C" fn tantivy_index_add_multi_int64s(
let real = ptr as *mut IndexWriterWrapper;
unsafe {
let arr = convert_to_rust_slice!(array, len);
(*real).add_multi_i64s(arr, offset).into()
(*real).add_array_i64s(arr, offset).into()
}
}
#[no_mangle]
pub extern "C" fn tantivy_index_add_multi_int64s_by_single_segment_writer(
pub extern "C" fn tantivy_index_add_array_int64s_by_single_segment_writer(
ptr: *mut c_void,
array: *const i64,
len: usize,
@ -462,12 +462,12 @@ pub extern "C" fn tantivy_index_add_multi_int64s_by_single_segment_writer(
let real = ptr as *mut IndexWriterWrapper;
unsafe {
let arr = convert_to_rust_slice!(array, len);
(*real).add_multi_i64s_by_single_segment_writer(arr).into()
(*real).add_array_i64s_by_single_segment_writer(arr).into()
}
}
#[no_mangle]
pub extern "C" fn tantivy_index_add_multi_f32s(
pub extern "C" fn tantivy_index_add_array_f32s(
ptr: *mut c_void,
array: *const f32,
len: usize,
@ -476,12 +476,12 @@ pub extern "C" fn tantivy_index_add_multi_f32s(
let real = ptr as *mut IndexWriterWrapper;
unsafe {
let arr = convert_to_rust_slice!(array, len);
(*real).add_multi_f32s(arr, offset).into()
(*real).add_array_f32s(arr, offset).into()
}
}
#[no_mangle]
pub extern "C" fn tantivy_index_add_multi_f32s_by_single_segment_writer(
pub extern "C" fn tantivy_index_add_array_f32s_by_single_segment_writer(
ptr: *mut c_void,
array: *const f32,
len: usize,
@ -489,12 +489,12 @@ pub extern "C" fn tantivy_index_add_multi_f32s_by_single_segment_writer(
let real = ptr as *mut IndexWriterWrapper;
unsafe {
let arr = convert_to_rust_slice!(array, len);
(*real).add_multi_f32s_by_single_segment_writer(arr).into()
(*real).add_array_f32s_by_single_segment_writer(arr).into()
}
}
#[no_mangle]
pub extern "C" fn tantivy_index_add_multi_f64s(
pub extern "C" fn tantivy_index_add_array_f64s(
ptr: *mut c_void,
array: *const f64,
len: usize,
@ -503,12 +503,12 @@ pub extern "C" fn tantivy_index_add_multi_f64s(
let real = ptr as *mut IndexWriterWrapper;
unsafe {
let arr = convert_to_rust_slice!(array, len);
(*real).add_multi_f64s(arr, offset).into()
(*real).add_array_f64s(arr, offset).into()
}
}
#[no_mangle]
pub extern "C" fn tantivy_index_add_multi_f64s_by_single_segment_writer(
pub extern "C" fn tantivy_index_add_array_f64s_by_single_segment_writer(
ptr: *mut c_void,
array: *const f64,
len: usize,
@ -516,12 +516,12 @@ pub extern "C" fn tantivy_index_add_multi_f64s_by_single_segment_writer(
let real = ptr as *mut IndexWriterWrapper;
unsafe {
let arr = convert_to_rust_slice!(array, len);
(*real).add_multi_f64s_by_single_segment_writer(arr).into()
(*real).add_array_f64s_by_single_segment_writer(arr).into()
}
}
#[no_mangle]
pub extern "C" fn tantivy_index_add_multi_bools(
pub extern "C" fn tantivy_index_add_array_bools(
ptr: *mut c_void,
array: *const bool,
len: usize,
@ -530,12 +530,12 @@ pub extern "C" fn tantivy_index_add_multi_bools(
let real = ptr as *mut IndexWriterWrapper;
unsafe {
let arr = convert_to_rust_slice!(array, len);
(*real).add_multi_bools(arr, offset).into()
(*real).add_array_bools(arr, offset).into()
}
}
#[no_mangle]
pub extern "C" fn tantivy_index_add_multi_bools_by_single_segment_writer(
pub extern "C" fn tantivy_index_add_array_bools_by_single_segment_writer(
ptr: *mut c_void,
array: *const bool,
len: usize,
@ -543,12 +543,12 @@ pub extern "C" fn tantivy_index_add_multi_bools_by_single_segment_writer(
let real = ptr as *mut IndexWriterWrapper;
unsafe {
let arr = convert_to_rust_slice!(array, len);
(*real).add_multi_bools_by_single_segment_writer(arr).into()
(*real).add_array_bools_by_single_segment_writer(arr).into()
}
}
#[no_mangle]
pub extern "C" fn tantivy_index_add_multi_keywords(
pub extern "C" fn tantivy_index_add_array_keywords(
ptr: *mut c_void,
array: *const *const c_char,
len: usize,
@ -557,12 +557,12 @@ pub extern "C" fn tantivy_index_add_multi_keywords(
let real = ptr as *mut IndexWriterWrapper;
unsafe {
let arr = convert_to_rust_slice!(array, len);
(*real).add_multi_keywords(arr, offset).into()
(*real).add_array_keywords(arr, offset).into()
}
}
#[no_mangle]
pub extern "C" fn tantivy_index_add_multi_keywords_by_single_segment_writer(
pub extern "C" fn tantivy_index_add_array_keywords_by_single_segment_writer(
ptr: *mut c_void,
array: *const *const c_char,
len: usize,
@ -571,7 +571,7 @@ pub extern "C" fn tantivy_index_add_multi_keywords_by_single_segment_writer(
unsafe {
let arr = convert_to_rust_slice!(array, len);
(*real)
.add_multi_keywords_by_single_segment_writer(arr)
.add_array_keywords_by_single_segment_writer(arr)
.into()
}
}

40
internal/core/thirdparty/tantivy/tantivy-wrapper.h vendored
View File

@ -264,12 +264,12 @@ struct TantivyIndexWrapper {
template <typename T>
void
add_multi_data(const T* array, uintptr_t len, int64_t offset) {
add_array_data(const T* array, uintptr_t len, int64_t offset) {
assert(!finished_);
if constexpr (std::is_same_v<T, bool>) {
auto res = RustResultWrapper(
tantivy_index_add_multi_bools(writer_, array, len, offset));
tantivy_index_add_array_bools(writer_, array, len, offset));
AssertInfo(res.result_->success,
"failed to add multi bools: {}",
res.result_->error);
@ -278,7 +278,7 @@ struct TantivyIndexWrapper {
if constexpr (std::is_same_v<T, int8_t>) {
auto res = RustResultWrapper(
tantivy_index_add_multi_int8s(writer_, array, len, offset));
tantivy_index_add_array_int8s(writer_, array, len, offset));
AssertInfo(res.result_->success,
"failed to add multi int8s: {}",
res.result_->error);
@ -287,7 +287,7 @@ struct TantivyIndexWrapper {
if constexpr (std::is_same_v<T, int16_t>) {
auto res = RustResultWrapper(
tantivy_index_add_multi_int16s(writer_, array, len, offset));
tantivy_index_add_array_int16s(writer_, array, len, offset));
AssertInfo(res.result_->success,
"failed to add multi int16s: {}",
res.result_->error);
@ -296,7 +296,7 @@ struct TantivyIndexWrapper {
if constexpr (std::is_same_v<T, int32_t>) {
auto res = RustResultWrapper(
tantivy_index_add_multi_int32s(writer_, array, len, offset));
tantivy_index_add_array_int32s(writer_, array, len, offset));
AssertInfo(res.result_->success,
"failed to add multi int32s: {}",
res.result_->error);
@ -305,7 +305,7 @@ struct TantivyIndexWrapper {
if constexpr (std::is_same_v<T, int64_t>) {
auto res = RustResultWrapper(
tantivy_index_add_multi_int64s(writer_, array, len, offset));
tantivy_index_add_array_int64s(writer_, array, len, offset));
AssertInfo(res.result_->success,
"failed to add multi int64s: {}",
res.result_->error);
@ -314,7 +314,7 @@ struct TantivyIndexWrapper {
if constexpr (std::is_same_v<T, float>) {
auto res = RustResultWrapper(
tantivy_index_add_multi_f32s(writer_, array, len, offset));
tantivy_index_add_array_f32s(writer_, array, len, offset));
AssertInfo(res.result_->success,
"failed to add multi f32s: {}",
res.result_->error);
@ -323,7 +323,7 @@ struct TantivyIndexWrapper {
if constexpr (std::is_same_v<T, double>) {
auto res = RustResultWrapper(
tantivy_index_add_multi_f64s(writer_, array, len, offset));
tantivy_index_add_array_f64s(writer_, array, len, offset));
AssertInfo(res.result_->success,
"failed to add multi f64s: {}",
res.result_->error);
@ -335,7 +335,7 @@ struct TantivyIndexWrapper {
for (uintptr_t i = 0; i < len; i++) {
views.push_back(array[i].c_str());
}
auto res = RustResultWrapper(tantivy_index_add_multi_keywords(
auto res = RustResultWrapper(tantivy_index_add_array_keywords(
writer_, views.data(), len, offset));
AssertInfo(res.result_->success,
"failed to add multi keywords: {}",
@ -344,7 +344,7 @@ struct TantivyIndexWrapper {
}
throw fmt::format(
"InvertedIndex.add_multi_data: unsupported data type: {}",
"InvertedIndex.add_array_data: unsupported data type: {}",
typeid(T).name());
}
@ -443,12 +443,12 @@ struct TantivyIndexWrapper {
template <typename T>
void
add_multi_data_by_single_segment_writer(const T* array, uintptr_t len) {
add_array_data_by_single_segment_writer(const T* array, uintptr_t len) {
assert(!finished_);
if constexpr (std::is_same_v<T, bool>) {
auto res = RustResultWrapper(
tantivy_index_add_multi_bools_by_single_segment_writer(
tantivy_index_add_array_bools_by_single_segment_writer(
writer_, array, len));
AssertInfo(res.result_->success,
"failed to add multi bools: {}",
@ -458,7 +458,7 @@ struct TantivyIndexWrapper {
if constexpr (std::is_same_v<T, int8_t>) {
auto res = RustResultWrapper(
tantivy_index_add_multi_int8s_by_single_segment_writer(
tantivy_index_add_array_int8s_by_single_segment_writer(
writer_, array, len));
AssertInfo(res.result_->success,
"failed to add multi int8s: {}",
@ -468,7 +468,7 @@ struct TantivyIndexWrapper {
if constexpr (std::is_same_v<T, int16_t>) {
auto res = RustResultWrapper(
tantivy_index_add_multi_int16s_by_single_segment_writer(
tantivy_index_add_array_int16s_by_single_segment_writer(
writer_, array, len));
AssertInfo(res.result_->success,
"failed to add multi int16s: {}",
@ -478,7 +478,7 @@ struct TantivyIndexWrapper {
if constexpr (std::is_same_v<T, int32_t>) {
auto res = RustResultWrapper(
tantivy_index_add_multi_int32s_by_single_segment_writer(
tantivy_index_add_array_int32s_by_single_segment_writer(
writer_, array, len));
AssertInfo(res.result_->success,
"failed to add multi int32s: {}",
@ -488,7 +488,7 @@ struct TantivyIndexWrapper {
if constexpr (std::is_same_v<T, int64_t>) {
auto res = RustResultWrapper(
tantivy_index_add_multi_int64s_by_single_segment_writer(
tantivy_index_add_array_int64s_by_single_segment_writer(
writer_, array, len));
AssertInfo(res.result_->success,
"failed to add multi int64s: {}",
@ -498,7 +498,7 @@ struct TantivyIndexWrapper {
if constexpr (std::is_same_v<T, float>) {
auto res = RustResultWrapper(
tantivy_index_add_multi_f32s_by_single_segment_writer(
tantivy_index_add_array_f32s_by_single_segment_writer(
writer_, array, len));
AssertInfo(res.result_->success,
"failed to add multi f32s: {}",
@ -508,7 +508,7 @@ struct TantivyIndexWrapper {
if constexpr (std::is_same_v<T, double>) {
auto res = RustResultWrapper(
tantivy_index_add_multi_f64s_by_single_segment_writer(
tantivy_index_add_array_f64s_by_single_segment_writer(
writer_, array, len));
AssertInfo(res.result_->success,
"failed to add multi f64s: {}",
@ -522,7 +522,7 @@ struct TantivyIndexWrapper {
views.push_back(array[i].c_str());
}
auto res = RustResultWrapper(
tantivy_index_add_multi_keywords_by_single_segment_writer(
tantivy_index_add_array_keywords_by_single_segment_writer(
writer_, views.data(), len));
AssertInfo(res.result_->success,
"failed to add multi keywords: {}",
@ -531,7 +531,7 @@ struct TantivyIndexWrapper {
}
throw fmt::format(
"InvertedIndex.add_multi_data: unsupported data type: {}",
"InvertedIndex.add_array_data: unsupported data type: {}",
typeid(T).name());
}

4
internal/core/thirdparty/tantivy/test.cpp vendored
View File

@ -235,7 +235,7 @@ test_array_int() {
int64_t offset = 0;
for (const auto& arr : vec_of_array) {
w.add_multi_data(arr.data(), arr.size(), offset++);
w.add_array_data(arr.data(), arr.size(), offset++);
}
w.finish();
@ -266,7 +266,7 @@ test_array_string() {
int64_t offset = 0;
for (const auto& arr : vec_of_array) {
w.add_multi_data(arr.data(), arr.size(), offset++);
w.add_array_data(arr.data(), arr.size(), offset++);
}
w.finish();