709 lines
27 KiB
Rust
709 lines
27 KiB
Rust
use crate::error::DBError;
|
|
use serde::{Deserialize, Serialize};
|
|
use std::collections::HashMap;
|
|
use std::path::PathBuf;
|
|
use std::sync::{Arc, RwLock};
|
|
use tantivy::{
|
|
collector::TopDocs,
|
|
directory::MmapDirectory,
|
|
query::{BooleanQuery, Occur, Query, QueryParser, TermQuery},
|
|
schema::{
|
|
DateOptions, Field, IndexRecordOption, NumericOptions, Schema, TextFieldIndexing, TextOptions, STORED, STRING,
|
|
},
|
|
tokenizer::TokenizerManager,
|
|
DateTime, Index, IndexReader, IndexWriter, TantivyDocument, Term,
|
|
};
|
|
use tantivy::schema::Value;
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub enum FieldDef {
|
|
Text {
|
|
stored: bool,
|
|
indexed: bool,
|
|
tokenized: bool,
|
|
fast: bool,
|
|
},
|
|
Numeric {
|
|
stored: bool,
|
|
indexed: bool,
|
|
fast: bool,
|
|
precision: NumericType,
|
|
},
|
|
Tag {
|
|
stored: bool,
|
|
separator: String,
|
|
case_sensitive: bool,
|
|
},
|
|
Geo {
|
|
stored: bool,
|
|
},
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub enum NumericType {
|
|
I64,
|
|
U64,
|
|
F64,
|
|
Date,
|
|
}
|
|
|
|
pub struct IndexSchema {
|
|
schema: Schema,
|
|
fields: HashMap<String, (Field, FieldDef)>,
|
|
default_search_fields: Vec<Field>,
|
|
}
|
|
|
|
pub struct TantivySearch {
|
|
index: Index,
|
|
writer: Arc<RwLock<IndexWriter>>,
|
|
reader: IndexReader,
|
|
index_schema: IndexSchema,
|
|
name: String,
|
|
config: IndexConfig,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct IndexConfig {
|
|
pub language: String,
|
|
pub stopwords: Vec<String>,
|
|
pub stemming: bool,
|
|
pub max_doc_count: Option<usize>,
|
|
pub default_score: f64,
|
|
}
|
|
|
|
impl Default for IndexConfig {
|
|
fn default() -> Self {
|
|
IndexConfig {
|
|
language: "english".to_string(),
|
|
stopwords: vec![],
|
|
stemming: true,
|
|
max_doc_count: None,
|
|
default_score: 1.0,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TantivySearch {
|
|
pub fn new_with_schema(
|
|
base_path: PathBuf,
|
|
name: String,
|
|
field_definitions: Vec<(String, FieldDef)>,
|
|
config: Option<IndexConfig>,
|
|
) -> Result<Self, DBError> {
|
|
let index_path = base_path.join(&name);
|
|
std::fs::create_dir_all(&index_path)
|
|
.map_err(|e| DBError(format!("Failed to create index dir: {}", e)))?;
|
|
|
|
// Build schema from field definitions
|
|
let mut schema_builder = Schema::builder();
|
|
let mut fields = HashMap::new();
|
|
let mut default_search_fields = Vec::new();
|
|
|
|
// Always add a document ID field
|
|
let id_field = schema_builder.add_text_field("_id", STRING | STORED);
|
|
fields.insert(
|
|
"_id".to_string(),
|
|
(
|
|
id_field,
|
|
FieldDef::Text {
|
|
stored: true,
|
|
indexed: true,
|
|
tokenized: false,
|
|
fast: false,
|
|
},
|
|
),
|
|
);
|
|
|
|
// Add user-defined fields
|
|
for (field_name, field_def) in field_definitions {
|
|
let field = match &field_def {
|
|
FieldDef::Text {
|
|
stored,
|
|
indexed,
|
|
tokenized,
|
|
fast: _fast,
|
|
} => {
|
|
let mut text_options = TextOptions::default();
|
|
if *stored {
|
|
text_options = text_options.set_stored();
|
|
}
|
|
if *indexed {
|
|
let indexing_options = if *tokenized {
|
|
TextFieldIndexing::default()
|
|
.set_tokenizer("default")
|
|
.set_index_option(IndexRecordOption::WithFreqsAndPositions)
|
|
} else {
|
|
TextFieldIndexing::default()
|
|
.set_tokenizer("raw")
|
|
.set_index_option(IndexRecordOption::Basic)
|
|
};
|
|
text_options = text_options.set_indexing_options(indexing_options);
|
|
let f = schema_builder.add_text_field(&field_name, text_options);
|
|
if *tokenized {
|
|
default_search_fields.push(f);
|
|
}
|
|
f
|
|
} else {
|
|
schema_builder.add_text_field(&field_name, text_options)
|
|
}
|
|
}
|
|
FieldDef::Numeric {
|
|
stored,
|
|
indexed,
|
|
fast,
|
|
precision,
|
|
} => match precision {
|
|
NumericType::I64 => {
|
|
let mut opts = NumericOptions::default();
|
|
if *stored {
|
|
opts = opts.set_stored();
|
|
}
|
|
if *indexed {
|
|
opts = opts.set_indexed();
|
|
}
|
|
if *fast {
|
|
opts = opts.set_fast();
|
|
}
|
|
schema_builder.add_i64_field(&field_name, opts)
|
|
}
|
|
NumericType::U64 => {
|
|
let mut opts = NumericOptions::default();
|
|
if *stored {
|
|
opts = opts.set_stored();
|
|
}
|
|
if *indexed {
|
|
opts = opts.set_indexed();
|
|
}
|
|
if *fast {
|
|
opts = opts.set_fast();
|
|
}
|
|
schema_builder.add_u64_field(&field_name, opts)
|
|
}
|
|
NumericType::F64 => {
|
|
let mut opts = NumericOptions::default();
|
|
if *stored {
|
|
opts = opts.set_stored();
|
|
}
|
|
if *indexed {
|
|
opts = opts.set_indexed();
|
|
}
|
|
if *fast {
|
|
opts = opts.set_fast();
|
|
}
|
|
schema_builder.add_f64_field(&field_name, opts)
|
|
}
|
|
NumericType::Date => {
|
|
let mut opts = DateOptions::default();
|
|
if *stored {
|
|
opts = opts.set_stored();
|
|
}
|
|
if *indexed {
|
|
opts = opts.set_indexed();
|
|
}
|
|
if *fast {
|
|
opts = opts.set_fast();
|
|
}
|
|
schema_builder.add_date_field(&field_name, opts)
|
|
}
|
|
},
|
|
FieldDef::Tag {
|
|
stored,
|
|
separator: _,
|
|
case_sensitive: _,
|
|
} => {
|
|
let mut text_options = TextOptions::default();
|
|
if *stored {
|
|
text_options = text_options.set_stored();
|
|
}
|
|
text_options = text_options.set_indexing_options(
|
|
TextFieldIndexing::default()
|
|
.set_tokenizer("raw")
|
|
.set_index_option(IndexRecordOption::Basic),
|
|
);
|
|
schema_builder.add_text_field(&field_name, text_options)
|
|
}
|
|
FieldDef::Geo { stored } => {
|
|
// For now, store as two f64 fields for lat/lon
|
|
let mut opts = NumericOptions::default();
|
|
if *stored {
|
|
opts = opts.set_stored();
|
|
}
|
|
opts = opts.set_indexed().set_fast();
|
|
let lat_field =
|
|
schema_builder.add_f64_field(&format!("{}_lat", field_name), opts.clone());
|
|
let lon_field =
|
|
schema_builder.add_f64_field(&format!("{}_lon", field_name), opts);
|
|
fields.insert(
|
|
format!("{}_lat", field_name),
|
|
(
|
|
lat_field,
|
|
FieldDef::Numeric {
|
|
stored: *stored,
|
|
indexed: true,
|
|
fast: true,
|
|
precision: NumericType::F64,
|
|
},
|
|
),
|
|
);
|
|
fields.insert(
|
|
format!("{}_lon", field_name),
|
|
(
|
|
lon_field,
|
|
FieldDef::Numeric {
|
|
stored: *stored,
|
|
indexed: true,
|
|
fast: true,
|
|
precision: NumericType::F64,
|
|
},
|
|
),
|
|
);
|
|
continue; // Skip adding the geo field itself
|
|
}
|
|
};
|
|
fields.insert(field_name.clone(), (field, field_def));
|
|
}
|
|
|
|
let schema = schema_builder.build();
|
|
let index_schema = IndexSchema {
|
|
schema: schema.clone(),
|
|
fields,
|
|
default_search_fields,
|
|
};
|
|
|
|
// Create or open index
|
|
let dir = MmapDirectory::open(&index_path)
|
|
.map_err(|e| DBError(format!("Failed to open index directory: {}", e)))?;
|
|
let mut index =
|
|
Index::open_or_create(dir, schema).map_err(|e| DBError(format!("Failed to create index: {}", e)))?;
|
|
|
|
// Configure tokenizers
|
|
let tokenizer_manager = TokenizerManager::default();
|
|
index.set_tokenizers(tokenizer_manager);
|
|
|
|
let writer = index
|
|
.writer(15_000_000)
|
|
.map_err(|e| DBError(format!("Failed to create index writer: {}", e)))?;
|
|
let reader = index
|
|
.reader()
|
|
.map_err(|e| DBError(format!("Failed to create reader: {}", e)))?;
|
|
|
|
let config = config.unwrap_or_default();
|
|
|
|
Ok(TantivySearch {
|
|
index,
|
|
writer: Arc::new(RwLock::new(writer)),
|
|
reader,
|
|
index_schema,
|
|
name,
|
|
config,
|
|
})
|
|
}
|
|
|
|
pub fn add_document_with_fields(
|
|
&self,
|
|
doc_id: &str,
|
|
fields: HashMap<String, String>,
|
|
) -> Result<(), DBError> {
|
|
let mut writer = self
|
|
.writer
|
|
.write()
|
|
.map_err(|e| DBError(format!("Failed to acquire writer lock: {}", e)))?;
|
|
|
|
// Delete existing document with same ID
|
|
if let Some((id_field, _)) = self.index_schema.fields.get("_id") {
|
|
writer.delete_term(Term::from_field_text(*id_field, doc_id));
|
|
}
|
|
|
|
// Create new document
|
|
let mut doc = tantivy::doc!();
|
|
|
|
// Add document ID
|
|
if let Some((id_field, _)) = self.index_schema.fields.get("_id") {
|
|
doc.add_text(*id_field, doc_id);
|
|
}
|
|
|
|
// Add other fields based on schema
|
|
for (field_name, field_value) in fields {
|
|
if let Some((field, field_def)) = self.index_schema.fields.get(&field_name) {
|
|
match field_def {
|
|
FieldDef::Text { .. } => {
|
|
doc.add_text(*field, &field_value);
|
|
}
|
|
FieldDef::Numeric { precision, .. } => match precision {
|
|
NumericType::I64 => {
|
|
if let Ok(v) = field_value.parse::<i64>() {
|
|
doc.add_i64(*field, v);
|
|
}
|
|
}
|
|
NumericType::U64 => {
|
|
if let Ok(v) = field_value.parse::<u64>() {
|
|
doc.add_u64(*field, v);
|
|
}
|
|
}
|
|
NumericType::F64 => {
|
|
if let Ok(v) = field_value.parse::<f64>() {
|
|
doc.add_f64(*field, v);
|
|
}
|
|
}
|
|
NumericType::Date => {
|
|
if let Ok(v) = field_value.parse::<i64>() {
|
|
doc.add_date(*field, DateTime::from_timestamp_millis(v));
|
|
}
|
|
}
|
|
},
|
|
FieldDef::Tag {
|
|
separator,
|
|
case_sensitive,
|
|
..
|
|
} => {
|
|
let tags = if !case_sensitive {
|
|
field_value.to_lowercase()
|
|
} else {
|
|
field_value.clone()
|
|
};
|
|
for tag in tags.split(separator.as_str()) {
|
|
doc.add_text(*field, tag.trim());
|
|
}
|
|
}
|
|
FieldDef::Geo { .. } => {
|
|
let parts: Vec<&str> = field_value.split(',').collect();
|
|
if parts.len() == 2 {
|
|
if let (Ok(lat), Ok(lon)) =
|
|
(parts[0].parse::<f64>(), parts[1].parse::<f64>())
|
|
{
|
|
if let Some((lat_field, _)) =
|
|
self.index_schema.fields.get(&format!("{}_lat", field_name))
|
|
{
|
|
doc.add_f64(*lat_field, lat);
|
|
}
|
|
if let Some((lon_field, _)) =
|
|
self.index_schema.fields.get(&format!("{}_lon", field_name))
|
|
{
|
|
doc.add_f64(*lon_field, lon);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
writer
|
|
.add_document(doc)
|
|
.map_err(|e| DBError(format!("Failed to add document: {}", e)))?;
|
|
writer
|
|
.commit()
|
|
.map_err(|e| DBError(format!("Failed to commit: {}", e)))?;
|
|
// Make new documents visible to searches
|
|
self.reader
|
|
.reload()
|
|
.map_err(|e| DBError(format!("Failed to reload reader: {}", e)))?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn search_with_options(
|
|
&self,
|
|
query_str: &str,
|
|
options: SearchOptions,
|
|
) -> Result<SearchResults, DBError> {
|
|
// Ensure reader is up to date with latest commits
|
|
self.reader
|
|
.reload()
|
|
.map_err(|e| DBError(format!("Failed to reload reader: {}", e)))?;
|
|
let searcher = self.reader.searcher();
|
|
|
|
// Ensure we have searchable fields
|
|
if self.index_schema.default_search_fields.is_empty() {
|
|
return Err(DBError("No searchable fields defined in schema".to_string()));
|
|
}
|
|
|
|
// Parse query based on search fields
|
|
let query_parser = QueryParser::for_index(
|
|
&self.index,
|
|
self.index_schema.default_search_fields.clone(),
|
|
);
|
|
let parsed_query = query_parser
|
|
.parse_query(query_str)
|
|
.map_err(|e| DBError(format!("Failed to parse query: {}", e)))?;
|
|
let mut clauses: Vec<(Occur, Box<dyn Query>)> = vec![(Occur::Must, parsed_query)];
|
|
|
|
// Apply filters if any
|
|
for filter in options.filters {
|
|
if let Some((field, field_def)) = self.index_schema.fields.get(&filter.field) {
|
|
match filter.filter_type {
|
|
FilterType::Equals(value) => {
|
|
match field_def {
|
|
FieldDef::Text { .. } | FieldDef::Tag { .. } => {
|
|
let term_query =
|
|
TermQuery::new(Term::from_field_text(*field, &value), IndexRecordOption::Basic);
|
|
clauses.push((Occur::Must, Box::new(term_query)));
|
|
}
|
|
FieldDef::Numeric { precision, .. } => {
|
|
// Equals on numeric fields: parse to the right numeric type and use term query
|
|
match precision {
|
|
NumericType::I64 => {
|
|
if let Ok(v) = value.parse::<i64>() {
|
|
let term = Term::from_field_i64(*field, v);
|
|
let tq = TermQuery::new(term, IndexRecordOption::Basic);
|
|
clauses.push((Occur::Must, Box::new(tq)));
|
|
}
|
|
}
|
|
NumericType::U64 => {
|
|
if let Ok(v) = value.parse::<u64>() {
|
|
let term = Term::from_field_u64(*field, v);
|
|
let tq = TermQuery::new(term, IndexRecordOption::Basic);
|
|
clauses.push((Occur::Must, Box::new(tq)));
|
|
}
|
|
}
|
|
NumericType::F64 => {
|
|
if let Ok(v) = value.parse::<f64>() {
|
|
let term = Term::from_field_f64(*field, v);
|
|
let tq = TermQuery::new(term, IndexRecordOption::Basic);
|
|
clauses.push((Occur::Must, Box::new(tq)));
|
|
}
|
|
}
|
|
NumericType::Date => {
|
|
if let Ok(v) = value.parse::<i64>() {
|
|
let dt = DateTime::from_timestamp_millis(v);
|
|
let term = Term::from_field_date(*field, dt);
|
|
let tq = TermQuery::new(term, IndexRecordOption::Basic);
|
|
clauses.push((Occur::Must, Box::new(tq)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
FieldDef::Geo { .. } => {
|
|
// Geo equals isn't supported in this simplified version
|
|
}
|
|
}
|
|
}
|
|
FilterType::Range { .. } => {
|
|
// TODO: Implement numeric range queries by building a RangeQuery per type
|
|
}
|
|
FilterType::InSet(values) => {
|
|
// OR across values
|
|
let mut sub_clauses: Vec<(Occur, Box<dyn Query>)> = vec![];
|
|
for value in values {
|
|
let term_query = TermQuery::new(
|
|
Term::from_field_text(*field, &value),
|
|
IndexRecordOption::Basic,
|
|
);
|
|
sub_clauses.push((Occur::Should, Box::new(term_query)));
|
|
}
|
|
clauses.push((Occur::Must, Box::new(BooleanQuery::new(sub_clauses))));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
let final_query: Box<dyn Query> = if clauses.len() == 1 {
|
|
clauses.pop().unwrap().1
|
|
} else {
|
|
Box::new(BooleanQuery::new(clauses))
|
|
};
|
|
|
|
// Execute search
|
|
let top_docs = searcher
|
|
.search(&*final_query, &TopDocs::with_limit(options.limit + options.offset))
|
|
.map_err(|e| DBError(format!("Search failed: {}", e)))?;
|
|
let total_hits = top_docs.len();
|
|
let mut documents = Vec::new();
|
|
|
|
for (score, doc_address) in top_docs.into_iter().skip(options.offset).take(options.limit) {
|
|
let retrieved_doc: TantivyDocument = searcher
|
|
.doc(doc_address)
|
|
.map_err(|e| DBError(format!("Failed to retrieve doc: {}", e)))?;
|
|
|
|
let mut doc_fields = HashMap::new();
|
|
|
|
// Extract stored fields (or synthesize)
|
|
for (field_name, (field, field_def)) in &self.index_schema.fields {
|
|
match field_def {
|
|
FieldDef::Text { stored, .. } | FieldDef::Tag { stored, .. } => {
|
|
if *stored {
|
|
if let Some(value) = retrieved_doc.get_first(*field) {
|
|
if let Some(text) = value.as_str() {
|
|
doc_fields.insert(field_name.clone(), text.to_string());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
FieldDef::Numeric {
|
|
stored, precision, ..
|
|
} => {
|
|
if *stored {
|
|
let value_str = match precision {
|
|
NumericType::I64 => retrieved_doc
|
|
.get_first(*field)
|
|
.and_then(|v| v.as_i64())
|
|
.map(|v| v.to_string()),
|
|
NumericType::U64 => retrieved_doc
|
|
.get_first(*field)
|
|
.and_then(|v| v.as_u64())
|
|
.map(|v| v.to_string()),
|
|
NumericType::F64 => retrieved_doc
|
|
.get_first(*field)
|
|
.and_then(|v| v.as_f64())
|
|
.map(|v| v.to_string()),
|
|
NumericType::Date => retrieved_doc
|
|
.get_first(*field)
|
|
.and_then(|v| v.as_datetime())
|
|
.map(|v| v.into_timestamp_millis().to_string()),
|
|
};
|
|
if let Some(v) = value_str {
|
|
doc_fields.insert(field_name.clone(), v);
|
|
}
|
|
}
|
|
}
|
|
FieldDef::Geo { stored } => {
|
|
if *stored {
|
|
let lat_field = self
|
|
.index_schema
|
|
.fields
|
|
.get(&format!("{}_lat", field_name))
|
|
.unwrap()
|
|
.0;
|
|
let lon_field = self
|
|
.index_schema
|
|
.fields
|
|
.get(&format!("{}_lon", field_name))
|
|
.unwrap()
|
|
.0;
|
|
let lat = retrieved_doc.get_first(lat_field).and_then(|v| v.as_f64());
|
|
let lon = retrieved_doc.get_first(lon_field).and_then(|v| v.as_f64());
|
|
if let (Some(lat), Some(lon)) = (lat, lon) {
|
|
doc_fields.insert(field_name.clone(), format!("{},{}", lat, lon));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
documents.push(SearchDocument {
|
|
fields: doc_fields,
|
|
score,
|
|
});
|
|
}
|
|
|
|
Ok(SearchResults {
|
|
total: total_hits,
|
|
documents,
|
|
})
|
|
}
|
|
|
|
pub fn get_info(&self) -> Result<IndexInfo, DBError> {
|
|
let searcher = self.reader.searcher();
|
|
let num_docs = searcher.num_docs();
|
|
let fields_info: Vec<FieldInfo> = self
|
|
.index_schema
|
|
.fields
|
|
.iter()
|
|
.map(|(name, (_, def))| FieldInfo {
|
|
name: name.clone(),
|
|
field_type: format!("{:?}", def),
|
|
})
|
|
.collect();
|
|
Ok(IndexInfo {
|
|
name: self.name.clone(),
|
|
num_docs,
|
|
fields: fields_info,
|
|
config: self.config.clone(),
|
|
})
|
|
}
|
|
|
|
/// Delete a document by its _id term. Returns true if the document existed before deletion.
|
|
pub fn delete_document_by_id(&self, doc_id: &str) -> Result<bool, DBError> {
|
|
// Determine existence by running a tiny term query
|
|
let existed = if let Some((id_field, _)) = self.index_schema.fields.get("_id") {
|
|
let term = Term::from_field_text(*id_field, doc_id);
|
|
let searcher = self.reader.searcher();
|
|
let tq = TermQuery::new(term.clone(), IndexRecordOption::Basic);
|
|
let hits = searcher
|
|
.search(&tq, &TopDocs::with_limit(1))
|
|
.map_err(|e| DBError(format!("Failed to search for existing doc: {}", e)))?;
|
|
!hits.is_empty()
|
|
} else {
|
|
false
|
|
};
|
|
|
|
// Perform deletion and commit
|
|
let mut writer = self
|
|
.writer
|
|
.write()
|
|
.map_err(|e| DBError(format!("Failed to acquire writer lock: {}", e)))?;
|
|
if let Some((id_field, _)) = self.index_schema.fields.get("_id") {
|
|
writer.delete_term(Term::from_field_text(*id_field, doc_id));
|
|
}
|
|
writer
|
|
.commit()
|
|
.map_err(|e| DBError(format!("Failed to commit delete: {}", e)))?;
|
|
// Refresh reader to observe deletion
|
|
self.reader
|
|
.reload()
|
|
.map_err(|e| DBError(format!("Failed to reload reader: {}", e)))?;
|
|
|
|
Ok(existed)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct SearchOptions {
|
|
pub limit: usize,
|
|
pub offset: usize,
|
|
pub filters: Vec<Filter>,
|
|
pub sort_by: Option<String>,
|
|
pub return_fields: Option<Vec<String>>,
|
|
pub highlight: bool,
|
|
}
|
|
|
|
impl Default for SearchOptions {
|
|
fn default() -> Self {
|
|
SearchOptions {
|
|
limit: 10,
|
|
offset: 0,
|
|
filters: vec![],
|
|
sort_by: None,
|
|
return_fields: None,
|
|
highlight: false,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Filter {
|
|
pub field: String,
|
|
pub filter_type: FilterType,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum FilterType {
|
|
Equals(String),
|
|
Range { min: String, max: String },
|
|
InSet(Vec<String>),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct SearchResults {
|
|
pub total: usize,
|
|
pub documents: Vec<SearchDocument>,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct SearchDocument {
|
|
pub fields: HashMap<String, String>,
|
|
pub score: f32,
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct IndexInfo {
|
|
pub name: String,
|
|
pub num_docs: u64,
|
|
pub fields: Vec<FieldInfo>,
|
|
pub config: IndexConfig,
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct FieldInfo {
|
|
pub name: String,
|
|
pub field_type: String,
|
|
} |