sha256 stringlengths 64 64 | language stringclasses 28
values | size int32 1 491k | lines int32 1 23.2k | content stringlengths 1 200k |
|---|---|---|---|---|
6a79266189f1e65405a967d3c0baec7de42c321cd73ddf3a6bf526486c6ce2f9 | Rust | 30,175 | 904 | mod mocks;
use std::sync::{Arc, Mutex};
use setsum::Setsum;
use mocks::MockManifestPublisher;
use wal3::{
unprefixed_snapshot_path, Error, Fragment, FragmentIdentifier, FragmentSeqNo, Garbage,
LogPosition, Snapshot, SnapshotCache, SnapshotPointer,
};
// Mock implementations for testing
#[derive(Default)]
st... |
d407be4fb3fbdfd7b05b95db341ddda7dda38efaa343e109bc3319c2640b92dd | Rust | 30,460 | 847 | use crate::{
config::SqliteLogConfig, BackfillMessage, CollectionInfo, CompactionManagerError,
LocalCompactionManager, PurgeLogsMessage,
};
use async_trait::async_trait;
use chroma_config::Configurable;
use chroma_error::{ChromaError, ErrorCodes, WrappedSqlxError};
use chroma_sqlite::{db::SqliteDb, helpers::get... |
05071468be5a896d5bacd0cdc05c55f8ebc987c8f292e819bf74e9cfb64aeb90 | Rust | 30,659 | 831 | use async_trait::async_trait;
use chroma_cache::{Cache, CacheConfig, Weighted};
use chroma_config::{registry::Registry, Configurable};
use chroma_error::ChromaError;
use chroma_types::CollectionUuid;
use fastbloom::AtomicBloomFilter;
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
use std::fmt::Debu... |
30458f672bd09bc6086514eeee35efbd352bea160101462656b5ecbb3e6be6fb | Rust | 30,664 | 817 | use crate::HnswIndexConfigError;
use super::config::HnswProviderConfig;
use super::{HnswIndex, HnswIndexConfig, IndexConfig, IndexUuid};
use crate::hnsw::WrappedHnswError;
use async_trait::async_trait;
use chroma_cache::AysncPartitionedMutex;
use chroma_cache::Cache;
use chroma_config::registry::Registry;
use chroma_... |
8d91bc91f97ac66dc2c4445217a69676ea053824ef63de60e14abf8d37360788 | Rust | 30,903 | 892 | use super::{CacheError, Weighted};
use ahash::RandomState;
use chroma_error::ChromaError;
use chroma_tracing::util::{StopWatchUnit, Stopwatch};
use clap::Parser;
use foyer::{
CacheBuilder, DirectFsDeviceOptions, Engine, FifoConfig, FifoPicker, HybridCacheBuilder,
InvalidRatioPicker, LargeEngineOptions, LfuConfi... |
146f9d34eb0d79aab324135e9f8513b5464ea66989fe4214ebf7e8dbba3ddb07 | Rust | 31,014 | 891 | use std::time::Duration;
use super::{distributed::DistributedExecutor, local::LocalExecutor, Executor};
use crate::executor::distributed::ClientSelectionConfig;
use async_trait::async_trait;
use backon::ExponentialBuilder;
use chroma_config::{registry::Registry, Configurable};
use chroma_error::ChromaError;
use chroma... |
830bbd78330512a4275c26f1e27f1432b8670de513675292562a1589ef4a5a3f | Rust | 31,211 | 846 | //! RankedGroupBy operator for grouping ranked search results by metadata keys.
//!
//! This operator takes ranked records from the RankExpr operator and:
//! 1. Groups records by one or more metadata field values
//! 2. Sorts records within each group by aggregate keys (MinK/MaxK)
//! 3. Keeps the top k records per gr... |
d5cc803eaaf844382fe56cff6f699343431ec8ecf59ead5b09761a6bd164ba9a | Rust | 31,245 | 824 | use crate::server::FoundationApiServer;
use axum::response::sse::Event;
use axum::{
http::HeaderMap,
routing::{get, post, MethodRouter},
Router,
};
use serde::{Deserialize, Serialize};
use uuid::Uuid;
/// HTTP header carrying the caller's Chroma Cloud token, forwarded to the FE
/// and the embedding servic... |
c148c99adb51a0912cb3a385d8928144957c6b3e663c087e783eff9910dcd248 | Rust | 31,274 | 828 | use std::{collections::HashMap, sync::Arc};
use chroma_blockstore::{BlockfileFlusher, BlockfileWriter};
use chroma_error::{ChromaError, ErrorCodes};
use dashmap::DashMap;
use thiserror::Error;
use tracing::Instrument;
use uuid::Uuid;
use crate::sparse::{
reader::{SparseReader, SparseReaderError},
types::{enco... |
6f95630271754331a7148915fde514b1e38c295f9bca313f1b91a92c0bf1c44a | Rust | 31,357 | 868 | //! Markdown chunking for wiki pages.
//!
//! The chunker parses markdown with the `tree-sitter-md` block grammar, emits
//! chunk 0 as the first non-blank line (so title search keeps working), then
//! greedy-packs top-level blocks into chunks no larger than `max_bytes` of
//! UTF-8 text.
//!
//! `foundation-research`... |
0e1253a4b1d17a7ee93181a43dc66742243b39436f4fd0e7420269413582d457 | Rust | 31,672 | 773 | use std::collections::HashSet;
use regex_syntax::hir::ClassUnicode;
use roaring::RoaringBitmap;
use super::hir::ChromaHir;
#[derive(Clone, Debug)]
pub enum Literal {
Char(char),
Class(ClassUnicode),
}
impl Literal {
pub fn width(&self) -> usize {
match self {
Literal::Char(_) => 1,
... |
8bc81100f0b36b93955e64cfd8ac866186c6b3979861a58bb0088124dd9d89a5 | Rust | 31,718 | 916 | use super::{
block::{delta::types::Delta, Block, BlockLoadError},
blockfile::{ArrowBlockfileReader, ArrowUnorderedBlockfileWriter},
config::ArrowBlockfileProviderConfig,
ordered_blockfile_writer::ArrowOrderedBlockfileWriter,
root::{FromBytesError, RootReader, RootWriter},
types::{ArrowReadableKe... |
07b064a12e46039322c5654f9cbce2112e51bb6f946224c8ddaafe259e2451dd | Rust | 32,296 | 1,062 | use crate::config_store::{ConfigStore, FileConfigStore};
use crate::terminal::{SystemTerminal, Terminal};
use crate::ui_utils::copy_to_clipboard;
use crate::utils::{
cloud_client, CliError, Profile, CHROMA_API_KEY_ENV_VAR, CHROMA_DATABASE_ENV_VAR,
CHROMA_TENANT_ENV_VAR, SELECTION_LIMIT,
};
use chroma::client::D... |
b11f2c99484055406ff40ea27db15c0114191488c1f0f785c4f9633e4de45028 | Rust | 32,433 | 866 | //! Version file management utilities for handling collection version files.
//! This module provides a centralized way to download, upload, and manage
//! collection version files stored in S3/storage. Version files track the
//! evolution of segments within a collection.
use chroma_storage::{GetOptions, PutOptions,... |
828fddbb345b8c203896a0d055e21517d0495b9981c1a8296eeffcabe1599096 | Rust | 33,134 | 919 | use std::{ops::BitAnd, sync::Arc};
use chroma_blockstore::{BlockfileFlusher, BlockfileReader, BlockfileWriter};
use chroma_error::{ChromaError, ErrorCodes};
use dashmap::DashMap;
use roaring::RoaringBitmap;
use thiserror::Error;
use uuid::Uuid;
use super::tokenizer::{DocumentTokens, QueryPlan, TokenLookup};
/// Key ... |
cd7be65956de2ccd540a5dd11e1931707edcbdfc2789bebe026c61337a69dcc5 | Rust | 33,776 | 880 | use std::ops::RangeBounds;
use super::{
super::{BlockfileError, Key, Value},
storage::{Readable, Storage, StorageBuilder, StorageManager, Writeable},
};
use crate::key::{InvalidKeyConversion, KeyWrapper};
use chroma_error::ChromaError;
#[derive(Clone)]
pub struct MemoryBlockfileWriter {
builder: StorageBu... |
fe923396705d2f62f4a9721939ba08fd0c0c8c9fc4ffb065ef2cb02b8fa0c952 | Rust | 34,100 | 953 | use async_trait::async_trait;
use chroma_blockstore::provider::BlockfileProvider;
use chroma_error::{ChromaError, ErrorCodes};
use chroma_index::hnsw_provider::HnswIndexProvider;
use chroma_log::Log;
use chroma_segment::spann_provider::SpannProvider;
use chroma_sysdb::SysDb;
use chroma_system::{Component, ComponentCont... |
bf88b2acf2ac5c586a58c0f94fd7a86b26e301b6294efcfb83138c17e4c58104 | Rust | 34,771 | 863 | use chroma_cache::{AysncPartitionedMutex, Cache, CacheConfig, CacheError, FoyerCacheConfig};
use chroma_config::{
registry::{Injectable, Registry},
Configurable,
};
use chroma_error::{ChromaError, ErrorCodes};
use chroma_index::IndexUuid;
use chroma_sqlite::db::SqliteDb;
use chroma_types::{Collection, Segment, ... |
c9673046503cdb3911207c7dc28d5054e4083b8d3c3d1f7d5de84e8cb59240e7 | Rust | 35,303 | 999 | use std::str::FromStr;
use std::sync::Arc;
use arrow::array::{Array, ArrayRef, RecordBatch, StringArray};
use backon::Retryable;
use bytes::Bytes;
use chroma_storage::admissioncontrolleds3::StorageRequestPriority;
use chroma_storage::{DeleteOptions, ETag, GetOptions, PutMode, PutOptions, Storage, StorageError};
use ch... |
bddd0b6cdc59d52fff9fa4fe9b849e1b64e9ddc82c962d2fea2a4fbfae96f27c | Rust | 36,062 | 898 | use async_trait::async_trait;
use chroma_blockstore::{
arrow::provider::{BlockManager, RootManagerError},
RootManager,
};
use chroma_cache::nop::NopCache;
use chroma_error::{ChromaError, ErrorCodes};
use chroma_index::{
hnsw_provider::{HnswIndexProvider, FILES},
usearch::USearchIndex,
IndexUuid,
};
... |
278e99dc1ec4f183e85b490741e42729bc279d0a5ceae2971c53e2f2032ac5ea | Rust | 36,479 | 973 | use std::sync::Arc;
use crate::config::GrpcLogConfig;
use crate::types::CollectionInfo;
use async_trait::async_trait;
use chroma_config::assignment::assignment_policy::AssignmentPolicy;
use chroma_config::registry::Registry;
use chroma_config::Configurable;
use chroma_error::{source_chain_contains, ChromaError, ErrorC... |
1a1304308a41fdcc5c035d5a17915580ef7aaab669f7bd52735ddf07ea26e9c0 | Rust | 36,814 | 902 | //! 1-bit RaBitQ quantization and associated query structures.
//!
//! This module contains:
//! - [`Code::<1>`]: 1-bit quantized code with precomputed `signed_sum`.
//! - [`QuantizedQuery`]: Pre-computed query quantization for the bitwise distance path.
use std::mem::size_of;
use bytemuck::{Pod, Zeroable};
use chrom... |
1e1d004b67e421cf1425202156c116de0bf0fbb2fa4536ff89348116afafcc82 | Rust | 37,264 | 1,019 | use super::*;
use chroma_sqlite::db::test_utils::get_new_sqlite_db;
use chroma_types::{
Collection, InternalCollectionConfiguration, KnnIndex, OperationRecord, Schema, SegmentScope,
SegmentType, SegmentUuid, VectorIndexConfiguration,
};
use proptest::prelude::*;
async fn fixture() -> (
tempfile::TempDir,
... |
b6bfbaba11be031ac3155f214f896461f5a07247d547e8a4164eb02887180868 | Rust | 37,435 | 992 | use crate::regex::{ChromaRegex, ChromaRegexError};
use crate::{
CompositeExpression, ContainsOperator, DocumentOperator, MetadataExpression, PrimitiveOperator,
Where,
};
use chroma_error::{ChromaError, ErrorCodes};
use serde::Deserialize;
use serde::Serialize;
use serde_json::Value;
use thiserror::Error;
const... |
dac4014dfe2f8311712d36989dcea6bf8c602cc68711fdb6c4196a28e62655a7 | Rust | 38,022 | 959 | use super::operator::OperatorType;
use super::{operator::TaskMessage, worker_thread::WorkerThread};
use crate::execution::affinity::{io_core_for_task, pin_current_thread};
use crate::execution::config::DispatcherConfig;
use crate::utils::{duration_ms, thread_stack_size_bytes};
use crate::{
Component, ComponentConte... |
6a70657ddc7c742ca080003254f5658cfb8822b98756d93702fcabc7dad3065d | Rust | 38,229 | 1,028 | use std::{cmp::min, collections::HashMap, collections::HashSet, sync::Arc};
use chroma_distance::DistanceFunction;
use chroma_error::{ChromaError, ErrorCodes};
use chroma_types::QuantizedCluster;
use rand::{seq::IteratorRandom, seq::SliceRandom, thread_rng, Rng};
use simsimd::SpatialSimilarity;
use thiserror::Error;
... |
9105407a597a288f6e164486127b42a6258b8b5d490df9d77cea55cb6352530a | Rust | 40,163 | 1,067 | use std::collections::HashMap;
use std::fmt::{Debug, Formatter};
use std::sync::Arc;
use chroma_blockstore::{
arrow::provider::BlockfileReaderOptions, provider::BlockfileProvider, BlockfileReader,
};
use chroma_distance::{normalize, DistanceFunction};
use chroma_error::{ChromaError, ErrorCodes};
use chroma_index::... |
89adce8265d991a7f09cfcb9b6acfef4aa99033623f2bf319407438fabfc68c9 | Rust | 40,196 | 1,025 | use std::collections::HashSet;
use std::ops::Add;
use std::sync::Arc;
use setsum::Setsum;
use chroma_storage::{ETag, StorageError};
use crate::interfaces::{
FragmentManagerFactory, FragmentPointer, FragmentPublisher, ManifestManagerFactory,
ManifestPublisher,
};
use crate::manifest::unprefixed_snapshot_path;... |
24770287b8419b7625f5739733104d72171779262d4fe62acd8d499f0b65fd2f | Rust | 40,683 | 1,160 | use crate::work_queue::state::QueueState;
use crate::work_queue::types::{FinishResult, WorkQueueError, WorkQueueRecord};
use async_trait::async_trait;
use chroma_config::assignment::assignment_policy::AssignmentPolicy;
use chroma_error::ChromaError;
use chroma_memberlist::memberlist_provider::Memberlist;
use chroma_st... |
4244a7aa4d290e9c75ff6311b1612c9ca420ec5435933b58f00dc57f67a3c4ef | Rust | 40,744 | 1,160 | #[cfg(test)]
mod regression;
use chroma_frontend::config::FrontendServerConfig;
use chroma_segment::local_hnsw::{
inspect_persisted_hnsw_index, inspect_persisted_hnsw_metadata, parse_persisted_hnsw_dim,
PersistedHnswLabelMismatch, PersistedHnswMetadata, HNSW_HEADER_FILE, HNSW_INDEX_FILES,
METADATA_FILE,
};... |
c08f5bb08b9598557a81e0c0ae2043ad89fa169a72dac73dd4897f7ea9aa525c | Rust | 41,125 | 1,091 | use super::init_schema::{
foundation_collection_schema, qwen_embedding_function, splade_embedding_function,
CollectionEmbeddingFunctions,
};
use super::whoami::{authorize_scope, ScopePolicy};
use super::FoundationScope;
use crate::collections::{
create_planned_collection, ensure_reserved_database, ensure_sl... |
b23518bb5f9455e0a1349fe40637404545f5447bad14bf1ec88f7533210be716 | Rust | 41,145 | 1,058 | //! Chroma client used by Foundation routes to proxy record I/O to the FE.
//!
//! A single long-lived [`ChromaHttpClient`] (one shared connection pool to the
//! FE ingress) is built once at startup. Each request cheaply re-scopes it via
//! [`ChromaHttpClient::with_scope`], which swaps the caller's auth method
//! (f... |
a0c04268c1e5bcf8023e69b4c4a327b509b361deb71a93ff0ea23c0544e0ea4f | Rust | 43,133 | 1,130 | mod provisioning;
use chroma_error::{ChromaError, ErrorCodes};
use chroma_types::{
BatchGetCollectionSoftDeleteStatusError, BatchGetCollectionVersionFilePathsError, Collection,
CollectionAndSegments, CollectionUuid, CountForksError, CreateDatabaseError,
CreateDatabaseResponse, Database, DatabaseName, Delet... |
d8c3b147632aeda1c6b1b16b20721c418b3c3e4d77f7dc7e7e16ce646a72a496 | Rust | 43,382 | 1,200 | //! `POST /api/upsert-page` — replace a wiki page's chunks.
//!
//! Acts as a Chroma *client*: it resolves the tenant's `wiki` collection through
//! the proxying Foundation Chroma client, transactionally reads the existing
//! chunk set for the slug to preserve `created_at` / bump `version`, re-chunks
//! the new cont... |
3833739f324533c87fc7062a771b28fb5603874066b21e3273e3505c607bcb8f | Rust | 43,521 | 1,174 | use super::block::delta::OrderedBlockDelta;
use super::migrations::apply_migrations_to_blockfile;
use super::migrations::MigrationError;
use super::provider::BlockManager;
use super::provider::RootManager;
use super::root::RootWriter;
use super::sparse_index::SparseIndexDelimiter;
use super::{
flusher::ArrowBlockfi... |
c3b8edcc0b37a3cd3c6c036adcc389423c995fdb7b7f6be53515c2c1bfdd23ab | Rust | 43,812 | 1,140 | use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use chroma_storage::{
admissioncontrolleds3::StorageRequestPriority, ETag, GetOptions, PutMode, PutOptions, Storage,
StorageError,
};
use setsum::Setsum;
use crate::gc::Garbage;
use crate::interfaces::s3::read_fragment;
use crate::interfaces::{M... |
bd75430f219c0a6d395f8830eaa2907412a2cd8b34a01333b3ed5ed88d76967f | Rust | 44,776 | 1,328 | //! s3heap - An S3-backed distributed heap for scheduling tasks at scale.
//!
//! # Overview
//!
//! s3heap provides a distributed, persistent heap data structure backed by S3 storage.
//! It enables scheduling and processing of tasks at scale across multiple workers,
//! with automatic deduplication and completion tra... |
d7100a868fa383f30a7ec76ebd74685aa84b7f07b0c360296542235cef6e99cb | Rust | 45,339 | 1,367 | use super::*;
use crate::sqlite_log::{LegacyEmbeddingsQueueConfig, SqliteLog, SqlitePushLogsError};
use chroma_segment::local_segment_manager::LocalSegmentManagerConfig;
use chroma_sysdb::test_sysdb::TestSysDb;
use chroma_system::{ComponentHandle, System};
use chroma_types::{
Collection, KnnIndex, Operation, Operat... |
a773085292f8bb9988262bcd70af158516cebcf9f0a4e3689b58b07a636c9900 | Rust | 46,962 | 1,195 | use crate::key::CompositeKey;
use crate::Key;
use chroma_error::ChromaError;
use parking_lot::Mutex;
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, HashMap};
use std::fmt::Debug;
use std::ops::{Bound, RangeBounds};
use std::sync::Arc;
use thiserror::Error;
use uuid::Uuid;
// ============
// Spar... |
634590893036a72c67d0a296b76441f8995e38012e72160082b6809234f54c84 | Rust | 47,203 | 1,201 | use std::cmp::Ordering;
use std::collections::HashMap;
use std::io::Read;
use std::ops::{Bound, RangeBounds};
use std::sync::Arc;
use crate::arrow::types::{ArrowReadableKey, ArrowReadableValue};
use arrow::array::ArrayData;
use arrow::buffer::Buffer;
use arrow::ipc::convert::fb_to_schema;
use arrow::ipc::reader::{read... |
815f8884989d17bed01a88ab42a575559d90a1cfae7604a2f3c9bc407c2613ee | Rust | 47,996 | 1,284 | use std::sync::Arc;
use std::time::Duration;
use bytes::Bytes;
use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
use setsum::Setsum;
use tracing::Span;
use chroma_storage::{ETag, Storage};
use chroma_types::Cmek;
use crate::{
reader::Limits, AppendOptions, CursorWitness, Error, Fragment, Fragmen... |
358446b0cfe042a227f0dc9cbc9f9bea321cc1c1936f5f88cc7d3247bd5ae250 | Rust | 48,194 | 1,138 | //! Model-based property test for the MaxScore sparse index.
//!
//! Each proptest case generates a small random program — a sequence of
//! commit batches (adds / overwrites / deletes across 1-4 dimensions and
//! a bounded offset space) interleaved with a few on-disk faults — and
//! runs it against both the real eng... |
7ba2f332d4599e5026c272858251cbfc9fa589876bfe7be186d1a66cb878c4a9 | Rust | 49,034 | 1,283 | use std::{
cell::OnceCell,
collections::HashSet,
sync::{atomic::AtomicU32, Arc},
};
use async_trait::async_trait;
use chroma_error::{ChromaError, ErrorCodes};
use chroma_segment::{
blockfile_metadata::{MetadataSegmentError, MetadataSegmentWriter},
blockfile_record::{
RecordSegmentReader, Re... |
9c120c435bab2b84d9f22a03191ae14ad97a9aa888b6428b8f6314f3c1cf0088 | Rust | 49,316 | 1,388 | #![recursion_limit = "256"]
//! Sparse Index Block-Max WAND Benchmark
//!
//! This benchmark evaluates the performance of the Block-Max WAND algorithm
//! for sparse vector search compared to brute force baseline using the
//! Wikipedia SPLADE dataset from HuggingFace.
//!
//! ## Usage Modes
//!
//! ### Full Benchmark ... |
8997332f0e28585ed4bfe3f6fa83432c2f0060a25ec0615159f3cb972dc4358f | Rust | 49,696 | 1,331 | use super::{
CollectionUuid, Metadata, MetadataValueConversionError, SegmentScope,
SegmentScopeConversionError,
};
use crate::collection_schema::Schema;
use crate::{chroma_proto, DatabaseUuid};
use chroma_error::{ChromaError, ErrorCodes};
use chroma_proto::CollectionVersionInfo;
use std::{collections::HashMap, ... |
f289d469ab887a93f295e3543a26aeea7158b00745c8a35299006ce6ffa24693 | Rust | 49,879 | 1,422 | use super::*;
use std::collections::BTreeMap;
use std::error::Error;
use std::io;
use super::chunkset::{push_json_record, utf8_chunks};
use super::citations::{read_citations, write_citations};
use super::ids::{
decode_fixed_base36_to_be_bytes, decode_index, encode_be_bytes_base36, encode_index, hex_lower,
sha2... |
0c73ecdf302cc4a726ac7eeb144ff900ba5202a285b5b9952dcfaaf64df7c624 | Rust | 49,964 | 1,497 | use crate::errors::{ChromaPyResult, InvalidDatabaseNameError, WrappedPyErr, WrappedUuidError};
use chroma_api_types::{OccReadMode, OccReadToken};
use chroma_cache::FoyerCacheConfig;
use chroma_cli::chroma_cli;
use chroma_config::{registry::Registry, Configurable};
use chroma_frontend::{
config::default_min_records_... |
b9972d4e672e54eadf988b4f04ca199b6662a280a006e1757392a7914a56523c | Rust | 50,279 | 1,417 | use std::collections::BTreeSet;
use chroma_api_types::{OccReadMode, OccReadToken};
use chroma_error::{ChromaError, ErrorCodes};
use thiserror::Error;
use crate::{
AddCollectionRecordsRequest, CollectionUuid, DatabaseName, DeleteCollectionRecordsRequest,
GetRequest, GetResponse, Operation, OperationRecord, Sca... |
6bf04e50fded5c62639e571cf8aa70c45d4e9dc37734d0cc43ac20259fce581f | Rust | 50,555 | 1,273 | //! Foundation MCP endpoint: route wiring, CORS, and the bearer-token auth gate.
//!
//! The same MCP service answers on two paths. The bare one addresses the key's
//! tenant and the configured default Foundation; the prefixed one names a
//! tenant and a Foundation in the path, which is what lets one key reach any
//... |
1ba67e85e9bfdafe06c3d1bf01944e74184f7f96539af06293b02a5f5dcb6ff5 | Rust | 50,704 | 1,288 | use crate::types::ChromaSegmentFlusher;
use super::blockfile_record::ApplyMaterializedLogError;
use super::blockfile_record::RecordSegmentReaderShard;
use super::types::{
BorrowedMaterializedLogRecord, HydratedMaterializedLogRecord, MaterializeLogsResult,
};
use chroma_blockstore::provider::BlockfileProvider;
use ... |
84f76234165e7f78c324207d2d07c32205bbf2acb603b349dc610697cab7073b | Rust | 51,511 | 1,402 | use async_trait::async_trait;
use chroma_blockstore::provider::BlockfileProvider;
use chroma_error::{ChromaError, ErrorCodes};
use chroma_index::hnsw_provider::HnswIndexProvider;
use chroma_log::Log;
use chroma_segment::{
blockfile_metadata::{MetadataSegmentError, MetadataSegmentWriter},
blockfile_record::{
... |
1a72cb9922ccfcacf4943cf47856641dbd6189462b66070e263236f5c85c752f | Rust | 51,522 | 1,309 | use super::util::TokenInstance;
use super::util::TokenInstanceEncodeError;
use chroma_blockstore::{BlockfileFlusher, BlockfileReader, BlockfileWriter};
use chroma_error::{ChromaError, ErrorCodes};
use chroma_types::regex::literal_expr::NgramLiteralProvider;
use futures::StreamExt;
use itertools::Itertools;
use parking_... |
0c496cecd3d1c3c99f78b2a9cc2e1a98d46fdab0573476d9ca570887bf340a02 | Rust | 52,107 | 1,325 | use std::sync::Arc;
use chroma_blockstore::{BlockfileFlusher, BlockfileReader, BlockfileWriter};
use chroma_error::{ChromaError, ErrorCodes};
use chroma_types::{
Directory, DirectoryBlock, SignedRoaringBitmap, SparsePostingBlock, SparsePostingBlockError,
DIRECTORY_PREFIX, MAX_BLOCK_ENTRIES,
};
use dashmap::Das... |
41b2ca5c18caae8f64c798e0008dbc3d2cd212be8e8a51271261edb5a72d6fff | Rust | 52,783 | 1,399 | use super::scheduler::Scheduler;
use super::scheduler_policy::LasCompactionTimeSchedulerPolicy;
use super::RebuildMessage;
use crate::compactor::types::RebuildInfo;
use crate::compactor::{
GetCollectionAssignmentMessage, GetCollectionAssignmentResponse, InProgressJobEntry,
ListInProgressJobsMessage, OneOffCompa... |
2add44156138e828a88126fbac9af3dc2372b080c0b03891e576d06f3e674c21 | Rust | 55,387 | 1,414 | //! # Revision History Function
//!
//! Archives every version of a record into a lightweight output collection (expected to have no vector/metadata
//! indexes). Each mutation in the source collection produces an immutable revision in the
//! history collection, enabling pagination over a record's full change timeline... |
4786f1dfe5a95de9b5c61b5c30d3f3348f31c6ed8442c9a18b4c8d60178f21d1 | Rust | 57,637 | 1,490 | use std::collections::HashSet;
use std::sync::Arc;
use std::time::Duration;
use async_trait::async_trait;
use chroma_blockstore::provider::BlockfileProvider;
use chroma_config::{registry::Registry, Configurable};
use chroma_error::ChromaError;
use chroma_index::hnsw_provider::HnswIndexProvider;
use chroma_index::usear... |
b12fc9e1caf4e19ebc2ecc5263582d965a84d99b6042e4db291ae62dc84a840f | Rust | 58,129 | 1,557 | //! This implements a statistics module that returns the token frequency of metadata.
//!
//! The core idea is the following: For each key-value pair associated with a record, aggregate so
//! (key, value) -> count. This gives a count of how frequently each key appears.
//!
//! The statistics executor is incremental -... |
d4b32b64ef3de6d5f1e5ac2fbaae8768921d50c3b2a897b463f7cd8ad22ee486 | Rust | 58,427 | 1,478 | use crate::{
collection_schema::is_embedding_function_default, default_batch_size, default_construction_ef,
default_construction_ef_spann, default_initial_lambda, default_m, default_m_spann,
default_merge_threshold, default_nreplica_count, default_num_centers_to_merge_to,
default_num_samples_kmeans, def... |
8b66cf9e6cb544dfaa2a76ede2c2d04f82d386a4588f05243cb536003ee12b97 | Rust | 63,931 | 1,755 | use std::collections::{HashMap, HashSet};
use std::str::FromStr;
use std::time::{Duration, SystemTime};
use chroma_config::assignment::assignment_policy::AssignmentPolicy;
use chroma_log::{CollectionInfo, CollectionRecord, Log};
use chroma_memberlist::memberlist_provider::{Member, Memberlist};
use chroma_sysdb::{Datab... |
4431bfe6391f2f2cc479c7779406b95bab6ba98ec2b6d497aa998cfbb2bc2dcb | Rust | 64,478 | 1,492 | use crate::fulltext::types::FullTextIndexError;
use chroma_blockstore::{
key::KeyWrapper, types::errors::BlockfileError, BlockfileFlusher, BlockfileReader,
BlockfileWriter,
};
use chroma_error::{ChromaError, ErrorCodes};
use futures::TryStreamExt;
use thiserror::Error;
use uuid::Uuid;
use core::ops::BitOr;
use... |
a41e4c03a07bd51ad3777802fac80bdf953648337d6aa3c9a513fc9d1f717ea5 | Rust | 66,047 | 1,747 | use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use chroma_storage::{
admissioncontrolleds3::StorageRequestPriority, ETag, PutMode, PutOptions, Storage, StorageError,
};
use chroma_types::Cmek;
use setsum::Setsum;
use crate::backoff::ExponentialBackoff;
use crate::interfaces::{
AppendWork, Fr... |
be17ad39efe4c3f5eb285a349c19ec3ac168f58dfee3343eb55b752f1e7f36da | Rust | 66,242 | 1,762 | #![recursion_limit = "256"]
#![doc = include_str!("../README.md")]
use std::sync::Arc;
use serde::{Deserialize, Serialize};
use uuid::Uuid;
// Re-export Setsum publicly for downstream crates
pub use setsum::Setsum;
mod backoff;
mod copy;
mod cursors;
mod destroy;
mod gc;
pub mod interfaces;
mod manifest;
mod quorum... |
5d456904562984e99e7d9fcd86304cf727c0fe9cb508bc8e9d5513f933661135 | Rust | 66,352 | 1,900 | use backon::ExponentialBuilder;
use backon::Retryable;
use chroma_api_types::{ErrorResponse, StaleReadError};
use chroma_error::ChromaValidationError;
use chroma_types::Collection;
use chroma_types::Metadata;
use chroma_types::Schema;
use chroma_types::WhereError;
use failsafe::futures::CircuitBreaker as _;
use failsaf... |
45d5136e1ee39364e6b5cc482439b4a30002bc766a420978d90115a8103a00d1 | Rust | 67,552 | 1,828 | use std::collections::HashMap;
use std::sync::Arc;
use crate::operators::truncate_dirty_log::{
TruncateDirtyLogError, TruncateDirtyLogOperator, TruncateDirtyLogOutput,
};
use crate::types::CleanupMode;
use crate::{config::GarbageCollectorConfig, types::GarbageCollectorResponse};
use async_trait::async_trait;
use c... |
ca379db19b8a9584878fa389cbcb6d3632310cfabc3ae15d1bb005aa6b5a76e5 | Rust | 67,845 | 1,943 | //! Internal domain types for the SysDb service.
//!
//! These types provide a layer of indirection between the protobuf types
//! and the backend implementations. This allows:
//! - Changing the wire format without affecting backends
//! - Backend-specific optimizations without affecting the API
//! - Cleaner internal... |
92908f820ae66d74bf299098c9fa6832c6ba171f4a786b26eda337dbbd22ef4b | Rust | 70,205 | 1,741 | mod persistence;
pub(crate) use persistence::validate_checkpoint;
use persistence::{validate_checkpoint_seq_id, CheckpointFingerprint, VerifiedCheckpoint};
#[cfg(test)]
mod regression;
pub use persistence::{
inspect_persisted_hnsw_index, inspect_persisted_hnsw_index_for_config_repair,
PersistedHnswIndex,
};
us... |
7214f0d1001386bc9027914b3de2ad8b41c21ee9466956b5d13d5fee22245d0d | Rust | 72,803 | 1,931 | use crate::construct_version_graph_orchestrator::{
ConstructVersionGraphError, ConstructVersionGraphOrchestrator,
};
use crate::operators::compute_versions_to_delete_from_graph::{
CollectionVersionAction, ComputeVersionsToDeleteError, ComputeVersionsToDeleteInput,
ComputeVersionsToDeleteOperator, ComputeVer... |
fe57c14c189cf6cc4d2cb8220e3d12592137a9041dcde991b4994ebca8c39cd9 | Rust | 73,206 | 2,055 | use crate::{DatabaseOrTopology, GetCollectionsOptions, SqliteSysDbConfig};
use async_trait::async_trait;
use chroma_config::registry::Registry;
use chroma_config::Configurable;
use chroma_error::{ChromaError, ErrorCodes, WrappedSqlxError};
use chroma_sqlite::db::SqliteDb;
use chroma_sqlite::helpers::{delete_metadata, g... |
01798f9d2f4c58a2a8348a9c3e3121689537698c681fceee605fb40cad20c2cd | Rust | 75,331 | 1,926 | use crate::object_storage::ObjectStorage;
use crate::StorageError;
use crate::{
config::{RateLimitingConfig, StorageConfig},
s3::S3Storage,
GetOptions,
};
use crate::{DeleteOptions, ETag, PutOptions, StorageConfigError};
use async_trait::async_trait;
use bytes::Bytes;
use chroma_config::registry::Registry;
... |
20de306575a411d2141803c89f2da69ba5cb673071ff0db5d1f04ae0c6bc2160 | Rust | 76,102 | 2,120 | // Presents an interface to a storage backend such as s3 or local disk.
// The interface is a simple key-value store, which maps to s3 well.
// For now the interface fetches a file and stores it at a specific
// location on disk. This is not ideal for s3, but it is a start.
// Ideally we would support streaming the fi... |
37fb946f0925eef646d1c033f02a6f67b5e391e247ae61a245322977f94cc35a | Rust | 76,805 | 2,339 | //! This module defines the topology-related configuration for multi-cloud, multi-region
//! configuration.
//!
//! There are three core structs:
//! - A [`ProviderRegion`] names a given cloud provider and identifies one geographic region that
//! they offer. For example, AWS has us-east-1 and GCP has europe-west1. ... |
e0fd0924d664ca2ded08cb9c7800e406cea951aad1aaee0f0b3f6e875c4265cc | Rust | 80,163 | 2,033 | //! Manifests, and their immutable cousin, snapshots, are the metadata that describe a log.
//!
//! A manifest transitively names every file in object storage that is part of the log.
//!
//! Snapshots are content-addressable and immutable, while manifests get overwritten. For that
//! reason, manifests embed the ETag... |
bb86ae6674f436473b5128c72e7e5198c62b518a9b4e7fe39b87f28cdbb0e745 | Rust | 80,206 | 2,085 | use std::future::Future;
use std::iter::Iterator;
use std::sync::atomic::AtomicBool;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant, SystemTime};
use arrow::array::{ArrayRef, BinaryArray, RecordBatch, UInt64Array};
use chroma_storage::{GetOptions, StorageError};
use chroma_types::Cmek;
use opentelemetr... |
9ca4ae2b96c4b078edb39e0f9eadb606d1ad967373664dc4cafff08cedcf7360 | Rust | 83,408 | 2,066 | use std::{
collections::{BTreeMap, HashMap},
ops::{BitAnd, BitOr, Bound},
};
use async_trait::async_trait;
use chroma_blockstore::{key::KeyWrapper, provider::BlockfileProvider};
use chroma_error::{ChromaError, ErrorCodes};
use chroma_index::metadata::types::MetadataIndexError;
use chroma_segment::{
blockfi... |
59d46ef35b30b1d868126fcb434a1087cfe9bffdd17359497d177232450d5565 | Rust | 87,177 | 2,180 | use bitpacking::{BitPacker, BitPacker4x};
use half::f16;
use thiserror::Error;
const BITPACK_GROUP_SIZE: usize = BitPacker4x::BLOCK_LEN; // 128
/// Sentinel value in `bits_per_delta` that marks a directory block (see
/// [`DirectoryBlock`] below).
const DIRECTORY_SENTINEL: u8 = 0xFF;
/// Directory format version pre... |
1f95bab950ee2a0fd14972513aac41f1a790047ecf33c1be7a30d598c2823128 | Rust | 93,872 | 2,422 | use std::{
collections::HashSet,
hash::RandomState,
sync::{
atomic::{AtomicU32, AtomicU64},
Arc,
},
};
use chroma_blockstore::{
arrow::provider::BlockfileReaderOptions, provider::BlockfileProvider, BlockfileReader,
BlockfileWriter, BlockfileWriterOptions,
};
use chroma_distance:... |
dc9b55de014272718729513b8b451e46118722a61c93c1636d3e6e1f599d7a61 | Rust | 94,344 | 2,539 | use super::distributed_spann::SpannSegmentWriterShardError;
use super::types::{HydratedMaterializedLogRecord, LogMaterializerError, MaterializeLogsResult};
use crate::bloom_filter::{BloomFilter, BloomFilterError, BloomFilterFlusher, BloomFilterManager};
use crate::types::{ChromaSegmentFlusher, PartitionedMaterializeLog... |
c6214f9fe713903294b7cb82682d756bf7454d724bdf2a1a326743bfde8ae97e | Rust | 95,165 | 2,708 | //! Collection operations for managing and querying vector embeddings.
//!
//! This module provides the [`ChromaCollection`] type, which represents a handle to a specific
//! collection within a Chroma database. Collections are the primary storage unit for vector
//! embeddings and their associated metadata, documents,... |
8b6f78940c3ab3bbe45a6240fecae12516f92cd9b6db6ab2afc71cfbb43acc61 | Rust | 99,798 | 3,095 | use crate::collection_configuration::InternalCollectionConfiguration;
use crate::collection_configuration::InternalUpdateCollectionConfiguration;
use crate::error::QueryConversionError;
use crate::operator::GetResult;
use crate::operator::Key;
use crate::operator::KnnBatchResult;
use crate::operator::KnnProjectionRecor... |
79b22840b7b2fa7bc8aab375a961126eb7b31027da867d5e0889ba6340fd14ad | Rust | 111,224 | 3,002 | use std::sync::{
atomic::{AtomicU32, Ordering},
Arc,
};
use chroma_blockstore::{
arrow::provider::BlockfileReaderOptions, provider::BlockfileProvider, BlockfileFlusher,
BlockfileReader, BlockfileWriterOptions,
};
use chroma_distance::{normalize, DistanceFunction};
use chroma_error::{ChromaError, ErrorC... |
659eb03c98e2eb3bbeea4e103c5c5c6fb5fb62176bfbca162b698433dd1fa543 | Rust | 116,929 | 3,010 | use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use setsum::Setsum;
use tokio::sync::Semaphore;
use tracing::{Instrument, Level};
use chroma_storage::{PutOptions, Storage, StorageError};
use chroma_types::Cmek;
use crate::interfaces::batch_manager::uploa... |
1ca07e3e56bcbd8734801c87fd021ed7adb5882827ea1bcc09603f813b68ed29 | Rust | 117,622 | 3,863 | use serde::{de::Error, ser::SerializeMap, Deserialize, Deserializer, Serialize, Serializer};
use serde_json::Value;
use std::{
cmp::Ordering,
collections::{BinaryHeap, HashSet},
fmt,
hash::{Hash, Hasher},
ops::{Add, Div, Mul, Neg, Sub},
};
use thiserror::Error;
use crate::{
chroma_proto, logica... |
e6faadd333f8f8a670dd367bdf194b6d67573c16470efec129c13dde7e7c4ad5 | Rust | 118,200 | 3,190 | use std::{
collections::{BTreeMap, HashMap},
num::TryFromIntError,
};
use chroma_error::{ChromaError, ErrorCodes};
use chroma_sqlite::{
db::SqliteDb,
helpers::{
delete_array_metadata, delete_array_metadata_keys, delete_metadata, update_metadata,
upsert_array_metadata,
},
table::... |
e24d133e5a335eef58f2342ed6015ff4d5a40ef835c0ef9545fa759343766bb3 | Rust | 118,324 | 3,041 | use super::migrations::{apply_migrations_to_blockfile, MigrationError};
use super::provider::{GetError, RootManager};
use super::root::{RootReader, RootWriter, Version};
use super::{block::delta::UnorderedBlockDelta, provider::BlockManager};
use super::{
block::Block,
flusher::ArrowBlockfileFlusher,
types::... |
b0e6d76005e9e1dbbc160d7f9ff81247968156bc820667db6ee01ffa67c8d66f | Rust | 120,514 | 3,154 | use chroma_error::{ChromaError, ErrorCodes};
use itertools::Itertools;
use serde::{ser::SerializeMap, Deserialize, Deserializer, Serialize, Serializer};
use serde_json::{Number, Value};
use sprs::CsVec;
use std::{
cmp::Ordering,
collections::{HashMap, HashSet},
mem::size_of_val,
ops::{BitAnd, BitOr},
};... |
8197392cb5099c838488ce529a271ccee0715491a6c2d431e23f7cda6b6729b7 | Rust | 128,112 | 3,221 | use crate::types::FlushCompactionRequest;
use crate::types::SysDbError;
use crate::types::{self as internal, validate_uuid};
use crate::{
backend::{Assignable, BackendFactory, Runnable},
config::RootConfig,
};
use backon::{ConstantBuilder, Retryable};
use chroma_config::{registry::Registry, Configurable};
use c... |
b7822b0fc2a7cea89f054919f04462d3c1170546d8c9f4b5d6d1a4fd07ae6bbc | Rust | 128,529 | 3,433 | use super::test_sysdb::TestSysDb;
use crate::sqlite::SqliteSysDb;
use crate::{DatabaseOrTopology, GetCollectionsOptions, GrpcSysDbConfig};
use async_trait::async_trait;
use chroma_config::registry::Registry;
use chroma_config::Configurable;
use chroma_error::{ChromaError, ErrorCodes, TonicError, TonicMissingFieldError}... |
5b82f16aa5e31ab9ed966226fea6bb8cd9bcb2c3bef76bcc038b77d1948e3f70 | Rust | 128,924 | 3,108 | use chroma_error::{ChromaError, ErrorCodes};
use chroma_types::{
logical_size_of_metadata, Chunk, DataRecord, DeletedMetadata, LogRecord,
MaterializedLogOperation, Metadata, MetadataDelta, MetadataValue, MetadataValueConversionError,
Operation, Schema, SegmentType, SegmentUuid, UpdateMetadata, UpdateMetadat... |
9948a8d250c4961edef878c420167d96e2850b2b26c93c40742b83a8300f94f2 | Rust | 159,333 | 4,016 | use std::collections::HashSet;
use std::convert::TryFrom;
use std::sync::Arc;
use std::time::{Duration, SystemTime};
use google_cloud_spanner::client::Client;
use google_cloud_spanner::key::Key;
use google_cloud_spanner::mutation::{delete, insert, update};
use google_cloud_spanner::statement::Statement;
use google_clo... |
43a491146aeceb6884302c99285af5096f363c7057344973a0497f595d98823b | Rust | 173,170 | 4,539 | use async_trait::async_trait;
use axum::{
extract::{DefaultBodyLimit, Path, Query, State},
http::{header::HeaderMap, StatusCode},
response::{IntoResponse, Response},
routing::{get, patch, post},
Json, Router, ServiceExt,
};
use chroma_api_types::{
ForkCollectionPayload, GetUserIdentityResponse, ... |
b2f865329820ed2dd8cfa0110ecf1ea9ccfe6b69c2d65e116ab5b3301e2019f5 | Rust | 184,241 | 3,987 | // NOTE(rescrv): All caches align to storage. For now, implement without caching. Caching
// should/could literally be a layer over storage, so add it later once correctness without caching
// is ensured by adequate testing.
use std::sync::Arc;
use setsum::Setsum;
use chroma_storage::Storage;
use crate::interfac... |
6d24dc8ce4fe010d1afcc557ac12561f55c58b857de1ce37c6f193d1b5118eee | Rust | 193,980 | 5,296 | use std::sync::Arc;
use std::{cell::OnceCell, collections::HashSet};
use chroma_blockstore::provider::BlockfileProvider;
use chroma_error::{ChromaError, ErrorCodes};
use chroma_index::{hnsw_provider::HnswIndexProvider, IndexUuid};
use chroma_log::Log;
use crate::compactor::RebuildInfo;
use crate::execution::operators... |
824864caada95346bfaed871b47d732838cac4471d62fd136e05b8a8db21a7d7 | Rust | 200,000 | 5,022 | #![recursion_limit = "256"]
use std::collections::hash_map::Entry;
use std::collections::HashMap;
use std::collections::HashSet;
use std::str::FromStr;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant, SystemTime};
use backon::{ExponentialBuilder, Retryable};
use chr... |
50d66e35c8f4ac674da166781c622454fb29bf055190b120b4da23e098424efa | Rust | 200,002 | 4,976 | //! Spanner backend implementation.
//!
//! This module provides the `SpannerBackend` which implements all SysDb
//! operations using Google Cloud Spanner as the underlying database.
use std::collections::hash_map::Entry;
use std::collections::HashMap;
use std::collections::HashSet;
use std::time::Duration;
#[cfg(tes... |
768d1ba9a04affc387460ae9fd062c0cb37ab36303cb2c56623b3dcc18266f82 | Rust | 200,002 | 5,245 | use super::utils::to_records;
use crate::{
config::FrontendConfig, executor::Executor, types::errors::ValidationError,
CollectionsWithSegmentsProvider,
};
use backon::{ExponentialBuilder, Retryable};
use chroma_api_types::{HeartbeatResponse, OccReadMode, OccReadToken, StaleReadError};
use chroma_config::{regist... |
97604b13eb6d25ff89085bcb08a3dc239a6297178bff72729d7a55a2280e77b6 | Rust | 200,006 | 5,134 | use chroma_error::{ChromaError, ErrorCodes};
use regex::Regex;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::{Arc, LazyLock};
use thiserror::Error;
use validator::Validate;
use crate::chroma_proto;
use crate::collection_configuration::{
EmbeddingFunctionConfiguration, InternalC... |
6e764985e1b8728abf5271b5aebab29b24c648a0627686ebe0565d98a6e2ff16 | Rust | 200,008 | 4,897 | use std::{
collections::{HashMap, HashSet},
sync::{
atomic::{AtomicU32, AtomicU64},
Arc,
},
};
use chroma_blockstore::{
arrow::provider::BlockfileReaderOptions,
provider::{BlockfileProvider, CreateError, OpenError},
BlockfileFlusher, BlockfileReader, BlockfileWriter, BlockfileWr... |
003287dd930b558d158cc241610fc1fffefa8d58eb201a97f37f7f573a774046 | Rust | 200,516 | 4,644 | use crate::types::ChromaSegmentFlusher;
use super::blockfile_record::ApplyMaterializedLogError;
use super::types::{MaterializeLogsResult, PartitionedMaterializeLogsResult};
use crate::blockfile_record::{RecordSegmentReader, RecordSegmentReaderShard};
use chroma_blockstore::arrow::provider::BlockfileReaderOptions;
use ... |
d17f172beee63e9040fcdef876a493142d8a691e8440d6ddcce2bafa23d85a65 | SAS | 1,156 | 26 | data work.Import;
set work.Import;
by ID;
Trial_Number = Trial -1;
CTrial_Number = Trial_Number;
Status = Status_MECFS_is_1;
Sex = Sex_Male_is_1;
Difficulty_Choice = Trial_Difficulty_Hard_is_1;
Successful_Completion = Successful_Completion_Yes_is_1;
Reward_Value = Value_of_Reward;
Reward_Probability = Probabi... |
2ce3d285defb90adfbe54eacc0f632eb9d0658bf26d2fbff924f8f3ddb2d2f25 | SAS | 2,016 | 28 | data work.Import;
set work.Import;
by ID;
Trial_Number = Trial -1;
CTrial_Number = Trial_Number;
Status = Status_MECFS_is_1;
Sex = Sex_Male_is_1;
Difficulty_Choice = Trial_Difficulty_Hard_is_1;
Successful_Completion = Successful_Completion_Yes_is_1;
Reward_Value = Value_of_Reward;
Reward_Probability = Probabi... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.