1use crate::{
16 PrepareSelectObjectSnapshotError, QueryError, SELECT_DEFAULT_READ_BUFFER_SIZE, SelectError, SelectGetObjectReader,
17 SelectInputMetrics, SelectObjectOptions, SelectObjectSnapshot, SelectObjectSnapshotReadError, SelectStorageError,
18 SelectStore, SnapshotConsistencyError,
19 input_stream::{CompressionFormat, compressed_input_reader, compressed_input_stream, processed_bytes_limit},
20 query::{
21 ast::{JsonPathSegment, JsonSource},
22 parser::RustFsDialect,
23 session::QueryExecutionTracker,
24 },
25 resolve_select_object_store_handle, select_is_err_bucket_not_found, select_is_err_object_not_found,
26 select_is_err_version_not_found,
27};
28use async_trait::async_trait;
29use bytes::Bytes;
30use chrono::{DateTime, Utc};
31use datafusion::{
32 execution::memory_pool::{MemoryPool, UnboundedMemoryPool},
33 object_store::{
34 Attributes, CopyOptions, Error as o_Error, GetOptions, GetRange, GetResult, GetResultPayload, ListResult,
35 MultipartUpload, ObjectMeta, ObjectStore, PutMultipartOptions, PutOptions, PutPayload, PutResult, Result, path::Path,
36 },
37 sql::{
38 planner::IdentNormalizer,
39 sqlparser::{
40 ast::{Expr, Ident, JsonPathElem, ObjectNamePart, SetExpr, Statement, TableFactor},
41 parser::Parser as SqlParser,
42 },
43 },
44};
45use futures::pin_mut;
46use futures::{Stream, StreamExt, TryStreamExt, future::ready, stream};
47use futures_core::stream::BoxStream;
48use http::{HeaderMap, HeaderValue, header::HeaderName};
49use rustfs_common::DEFAULT_DELIMITER;
50use s3s::header::{
51 X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_ALGORITHM, X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY,
52 X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY_MD5,
53};
54use s3s::{
55 S3Error, S3ErrorCode, S3Result,
56 dto::{CompressionType, InputSerialization, ScanRange, SelectObjectContentInput},
57};
58use std::collections::VecDeque;
59use std::ops::Range;
60use std::sync::Arc;
61#[cfg(test)]
62use std::sync::atomic::{AtomicUsize, Ordering};
63use tokio::{io::AsyncReadExt, sync::OnceCell};
64use tokio_util::io::ReaderStream;
65use transform_stream::AsyncTryStream;
66
67use crate::csv_input::{CsvSyntax, csv_input_requires_normalization, normalize_csv_stream};
68use crate::storage_api::object_store::HTTPRangeSpec;
69
70mod json_document;
71
72use json_document::{compressed_json_document_ndjson_stream, json_document_ndjson_stream};
73
74fn select_default_read_buffer_size_u64() -> u64 {
75 u64::try_from(SELECT_DEFAULT_READ_BUFFER_SIZE).unwrap_or(u64::MAX)
76}
77
78fn compression_format(input: &InputSerialization) -> Result<Option<CompressionFormat>, SelectError> {
79 match input.compression_type.as_ref().map(|value| value.as_str()) {
80 None | Some(CompressionType::NONE) => Ok(None),
81 Some(CompressionType::GZIP) => Ok(Some(CompressionFormat::Gzip)),
82 Some(CompressionType::BZIP2) => Ok(Some(CompressionFormat::Bzip2)),
83 Some(_) => Err(SelectError::InvalidCompressionFormat),
84 }
85}
86
87pub const MAX_JSON_DOCUMENT_BYTES: u64 = 128 * 1024 * 1024;
93#[cfg(test)]
94use json_document::{
95 JSON_CANCELLATION_CHECK_BYTES, JSON_CANCELLATION_CHECK_KEYS, escaped_json_object_with_size, flatten_json_document_to_ndjson,
96 json_key_eq_ignore_ascii_case_with_checkpoint, parse_json_document_to_lines, remove_json_source_key_with_checkpoint,
97 validate_json_document_size,
98};
99pub const INVALID_SCAN_RANGE_MESSAGE: &str =
100 "The value of a parameter in ScanRange element is invalid. Check the service API documentation and try again.";
101const NORMALIZED_RECORD_DELIMITER: &[u8] = b"\r\n";
102const NORMALIZED_FIELD_DELIMITER: &[u8] = &[DEFAULT_DELIMITER];
103
104pub fn is_noop_scan_range(scan_range: &ScanRange) -> bool {
106 scan_range.start == Some(0) && scan_range.end.is_none()
107}
108
109pub struct EcObjectStore {
110 input: Arc<SelectObjectContentInput>,
111 need_convert: bool,
112 delimiter: String,
113 is_json_document: bool,
117 json_source: JsonSource,
119 input_metrics: Arc<SelectInputMetrics>,
120 memory_pool: Arc<dyn MemoryPool>,
121 query_tracker: Option<QueryExecutionTracker>,
122 store: Option<Arc<SelectStore>>,
123 snapshot: OnceCell<Arc<SelectObjectSnapshot>>,
124 #[cfg(test)]
125 reader_open_count: Arc<AtomicUsize>,
126}
127
128#[derive(Debug, thiserror::Error)]
129pub(crate) enum EcObjectStoreBuildError {
130 #[error("ec store not inited")]
131 StoreUnavailable,
132 #[error("SelectObjectContent snapshot consistency failure: {0}")]
133 Snapshot(#[source] SnapshotConsistencyError),
134}
135
136#[derive(Debug, thiserror::Error)]
137pub(crate) enum SelectObjectStoreError {
138 #[error("SelectObjectContent bucket does not exist")]
139 BucketNotFound {
140 #[source]
141 source: SelectStorageError,
142 },
143 #[error("SelectObjectContent object does not exist")]
144 ObjectNotFound {
145 #[source]
146 source: SelectStorageError,
147 },
148 #[error("SelectObjectContent storage failure")]
149 Storage {
150 #[source]
151 source: SelectStorageError,
152 },
153 #[error("SelectObjectContent ScanRange is invalid")]
154 InvalidScanRange,
155}
156
157impl SelectObjectStoreError {
158 pub(crate) fn select_error(&self) -> SelectError {
159 match self {
160 Self::BucketNotFound { .. } => SelectError::BucketNotFound,
161 Self::ObjectNotFound { .. } => SelectError::ObjectNotFound,
162 Self::InvalidScanRange => SelectError::InvalidScanRange,
163 Self::Storage { .. } => SelectError::InternalError,
164 }
165 }
166}
167
168#[derive(Clone, Copy, Debug)]
169pub struct SelectScanRange {
170 start: u64,
171 end: u64,
172}
173
174impl SelectScanRange {
175 pub const fn new(start: u64, end: u64) -> Self {
176 Self { start, end }
177 }
178
179 pub const fn start(&self) -> u64 {
180 self.start
181 }
182
183 pub const fn end(&self) -> u64 {
184 self.end
185 }
186}
187
188#[derive(Clone, Copy, Debug)]
189pub struct InvalidScanRange;
190
191impl EcObjectStore {
192 pub fn new(input: Arc<SelectObjectContentInput>) -> S3Result<Self> {
193 let source = legacy_json_source_from_input(&input);
194 Self::build_lazy(
195 input,
196 Arc::new(UnboundedMemoryPool::default()),
197 None,
198 Arc::new(SelectInputMetrics::default()),
199 source,
200 )
201 .map_err(map_build_error_to_s3)
202 }
203
204 pub fn new_with_snapshot(input: Arc<SelectObjectContentInput>, snapshot: Arc<SelectObjectSnapshot>) -> S3Result<Self> {
205 let source = legacy_json_source_from_input(&input);
206 Self::build_with_snapshot(
207 input,
208 Arc::new(UnboundedMemoryPool::default()),
209 None,
210 Arc::new(SelectInputMetrics::default()),
211 snapshot,
212 source,
213 )
214 .map_err(map_build_error_to_s3)
215 }
216
217 pub(crate) fn new_with_memory_pool_and_source(
218 input: Arc<SelectObjectContentInput>,
219 memory_pool: Arc<dyn MemoryPool>,
220 input_metrics: Arc<SelectInputMetrics>,
221 snapshot: Option<Arc<SelectObjectSnapshot>>,
222 source: JsonSource,
223 ) -> std::result::Result<Self, EcObjectStoreBuildError> {
224 match snapshot {
225 Some(snapshot) => Self::build_with_snapshot(input, memory_pool, None, input_metrics, snapshot, source),
226 None => Self::build_lazy(input, memory_pool, None, input_metrics, source),
227 }
228 }
229
230 pub(crate) fn new_with_query_tracker_and_source(
231 input: Arc<SelectObjectContentInput>,
232 memory_pool: Arc<dyn MemoryPool>,
233 query_tracker: QueryExecutionTracker,
234 input_metrics: Arc<SelectInputMetrics>,
235 snapshot: Option<Arc<SelectObjectSnapshot>>,
236 source: JsonSource,
237 ) -> std::result::Result<Self, EcObjectStoreBuildError> {
238 match snapshot {
239 Some(snapshot) => Self::build_with_snapshot(input, memory_pool, Some(query_tracker), input_metrics, snapshot, source),
240 None => Self::build_lazy(input, memory_pool, Some(query_tracker), input_metrics, source),
241 }
242 }
243
244 fn build_lazy(
245 input: Arc<SelectObjectContentInput>,
246 memory_pool: Arc<dyn MemoryPool>,
247 query_tracker: Option<QueryExecutionTracker>,
248 input_metrics: Arc<SelectInputMetrics>,
249 source: JsonSource,
250 ) -> std::result::Result<Self, EcObjectStoreBuildError> {
251 let store = resolve_select_object_store_handle().ok_or(EcObjectStoreBuildError::StoreUnavailable)?;
252 Ok(Self::build(input, memory_pool, query_tracker, input_metrics, Some(store), None, source))
253 }
254
255 fn build_with_snapshot(
256 input: Arc<SelectObjectContentInput>,
257 memory_pool: Arc<dyn MemoryPool>,
258 query_tracker: Option<QueryExecutionTracker>,
259 input_metrics: Arc<SelectInputMetrics>,
260 snapshot: Arc<SelectObjectSnapshot>,
261 source: JsonSource,
262 ) -> std::result::Result<Self, EcObjectStoreBuildError> {
263 if !snapshot.is_for(&input.bucket, &input.key) {
264 return Err(EcObjectStoreBuildError::Snapshot(SnapshotConsistencyError::ObjectChanged));
265 }
266 Ok(Self::build(
267 input,
268 memory_pool,
269 query_tracker,
270 input_metrics,
271 None,
272 Some(snapshot),
273 source,
274 ))
275 }
276
277 fn build(
278 input: Arc<SelectObjectContentInput>,
279 memory_pool: Arc<dyn MemoryPool>,
280 query_tracker: Option<QueryExecutionTracker>,
281 input_metrics: Arc<SelectInputMetrics>,
282 store: Option<Arc<SelectStore>>,
283 snapshot: Option<Arc<SelectObjectSnapshot>>,
284 source: JsonSource,
285 ) -> Self {
286 let (need_convert, delimiter) = if let Some(csv) = input.request.input_serialization.csv.as_ref() {
287 if let Some(delimiter) = csv.field_delimiter.as_ref() {
288 if delimiter.len() > 1 {
289 (true, delimiter.to_owned())
290 } else {
291 (false, String::new())
292 }
293 } else {
294 (false, String::new())
295 }
296 } else {
297 (false, String::new())
298 };
299
300 let is_json_document = is_json_document_input(&input);
303
304 Self {
305 input,
306 need_convert,
307 delimiter,
308 is_json_document,
309 json_source: source,
310 input_metrics,
311 memory_pool,
312 query_tracker,
313 store,
314 snapshot: match snapshot {
315 Some(snapshot) => OnceCell::new_with(Some(snapshot)),
316 None => OnceCell::new(),
317 },
318 #[cfg(test)]
319 reader_open_count: Arc::new(AtomicUsize::new(0)),
320 }
321 }
322
323 fn scan_range(&self, object_size: u64) -> Result<Option<SelectScanRange>> {
324 let Some(scan_range) = self.input.request.scan_range.as_ref() else {
325 return Ok(None);
326 };
327 if is_noop_scan_range(scan_range) {
328 return Ok(None);
329 }
330 scan_range_from_bounds(scan_range.start, scan_range.end, object_size)
331 }
332
333 fn record_delimiter(&self) -> Vec<u8> {
334 self.input
335 .request
336 .input_serialization
337 .csv
338 .as_ref()
339 .and_then(|csv| csv.record_delimiter.as_ref())
340 .map(|delimiter| delimiter.as_bytes().to_vec())
341 .unwrap_or_else(|| b"\n".to_vec())
342 }
343
344 fn record_delimiter_for_conversion(&self) -> Option<Vec<u8>> {
345 let delimiter = self.record_delimiter();
346 (self.need_convert || (delimiter.len() == 2 && delimiter != NORMALIZED_RECORD_DELIMITER)).then_some(delimiter)
347 }
348
349 fn convert_csv_stream<S>(&self, stream: S) -> BoxStream<'static, Result<Bytes>>
350 where
351 S: Stream<Item = Result<Bytes>> + Send + 'static,
352 {
353 if let Some(csv) = self.input.request.input_serialization.csv.as_ref()
354 && csv_input_requires_normalization(csv.quote_character.as_deref(), csv.quote_escape_character.as_deref())
355 {
356 let syntax = CsvSyntax {
357 quote: csv.quote_character.as_deref(),
358 escape: csv.quote_escape_character.as_deref(),
359 field: csv.field_delimiter.as_deref(),
360 record: csv.record_delimiter.as_deref(),
361 comment: csv.comments.as_ref().and_then(|comment| comment.as_bytes().first().copied()),
362 };
363 return normalize_csv_stream(stream, &syntax);
364 }
365 convert_csv_delimiter_stream(
366 stream,
367 self.record_delimiter_for_conversion(),
368 self.need_convert.then(|| self.delimiter.clone()),
369 )
370 }
371
372 fn csv_has_header(&self) -> bool {
373 self.input
374 .request
375 .input_serialization
376 .csv
377 .as_ref()
378 .and_then(|csv| csv.file_header_info.as_ref())
379 .is_some_and(|info| matches!(info.as_str(), "USE" | "IGNORE"))
380 }
381
382 async fn snapshot(&self, version: Option<&str>) -> Result<&Arc<SelectObjectSnapshot>> {
383 let snapshot = self
384 .snapshot
385 .get_or_try_init(|| async {
386 let store = self.store.as_ref().ok_or_else(|| o_Error::Generic {
387 store: "EcObjectStore",
388 source: "prepared snapshot is unavailable".into(),
389 })?;
390 let opts = SelectObjectOptions {
391 version_id: version.map(|version| {
392 let version = version.trim();
393 if version.eq_ignore_ascii_case("null") {
394 uuid::Uuid::nil().to_string()
395 } else {
396 version.to_owned()
397 }
398 }),
399 ..Default::default()
400 };
401 let snapshot = store
402 .prepare_select_object_snapshot(&self.input.bucket, &self.input.key, &select_read_headers(&self.input), &opts)
403 .await
404 .map_err(|err| map_prepare_snapshot_error(&self.input.bucket, &self.input.key, err))?;
405 Ok::<_, o_Error>(Arc::new(snapshot))
406 })
407 .await?;
408 if let Some(requested) = version
409 && !snapshot.matches_version(requested)
410 {
411 return Err(o_Error::Generic {
412 store: "EcObjectStore",
413 source: "prepared snapshot is pinned to a different object version".into(),
414 });
415 }
416 Ok(snapshot)
417 }
418
419 async fn object_reader(&self, range: Option<HTTPRangeSpec>) -> Result<SelectGetObjectReader> {
420 #[cfg(test)]
421 self.reader_open_count.fetch_add(1, Ordering::Relaxed);
422 self.snapshot(None)
423 .await?
424 .open_reader(range)
425 .await
426 .map_err(|err| snapshot_read_error(&self.input.bucket, &self.input.key, err))
427 }
428
429 async fn read_raw_range(&self, range: Range<u64>) -> Result<Bytes> {
430 if range.is_empty() {
431 return Ok(Bytes::new());
432 }
433 let snapshot = self.snapshot(None).await?;
434 let reader = self.object_reader(Some(http_range_spec_from_range(range.clone()))).await?;
435 let object_size = snapshot.logical_size();
436 let resolved_range = GetRange::Bounded(range)
437 .as_range(object_size)
438 .map_err(|err| o_Error::Generic {
439 store: "EcObjectStore",
440 source: Box::new(err),
441 })?;
442 let expected_size = usize::try_from(resolved_range.end - resolved_range.start).map_err(|err| o_Error::Generic {
443 store: "EcObjectStore",
444 source: Box::new(err),
445 })?;
446 let mut reader = reader.stream;
447 let mut bytes = Vec::new();
448 reader.read_to_end(&mut bytes).await.map_err(|err| o_Error::Generic {
449 store: "EcObjectStore",
450 source: Box::new(err),
451 })?;
452 if bytes.len() < expected_size {
453 return Err(incomplete_object_stream_error(expected_size - bytes.len()));
454 }
455 bytes.truncate(expected_size);
456 Ok(Bytes::from(bytes))
457 }
458
459 async fn read_header_record(&self, object_size: u64, delimiter: &[u8]) -> Result<Bytes> {
460 if object_size == 0 {
461 return Ok(Bytes::new());
462 }
463
464 let mut end = select_default_read_buffer_size_u64().min(object_size);
465 loop {
466 let bytes = self.read_raw_range(0..end).await?;
467 if let Some(pos) = find_delimiter(&bytes, delimiter) {
468 return Ok(bytes.slice(0..pos + delimiter.len()));
469 }
470 if end == object_size {
471 return Ok(bytes);
472 }
473 end = end.saturating_mul(2).min(object_size);
474 }
475 }
476
477 async fn scan_range_read_start(&self, scan_range: SelectScanRange, delimiter: &[u8]) -> Result<u64> {
478 let delimiter_len = u64::try_from(delimiter.len()).unwrap_or(u64::MAX);
479 let fallback_start = scan_range.start().saturating_sub(delimiter_len);
480 if delimiter.len() != 2 || delimiter[0] != delimiter[1] || scan_range.start() == 0 {
481 return Ok(fallback_start);
482 }
483
484 let context_start = scan_range.start().saturating_sub(select_default_read_buffer_size_u64());
485 let context = self.read_raw_range(context_start..scan_range.start()).await?;
486 let suffix_len = context.iter().rev().take_while(|byte| **byte == delimiter[0]).count();
487 if suffix_len == context.len() && context_start > 0 {
488 return Err(o_Error::Generic {
489 store: "EcObjectStore",
490 source: "self-overlapping CSV record delimiter exceeds the bounded ScanRange context".into(),
491 });
492 }
493 if suffix_len == 0 {
494 return Ok(fallback_start);
495 }
496 Ok(scan_range.start().saturating_sub(u64::from(suffix_len % 2 != 0)))
497 }
498}
499
500pub(crate) fn is_json_document_input(input: &SelectObjectContentInput) -> bool {
501 input
502 .request
503 .input_serialization
504 .json
505 .as_ref()
506 .and_then(|json| json.type_.as_ref())
507 .is_some_and(|json_type| json_type.as_str() == "DOCUMENT")
508}
509
510pub(crate) fn legacy_json_source_from_input(input: &SelectObjectContentInput) -> JsonSource {
512 if !is_json_document_input(input) {
513 return JsonSource::default();
514 }
515 let Ok(mut statements) = SqlParser::parse_sql(&RustFsDialect, &input.request.expression) else {
516 return JsonSource::default();
517 };
518 if statements.len() != 1 {
519 return JsonSource::default();
520 }
521 let Some(Statement::Query(query)) = statements.pop() else {
522 return JsonSource::default();
523 };
524 let SetExpr::Select(select) = query.body.as_ref() else {
525 return JsonSource::default();
526 };
527 let [table] = select.from.as_slice() else {
528 return JsonSource::default();
529 };
530 let TableFactor::Table {
531 name, alias, json_path, ..
532 } = &table.relation
533 else {
534 return JsonSource::default();
535 };
536 let Some(ObjectNamePart::Identifier(table_name)) = name.0.first() else {
537 return JsonSource::default();
538 };
539 if name.0.len() > 2 {
540 return JsonSource::default();
541 }
542 let is_s3_object = if table_name.quote_style.is_some() {
543 table_name.value == "S3Object"
544 } else {
545 table_name.value.eq_ignore_ascii_case("S3Object")
546 };
547 if !is_s3_object {
548 return JsonSource::default();
549 }
550 let path = match (name.0.get(1), json_path.as_ref()) {
551 (Some(ObjectNamePart::Identifier(sub_path)), None) => vec![JsonPathSegment::Key {
552 name: sub_path.value.clone(),
553 quoted: sub_path.quote_style.is_some(),
554 }],
555 (None, None) => Vec::new(),
556 (None, Some(json_path)) if matches!(json_path.path.as_slice(), [JsonPathElem::Bracket { key: Expr::Wildcard(_) }]) => {
557 vec![JsonPathSegment::ArrayWildcard]
558 }
559 _ => return JsonSource::default(),
560 };
561 let scalar_column = alias
562 .as_ref()
563 .map(|alias| IdentNormalizer::default().normalize(alias.name.clone()))
564 .or_else(|| match path.as_slice() {
565 [] => Some(IdentNormalizer::default().normalize(table_name.clone())),
566 [JsonPathSegment::Key { name, quoted }] => {
567 let alias = if *quoted {
568 Ident::with_quote('"', name)
569 } else {
570 Ident::new(name)
571 };
572 Some(IdentNormalizer::default().normalize(alias))
573 }
574 [JsonPathSegment::ArrayWildcard] => Some(IdentNormalizer::default().normalize(Ident::new("_1"))),
575 _ => None,
576 });
577 JsonSource::new(path, scalar_column)
578}
579
580impl std::fmt::Debug for EcObjectStore {
581 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
582 f.debug_struct("EcObjectStore")
583 .field("bucket", &self.input.bucket)
584 .field("object", &self.input.key)
585 .field("need_convert", &self.need_convert)
586 .field("is_json_document", &self.is_json_document)
587 .field("json_source", &self.json_source)
588 .finish_non_exhaustive()
589 }
590}
591
592impl std::fmt::Display for EcObjectStore {
593 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
594 f.write_str("EcObjectStore")
595 }
596}
597
598fn unsupported_store_error(op: &str) -> o_Error {
599 o_Error::Generic {
600 store: "s3select-api",
601 source: Box::new(std::io::Error::new(
602 std::io::ErrorKind::Unsupported,
603 format!("operation {op} is not supported in EcObjectStore"),
604 )),
605 }
606}
607
608fn insert_header(headers: &mut HeaderMap, name: HeaderName, value: Option<&str>) {
609 if let Some(value) = value
610 && let Ok(value) = HeaderValue::from_str(value)
611 {
612 headers.insert(name, value);
613 }
614}
615
616fn select_read_headers(input: &SelectObjectContentInput) -> HeaderMap {
617 let mut headers = HeaderMap::new();
618 insert_header(
619 &mut headers,
620 X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_ALGORITHM,
621 input.sse_customer_algorithm.as_deref(),
622 );
623 insert_header(&mut headers, X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY, input.sse_customer_key.as_deref());
624 insert_header(
625 &mut headers,
626 X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY_MD5,
627 input.sse_customer_key_md5.as_deref(),
628 );
629 headers
630}
631
632fn http_range_spec_from_get_range(range: &GetRange) -> HTTPRangeSpec {
633 match range {
634 GetRange::Bounded(range) => http_range_spec_from_range(range.clone()),
635 GetRange::Offset(start) => HTTPRangeSpec {
636 is_suffix_length: false,
637 start: *start as i64,
638 end: -1,
639 },
640 GetRange::Suffix(length) => HTTPRangeSpec {
641 is_suffix_length: true,
642 start: *length as i64,
643 end: -1,
644 },
645 }
646}
647
648fn http_range_spec_from_range(range: Range<u64>) -> HTTPRangeSpec {
649 HTTPRangeSpec {
650 is_suffix_length: false,
651 start: range.start as i64,
652 end: range.end.saturating_sub(1) as i64,
653 }
654}
655
656fn http_range_spec_from_start(start: u64) -> HTTPRangeSpec {
657 HTTPRangeSpec {
658 is_suffix_length: false,
659 start: start as i64,
660 end: -1,
661 }
662}
663
664fn find_delimiter(bytes: &[u8], delimiter: &[u8]) -> Option<usize> {
665 if delimiter.is_empty() {
666 return None;
667 }
668 bytes.windows(delimiter.len()).position(|window| window == delimiter)
669}
670
671fn map_prepare_snapshot_error(bucket: &str, object: &str, err: PrepareSelectObjectSnapshotError) -> o_Error {
672 match err {
673 PrepareSelectObjectSnapshotError::Storage(err) => map_storage_error(bucket, object, err),
674 err => o_Error::Generic {
675 store: "EcObjectStore",
676 source: Box::new(err),
677 },
678 }
679}
680
681fn map_build_error_to_s3(error: EcObjectStoreBuildError) -> S3Error {
682 let mut s3_error = S3Error::with_message(S3ErrorCode::InternalError, SelectError::InternalError.to_string());
683 s3_error.set_source(Box::new(error));
684 s3_error
685}
686
687fn snapshot_read_error(bucket: &str, object: &str, err: SelectObjectSnapshotReadError) -> o_Error {
688 match err {
689 SelectObjectSnapshotReadError::Storage(err) => map_storage_error(bucket, object, err),
690 err => o_Error::Generic {
691 store: "EcObjectStore",
692 source: Box::new(err),
693 },
694 }
695}
696
697fn map_storage_error(bucket: &str, object: &str, err: SelectStorageError) -> o_Error {
698 if select_is_err_bucket_not_found(&err) {
699 return o_Error::NotFound {
700 path: format!("{bucket}/{object}"),
701 source: Box::new(SelectObjectStoreError::BucketNotFound { source: err }),
702 };
703 }
704 if select_is_err_object_not_found(&err) || select_is_err_version_not_found(&err) {
705 return o_Error::NotFound {
706 path: format!("{bucket}/{object}"),
707 source: Box::new(SelectObjectStoreError::ObjectNotFound { source: err }),
708 };
709 }
710 o_Error::Generic {
711 store: "EcObjectStore",
712 source: Box::new(SelectObjectStoreError::Storage { source: err }),
713 }
714}
715
716fn snapshot_last_modified(snapshot: &SelectObjectSnapshot) -> Result<DateTime<Utc>> {
717 let mod_time = snapshot.object_info().mod_time.ok_or_else(|| o_Error::Generic {
718 store: "EcObjectStore",
719 source: std::io::Error::new(std::io::ErrorKind::InvalidData, "snapshot metadata has no modification time").into(),
720 })?;
721 DateTime::<Utc>::from_timestamp(mod_time.unix_timestamp(), mod_time.nanosecond()).ok_or_else(|| o_Error::Generic {
722 store: "EcObjectStore",
723 source: std::io::Error::new(std::io::ErrorKind::InvalidData, "snapshot modification time is out of range").into(),
724 })
725}
726
727pub fn scan_range_from_bounds(start: Option<i64>, end: Option<i64>, object_size: u64) -> Result<Option<SelectScanRange>> {
728 parse_scan_range_from_bounds(start, end, object_size).map_err(|_| invalid_scan_range_store_error())
729}
730
731pub fn validate_scan_range_bounds(
732 start: Option<i64>,
733 end: Option<i64>,
734 object_size: u64,
735) -> std::result::Result<(), InvalidScanRange> {
736 parse_scan_range_from_bounds(start, end, object_size).map(|_| ())
737}
738
739fn parse_scan_range_from_bounds(
740 start: Option<i64>,
741 end: Option<i64>,
742 object_size: u64,
743) -> std::result::Result<Option<SelectScanRange>, InvalidScanRange> {
744 if start.is_none() && end.is_none() {
745 return Ok(None);
746 }
747 if start.is_some_and(|value| value < 0) || end.is_some_and(|value| value < 0) {
748 return Err(InvalidScanRange);
749 }
750 if let (Some(start), Some(end)) = (start, end)
751 && start > end
752 {
753 return Err(InvalidScanRange);
754 }
755 if let Some(start) = start {
756 let start = start as u64;
757 if object_size == 0 {
758 if start > 0 {
759 return Err(InvalidScanRange);
760 }
761 return Ok(Some(SelectScanRange::new(0, 0)));
762 }
763 if start >= object_size {
764 return Err(InvalidScanRange);
765 }
766 }
767 if object_size == 0 {
768 return Ok(Some(SelectScanRange::new(0, 0)));
769 }
770
771 let last_byte = object_size - 1;
772 let (start, end) = match (start, end) {
773 (Some(start), Some(end)) => (start as u64, (end as u64).min(last_byte)),
774 (Some(start), None) => (start as u64, last_byte),
775 (None, Some(suffix_len)) => {
776 let suffix_len = suffix_len as u64;
777 (object_size.saturating_sub(suffix_len), last_byte)
778 }
779 (None, None) => return Ok(None),
780 };
781 Ok(Some(SelectScanRange::new(start, end)))
782}
783
784fn invalid_scan_range_store_error() -> o_Error {
785 o_Error::Generic {
786 store: "EcObjectStore",
787 source: Box::new(SelectObjectStoreError::InvalidScanRange),
788 }
789}
790
791#[async_trait]
792impl ObjectStore for EcObjectStore {
793 async fn put_opts(&self, _location: &Path, _payload: PutPayload, _opts: PutOptions) -> Result<PutResult> {
794 Err(unsupported_store_error("put_opts"))
795 }
796
797 async fn put_multipart_opts(&self, _location: &Path, _opts: PutMultipartOptions) -> Result<Box<dyn MultipartUpload>> {
798 Err(unsupported_store_error("put_multipart_opts"))
799 }
800
801 async fn get_opts(&self, location: &Path, options: GetOptions) -> Result<GetResult> {
802 let snapshot = self.snapshot(options.version.as_deref()).await?;
806 let original_size = snapshot.logical_size();
807 let compression = compression_format(&self.input.request.input_serialization).map_err(|source| o_Error::Generic {
808 store: "EcObjectStore",
809 source: Box::new(source),
810 })?;
811 let has_effective_request_range = self
812 .input
813 .request
814 .scan_range
815 .as_ref()
816 .is_some_and(|scan_range| !is_noop_scan_range(scan_range));
817 if compression.is_some() && (options.range.is_some() || has_effective_request_range) {
818 return Err(o_Error::Generic {
819 store: "EcObjectStore",
820 source: Box::new(SelectError::UnsupportedScanRangeInput),
821 });
822 }
823 let object_info = snapshot.object_info();
824 let meta = ObjectMeta {
825 location: location.clone(),
826 last_modified: snapshot_last_modified(snapshot)?,
827 size: original_size,
828 e_tag: object_info.etag.clone(),
829 version: object_info.version_id.map(|version| version.to_string()),
830 };
831 let result_range = match options.range.as_ref() {
832 Some(range) => range.as_range(original_size).map_err(|err| o_Error::Generic {
833 store: "EcObjectStore",
834 source: Box::new(err),
835 })?,
836 None => 0..original_size,
837 };
838 if options.head {
839 return Ok(GetResult {
840 payload: GetResultPayload::Stream(stream::empty().boxed()),
841 meta,
842 range: result_range,
843 attributes: Attributes::default(),
844 });
845 }
846
847 let needs_scan_context = options.range.is_none() && has_effective_request_range;
848 let scan_context = if needs_scan_context {
849 if let Some(scan_range) = self.scan_range(original_size)? {
850 let delimiter = self.record_delimiter();
851 let read_start = self.scan_range_read_start(scan_range, &delimiter).await?;
852 Some((scan_range, read_start))
853 } else {
854 None
855 }
856 } else {
857 None
858 };
859
860 let range = options.range.as_ref().map(http_range_spec_from_get_range);
861 let reader = if let Some((_, read_start)) = scan_context.as_ref() {
862 let range = (original_size > 0).then(|| http_range_spec_from_start(*read_start));
863 self.object_reader(range).await?
864 } else {
865 self.object_reader(range).await?
866 };
867
868 let meter_input = self.input.request.input_serialization.parquet.is_none();
869 let payload = if let Some(compression) = compression {
870 let max_processed_bytes = processed_bytes_limit();
871 let query_guard = match self.query_tracker.as_ref() {
872 Some(query_tracker) => Some(query_tracker.query_guard().ok_or_else(|| o_Error::Generic {
873 store: "EcObjectStore",
874 source: Box::new(QueryError::Cancel),
875 })?),
876 None => None,
877 };
878 if self.is_json_document {
879 let reader = compressed_input_reader(
880 reader.stream,
881 original_size,
882 compression,
883 Arc::clone(&self.input_metrics),
884 max_processed_bytes,
885 query_guard,
886 );
887 let stream = compressed_json_document_ndjson_stream(
888 reader,
889 self.json_source.clone(),
890 Arc::clone(&self.memory_pool),
891 self.query_tracker.clone(),
892 );
893 GetResultPayload::Stream(stream)
894 } else {
895 let input_record_delimiter = if self.input.request.input_serialization.csv.is_some() {
896 self.record_delimiter()
897 } else {
898 b"\n".to_vec()
899 };
900 let stream = compressed_input_stream(
901 reader.stream,
902 original_size,
903 compression,
904 Arc::clone(&self.input_metrics),
905 input_record_delimiter,
906 max_processed_bytes,
907 query_guard,
908 )?;
909 let stream = self.convert_csv_stream(stream);
910 GetResultPayload::Stream(stream)
911 }
912 } else if options.range.is_some() {
913 let size = usize::try_from(result_range.end - result_range.start).map_err(|err| o_Error::Generic {
914 store: "EcObjectStore",
915 source: Box::new(err),
916 })?;
917 let stream = bytes_stream(ReaderStream::with_capacity(reader.stream, SELECT_DEFAULT_READ_BUFFER_SIZE), size);
918 if meter_input {
919 GetResultPayload::Stream(meter_uncompressed_input_stream(stream, Arc::clone(&self.input_metrics)).boxed())
920 } else {
921 GetResultPayload::Stream(stream.boxed())
922 }
923 } else if self.is_json_document {
924 let stream = json_document_ndjson_stream(
926 reader.stream,
927 original_size,
928 self.json_source.clone(),
929 Arc::clone(&self.input_metrics),
930 Arc::clone(&self.memory_pool),
931 self.query_tracker.clone(),
932 )?;
933 GetResultPayload::Stream(stream)
934 } else if let Some((scan_range, read_start)) = scan_context {
935 let delimiter = self.record_delimiter();
936 let include_header = self.csv_has_header();
937 let header = if include_header && read_start > 0 {
938 let input_metrics = self.input_metrics.recorder();
939 let header = self.read_header_record(original_size, &delimiter).await?;
940 input_metrics.record_uncompressed(header.len());
941 Some(header)
942 } else {
943 None
944 };
945 let stream = scan_range_stream(
946 meter_uncompressed_input_stream(
947 ReaderStream::with_capacity(reader.stream, SELECT_DEFAULT_READ_BUFFER_SIZE),
948 Arc::clone(&self.input_metrics),
949 ),
950 delimiter,
951 scan_range,
952 include_header && header.is_none(),
953 read_start,
954 original_size,
955 )
956 .boxed();
957 let stream = if let Some(header) = header {
958 stream::once(ready(Ok(header))).chain(stream).boxed()
959 } else {
960 stream
961 };
962 let stream = self.convert_csv_stream(stream);
963 GetResultPayload::Stream(stream)
964 } else {
965 let stream_size = usize::try_from(original_size).map_err(|err| o_Error::Generic {
966 store: "EcObjectStore",
967 source: Box::new(err),
968 })?;
969 let stream = bytes_stream(ReaderStream::with_capacity(reader.stream, SELECT_DEFAULT_READ_BUFFER_SIZE), stream_size);
970 if meter_input {
971 let stream = meter_uncompressed_input_stream(stream, Arc::clone(&self.input_metrics));
972 let stream = self.convert_csv_stream(stream);
973 GetResultPayload::Stream(stream)
974 } else {
975 GetResultPayload::Stream(stream.boxed())
976 }
977 };
978
979 Ok(GetResult {
980 payload,
981 meta,
982 range: result_range,
983 attributes: Attributes::default(),
984 })
985 }
986
987 async fn get_ranges(&self, _location: &Path, ranges: &[Range<u64>]) -> Result<Vec<Bytes>> {
988 let mut out = Vec::with_capacity(ranges.len());
989 for range in ranges {
990 out.push(self.read_raw_range(range.clone()).await?);
991 }
992 Ok(out)
993 }
994
995 fn delete_stream(&self, _locations: BoxStream<'static, Result<Path>>) -> BoxStream<'static, Result<Path>> {
996 stream::once(ready(Err(unsupported_store_error("delete_stream")))).boxed()
997 }
998
999 fn list(&self, _prefix: Option<&Path>) -> BoxStream<'static, Result<ObjectMeta>> {
1000 stream::once(ready(Err(unsupported_store_error("list")))).boxed()
1001 }
1002
1003 async fn list_with_delimiter(&self, _prefix: Option<&Path>) -> Result<ListResult> {
1004 Err(unsupported_store_error("list_with_delimiter"))
1005 }
1006
1007 async fn copy_opts(&self, _from: &Path, _to: &Path, _options: CopyOptions) -> Result<()> {
1008 Err(unsupported_store_error("copy_opts"))
1009 }
1010}
1011
1012struct CsvDelimiterConverter {
1013 record_delimiter: Option<Vec<u8>>,
1014 field_delimiter: Option<Vec<u8>>,
1015 carry: Vec<u8>,
1016}
1017
1018impl CsvDelimiterConverter {
1019 fn new(record_delimiter: Option<Vec<u8>>, field_delimiter: Option<Vec<u8>>) -> Self {
1020 Self {
1021 record_delimiter: record_delimiter.filter(|delimiter| !delimiter.is_empty()),
1022 field_delimiter: field_delimiter.filter(|delimiter| !delimiter.is_empty()),
1023 carry: Vec::new(),
1024 }
1025 }
1026
1027 fn max_delimiter_len(&self) -> usize {
1028 self.record_delimiter
1029 .as_ref()
1030 .into_iter()
1031 .chain(self.field_delimiter.as_ref())
1032 .map(Vec::len)
1033 .max()
1034 .unwrap_or(1)
1035 }
1036
1037 fn convert_prefix(&self, bytes: &[u8], end: usize) -> (Vec<u8>, usize) {
1038 let mut converted = Vec::with_capacity(bytes.len());
1039 let mut pos = 0;
1040 while pos < end {
1041 let record_match = self
1042 .record_delimiter
1043 .as_ref()
1044 .filter(|delimiter| bytes[pos..].starts_with(delimiter));
1045 let field_match = self
1046 .field_delimiter
1047 .as_ref()
1048 .filter(|delimiter| bytes[pos..].starts_with(delimiter));
1049 if let Some(delimiter) = field_match
1050 && record_match.is_none_or(|record_delimiter| delimiter.len() > record_delimiter.len())
1051 {
1052 converted.extend_from_slice(NORMALIZED_FIELD_DELIMITER);
1053 pos += delimiter.len();
1054 } else if let Some(delimiter) = record_match {
1055 if delimiter.len() == 2 && delimiter != NORMALIZED_RECORD_DELIMITER {
1056 converted.extend_from_slice(NORMALIZED_RECORD_DELIMITER);
1057 } else {
1058 converted.extend_from_slice(delimiter);
1059 }
1060 pos += delimiter.len();
1061 } else {
1062 converted.push(bytes[pos]);
1063 pos += 1;
1064 }
1065 }
1066 (converted, pos)
1067 }
1068
1069 fn convert_chunk(&mut self, chunk: &[u8]) -> Vec<u8> {
1070 let mut combined = Vec::with_capacity(self.carry.len() + chunk.len());
1071 combined.extend_from_slice(&self.carry);
1072 combined.extend_from_slice(chunk);
1073
1074 let safe_end = combined.len().saturating_sub(self.max_delimiter_len().saturating_sub(1));
1075 let (converted, pos) = self.convert_prefix(&combined, safe_end);
1076 self.carry.clear();
1077 self.carry.extend_from_slice(&combined[pos..]);
1078 converted
1079 }
1080
1081 fn finish(&mut self) -> Vec<u8> {
1082 let (converted, _) = self.convert_prefix(&self.carry, self.carry.len());
1083 self.carry.clear();
1084 converted
1085 }
1086}
1087
1088fn convert_delimiter_stream<S>(
1089 stream: S,
1090 record_delimiter: Option<Vec<u8>>,
1091 field_delimiter: Option<Vec<u8>>,
1092) -> BoxStream<'static, Result<Bytes>>
1093where
1094 S: Stream<Item = Result<Bytes>> + Send + 'static,
1095{
1096 AsyncTryStream::<Bytes, o_Error, _>::new(|mut y| async move {
1097 let mut converter = CsvDelimiterConverter::new(record_delimiter, field_delimiter);
1098 pin_mut!(stream);
1099 while let Some(result) = stream.next().await {
1100 let bytes = result?;
1101 let converted = converter.convert_chunk(&bytes);
1102 if !converted.is_empty() {
1103 y.yield_ok(Bytes::from(converted)).await;
1104 }
1105 }
1106 let converted = converter.finish();
1107 if !converted.is_empty() {
1108 y.yield_ok(Bytes::from(converted)).await;
1109 }
1110 Ok(())
1111 })
1112 .boxed()
1113}
1114
1115#[cfg(test)]
1116fn convert_record_delimiter_stream<S>(stream: S, delimiter: Vec<u8>) -> BoxStream<'static, Result<Bytes>>
1117where
1118 S: Stream<Item = Result<Bytes>> + Send + 'static,
1119{
1120 convert_delimiter_stream(stream, Some(delimiter), None)
1122}
1123
1124#[cfg(test)]
1125fn convert_field_delimiter_stream<S>(stream: S, delimiter: String) -> BoxStream<'static, Result<Bytes>>
1126where
1127 S: Stream<Item = Result<Bytes>> + Send + 'static,
1128{
1129 convert_delimiter_stream(stream, None, Some(delimiter.into_bytes()))
1130}
1131
1132fn convert_csv_delimiter_stream<S>(
1133 stream: S,
1134 record_delimiter: Option<Vec<u8>>,
1135 field_delimiter: Option<String>,
1136) -> BoxStream<'static, Result<Bytes>>
1137where
1138 S: Stream<Item = Result<Bytes>> + Send + 'static,
1139{
1140 match (record_delimiter, field_delimiter) {
1141 (None, None) => stream.boxed(),
1142 (record, field) => convert_delimiter_stream(stream, record, field.map(String::into_bytes)),
1143 }
1144}
1145
1146struct ScanRangeState<S> {
1147 stream: S,
1148 delimiter: Vec<u8>,
1149 range: SelectScanRange,
1150 include_header: bool,
1151 offset: u64,
1152 record_start: u64,
1153 record: Vec<u8>,
1154 pending: VecDeque<Bytes>,
1155 done: bool,
1156 expected_end: u64,
1157}
1158
1159fn scan_range_stream<S>(
1160 stream: S,
1161 delimiter: Vec<u8>,
1162 range: SelectScanRange,
1163 include_header: bool,
1164 base_offset: u64,
1165 expected_end: u64,
1166) -> BoxStream<'static, Result<Bytes>>
1167where
1168 S: Stream<Item = std::io::Result<Bytes>> + Send + Unpin + 'static,
1169{
1170 let state = ScanRangeState {
1171 stream,
1172 delimiter,
1173 range,
1174 include_header,
1175 offset: base_offset,
1176 record_start: base_offset,
1177 record: Vec::new(),
1178 pending: VecDeque::new(),
1179 done: false,
1180 expected_end,
1181 };
1182
1183 stream::unfold(state, |mut state| async move {
1184 loop {
1185 if let Some(bytes) = state.pending.pop_front() {
1186 return Some((Ok(bytes), state));
1187 }
1188 if state.done {
1189 return None;
1190 }
1191 match state.stream.next().await {
1192 Some(Ok(bytes)) => state.push_chunk(&bytes),
1193 Some(Err(err)) => {
1194 state.done = true;
1195 return Some((
1196 Err(o_Error::Generic {
1197 store: "EcObjectStore",
1198 source: Box::new(err),
1199 }),
1200 state,
1201 ));
1202 }
1203 None => {
1204 if state.offset < state.expected_end {
1205 state.done = true;
1206 return Some((Err(incomplete_object_stream_error(state.expected_end - state.offset)), state));
1207 }
1208 state.finish_pending_record();
1209 state.done = true;
1210 }
1211 }
1212 }
1213 })
1214 .boxed()
1215}
1216
1217impl<S> ScanRangeState<S> {
1218 fn push_chunk(&mut self, bytes: &[u8]) {
1219 if bytes.is_empty() || self.done {
1220 return;
1221 }
1222 if self.record.is_empty() {
1223 self.record_start = self.offset;
1224 }
1225 let search_start = self.record.len().saturating_sub(self.delimiter.len().saturating_sub(1));
1226 self.record.extend_from_slice(bytes);
1227 self.offset = self.offset.saturating_add(bytes.len() as u64);
1228
1229 let mut search_start = search_start;
1230 while let Some(pos) = find_delimiter(&self.record[search_start..], &self.delimiter) {
1231 let record_end = search_start + pos + self.delimiter.len();
1232 self.finish_record(record_end);
1233 if self.done {
1234 break;
1235 }
1236 search_start = 0;
1237 }
1238 }
1239
1240 fn finish_record(&mut self, record_end: usize) {
1241 let record = self.record.drain(..record_end).collect::<Vec<_>>();
1242 let record_start = self.record_start;
1243 self.record_start = self.record_start.saturating_add(record_end as u64);
1244 self.push_record(record, record_start);
1245 }
1246
1247 fn finish_pending_record(&mut self) {
1248 if self.record.is_empty() {
1249 return;
1250 }
1251 let record = std::mem::take(&mut self.record);
1252 let record_start = self.record_start;
1253 self.push_record(record, record_start);
1254 }
1255
1256 fn push_record(&mut self, record: Vec<u8>, record_start: u64) {
1257 let include_header = self.include_header && record_start == 0;
1258 let include_record = record_start >= self.range.start() && record_start <= self.range.end();
1259 if include_header || include_record {
1260 self.pending.push_back(Bytes::from(record));
1261 } else {
1262 if record_start > self.range.end() {
1263 self.done = true;
1264 }
1265 }
1266 }
1267}
1268
1269fn meter_uncompressed_input_stream<S, E>(
1270 stream: S,
1271 input_metrics: Arc<SelectInputMetrics>,
1272) -> impl Stream<Item = std::result::Result<Bytes, E>> + Send + 'static
1273where
1274 S: Stream<Item = std::result::Result<Bytes, E>> + Send + 'static,
1275 E: Send + 'static,
1276{
1277 let input_metrics = input_metrics.recorder();
1278 stream.inspect_ok(move |bytes| input_metrics.record_uncompressed(bytes.len()))
1279}
1280
1281pub fn bytes_stream<S>(stream: S, content_length: usize) -> impl Stream<Item = Result<Bytes>> + Send + 'static
1282where
1283 S: Stream<Item = Result<Bytes, std::io::Error>> + Send + 'static,
1284{
1285 AsyncTryStream::<Bytes, o_Error, _>::new(|mut y| async move {
1286 pin_mut!(stream);
1287 let mut remaining: usize = content_length;
1288 while remaining > 0 {
1289 let Some(result) = stream.next().await else {
1290 break;
1291 };
1292 let mut bytes = result.map_err(|e| o_Error::Generic {
1293 store: "",
1294 source: Box::new(e),
1295 })?;
1296 if bytes.len() > remaining {
1297 bytes.truncate(remaining);
1298 }
1299 remaining -= bytes.len();
1300 y.yield_ok(bytes).await;
1301 }
1302 if remaining > 0 {
1303 return Err(incomplete_object_stream_error(remaining));
1304 }
1305 Ok(())
1306 })
1307}
1308
1309fn incomplete_object_stream_error(remaining: impl std::fmt::Display) -> o_Error {
1310 o_Error::Generic {
1311 store: "EcObjectStore",
1312 source: Box::new(std::io::Error::new(
1313 std::io::ErrorKind::UnexpectedEof,
1314 format!("object stream ended with {remaining} bytes remaining"),
1315 )),
1316 }
1317}
1318
1319#[cfg(test)]
1320mod test {
1321 use super::{
1322 EcObjectStore, EcObjectStoreBuildError, OnceCell, SELECT_DEFAULT_READ_BUFFER_SIZE, SelectObjectOptions,
1323 SelectObjectSnapshot, SelectScanRange, SnapshotConsistencyError, bytes_stream, compressed_json_document_ndjson_stream,
1324 convert_csv_delimiter_stream, convert_field_delimiter_stream, convert_record_delimiter_stream,
1325 escaped_json_object_with_size, find_delimiter, flatten_json_document_to_ndjson, http_range_spec_from_get_range,
1326 json_document_ndjson_stream, json_key_eq_ignore_ascii_case_with_checkpoint, legacy_json_source_from_input,
1327 map_storage_error, meter_uncompressed_input_stream, remove_json_source_key_with_checkpoint, scan_range_from_bounds,
1328 scan_range_stream, select_read_headers, snapshot_last_modified, validate_json_document_size,
1329 };
1330 use crate::input_stream::{CompressionFormat, MAX_SELECT_RECORD_BYTES, compressed_input_reader, encode_compressed_fixture};
1331 use crate::query::ast::{JsonPathSegment, JsonSource};
1332 use crate::query::session::{QueryExecutionGuard, QueryExecutionOwner, QueryExecutionTracker};
1333 use crate::storage_api::SelectPutObjReader;
1334 use crate::storage_api::object_store::ObjectIO as _;
1335 use crate::{QueryError, SelectError, SelectInputMetrics, SelectStorageError};
1336 use bytes::Bytes;
1337 use datafusion::{
1338 common::DataFusionError,
1339 execution::memory_pool::{GreedyMemoryPool, MemoryLimit, MemoryPool, MemoryReservation},
1340 execution::{config::SessionConfig, context::SessionContext},
1341 object_store::{self, GetOptions, GetRange, GetResultPayload, ObjectStore as _, path::Path},
1342 physical_plan::ExecutionPlanProperties,
1343 prelude::CsvReadOptions,
1344 };
1345 use futures::{StreamExt, TryStreamExt, stream};
1346 use http::HeaderMap;
1347 use parking_lot::Mutex;
1348 use rustfs_test_utils::PutObjectCommitBarrier;
1349 use s3s::S3ErrorCode;
1350 use s3s::dto::{
1351 CSVInput, CSVOutput, CompressionType, ExpressionType, FileHeaderInfo, InputSerialization, JSONInput, JSONOutput,
1352 JSONType, OutputSerialization, ScanRange, SelectObjectContentInput, SelectObjectContentRequest,
1353 };
1354 use s3s::header::{
1355 X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_ALGORITHM, X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY,
1356 X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY_MD5,
1357 };
1358 use std::sync::{
1359 Arc,
1360 atomic::{AtomicUsize, Ordering},
1361 };
1362
1363 use tokio::{io::AsyncReadExt, sync::Semaphore};
1364
1365 const JSON_DOCUMENT_TEST_MEMORY_BYTES: usize = 8 * 1024 * 1024;
1366
1367 #[derive(Debug)]
1368 struct AdmissionObservingMemoryPool {
1369 inner: GreedyMemoryPool,
1370 admission: Arc<Semaphore>,
1371 reservation_release: Mutex<Option<tokio::sync::oneshot::Sender<bool>>>,
1372 }
1373
1374 impl AdmissionObservingMemoryPool {
1375 fn new(pool_size: usize, admission: Arc<Semaphore>) -> (Self, tokio::sync::oneshot::Receiver<bool>) {
1376 let (reservation_release, reservation_released) = tokio::sync::oneshot::channel();
1377 (
1378 Self {
1379 inner: GreedyMemoryPool::new(pool_size),
1380 admission,
1381 reservation_release: Mutex::new(Some(reservation_release)),
1382 },
1383 reservation_released,
1384 )
1385 }
1386 }
1387
1388 impl std::fmt::Display for AdmissionObservingMemoryPool {
1389 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1390 std::fmt::Display::fmt(&self.inner, f)
1391 }
1392 }
1393
1394 impl MemoryPool for AdmissionObservingMemoryPool {
1395 fn name(&self) -> &str {
1396 self.inner.name()
1397 }
1398
1399 fn grow(&self, reservation: &MemoryReservation, additional: usize) {
1400 self.inner.grow(reservation, additional);
1401 }
1402
1403 fn shrink(&self, reservation: &MemoryReservation, shrink: usize) {
1404 self.inner.shrink(reservation, shrink);
1405 if self.inner.reserved() == 0
1406 && let Some(reservation_release) = self.reservation_release.lock().take()
1407 {
1408 let _ = reservation_release.send(self.admission.available_permits() == 0);
1409 }
1410 }
1411
1412 fn try_grow(&self, reservation: &MemoryReservation, additional: usize) -> datafusion::common::Result<()> {
1413 self.inner.try_grow(reservation, additional)
1414 }
1415
1416 fn reserved(&self) -> usize {
1417 self.inner.reserved()
1418 }
1419
1420 fn memory_limit(&self) -> MemoryLimit {
1421 self.inner.memory_limit()
1422 }
1423 }
1424
1425 fn source_key(name: &str) -> JsonPathSegment {
1426 JsonPathSegment::Key {
1427 name: name.to_string(),
1428 quoted: false,
1429 }
1430 }
1431
1432 fn quoted_source_key(name: &str) -> JsonPathSegment {
1433 JsonPathSegment::Key {
1434 name: name.to_string(),
1435 quoted: true,
1436 }
1437 }
1438
1439 fn csv_input(bucket: &str, object: &str) -> Arc<SelectObjectContentInput> {
1440 Arc::new(SelectObjectContentInput {
1441 bucket: bucket.to_string(),
1442 expected_bucket_owner: None,
1443 key: object.to_string(),
1444 sse_customer_algorithm: None,
1445 sse_customer_key: None,
1446 sse_customer_key_md5: None,
1447 request: SelectObjectContentRequest {
1448 expression: "SELECT * FROM s3object".to_string(),
1449 expression_type: ExpressionType::from_static(ExpressionType::SQL),
1450 input_serialization: InputSerialization {
1451 csv: Some(CSVInput::default()),
1452 ..Default::default()
1453 },
1454 output_serialization: OutputSerialization {
1455 csv: Some(CSVOutput::default()),
1456 ..Default::default()
1457 },
1458 request_progress: None,
1459 scan_range: None,
1460 },
1461 })
1462 }
1463
1464 fn json_document_input(bucket: &str, object: &str, expression: &str) -> Arc<SelectObjectContentInput> {
1465 Arc::new(SelectObjectContentInput {
1466 bucket: bucket.to_string(),
1467 expected_bucket_owner: None,
1468 key: object.to_string(),
1469 sse_customer_algorithm: None,
1470 sse_customer_key: None,
1471 sse_customer_key_md5: None,
1472 request: SelectObjectContentRequest {
1473 expression: expression.to_string(),
1474 expression_type: ExpressionType::from_static(ExpressionType::SQL),
1475 input_serialization: InputSerialization {
1476 json: Some(JSONInput {
1477 type_: Some(JSONType::from_static(JSONType::DOCUMENT)),
1478 }),
1479 ..Default::default()
1480 },
1481 output_serialization: OutputSerialization {
1482 csv: Some(CSVOutput::default()),
1483 ..Default::default()
1484 },
1485 request_progress: None,
1486 scan_range: None,
1487 },
1488 })
1489 }
1490
1491 #[test]
1492 fn legacy_source_adapter_normalizes_scalar_bindings() {
1493 let input = json_document_input("bucket", "input.json", "SELECT V FROM S3Object AS V");
1494 let implicit = json_document_input("bucket", "input.json", "SELECT S3Object FROM S3Object");
1495 let wildcard = json_document_input("bucket", "input.json", "SELECT _1 FROM S3Object[*]");
1496 let key = json_document_input("bucket", "input.json", "SELECT * FROM S3Object.LongKey");
1497 let quoted_key = json_document_input("bucket", "input.json", "SELECT * FROM S3Object.\"LongKey\"");
1498
1499 assert_eq!(legacy_json_source_from_input(&input), JsonSource::new(Vec::new(), Some("v".to_string())));
1500 assert_eq!(
1501 legacy_json_source_from_input(&implicit),
1502 JsonSource::new(Vec::new(), Some("s3object".to_string()))
1503 );
1504 assert_eq!(
1505 legacy_json_source_from_input(&wildcard),
1506 JsonSource::new(vec![JsonPathSegment::ArrayWildcard], Some("_1".to_string()))
1507 );
1508 assert_eq!(legacy_json_source_from_input(&key).scalar_column(), Some("longkey"));
1509 assert_eq!(legacy_json_source_from_input("ed_key).scalar_column(), Some("LongKey"));
1510 }
1511
1512 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
1513 #[serial_test::serial]
1514 async fn legacy_public_constructors_preserve_single_key_json_source() {
1515 const BUCKET: &str = "s3select-legacy-json-source";
1516 const OBJECT: &str = "input.json";
1517
1518 let env = crate::storage_api::select_test_ecstore_env().await;
1519 env.make_bucket(BUCKET, false).await;
1520 env.put_object_bytes(BUCKET, OBJECT, br#"{"employees":[{"name":"Alice"}]}"#.to_vec())
1521 .await;
1522 let input = json_document_input(BUCKET, OBJECT, "SELECT e.name FROM S3Object.employees AS e");
1523 let snapshot = prepare_test_snapshot(BUCKET, OBJECT).await;
1524
1525 let lazy = EcObjectStore::new(Arc::clone(&input)).expect("legacy lazy constructor should resolve the global store");
1526 let pinned =
1527 EcObjectStore::new_with_snapshot(input, snapshot).expect("legacy pinned constructor should accept the snapshot");
1528 let expected = JsonSource::new(vec![source_key("employees")], Some("e".to_string()));
1529
1530 assert_eq!(lazy.json_source, expected);
1531 assert_eq!(pinned.json_source, expected);
1532 }
1533
1534 fn json_input(bucket: &str, object: &str, json_type: &'static str) -> Arc<SelectObjectContentInput> {
1535 let mut input = (*csv_input(bucket, object)).clone();
1536 input.request.input_serialization = InputSerialization {
1537 json: Some(JSONInput {
1538 type_: Some(JSONType::from_static(json_type)),
1539 }),
1540 ..Default::default()
1541 };
1542 input.request.output_serialization = OutputSerialization {
1543 json: Some(JSONOutput::default()),
1544 ..Default::default()
1545 };
1546 Arc::new(input)
1547 }
1548
1549 #[test]
1550 fn lazy_snapshot_headers_preserve_ssec_context() {
1551 let mut input = (*csv_input("bucket", "object.csv")).clone();
1552 input.sse_customer_algorithm = Some("AES256".to_string());
1553 input.sse_customer_key = Some("customer-key".to_string());
1554 input.sse_customer_key_md5 = Some("customer-key-md5".to_string());
1555
1556 let headers = select_read_headers(&input);
1557
1558 assert_eq!(
1559 headers
1560 .get(X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_ALGORITHM)
1561 .and_then(|value| value.to_str().ok()),
1562 Some("AES256")
1563 );
1564 assert_eq!(
1565 headers
1566 .get(X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY)
1567 .and_then(|value| value.to_str().ok()),
1568 Some("customer-key")
1569 );
1570 assert_eq!(
1571 headers
1572 .get(X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY_MD5)
1573 .and_then(|value| value.to_str().ok()),
1574 Some("customer-key-md5")
1575 );
1576 }
1577
1578 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
1579 #[serial_test::serial]
1580 async fn legacy_constructor_retries_snapshot_after_not_found() {
1581 let env = crate::storage_api::select_test_ecstore_env().await;
1582 let bucket = "s3select-lazy-snapshot-retry";
1583 let object = "input.csv";
1584 env.make_bucket(bucket, false).await;
1585 let store = EcObjectStore::new(csv_input(bucket, object)).expect("legacy constructor should resolve the global store");
1586
1587 let error = store
1588 .get_opts(
1589 &Path::from(object),
1590 GetOptions {
1591 head: true,
1592 ..Default::default()
1593 },
1594 )
1595 .await
1596 .expect_err("missing object should remain a typed not-found error");
1597 assert!(matches!(error, object_store::Error::NotFound { .. }));
1598
1599 env.put_object_bytes(bucket, object, b"id,name\n1,Alice\n".to_vec()).await;
1600 let result = store
1601 .get_opts(
1602 &Path::from(object),
1603 GetOptions {
1604 head: true,
1605 ..Default::default()
1606 },
1607 )
1608 .await
1609 .expect("failed snapshot initialization must not be cached");
1610 assert_eq!(result.meta.size, 16);
1611 }
1612
1613 #[tokio::test]
1614 #[serial_test::serial]
1615 async fn legacy_constructor_maps_missing_bucket_to_not_found() {
1616 let _env = crate::storage_api::select_test_ecstore_env().await;
1617 let bucket = "s3select-lazy-snapshot-missing-bucket";
1618 let object = "input.csv";
1619 let store = EcObjectStore::new(csv_input(bucket, object)).expect("legacy constructor should resolve the global store");
1620
1621 let error = store
1622 .get_opts(
1623 &Path::from(object),
1624 GetOptions {
1625 head: true,
1626 ..Default::default()
1627 },
1628 )
1629 .await
1630 .expect_err("missing bucket should remain a typed not-found error");
1631
1632 assert!(matches!(error, object_store::Error::NotFound { .. }));
1633 }
1634
1635 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
1636 #[serial_test::serial]
1637 async fn legacy_constructor_reuses_head_snapshot_for_body() {
1638 const BUCKET: &str = "s3select-lazy-snapshot-head-body";
1639 const OBJECT: &str = "input.csv";
1640 const OLD_DATA: &[u8] = b"id,name\n1,old\n";
1641 const NEW_DATA: &[u8] = b"id,name\n1,new\n";
1642
1643 let env = crate::storage_api::select_test_ecstore_env().await;
1644 env.make_bucket(BUCKET, false).await;
1645 env.put_object_bytes(BUCKET, OBJECT, OLD_DATA.to_vec()).await;
1646 let store = EcObjectStore::new(csv_input(BUCKET, OBJECT)).expect("legacy constructor should resolve the global store");
1647 let head = store
1648 .get_opts(
1649 &Path::from(OBJECT),
1650 GetOptions {
1651 head: true,
1652 ..Default::default()
1653 },
1654 )
1655 .await
1656 .expect("HEAD should lazily prepare the snapshot");
1657 assert_eq!(head.meta.size, u64::try_from(OLD_DATA.len()).expect("fixture length should fit in u64"));
1658
1659 let commit_barrier = PutObjectCommitBarrier::before_namespace(BUCKET, OBJECT);
1660 let writer = tokio::spawn(async move {
1661 env.put_object_bytes(BUCKET, OBJECT, NEW_DATA.to_vec()).await;
1662 });
1663 commit_barrier.wait_until_paused().await;
1664 commit_barrier.release_and_wait_until_namespace_pending().await;
1665 assert!(!writer.is_finished(), "overwrite must wait for the lazy snapshot");
1666
1667 let result = store
1668 .get_opts(&Path::from(OBJECT), GetOptions::default())
1669 .await
1670 .expect("body should reuse the HEAD snapshot");
1671 let GetResultPayload::Stream(stream) = result.payload else {
1672 panic!("expected streaming snapshot body");
1673 };
1674 let bytes = stream
1675 .try_collect::<Vec<_>>()
1676 .await
1677 .expect("collect lazy snapshot body")
1678 .concat();
1679 assert_eq!(bytes, OLD_DATA);
1680 assert_eq!(store.reader_open_count.load(Ordering::Relaxed), 1);
1681
1682 drop(store);
1683 tokio::time::timeout(std::time::Duration::from_secs(5), writer)
1684 .await
1685 .expect("overwrite should finish after the lazy snapshot is released")
1686 .expect("overwrite task should join");
1687 assert_eq!(read_current_object(BUCKET, OBJECT).await, NEW_DATA);
1688 }
1689
1690 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
1691 #[serial_test::serial]
1692 async fn legacy_constructor_first_version_pins_later_reads() {
1693 const BUCKET: &str = "s3select-lazy-snapshot-version";
1694 const OBJECT: &str = "input.csv";
1695 const OLD_DATA: &[u8] = b"old-marker\n";
1696 const NEW_DATA: &[u8] = b"new-poison-value\n";
1697
1698 let env = crate::storage_api::select_test_ecstore_env().await;
1699 env.make_bucket(BUCKET, true).await;
1700 let versioned_opts = SelectObjectOptions {
1701 versioned: true,
1702 ..Default::default()
1703 };
1704 let mut old_reader = SelectPutObjReader::from_vec(OLD_DATA.to_vec());
1705 let old_info = env
1706 .ecstore
1707 .put_object(BUCKET, OBJECT, &mut old_reader, &versioned_opts)
1708 .await
1709 .expect("put old version fixture");
1710 let old_version = old_info
1711 .version_id
1712 .expect("versioned PUT should return a version ID")
1713 .to_string();
1714 let mut new_reader = SelectPutObjReader::from_vec(NEW_DATA.to_vec());
1715 let new_info = env
1716 .ecstore
1717 .put_object(BUCKET, OBJECT, &mut new_reader, &versioned_opts)
1718 .await
1719 .expect("put latest version poison fixture");
1720 let new_version = new_info
1721 .version_id
1722 .expect("versioned PUT should return a version ID")
1723 .to_string();
1724
1725 let store = EcObjectStore::new(csv_input(BUCKET, OBJECT)).expect("legacy constructor should resolve the global store");
1726 let head = store
1727 .get_opts(
1728 &Path::from(OBJECT),
1729 GetOptions {
1730 head: true,
1731 version: Some(old_version.to_uppercase()),
1732 ..Default::default()
1733 },
1734 )
1735 .await
1736 .expect("first HEAD should bind the requested old version");
1737 assert_eq!(head.meta.version.as_deref(), Some(old_version.as_str()));
1738
1739 let mismatch = store
1740 .get_opts(
1741 &Path::from(OBJECT),
1742 GetOptions {
1743 head: true,
1744 version: Some(new_version),
1745 ..Default::default()
1746 },
1747 )
1748 .await
1749 .expect_err("an explicit different version must not reuse the pinned snapshot");
1750 assert!(mismatch.to_string().contains("different object version"));
1751
1752 let range = store
1753 .get_opts(
1754 &Path::from(OBJECT),
1755 GetOptions {
1756 range: Some(GetRange::Bounded(0..3)),
1757 ..Default::default()
1758 },
1759 )
1760 .await
1761 .expect("later range should reuse the old-version snapshot");
1762 let GetResultPayload::Stream(range_stream) = range.payload else {
1763 panic!("expected ranged snapshot stream");
1764 };
1765 assert_eq!(
1766 range_stream
1767 .try_collect::<Vec<_>>()
1768 .await
1769 .expect("collect old-version range")
1770 .concat(),
1771 b"old"
1772 );
1773
1774 let body = store
1775 .get_opts(&Path::from(OBJECT), GetOptions::default())
1776 .await
1777 .expect("later body should reuse the old-version snapshot");
1778 let GetResultPayload::Stream(body_stream) = body.payload else {
1779 panic!("expected full snapshot stream");
1780 };
1781 assert_eq!(
1782 body_stream
1783 .try_collect::<Vec<_>>()
1784 .await
1785 .expect("collect old-version body")
1786 .concat(),
1787 OLD_DATA
1788 );
1789 }
1790
1791 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
1792 #[serial_test::serial]
1793 async fn legacy_constructor_normalizes_null_version_before_snapshot_prepare() {
1794 const BUCKET: &str = "s3select-lazy-snapshot-null-version";
1795 const OBJECT: &str = "input.csv";
1796 const DATA: &[u8] = b"null-version-marker\n";
1797
1798 let env = crate::storage_api::select_test_ecstore_env().await;
1799 env.make_bucket(BUCKET, false).await;
1800 env.put_object_bytes(BUCKET, OBJECT, DATA.to_vec()).await;
1801 let store = EcObjectStore::new(csv_input(BUCKET, OBJECT)).expect("legacy constructor should resolve the global store");
1802
1803 let head = store
1804 .get_opts(
1805 &Path::from(OBJECT),
1806 GetOptions {
1807 head: true,
1808 version: Some("NULL".to_string()),
1809 ..Default::default()
1810 },
1811 )
1812 .await
1813 .expect("null version should prepare an unversioned snapshot");
1814 assert!(head.meta.version.is_none());
1815
1816 let body = store
1817 .get_opts(
1818 &Path::from(OBJECT),
1819 GetOptions {
1820 version: Some(uuid::Uuid::nil().to_string()),
1821 ..Default::default()
1822 },
1823 )
1824 .await
1825 .expect("nil UUID should match the pinned null-version snapshot");
1826 let GetResultPayload::Stream(body_stream) = body.payload else {
1827 panic!("expected null-version snapshot stream");
1828 };
1829 assert_eq!(
1830 body_stream
1831 .try_collect::<Vec<_>>()
1832 .await
1833 .expect("collect null-version body")
1834 .concat(),
1835 DATA
1836 );
1837 }
1838
1839 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
1840 #[serial_test::serial]
1841 async fn prepared_snapshot_rejects_a_different_query_object() {
1842 const BUCKET: &str = "s3select-snapshot-identity";
1843 const OBJECT: &str = "source.csv";
1844
1845 let env = crate::storage_api::select_test_ecstore_env().await;
1846 env.make_bucket(BUCKET, false).await;
1847 env.put_object_bytes(BUCKET, OBJECT, b"source-marker\n".to_vec()).await;
1848 let snapshot = Arc::new(
1849 env.ecstore
1850 .prepare_select_object_snapshot(BUCKET, OBJECT, &HeaderMap::new(), &Default::default())
1851 .await
1852 .expect("prepare source snapshot"),
1853 );
1854
1855 let error = EcObjectStore::new_with_snapshot(csv_input(BUCKET, "different.csv"), snapshot)
1856 .expect_err("a snapshot must remain bound to its source object");
1857
1858 assert_eq!(error.code(), &S3ErrorCode::InternalError);
1859 assert!(error.source().is_some_and(|source| {
1860 source
1861 .downcast_ref::<EcObjectStoreBuildError>()
1862 .is_some_and(|error| matches!(error, EcObjectStoreBuildError::Snapshot(SnapshotConsistencyError::ObjectChanged)))
1863 }));
1864 }
1865
1866 async fn prepare_test_snapshot(bucket: &str, object: &str) -> Arc<SelectObjectSnapshot> {
1867 let env = crate::storage_api::select_test_ecstore_env().await;
1868 Arc::new(
1869 env.ecstore
1870 .prepare_select_object_snapshot(bucket, object, &HeaderMap::new(), &Default::default())
1871 .await
1872 .expect("prepare SelectObjectContent snapshot"),
1873 )
1874 }
1875
1876 fn scan_range_csv_store(
1877 bucket: &str,
1878 object: &str,
1879 snapshot: Arc<SelectObjectSnapshot>,
1880 record_delimiter: &str,
1881 file_header_info: Option<FileHeaderInfo>,
1882 start: i64,
1883 end: i64,
1884 ) -> EcObjectStore {
1885 EcObjectStore::new_with_snapshot(
1886 Arc::new(SelectObjectContentInput {
1887 bucket: bucket.to_string(),
1888 expected_bucket_owner: None,
1889 key: object.to_string(),
1890 sse_customer_algorithm: None,
1891 sse_customer_key: None,
1892 sse_customer_key_md5: None,
1893 request: SelectObjectContentRequest {
1894 expression: "SELECT * FROM s3object".to_string(),
1895 expression_type: ExpressionType::from_static(ExpressionType::SQL),
1896 input_serialization: InputSerialization {
1897 csv: Some(CSVInput {
1898 record_delimiter: Some(record_delimiter.to_string()),
1899 file_header_info,
1900 ..Default::default()
1901 }),
1902 ..Default::default()
1903 },
1904 output_serialization: OutputSerialization {
1905 csv: Some(CSVOutput::default()),
1906 ..Default::default()
1907 },
1908 request_progress: None,
1909 scan_range: Some(ScanRange {
1910 start: Some(start),
1911 end: Some(end),
1912 }),
1913 },
1914 }),
1915 snapshot,
1916 )
1917 .expect("snapshot should match SelectObjectContent input")
1918 }
1919
1920 async fn read_current_object(bucket: &str, object: &str) -> Vec<u8> {
1921 let snapshot = prepare_test_snapshot(bucket, object).await;
1922 let mut reader = snapshot.open_reader(None).await.expect("current object reader should open");
1923 let mut bytes = Vec::new();
1924 reader
1925 .stream
1926 .read_to_end(&mut bytes)
1927 .await
1928 .expect("current object should be readable");
1929 bytes
1930 }
1931
1932 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
1933 #[serial_test::serial]
1934 async fn head_uses_snapshot_metadata_without_opening_body() {
1935 let env = crate::storage_api::select_test_ecstore_env().await;
1936 let bucket = "s3select-snapshot-head";
1937 let object = "input.csv";
1938 env.make_bucket(bucket, false).await;
1939 let mut reader = SelectPutObjReader::from_vec(b"id,name\n1,Alice\n".to_vec());
1940 env.ecstore
1941 .put_object(bucket, object, &mut reader, &Default::default())
1942 .await
1943 .expect("put HEAD fixture");
1944
1945 let snapshot = prepare_test_snapshot(bucket, object).await;
1946 let expected_modified = snapshot_last_modified(&snapshot).expect("snapshot modification time");
1947 let expected_size = snapshot.logical_size();
1948 let expected_etag = snapshot.object_info().etag.clone();
1949 let expected_version = snapshot.object_info().version_id.map(|version| version.to_string());
1950 let input = Arc::new(SelectObjectContentInput {
1951 bucket: bucket.to_string(),
1952 expected_bucket_owner: None,
1953 key: object.to_string(),
1954 sse_customer_algorithm: Some("secret-algorithm".to_string()),
1955 sse_customer_key: Some("secret-customer-key".to_string()),
1956 sse_customer_key_md5: Some("secret-customer-key-md5".to_string()),
1957 request: SelectObjectContentRequest {
1958 expression: "SELECT * FROM s3object".to_string(),
1959 expression_type: ExpressionType::from_static(ExpressionType::SQL),
1960 input_serialization: InputSerialization {
1961 csv: Some(CSVInput::default()),
1962 ..Default::default()
1963 },
1964 output_serialization: OutputSerialization {
1965 csv: Some(CSVOutput::default()),
1966 ..Default::default()
1967 },
1968 request_progress: None,
1969 scan_range: None,
1970 },
1971 });
1972 let store = EcObjectStore::new_with_snapshot(input, snapshot).expect("snapshot should match SelectObjectContent input");
1973 let debug = format!("{store:?}");
1974 assert!(!debug.contains("secret-customer-key"));
1975
1976 let result = store
1977 .get_opts(
1978 &Path::from(object),
1979 GetOptions {
1980 head: true,
1981 ..Default::default()
1982 },
1983 )
1984 .await
1985 .expect("HEAD from snapshot metadata");
1986
1987 assert_eq!(result.meta.last_modified, expected_modified);
1988 assert_eq!(result.meta.size, expected_size);
1989 assert_eq!(result.meta.e_tag, expected_etag);
1990 assert_eq!(result.meta.version, expected_version);
1991 assert_eq!(store.reader_open_count.load(Ordering::Relaxed), 0);
1992 }
1993
1994 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
1995 #[serial_test::serial]
1996 async fn snapshot_keeps_csv_header_and_body_on_one_generation_during_overwrite() {
1997 const BUCKET: &str = "s3select-snapshot-header-body-race";
1998 const OBJECT: &str = "input.csv";
1999 const OLD_DATA: &[u8] = b"old_header,value\nskip_old,0\nold_body,1\n";
2000 const NEW_DATA: &[u8] = b"new_header,value\nskip_new,0\nnew_body,1\n";
2001
2002 let env = crate::storage_api::select_test_ecstore_env().await;
2003 env.make_bucket(BUCKET, false).await;
2004 let mut reader = SelectPutObjReader::from_vec(OLD_DATA.to_vec());
2005 env.ecstore
2006 .put_object(BUCKET, OBJECT, &mut reader, &Default::default())
2007 .await
2008 .expect("put old CSV header/body fixture");
2009
2010 let selected_start = i64::try_from(b"old_header,value\nskip_old,0\n".len()).expect("fixture offset should fit in i64");
2011 let snapshot = prepare_test_snapshot(BUCKET, OBJECT).await;
2012 let store = scan_range_csv_store(
2013 BUCKET,
2014 OBJECT,
2015 snapshot,
2016 "\n",
2017 Some(FileHeaderInfo::from_static(FileHeaderInfo::USE)),
2018 selected_start,
2019 selected_start,
2020 );
2021 let commit_barrier = PutObjectCommitBarrier::before_namespace(BUCKET, OBJECT);
2022 let writer = tokio::spawn(async move {
2023 env.put_object_bytes(BUCKET, OBJECT, NEW_DATA.to_vec()).await;
2024 });
2025 commit_barrier.wait_until_paused().await;
2026 commit_barrier.release_and_wait_until_namespace_pending().await;
2027 assert!(
2028 !writer.is_finished(),
2029 "overwrite must remain blocked while the SelectObjectContent snapshot is alive"
2030 );
2031
2032 let result = store
2033 .get_opts(&Path::from(OBJECT), GetOptions::default())
2034 .await
2035 .expect("read CSV header and body from one snapshot");
2036 let GetResultPayload::Stream(stream) = result.payload else {
2037 panic!("expected streaming CSV header/body payload");
2038 };
2039 let bytes = stream
2040 .try_collect::<Vec<_>>()
2041 .await
2042 .expect("collect CSV header/body snapshot")
2043 .concat();
2044
2045 assert_eq!(bytes, b"old_header,value\nold_body,1\n");
2046 assert_eq!(store.reader_open_count.load(Ordering::Relaxed), 2);
2047 assert!(!writer.is_finished(), "overwrite must remain blocked after both snapshot readers finish");
2048
2049 drop(store);
2050 tokio::time::timeout(std::time::Duration::from_secs(5), writer)
2051 .await
2052 .expect("overwrite should finish after the snapshot is released")
2053 .expect("overwrite task should join");
2054 assert_eq!(read_current_object(BUCKET, OBJECT).await, NEW_DATA);
2055 }
2056
2057 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
2058 #[serial_test::serial]
2059 async fn snapshot_keeps_scan_range_context_and_main_reader_on_one_generation_during_overwrite() {
2060 const BUCKET: &str = "s3select-snapshot-scan-context-race";
2061 const OBJECT: &str = "input.csv";
2062 const OLD_DATA: &[u8] = b"111aaa222aa333aa";
2063 const NEW_DATA: &[u8] = b"999aaa888aa777aa";
2064
2065 let env = crate::storage_api::select_test_ecstore_env().await;
2066 env.make_bucket(BUCKET, false).await;
2067 let mut reader = SelectPutObjReader::from_vec(OLD_DATA.to_vec());
2068 env.ecstore
2069 .put_object(BUCKET, OBJECT, &mut reader, &Default::default())
2070 .await
2071 .expect("put old ScanRange context fixture");
2072
2073 let snapshot = prepare_test_snapshot(BUCKET, OBJECT).await;
2074 let store = scan_range_csv_store(BUCKET, OBJECT, snapshot, "aa", None, 4, 5);
2075 let commit_barrier = PutObjectCommitBarrier::before_namespace(BUCKET, OBJECT);
2076 let writer = tokio::spawn(async move {
2077 env.put_object_bytes(BUCKET, OBJECT, NEW_DATA.to_vec()).await;
2078 });
2079 commit_barrier.wait_until_paused().await;
2080 commit_barrier.release_and_wait_until_namespace_pending().await;
2081 assert!(
2082 !writer.is_finished(),
2083 "overwrite must remain blocked while the SelectObjectContent snapshot is alive"
2084 );
2085
2086 let result = store
2087 .get_opts(&Path::from(OBJECT), GetOptions::default())
2088 .await
2089 .expect("read ScanRange context and main body from one snapshot");
2090 let GetResultPayload::Stream(stream) = result.payload else {
2091 panic!("expected streaming ScanRange context payload");
2092 };
2093 let bytes = stream
2094 .try_collect::<Vec<_>>()
2095 .await
2096 .expect("collect ScanRange context snapshot")
2097 .concat();
2098
2099 assert_eq!(bytes, b"a222\r\n");
2100 assert_eq!(store.reader_open_count.load(Ordering::Relaxed), 2);
2101 assert!(
2102 !writer.is_finished(),
2103 "overwrite must remain blocked after context and main readers finish"
2104 );
2105
2106 drop(store);
2107 tokio::time::timeout(std::time::Duration::from_secs(5), writer)
2108 .await
2109 .expect("overwrite should finish after the snapshot is released")
2110 .expect("overwrite task should join");
2111 assert_eq!(read_current_object(BUCKET, OBJECT).await, NEW_DATA);
2112 }
2113
2114 #[tokio::test]
2115 async fn test_scan_range_stream_keeps_header_and_selected_record() {
2116 let chunks = stream::iter(vec![Ok::<_, std::io::Error>(Bytes::from_static(b"h1,h2\n1,a\n2,b\n3,c\n"))]);
2117 let mut stream = scan_range_stream(chunks, b"\n".to_vec(), SelectScanRange::new(10, 11), true, 0, 18);
2118 let mut output = Vec::new();
2119 while let Some(bytes) = stream.next().await {
2120 output.extend_from_slice(&bytes.unwrap());
2121 }
2122 assert_eq!(output, b"h1,h2\n2,b\n");
2123 }
2124
2125 #[tokio::test]
2126 async fn test_scan_range_stream_skips_record_when_start_is_in_middle() {
2127 let chunks = stream::iter(vec![Ok::<_, std::io::Error>(Bytes::from_static(b"1,a\n2,b\n3,c\n"))]);
2128 let mut stream = scan_range_stream(chunks, b"\n".to_vec(), SelectScanRange::new(2, 7), false, 0, 12);
2129 let mut output = Vec::new();
2130 while let Some(bytes) = stream.next().await {
2131 output.extend_from_slice(&bytes.unwrap());
2132 }
2133 assert_eq!(output, b"2,b\n");
2134 }
2135
2136 #[tokio::test]
2137 async fn test_scan_range_stream_keeps_record_when_end_is_in_middle() {
2138 let chunks = stream::iter(vec![Ok::<_, std::io::Error>(Bytes::from_static(b"1,a\n2,b\n3,c\n"))]);
2139 let mut stream = scan_range_stream(chunks, b"\n".to_vec(), SelectScanRange::new(0, 5), false, 0, 12);
2140 let mut output = Vec::new();
2141 while let Some(bytes) = stream.next().await {
2142 output.extend_from_slice(&bytes.unwrap());
2143 }
2144 assert_eq!(output, b"1,a\n2,b\n");
2145 }
2146
2147 #[tokio::test]
2148 async fn test_scan_range_stream_uses_base_offset_for_range_reader() {
2149 let chunks = stream::iter(vec![Ok::<_, std::io::Error>(Bytes::from_static(b"\n2,b\n3,c\n"))]);
2150 let mut stream = scan_range_stream(chunks, b"\n".to_vec(), SelectScanRange::new(4, 7), false, 3, 12);
2151 let mut output = Vec::new();
2152 while let Some(bytes) = stream.next().await {
2153 output.extend_from_slice(&bytes.unwrap());
2154 }
2155 assert_eq!(output, b"2,b\n");
2156 }
2157
2158 #[tokio::test]
2159 async fn test_scan_range_stream_handles_delimiter_split_across_chunks() {
2160 let chunks = stream::iter(vec![
2161 Ok::<_, std::io::Error>(Bytes::from_static(b"h1,h2\r")),
2162 Ok::<_, std::io::Error>(Bytes::from_static(b"\n1,a\r\n2,b\r")),
2163 Ok::<_, std::io::Error>(Bytes::from_static(b"\n3,c\r\n")),
2164 ]);
2165 let mut stream = scan_range_stream(chunks, b"\r\n".to_vec(), SelectScanRange::new(12, 14), true, 0, 22);
2166 let mut output = Vec::new();
2167 while let Some(bytes) = stream.next().await {
2168 output.extend_from_slice(&bytes.unwrap());
2169 }
2170 assert_eq!(output, b"h1,h2\r\n2,b\r\n");
2171 }
2172
2173 #[tokio::test]
2174 async fn test_scan_range_stream_converts_custom_delimiter_split_across_chunks() {
2175 let chunks = stream::iter(vec![
2176 Ok::<_, std::io::Error>(Bytes::from_static(b"h1,h2^")),
2177 Ok::<_, std::io::Error>(Bytes::from_static(b"Y1,a^Y2,b^")),
2178 Ok::<_, std::io::Error>(Bytes::from_static(b"Y3,c^Y")),
2179 ]);
2180 let stream = scan_range_stream(chunks, b"^Y".to_vec(), SelectScanRange::new(12, 14), true, 0, 22);
2181 let mut stream = convert_record_delimiter_stream(stream, b"^Y".to_vec());
2182 let mut output = Vec::new();
2183 while let Some(bytes) = stream.next().await {
2184 output.extend_from_slice(&bytes.expect("custom-delimiter ScanRange chunk should be valid"));
2185 }
2186 assert_eq!(output, b"h1,h2\r\n2,b\r\n");
2187 }
2188
2189 #[tokio::test]
2190 async fn test_record_delimiter_conversion_carries_partial_delimiter() {
2191 let chunks = stream::iter(vec![
2192 Ok::<_, object_store::Error>(Bytes::from_static(b"a,1^")),
2193 Ok::<_, object_store::Error>(Bytes::from_static(b"Yb,2^Y")),
2194 ]);
2195 let output = convert_record_delimiter_stream(chunks, b"^Y".to_vec())
2196 .try_collect::<Vec<_>>()
2197 .await
2198 .expect("convert record delimiter")
2199 .concat();
2200 assert_eq!(output, b"a,1\r\nb,2\r\n");
2201 }
2202
2203 #[tokio::test]
2204 async fn test_record_delimiter_conversion_preserves_overlapping_match_order() {
2205 let chunks = stream::iter(vec![
2206 Ok::<_, object_store::Error>(Bytes::from_static(b"a")),
2207 Ok::<_, object_store::Error>(Bytes::from_static(b"aa")),
2208 Ok::<_, object_store::Error>(Bytes::from_static(b"a")),
2209 ]);
2210 let output = convert_record_delimiter_stream(chunks, b"aa".to_vec())
2211 .try_collect::<Vec<_>>()
2212 .await
2213 .expect("convert overlapping record delimiter")
2214 .concat();
2215 assert_eq!(output, b"\r\n\r\n");
2216 }
2217
2218 #[tokio::test]
2219 async fn test_record_and_field_delimiter_conversion_order() {
2220 let chunks = stream::iter(vec![
2221 Ok::<_, object_store::Error>(Bytes::from_static(b"a\r")),
2222 Ok::<_, object_store::Error>(Bytes::from_static(b"\n1^")),
2223 Ok::<_, object_store::Error>(Bytes::from_static(b"Yb\r\n2^Y")),
2224 ]);
2225 let output = convert_csv_delimiter_stream(chunks, Some(b"^Y".to_vec()), Some("\r\n".to_string()))
2226 .try_collect::<Vec<_>>()
2227 .await
2228 .expect("convert record and field delimiters")
2229 .concat();
2230 assert_eq!(output, b"a,1\r\nb,2\r\n");
2231 }
2232
2233 #[tokio::test]
2234 async fn test_record_delimiter_takes_precedence_when_delimiters_match() {
2235 let chunks = stream::iter(vec![
2236 Ok::<_, object_store::Error>(Bytes::from_static(b"a^")),
2237 Ok::<_, object_store::Error>(Bytes::from_static(b"Yb^Y")),
2238 ]);
2239 let output = convert_csv_delimiter_stream(chunks, Some(b"^Y".to_vec()), Some("^Y".to_string()))
2240 .try_collect::<Vec<_>>()
2241 .await
2242 .expect("convert matching record and field delimiters")
2243 .concat();
2244 assert_eq!(output, b"a\r\nb\r\n");
2245
2246 let chunks = stream::iter(vec![Ok::<_, object_store::Error>(Bytes::from_static(b"a\r\nb\r\n"))]);
2247 let output = convert_csv_delimiter_stream(chunks, Some(b"\r\n".to_vec()), Some("\r\n".to_string()))
2248 .try_collect::<Vec<_>>()
2249 .await
2250 .expect("preserve matching normalized record delimiter")
2251 .concat();
2252 assert_eq!(output, b"a\r\nb\r\n");
2253 }
2254
2255 #[tokio::test]
2256 async fn test_longer_field_delimiter_takes_precedence_over_record_prefix() {
2257 let chunks = stream::iter(vec![
2258 Ok::<_, object_store::Error>(Bytes::from_static(b"a^")),
2259 Ok::<_, object_store::Error>(Bytes::from_static(b"YQb^Y")),
2260 ]);
2261 let output = convert_csv_delimiter_stream(chunks, Some(b"^Y".to_vec()), Some("^YQ".to_string()))
2262 .try_collect::<Vec<_>>()
2263 .await
2264 .expect("convert record delimiter that prefixes field delimiter")
2265 .concat();
2266 assert_eq!(output, b"a,b\r\n");
2267
2268 let chunks = stream::iter(vec![Ok::<_, object_store::Error>(Bytes::from_static(b"a\nXb\nc\nXd\n"))]);
2269 let output = convert_csv_delimiter_stream(chunks, Some(b"\n".to_vec()), Some("\nX".to_string()))
2270 .try_collect::<Vec<_>>()
2271 .await
2272 .expect("preserve longer field delimiter with native record prefix")
2273 .concat();
2274 assert_eq!(output, b"a,b\nc,d\n");
2275 }
2276
2277 #[tokio::test]
2278 async fn test_scan_range_stream_rejects_early_eof() {
2279 let chunks = stream::iter(vec![Ok::<_, std::io::Error>(Bytes::from_static(b"1,a\n"))]);
2280 let mut output = scan_range_stream(chunks, b"\n".to_vec(), SelectScanRange::new(0, 7), false, 0, 8);
2281
2282 assert_eq!(output.next().await.expect("first stream item").expect("first record"), b"1,a\n"[..]);
2283 let err = output
2284 .next()
2285 .await
2286 .expect("early EOF error")
2287 .expect_err("short ScanRange stream must fail");
2288 let object_store::Error::Generic { source, .. } = err else {
2289 panic!("expected generic object store error");
2290 };
2291 let source = source.downcast_ref::<std::io::Error>().expect("I/O error source");
2292 assert_eq!(source.kind(), std::io::ErrorKind::UnexpectedEof);
2293 assert!(source.to_string().contains("4 bytes remaining"));
2294 assert!(output.next().await.is_none());
2295 }
2296
2297 #[test]
2298 fn test_find_delimiter_handles_multi_byte_delimiter() {
2299 assert_eq!(find_delimiter(b"one\r\ntwo", b"\r\n"), Some(3));
2300 assert_eq!(find_delimiter(b"one\ntwo", b"\r\n"), None);
2301 }
2302
2303 #[test]
2304 fn test_scan_range_end_only_uses_aws_suffix_semantics() {
2305 let range = scan_range_from_bounds(None, Some(35), 100).unwrap().unwrap();
2306 assert_eq!(range.start(), 65);
2307 assert_eq!(range.end(), 99);
2308 }
2309
2310 #[test]
2311 fn test_scan_range_start_after_object_is_rejected_before_reader() {
2312 let err = scan_range_from_bounds(Some(100), None, 100).unwrap_err();
2313 assert!(err.to_string().contains("ScanRange"));
2314 }
2315
2316 #[test]
2317 fn test_scan_range_start_after_end_is_rejected() {
2318 let err = scan_range_from_bounds(Some(20), Some(10), 100).unwrap_err();
2319 assert!(err.to_string().contains("ScanRange"));
2320 }
2321
2322 #[test]
2323 fn test_get_range_conversion_for_parquet_bounded_ranges() {
2324 let range = http_range_spec_from_get_range(&GetRange::Bounded(10..20));
2325 assert!(!range.is_suffix_length);
2326 assert_eq!(range.start, 10);
2327 assert_eq!(range.end, 19);
2328 }
2329
2330 #[tokio::test]
2331 async fn test_scan_range_output_can_convert_field_delimiter() {
2332 let chunks = stream::iter(vec![Ok::<_, std::io::Error>(Bytes::from_static(b"a&&1\nb&&2\n"))]);
2333 let stream = scan_range_stream(chunks, b"\n".to_vec(), SelectScanRange::new(0, 10), false, 0, 10);
2334 let mut stream = convert_field_delimiter_stream(stream, "&&".to_string());
2335 let mut output = Vec::new();
2336 while let Some(bytes) = stream.next().await {
2337 output.extend_from_slice(&bytes.unwrap());
2338 }
2339 assert_eq!(output, b"a,1\nb,2\n");
2340 }
2341
2342 #[tokio::test]
2343 async fn delimiter_conversion_keeps_uncompressed_metrics_equal() {
2344 let input = Bytes::from_static(b"a&&1\nb&&2\n");
2345 let input_metrics = Arc::new(SelectInputMetrics::default());
2346 let stream = stream::iter([Ok::<_, object_store::Error>(input.clone())]);
2347 let stream = meter_uncompressed_input_stream(stream, Arc::clone(&input_metrics));
2348 let output = convert_field_delimiter_stream(stream, "&&".to_string())
2349 .try_collect::<Vec<_>>()
2350 .await
2351 .expect("delimiter conversion should succeed")
2352 .concat();
2353
2354 assert_eq!(output, b"a,1\nb,2\n");
2355 let input_len = u64::try_from(input.len()).expect("fixture length should fit in u64");
2356 assert_eq!(input_metrics.snapshot().bytes_scanned, input_len);
2357 assert_eq!(input_metrics.snapshot().bytes_processed, input_len);
2358 }
2359
2360 #[tokio::test]
2361 async fn test_field_delimiter_stream_converts_delimiter_split_across_chunks() {
2362 let chunks = stream::iter(vec![
2363 Ok::<_, object_store::Error>(Bytes::from_static(b"a&")),
2364 Ok::<_, object_store::Error>(Bytes::from_static(b"&1\nb&&2\n")),
2365 ]);
2366 let mut stream = convert_field_delimiter_stream(chunks, "&&".to_string());
2367 let mut output = Vec::new();
2368 while let Some(bytes) = stream.next().await {
2369 output.extend_from_slice(&bytes.unwrap());
2370 }
2371 assert_eq!(output, b"a,1\nb,2\n");
2372 }
2373
2374 #[tokio::test]
2375 async fn test_field_delimiter_stream_converts_delimiter_at_stream_end() {
2376 let chunks = stream::iter(vec![
2377 Ok::<_, object_store::Error>(Bytes::from_static(b"a&")),
2378 Ok::<_, object_store::Error>(Bytes::from_static(b"&")),
2379 ]);
2380 let mut stream = convert_field_delimiter_stream(chunks, "&&".to_string());
2381 let mut output = Vec::new();
2382 while let Some(bytes) = stream.next().await {
2383 output.extend_from_slice(&bytes.unwrap());
2384 }
2385 assert_eq!(output, b"a,");
2386 }
2387
2388 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
2389 #[serial_test::serial]
2390 async fn test_scan_range_self_overlapping_delimiter_retains_record_context() {
2391 let env = crate::storage_api::select_test_ecstore_env().await;
2392 let bucket = "s3select-scan-range-record-context";
2393 let object = "input.csv";
2394 env.make_bucket(bucket, false).await;
2395 let mut reader = SelectPutObjReader::from_vec(b"111aaa222aa333aa".to_vec());
2396 env.ecstore
2397 .put_object(bucket, object, &mut reader, &Default::default())
2398 .await
2399 .expect("put self-overlapping delimiter ScanRange fixture");
2400
2401 let make_store = |start, end, file_header_info, snapshot| EcObjectStore {
2402 input: Arc::new(SelectObjectContentInput {
2403 bucket: bucket.to_string(),
2404 expected_bucket_owner: None,
2405 key: object.to_string(),
2406 sse_customer_algorithm: None,
2407 sse_customer_key: None,
2408 sse_customer_key_md5: None,
2409 request: SelectObjectContentRequest {
2410 expression: "SELECT * FROM s3object".to_string(),
2411 expression_type: ExpressionType::from_static(ExpressionType::SQL),
2412 input_serialization: InputSerialization {
2413 csv: Some(CSVInput {
2414 record_delimiter: Some("aa".to_string()),
2415 file_header_info,
2416 ..Default::default()
2417 }),
2418 ..Default::default()
2419 },
2420 output_serialization: OutputSerialization {
2421 csv: Some(CSVOutput::default()),
2422 ..Default::default()
2423 },
2424 request_progress: None,
2425 scan_range: Some(ScanRange {
2426 start: Some(start),
2427 end: Some(end),
2428 }),
2429 },
2430 }),
2431 need_convert: false,
2432 delimiter: String::new(),
2433 is_json_document: false,
2434 json_source: JsonSource::default(),
2435 input_metrics: Arc::new(SelectInputMetrics::default()),
2436 memory_pool: Arc::new(GreedyMemoryPool::new(1024)),
2437 query_tracker: None,
2438 store: None,
2439 snapshot: OnceCell::new_with(Some(snapshot)),
2440 reader_open_count: Arc::new(AtomicUsize::new(0)),
2441 };
2442
2443 let store = make_store(6, 6, None, prepare_test_snapshot(bucket, object).await);
2444 let result = store
2445 .get_opts(&Path::from(object), GetOptions::default())
2446 .await
2447 .expect("read ScanRange starting inside record data");
2448 let GetResultPayload::Stream(stream) = result.payload else {
2449 panic!("expected streaming ScanRange payload");
2450 };
2451 let chunks: Vec<Bytes> = stream.try_collect().await.expect("collect record-data ScanRange output");
2452 assert!(chunks.concat().is_empty());
2453 drop(store);
2454
2455 let store = make_store(4, 5, None, prepare_test_snapshot(bucket, object).await);
2456 let result = store
2457 .get_opts(&Path::from(object), GetOptions::default())
2458 .await
2459 .expect("read ScanRange starting inside overlapping delimiter");
2460 let GetResultPayload::Stream(stream) = result.payload else {
2461 panic!("expected streaming overlapping-delimiter payload");
2462 };
2463 let chunks: Vec<Bytes> = stream
2464 .try_collect()
2465 .await
2466 .expect("collect overlapping-delimiter ScanRange output");
2467 assert_eq!(chunks.concat(), b"a222\r\n");
2468 drop(store);
2469
2470 let mut reader = SelectPutObjReader::from_vec(b"111aa222aa333aa".to_vec());
2471 env.ecstore
2472 .put_object(bucket, object, &mut reader, &Default::default())
2473 .await
2474 .expect("put exact review ScanRange fixture");
2475 let result = make_store(6, 6, None, prepare_test_snapshot(bucket, object).await)
2476 .get_opts(&Path::from(object), GetOptions::default())
2477 .await
2478 .expect("read exact review ScanRange fixture");
2479 let GetResultPayload::Stream(stream) = result.payload else {
2480 panic!("expected streaming exact review ScanRange payload");
2481 };
2482 let chunks: Vec<Bytes> = stream.try_collect().await.expect("collect exact review ScanRange output");
2483 assert!(chunks.concat().is_empty());
2484
2485 let result = make_store(5, 5, None, prepare_test_snapshot(bucket, object).await)
2486 .get_opts(&Path::from(object), GetOptions::default())
2487 .await
2488 .expect("read ScanRange starting after an even delimiter run");
2489 let GetResultPayload::Stream(stream) = result.payload else {
2490 panic!("expected streaming even-run ScanRange payload");
2491 };
2492 let chunks: Vec<Bytes> = stream.try_collect().await.expect("collect even-run ScanRange output");
2493 assert_eq!(chunks.concat(), b"222\r\n");
2494
2495 let mut reader = SelectPutObjReader::from_vec(b"h1aav1aav2aa".to_vec());
2496 env.ecstore
2497 .put_object(bucket, object, &mut reader, &Default::default())
2498 .await
2499 .expect("put ScanRange header snapshot fixture");
2500 let result = make_store(
2501 8,
2502 8,
2503 Some(FileHeaderInfo::from_static(FileHeaderInfo::USE)),
2504 prepare_test_snapshot(bucket, object).await,
2505 )
2506 .get_opts(&Path::from(object), GetOptions::default())
2507 .await
2508 .expect("read ScanRange with a separate header read");
2509 let GetResultPayload::Stream(stream) = result.payload else {
2510 panic!("expected streaming ScanRange header payload");
2511 };
2512 let chunks: Vec<Bytes> = stream.try_collect().await.expect("collect ScanRange header output");
2513 assert_eq!(chunks.concat(), b"h1\r\nv2\r\n");
2514
2515 let mut reader = SelectPutObjReader::from_vec(b"aaa222aa".to_vec());
2516 env.ecstore
2517 .put_object(bucket, object, &mut reader, &Default::default())
2518 .await
2519 .expect("put object-start delimiter context fixture");
2520 let result = make_store(3, 3, None, prepare_test_snapshot(bucket, object).await)
2521 .get_opts(&Path::from(object), GetOptions::default())
2522 .await
2523 .expect("read delimiter context that reaches the object start");
2524 let GetResultPayload::Stream(stream) = result.payload else {
2525 panic!("expected streaming object-start context payload");
2526 };
2527 let chunks: Vec<Bytes> = stream.try_collect().await.expect("collect object-start context output");
2528 assert!(chunks.concat().is_empty());
2529
2530 let run_start = SELECT_DEFAULT_READ_BUFFER_SIZE + 7;
2531 let mut large_fixture = vec![b'b'; run_start];
2532 large_fixture.extend_from_slice(b"aaa222aa");
2533 let mut reader = SelectPutObjReader::from_vec(large_fixture);
2534 env.ecstore
2535 .put_object(bucket, object, &mut reader, &Default::default())
2536 .await
2537 .expect("put large self-overlapping delimiter ScanRange fixture");
2538 let scan_start = i64::try_from(run_start + 3).expect("fixture offset should fit in i64");
2539 let result = make_store(scan_start, scan_start, None, prepare_test_snapshot(bucket, object).await)
2540 .get_opts(&Path::from(object), GetOptions::default())
2541 .await
2542 .expect("read large ScanRange with bounded delimiter context");
2543 let GetResultPayload::Stream(stream) = result.payload else {
2544 panic!("expected streaming large ScanRange payload");
2545 };
2546 let chunks: Vec<Bytes> = stream.try_collect().await.expect("collect large ScanRange output");
2547 assert!(chunks.concat().is_empty());
2548
2549 let mut oversized_run = vec![b'b'];
2550 oversized_run.resize(SELECT_DEFAULT_READ_BUFFER_SIZE + 2, b'a');
2551 let scan_start = i64::try_from(oversized_run.len()).expect("fixture offset should fit in i64");
2552 oversized_run.extend_from_slice(b"222aa");
2553 let mut reader = SelectPutObjReader::from_vec(oversized_run);
2554 env.ecstore
2555 .put_object(bucket, object, &mut reader, &Default::default())
2556 .await
2557 .expect("put oversized delimiter context fixture");
2558 let err = make_store(scan_start, scan_start, None, prepare_test_snapshot(bucket, object).await)
2559 .get_opts(&Path::from(object), GetOptions::default())
2560 .await
2561 .expect_err("oversized self-overlapping delimiter context must fail closed");
2562 assert!(err.to_string().contains("bounded ScanRange context"));
2563 }
2564
2565 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
2566 #[serial_test::serial]
2567 async fn test_self_overlapping_record_delimiter_uses_single_full_file_partition() {
2568 const TARGET_PARTITIONS: usize = 4;
2569
2570 let mut input_bytes = Vec::with_capacity(SELECT_DEFAULT_READ_BUFFER_SIZE + 8);
2571 input_bytes.extend_from_slice(b"0,");
2572 input_bytes.resize(SELECT_DEFAULT_READ_BUFFER_SIZE - 1, b'b');
2573 input_bytes.extend_from_slice(b"aaaX,caa");
2574 assert!(input_bytes.len() > 1024 * 1024);
2575 assert_eq!(
2576 &input_bytes[SELECT_DEFAULT_READ_BUFFER_SIZE - 1..SELECT_DEFAULT_READ_BUFFER_SIZE + 2],
2577 b"aaa"
2578 );
2579
2580 let env = crate::storage_api::select_test_ecstore_env().await;
2581 let bucket = "s3select-record-delimiter";
2582 let object = "input.csv";
2583 env.make_bucket(bucket, false).await;
2584 let mut reader = SelectPutObjReader::from_vec(input_bytes);
2585 env.ecstore
2586 .put_object(bucket, object, &mut reader, &Default::default())
2587 .await
2588 .expect("put multi-byte record-delimited test object");
2589
2590 let input = Arc::new(SelectObjectContentInput {
2591 bucket: bucket.to_string(),
2592 expected_bucket_owner: None,
2593 key: object.to_string(),
2594 sse_customer_algorithm: None,
2595 sse_customer_key: None,
2596 sse_customer_key_md5: None,
2597 request: SelectObjectContentRequest {
2598 expression: "SELECT * FROM s3object".to_string(),
2599 expression_type: ExpressionType::from_static(ExpressionType::SQL),
2600 input_serialization: InputSerialization {
2601 csv: Some(CSVInput {
2602 record_delimiter: Some("aa".to_string()),
2603 ..Default::default()
2604 }),
2605 ..Default::default()
2606 },
2607 output_serialization: OutputSerialization {
2608 csv: Some(CSVOutput::default()),
2609 ..Default::default()
2610 },
2611 request_progress: None,
2612 scan_range: None,
2613 },
2614 });
2615 let snapshot = prepare_test_snapshot(bucket, object).await;
2616 let store = Arc::new(EcObjectStore {
2617 input,
2618 need_convert: false,
2619 delimiter: String::new(),
2620 is_json_document: false,
2621 json_source: JsonSource::default(),
2622 input_metrics: Arc::new(SelectInputMetrics::default()),
2623 memory_pool: Arc::new(GreedyMemoryPool::new(32 * 1024 * 1024)),
2624 query_tracker: None,
2625 store: None,
2626 snapshot: OnceCell::new_with(Some(snapshot)),
2627 reader_open_count: Arc::new(AtomicUsize::new(0)),
2628 });
2629
2630 let config = SessionConfig::new()
2631 .with_repartition_file_scans(false)
2632 .with_repartition_file_min_size(0)
2633 .with_target_partitions(TARGET_PARTITIONS);
2634 let context = SessionContext::new_with_config(config);
2635 let store_url = url::Url::parse(&format!("s3://{bucket}")).expect("valid object store URL");
2636 context.runtime_env().register_object_store(&store_url, store);
2637 context
2638 .register_csv("records", &format!("s3://{bucket}/{object}"), CsvReadOptions::new().has_header(false))
2639 .await
2640 .expect("register partitioned CSV");
2641
2642 let scan_plan = context
2643 .sql("SELECT * FROM records")
2644 .await
2645 .expect("plan partitioned CSV")
2646 .create_physical_plan()
2647 .await
2648 .expect("create partitioned CSV physical plan");
2649 assert_eq!(scan_plan.output_partitioning().partition_count(), 1);
2650
2651 let batches = context
2652 .sql("SELECT column_1 FROM records")
2653 .await
2654 .expect("plan exact-result query")
2655 .collect()
2656 .await
2657 .expect("query self-overlapping record-delimited CSV");
2658 let values = batches
2659 .iter()
2660 .flat_map(|batch| {
2661 let column = batch
2662 .column(0)
2663 .as_any()
2664 .downcast_ref::<datafusion::arrow::array::StringArray>()
2665 .expect("mixed first column should be Utf8");
2666 column.iter().map(|value| value.map(str::to_string)).collect::<Vec<_>>()
2667 })
2668 .collect::<Vec<_>>();
2669 assert_eq!(values, vec![Some("0".to_string()), Some("aX".to_string())]);
2670 }
2671
2672 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
2673 #[serial_test::serial]
2674 async fn test_get_opts_validates_raw_length_before_delimiter_conversion() {
2675 let env = crate::storage_api::select_test_ecstore_env().await;
2676 let bucket = "s3select-multi-byte-delimiter";
2677 let object = "input.csv";
2678 let input_bytes = b"a\r\n1^Y";
2679 env.make_bucket(bucket, false).await;
2680 let mut reader = SelectPutObjReader::from_vec(input_bytes.to_vec());
2681 env.ecstore
2682 .put_object(bucket, object, &mut reader, &Default::default())
2683 .await
2684 .expect("put multi-byte-delimited test object");
2685
2686 let input = Arc::new(SelectObjectContentInput {
2687 bucket: bucket.to_string(),
2688 expected_bucket_owner: None,
2689 key: object.to_string(),
2690 sse_customer_algorithm: None,
2691 sse_customer_key: None,
2692 sse_customer_key_md5: None,
2693 request: SelectObjectContentRequest {
2694 expression: "SELECT * FROM s3object".to_string(),
2695 expression_type: ExpressionType::from_static(ExpressionType::SQL),
2696 input_serialization: InputSerialization {
2697 csv: Some(CSVInput {
2698 field_delimiter: Some("\r\n".to_string()),
2699 record_delimiter: Some("^Y".to_string()),
2700 ..Default::default()
2701 }),
2702 ..Default::default()
2703 },
2704 output_serialization: OutputSerialization {
2705 csv: Some(CSVOutput::default()),
2706 ..Default::default()
2707 },
2708 request_progress: None,
2709 scan_range: None,
2710 },
2711 });
2712 let snapshot = prepare_test_snapshot(bucket, object).await;
2713 let input_metrics = Arc::new(SelectInputMetrics::default());
2714 let store = super::EcObjectStore {
2715 input,
2716 need_convert: true,
2717 delimiter: "\r\n".to_string(),
2718 is_json_document: false,
2719 json_source: JsonSource::default(),
2720 input_metrics: Arc::clone(&input_metrics),
2721 memory_pool: Arc::new(GreedyMemoryPool::new(1024)),
2722 query_tracker: None,
2723 store: None,
2724 snapshot: OnceCell::new_with(Some(snapshot)),
2725 reader_open_count: Arc::new(AtomicUsize::new(0)),
2726 };
2727
2728 let result = store
2729 .get_opts(&Path::from(object), GetOptions::default())
2730 .await
2731 .expect("read multi-byte-delimited test object");
2732 let GetResultPayload::Stream(stream) = result.payload else {
2733 panic!("expected streaming object payload");
2734 };
2735 let chunks: Vec<Bytes> = stream.try_collect().await.expect("collect converted object stream");
2736
2737 assert_eq!(chunks.concat(), b"a,1\r\n");
2738 let input_len = u64::try_from(input_bytes.len()).expect("fixture length should fit in u64");
2739 assert_eq!(input_metrics.snapshot().bytes_scanned, input_len);
2740 assert_eq!(input_metrics.snapshot().bytes_processed, input_len);
2741
2742 let requested_range = 3..10;
2743 let ranges = store
2744 .get_ranges(&Path::from(object), std::slice::from_ref(&requested_range))
2745 .await
2746 .expect("bounded range past EOF should return the object remainder");
2747 assert_eq!(ranges, vec![Bytes::from_static(b"1^Y")]);
2748 }
2749
2750 #[tokio::test]
2751 async fn test_bytes_stream_stops_at_content_length() {
2752 let poll_count = Arc::new(AtomicUsize::new(0));
2753 let stream_poll_count = Arc::clone(&poll_count);
2754 let source = stream::unfold(0, move |index| {
2755 let stream_poll_count = Arc::clone(&stream_poll_count);
2756 async move {
2757 stream_poll_count.fetch_add(1, Ordering::SeqCst);
2758 let bytes = match index {
2759 0 => Bytes::from_static(b"abcd"),
2760 1 => Bytes::from_static(b"efgh"),
2761 _ => return None,
2762 };
2763 Some((Ok::<_, std::io::Error>(bytes), index + 1))
2764 }
2765 });
2766
2767 let chunks: Vec<Bytes> = bytes_stream(source, 4).try_collect().await.unwrap();
2768
2769 assert_eq!(chunks, vec![Bytes::from_static(b"abcd")]);
2770 assert_eq!(poll_count.load(Ordering::SeqCst), 1);
2771 }
2772
2773 #[tokio::test]
2774 async fn metered_stream_counts_only_polled_chunks() {
2775 let poll_count = Arc::new(AtomicUsize::new(0));
2776 let source_poll_count = Arc::clone(&poll_count);
2777 let source = stream::unfold(0, move |index| {
2778 let source_poll_count = Arc::clone(&source_poll_count);
2779 async move {
2780 source_poll_count.fetch_add(1, Ordering::SeqCst);
2781 let bytes = match index {
2782 0 => Bytes::from_static(b"abcd"),
2783 1 => Bytes::from_static(b"efgh"),
2784 _ => return None,
2785 };
2786 Some((Ok::<_, std::io::Error>(bytes), index + 1))
2787 }
2788 });
2789 let input_metrics = Arc::new(SelectInputMetrics::default());
2790 let mut metered = Box::pin(meter_uncompressed_input_stream(source, Arc::clone(&input_metrics)));
2791
2792 assert_eq!(metered.next().await.expect("first chunk").expect("valid chunk"), b"abcd"[..]);
2793 drop(metered);
2794
2795 assert_eq!(input_metrics.snapshot().bytes_scanned, 4);
2796 assert_eq!(input_metrics.snapshot().bytes_processed, 4);
2797 assert_eq!(poll_count.load(Ordering::SeqCst), 1);
2798 }
2799
2800 #[tokio::test]
2801 async fn test_bytes_stream_rejects_early_eof() {
2802 let source = stream::iter(vec![Ok::<_, std::io::Error>(Bytes::from_static(b"ab"))]);
2803 let output = bytes_stream(source, 4);
2804 futures::pin_mut!(output);
2805
2806 assert_eq!(output.next().await.expect("first stream item").expect("first chunk"), b"ab"[..]);
2807 let err = output
2808 .next()
2809 .await
2810 .expect("early EOF error")
2811 .expect_err("short stream must fail");
2812 let object_store::Error::Generic { store, source } = err else {
2813 panic!("expected generic object store error");
2814 };
2815 assert_eq!(store, "EcObjectStore");
2816 let source = source.downcast_ref::<std::io::Error>().expect("I/O error source");
2817 assert_eq!(source.kind(), std::io::ErrorKind::UnexpectedEof);
2818 assert!(source.to_string().contains("2 bytes remaining"));
2819 assert!(output.next().await.is_none());
2820 }
2821
2822 #[tokio::test]
2823 async fn full_and_range_object_streams_record_input_metrics() {
2824 const BUCKET: &str = "s3select-input-metrics";
2825 const OBJECT: &str = "input.csv";
2826 const DATA: &[u8] = b"id,name\n1,a\n";
2827
2828 let env = crate::storage_api::select_test_ecstore_env().await;
2829 env.make_bucket(BUCKET, false).await;
2830 let mut reader = SelectPutObjReader::from_vec(DATA.to_vec());
2831 env.ecstore
2832 .put_object(BUCKET, OBJECT, &mut reader, &Default::default())
2833 .await
2834 .expect("put input metrics fixture");
2835 let snapshot = prepare_test_snapshot(BUCKET, OBJECT).await;
2836 let input_metrics = Arc::new(SelectInputMetrics::default());
2837 let store = EcObjectStore::build_with_snapshot(
2838 csv_input(BUCKET, OBJECT),
2839 Arc::new(GreedyMemoryPool::new(1024 * 1024)),
2840 None,
2841 Arc::clone(&input_metrics),
2842 Arc::clone(&snapshot),
2843 JsonSource::default(),
2844 )
2845 .expect("build metrics-aware object store");
2846
2847 let result = store
2848 .get_opts(&Path::from(OBJECT), GetOptions::default())
2849 .await
2850 .expect("open full object stream");
2851 let GetResultPayload::Stream(stream) = result.payload else {
2852 panic!("expected streaming object payload");
2853 };
2854 let body = stream
2855 .try_collect::<Vec<_>>()
2856 .await
2857 .expect("read full object stream")
2858 .concat();
2859 assert_eq!(body, DATA);
2860 let data_len = u64::try_from(DATA.len()).expect("fixture length should fit in u64");
2861 assert_eq!(input_metrics.snapshot().bytes_scanned, data_len);
2862 assert_eq!(input_metrics.snapshot().bytes_processed, data_len);
2863
2864 input_metrics.reset();
2865
2866 let result = store
2867 .get_opts(
2868 &Path::from(OBJECT),
2869 GetOptions {
2870 range: Some(GetRange::Bounded(0..2)),
2871 ..Default::default()
2872 },
2873 )
2874 .await
2875 .expect("open schema-style range stream");
2876 let GetResultPayload::Stream(stream) = result.payload else {
2877 panic!("expected range stream payload");
2878 };
2879 let range = stream
2880 .try_collect::<Vec<_>>()
2881 .await
2882 .expect("read schema-style range")
2883 .concat();
2884 assert_eq!(range, b"id"[..]);
2885 assert_eq!(input_metrics.snapshot().bytes_scanned, 2);
2886 assert_eq!(input_metrics.snapshot().bytes_processed, 2);
2887 }
2888
2889 #[tokio::test]
2890 async fn unicode_csv_quotes_preserve_raw_offsets_and_metrics() {
2891 const BUCKET: &str = "s3select-unicode-csv-stream";
2892 const HEADER: &str = "عnameع,عkindع\n";
2893 const SKIP: &str = "عskipع,عzeroع\n";
2894 const ROW: &str = "عA,Bع,عAععBع\n";
2895 let data = format!("{HEADER}{SKIP}{ROW}");
2896 let env = crate::storage_api::select_test_ecstore_env().await;
2897 env.make_bucket(BUCKET, false).await;
2898 for (object, compression, range_offset) in [
2899 ("plain.csv", None, None),
2900 ("range.csv", None, Some(0)),
2901 ("range-mid-character.csv", None, Some(1)),
2902 ("gzip.csv", Some(CompressionFormat::Gzip), None),
2903 ("bzip.csv", Some(CompressionFormat::Bzip2), None),
2904 ] {
2905 let bytes = match compression {
2906 Some(format) => encode_compressed_fixture(format, data.as_bytes()).await,
2907 None => data.as_bytes().to_vec(),
2908 };
2909 let raw_size = bytes.len();
2910 let mut reader = SelectPutObjReader::from_vec(bytes);
2911 env.ecstore
2912 .put_object(BUCKET, object, &mut reader, &Default::default())
2913 .await
2914 .expect("write Unicode CSV fixture");
2915 let mut input = (*csv_input(BUCKET, object)).clone();
2916 let csv = input.request.input_serialization.csv.as_mut().expect("CSV input");
2917 csv.file_header_info = Some(FileHeaderInfo::from_static(FileHeaderInfo::USE));
2918 csv.quote_character = Some("ع".to_owned());
2919 csv.quote_escape_character = Some("\\".to_owned());
2920 csv.record_delimiter = Some("\n".to_owned());
2921 input.request.input_serialization.compression_type = compression.map(|format| {
2922 CompressionType::from_static(match format {
2923 CompressionFormat::Gzip => CompressionType::GZIP,
2924 CompressionFormat::Bzip2 => CompressionType::BZIP2,
2925 })
2926 });
2927 let start = HEADER.len() + SKIP.len();
2928 if let Some(range_offset) = range_offset {
2929 let offset = i64::try_from(start + range_offset).expect("fixture offset");
2930 input.request.scan_range = Some(ScanRange {
2931 start: Some(offset),
2932 end: Some(offset),
2933 });
2934 }
2935 let metrics = Arc::new(SelectInputMetrics::default());
2936 let store = EcObjectStore::build_with_snapshot(
2937 Arc::new(input),
2938 Arc::new(GreedyMemoryPool::new(1024 * 1024)),
2939 None,
2940 Arc::clone(&metrics),
2941 prepare_test_snapshot(BUCKET, object).await,
2942 JsonSource::default(),
2943 )
2944 .expect("snapshot store");
2945 let result = store
2946 .get_opts(&Path::from(object), GetOptions::default())
2947 .await
2948 .expect("open Unicode CSV stream");
2949 let GetResultPayload::Stream(stream) = result.payload else { panic!("CSV must remain streaming") };
2950 let output = stream.try_collect::<Vec<_>>().await.expect("normalize CSV stream").concat();
2951 let expected = match range_offset {
2952 Some(0) => "\"name\",\"kind\"\n\"A,B\",\"AعB\"\n",
2953 Some(_) => "\"name\",\"kind\"\n",
2954 None => "\"name\",\"kind\"\n\"skip\",\"zero\"\n\"A,B\",\"AعB\"\n",
2955 };
2956 assert_eq!(output, expected.as_bytes(), "object={object}");
2957 let measured = metrics.snapshot();
2958 if let Some(range_offset) = range_offset {
2959 let processed = u64::try_from(ROW.len() + 1 - range_offset + HEADER.len()).expect("raw range length");
2962 assert_eq!(measured.bytes_scanned, processed);
2963 assert_eq!(measured.bytes_processed, processed);
2964 } else {
2965 assert_eq!(measured.bytes_scanned, u64::try_from(raw_size).expect("raw length"));
2966 assert_eq!(measured.bytes_processed, u64::try_from(data.len()).expect("decoded length"));
2967 }
2968 }
2969 }
2970
2971 #[tokio::test]
2972 async fn compressed_object_uses_one_full_stream_and_rejects_internal_ranges() {
2973 const BUCKET: &str = "s3select-compressed-object";
2974 const OBJECT: &str = "input.csv";
2975 const DATA: &[u8] = b"id,name\n1,Alice\n2,Bob\n";
2976
2977 let compressed = encode_compressed_fixture(CompressionFormat::Gzip, DATA).await;
2978 let env = crate::storage_api::select_test_ecstore_env().await;
2979 env.make_bucket(BUCKET, false).await;
2980 let mut reader = SelectPutObjReader::from_vec(compressed.clone());
2981 env.ecstore
2982 .put_object(BUCKET, OBJECT, &mut reader, &Default::default())
2983 .await
2984 .expect("put compressed CSV fixture");
2985 let snapshot = prepare_test_snapshot(BUCKET, OBJECT).await;
2986 let mut input = (*csv_input(BUCKET, OBJECT)).clone();
2987 input.request.input_serialization.compression_type = Some(CompressionType::from_static(CompressionType::GZIP));
2988 input.request.scan_range = Some(ScanRange {
2989 start: Some(0),
2990 end: None,
2991 });
2992 let input_metrics = Arc::new(SelectInputMetrics::default());
2993 let store = EcObjectStore::build_with_snapshot(
2994 Arc::new(input),
2995 Arc::new(GreedyMemoryPool::new(1024 * 1024)),
2996 None,
2997 Arc::clone(&input_metrics),
2998 Arc::clone(&snapshot),
2999 JsonSource::default(),
3000 )
3001 .expect("build compressed object store");
3002
3003 let error = store
3004 .get_opts(
3005 &Path::from(OBJECT),
3006 GetOptions {
3007 range: Some(GetRange::Bounded(0..1)),
3008 ..Default::default()
3009 },
3010 )
3011 .await
3012 .expect_err("compressed input must reject DataFusion byte ranges");
3013 assert_eq!(
3014 QueryError::from(DataFusionError::ObjectStore(Box::new(error))).select_error(),
3015 SelectError::UnsupportedScanRangeInput
3016 );
3017 assert_eq!(store.reader_open_count.load(Ordering::SeqCst), 0);
3018
3019 let mut scan_input = (*csv_input(BUCKET, OBJECT)).clone();
3020 scan_input.request.input_serialization.compression_type = Some(CompressionType::from_static(CompressionType::GZIP));
3021 scan_input.request.scan_range = Some(ScanRange {
3022 start: Some(1),
3023 end: None,
3024 });
3025 let scan_store = EcObjectStore::build_with_snapshot(
3026 Arc::new(scan_input),
3027 Arc::new(GreedyMemoryPool::new(1024 * 1024)),
3028 None,
3029 Arc::new(SelectInputMetrics::default()),
3030 snapshot,
3031 JsonSource::default(),
3032 )
3033 .expect("build compressed ScanRange object store");
3034 let error = scan_store
3035 .get_opts(&Path::from(OBJECT), GetOptions::default())
3036 .await
3037 .expect_err("compressed request ScanRange must fail before object I/O");
3038 assert_eq!(
3039 QueryError::from(DataFusionError::ObjectStore(Box::new(error))).select_error(),
3040 SelectError::UnsupportedScanRangeInput
3041 );
3042 assert_eq!(scan_store.reader_open_count.load(Ordering::SeqCst), 0);
3043
3044 let result = store
3045 .get_opts(&Path::from(OBJECT), GetOptions::default())
3046 .await
3047 .expect("open full compressed object stream");
3048 let GetResultPayload::Stream(stream) = result.payload else {
3049 panic!("expected compressed stream payload");
3050 };
3051 let body = stream
3052 .try_collect::<Vec<_>>()
3053 .await
3054 .expect("decode compressed object")
3055 .concat();
3056
3057 assert_eq!(body, DATA);
3058 assert_eq!(store.reader_open_count.load(Ordering::SeqCst), 1);
3059 assert_eq!(
3060 input_metrics.snapshot().bytes_scanned,
3061 u64::try_from(compressed.len()).expect("compressed fixture length should fit in u64")
3062 );
3063 assert_eq!(
3064 input_metrics.snapshot().bytes_processed,
3065 u64::try_from(DATA.len()).expect("input fixture length should fit in u64")
3066 );
3067 }
3068
3069 #[tokio::test]
3070 async fn compressed_stream_throughput_is_independent_of_query_memory_pool() {
3071 const BUCKET: &str = "s3select-compressed-throughput";
3072 const OBJECT: &str = "input.csv.gz";
3073
3074 let data = b"a\n".repeat(1024 * 1024);
3075 let compressed = encode_compressed_fixture(CompressionFormat::Gzip, &data).await;
3076 let env = crate::storage_api::select_test_ecstore_env().await;
3077 env.make_bucket(BUCKET, false).await;
3078 let mut reader = SelectPutObjReader::from_vec(compressed);
3079 env.ecstore
3080 .put_object(BUCKET, OBJECT, &mut reader, &Default::default())
3081 .await
3082 .expect("put compressed throughput fixture");
3083 let snapshot = prepare_test_snapshot(BUCKET, OBJECT).await;
3084 let mut input = (*csv_input(BUCKET, OBJECT)).clone();
3085 input.request.input_serialization.compression_type = Some(CompressionType::from_static(CompressionType::GZIP));
3086 let metrics = Arc::new(SelectInputMetrics::default());
3087 let store = EcObjectStore::build_with_snapshot(
3088 Arc::new(input),
3089 Arc::new(GreedyMemoryPool::new(1)),
3090 None,
3091 Arc::clone(&metrics),
3092 snapshot,
3093 JsonSource::default(),
3094 )
3095 .expect("build compressed throughput store");
3096
3097 let result = store
3098 .get_opts(&Path::from(OBJECT), GetOptions::default())
3099 .await
3100 .expect("open compressed throughput stream");
3101 let GetResultPayload::Stream(stream) = result.payload else {
3102 panic!("expected compressed stream payload");
3103 };
3104 let decoded = stream
3105 .try_collect::<Vec<_>>()
3106 .await
3107 .expect("streamed decoded bytes should not consume the query memory pool")
3108 .concat();
3109
3110 assert_eq!(decoded, data);
3111 assert_eq!(
3112 metrics.snapshot().bytes_processed,
3113 u64::try_from(data.len()).expect("fixture length should fit in u64")
3114 );
3115 }
3116
3117 #[tokio::test]
3118 async fn dropping_real_object_stream_counts_only_consumed_bytes() {
3119 const BUCKET: &str = "s3select-partial-input-metrics";
3120 const OBJECT: &str = "large.csv";
3121
3122 let data = vec![b'x'; SELECT_DEFAULT_READ_BUFFER_SIZE * 3];
3123 let env = crate::storage_api::select_test_ecstore_env().await;
3124 env.make_bucket(BUCKET, false).await;
3125 let mut reader = SelectPutObjReader::from_vec(data.clone());
3126 env.ecstore
3127 .put_object(BUCKET, OBJECT, &mut reader, &Default::default())
3128 .await
3129 .expect("put partial input metrics fixture");
3130 let snapshot = prepare_test_snapshot(BUCKET, OBJECT).await;
3131 let input_metrics = Arc::new(SelectInputMetrics::default());
3132 let store = EcObjectStore::build_with_snapshot(
3133 csv_input(BUCKET, OBJECT),
3134 Arc::new(GreedyMemoryPool::new(1024 * 1024)),
3135 None,
3136 Arc::clone(&input_metrics),
3137 snapshot,
3138 JsonSource::default(),
3139 )
3140 .expect("build metrics-aware object store");
3141
3142 let result = store
3143 .get_opts(&Path::from(OBJECT), GetOptions::default())
3144 .await
3145 .expect("open partial object stream");
3146 let GetResultPayload::Stream(mut stream) = result.payload else {
3147 panic!("expected streaming object payload");
3148 };
3149 let first = stream
3150 .next()
3151 .await
3152 .expect("first object chunk")
3153 .expect("first object chunk should be valid");
3154 drop(stream);
3155
3156 assert!(first.len() < data.len(), "fixture must span multiple reader chunks");
3157 let consumed = u64::try_from(first.len()).expect("chunk length should fit in u64");
3158 assert_eq!(input_metrics.snapshot().bytes_scanned, consumed);
3159 assert_eq!(input_metrics.snapshot().bytes_processed, consumed);
3160 }
3161
3162 #[tokio::test]
3163 async fn json_object_streams_record_input_metrics() {
3164 const BUCKET: &str = "s3select-json-input-metrics";
3165 const LINES_OBJECT: &str = "input.jsonl";
3166 const LINES_DATA: &[u8] = b"{\"id\":1}\n{\"id\":2}\n";
3167 const DOCUMENT_OBJECT: &str = "input.json";
3168 const DOCUMENT_DATA: &[u8] = b"[{\"id\":1},{\"id\":2}]";
3169
3170 let env = crate::storage_api::select_test_ecstore_env().await;
3171 env.make_bucket(BUCKET, false).await;
3172 for (object, data, json_type) in [
3173 (LINES_OBJECT, LINES_DATA, JSONType::LINES),
3174 (DOCUMENT_OBJECT, DOCUMENT_DATA, JSONType::DOCUMENT),
3175 ] {
3176 let mut reader = SelectPutObjReader::from_vec(data.to_vec());
3177 env.ecstore
3178 .put_object(BUCKET, object, &mut reader, &Default::default())
3179 .await
3180 .expect("put JSON input metrics fixture");
3181 let snapshot = prepare_test_snapshot(BUCKET, object).await;
3182 let input_metrics = Arc::new(SelectInputMetrics::default());
3183 let memory_limit = if json_type == JSONType::DOCUMENT {
3184 JSON_DOCUMENT_TEST_MEMORY_BYTES
3185 } else {
3186 1024 * 1024
3187 };
3188 let store = EcObjectStore::build_with_snapshot(
3189 json_input(BUCKET, object, json_type),
3190 Arc::new(GreedyMemoryPool::new(memory_limit)),
3191 None,
3192 Arc::clone(&input_metrics),
3193 snapshot,
3194 JsonSource::default(),
3195 )
3196 .expect("build metrics-aware JSON object store");
3197
3198 let result = store
3199 .get_opts(&Path::from(object), GetOptions::default())
3200 .await
3201 .expect("open JSON object stream");
3202 let GetResultPayload::Stream(stream) = result.payload else {
3203 panic!("expected streaming JSON payload");
3204 };
3205 stream.try_collect::<Vec<_>>().await.expect("read JSON object stream");
3206
3207 let input_len = u64::try_from(data.len()).expect("fixture length should fit in u64");
3208 assert_eq!(input_metrics.snapshot().bytes_scanned, input_len, "JSON type {json_type}");
3209 assert_eq!(input_metrics.snapshot().bytes_processed, input_len, "JSON type {json_type}");
3210 }
3211 }
3212
3213 #[tokio::test]
3214 async fn scan_range_metrics_include_header_and_raw_range_once() {
3215 const BUCKET: &str = "s3select-scan-range-input-metrics";
3216 const OBJECT: &str = "input.csv";
3217 const DATA: &[u8] = b"h1,h2\nr1,a\nr2,b\n";
3218 const HEADER_LEN: usize = b"h1,h2\n".len();
3219 const RECORD_START: usize = b"h1,h2\nr1,a\n".len();
3220 const READ_START: usize = RECORD_START - 1;
3221
3222 let env = crate::storage_api::select_test_ecstore_env().await;
3223 env.make_bucket(BUCKET, false).await;
3224 let mut reader = SelectPutObjReader::from_vec(DATA.to_vec());
3225 env.ecstore
3226 .put_object(BUCKET, OBJECT, &mut reader, &Default::default())
3227 .await
3228 .expect("put ScanRange input metrics fixture");
3229 let snapshot = prepare_test_snapshot(BUCKET, OBJECT).await;
3230 let mut input = (*csv_input(BUCKET, OBJECT)).clone();
3231 input
3232 .request
3233 .input_serialization
3234 .csv
3235 .as_mut()
3236 .expect("CSV input")
3237 .file_header_info = Some(FileHeaderInfo::from_static(FileHeaderInfo::USE));
3238 input.request.scan_range = Some(ScanRange {
3239 start: Some(i64::try_from(RECORD_START).expect("fixture offset should fit in i64")),
3240 end: Some(i64::try_from(RECORD_START).expect("fixture offset should fit in i64")),
3241 });
3242 let input_metrics = Arc::new(SelectInputMetrics::default());
3243 let store = EcObjectStore::build_with_snapshot(
3244 Arc::new(input),
3245 Arc::new(GreedyMemoryPool::new(1024 * 1024)),
3246 None,
3247 Arc::clone(&input_metrics),
3248 snapshot,
3249 JsonSource::default(),
3250 )
3251 .expect("build ScanRange metrics-aware object store");
3252
3253 let result = store
3254 .get_opts(&Path::from(OBJECT), GetOptions::default())
3255 .await
3256 .expect("open ScanRange object stream");
3257 let GetResultPayload::Stream(stream) = result.payload else {
3258 panic!("expected streaming ScanRange payload");
3259 };
3260 let body = stream
3261 .try_collect::<Vec<_>>()
3262 .await
3263 .expect("read ScanRange object stream")
3264 .concat();
3265
3266 assert_eq!(body, b"h1,h2\nr2,b\n");
3267 let expected_input = u64::try_from(HEADER_LEN + DATA.len() - READ_START).expect("fixture length should fit in u64");
3268 assert_eq!(input_metrics.snapshot().bytes_scanned, expected_input);
3269 assert_eq!(input_metrics.snapshot().bytes_processed, expected_input);
3270 }
3271
3272 #[tokio::test]
3273 async fn test_json_document_stream_respects_query_memory_pool() {
3274 let input = b"{}".to_vec();
3275 let memory_pool: Arc<dyn MemoryPool> = Arc::new(GreedyMemoryPool::new(1));
3276 let mut output = json_document_ndjson_stream(
3277 Box::new(std::io::Cursor::new(input.clone())),
3278 input.len() as u64,
3279 JsonSource::default(),
3280 Arc::new(SelectInputMetrics::default()),
3281 memory_pool,
3282 None,
3283 )
3284 .expect("build constrained JSON document stream");
3285
3286 let err = output
3287 .next()
3288 .await
3289 .expect("memory error")
3290 .expect_err("reservation should exceed the pool");
3291 let object_store::Error::Generic { source, .. } = err else {
3292 panic!("expected generic object store error");
3293 };
3294 assert!(matches!(
3295 source.downcast_ref::<DataFusionError>(),
3296 Some(DataFusionError::ResourcesExhausted(_))
3297 ));
3298 }
3299
3300 #[tokio::test]
3301 async fn compressed_json_document_uses_decoded_size_and_metric_boundaries() {
3302 const INPUT: &[u8] = br#"[{"id":1},{"id":2}]"#;
3303 const EXPECTED: &[u8] = b"{\"id\":1}\n{\"id\":2}\n";
3304
3305 for format in [CompressionFormat::Gzip, CompressionFormat::Bzip2] {
3306 let compressed = encode_compressed_fixture(format, INPUT).await;
3307 let compressed_len = u64::try_from(compressed.len()).expect("compressed fixture length should fit in u64");
3308 let input_metrics = Arc::new(SelectInputMetrics::default());
3309 let reader = compressed_input_reader(
3310 Box::new(std::io::Cursor::new(compressed)),
3311 compressed_len,
3312 format,
3313 Arc::clone(&input_metrics),
3314 u64::MAX,
3315 None,
3316 );
3317 let output = compressed_json_document_ndjson_stream(
3318 reader,
3319 JsonSource::default(),
3320 Arc::new(GreedyMemoryPool::new(JSON_DOCUMENT_TEST_MEMORY_BYTES)),
3321 None,
3322 )
3323 .try_collect::<Vec<_>>()
3324 .await
3325 .expect("compressed JSON DOCUMENT should decode and parse")
3326 .concat();
3327
3328 assert_eq!(output, EXPECTED);
3329 assert_eq!(input_metrics.snapshot().bytes_scanned, compressed_len);
3330 assert_eq!(
3331 input_metrics.snapshot().bytes_processed,
3332 u64::try_from(INPUT.len()).expect("JSON fixture length should fit in u64")
3333 );
3334 }
3335 }
3336
3337 async fn compressed_json_document_select_error(
3338 format: CompressionFormat,
3339 compressed: Vec<u8>,
3340 max_processed_bytes: u64,
3341 ) -> SelectError {
3342 let compressed_len = u64::try_from(compressed.len()).expect("compressed fixture length should fit in u64");
3343 let reader = compressed_input_reader(
3344 Box::new(std::io::Cursor::new(compressed)),
3345 compressed_len,
3346 format,
3347 Arc::new(SelectInputMetrics::default()),
3348 max_processed_bytes,
3349 None,
3350 );
3351 let mut output = compressed_json_document_ndjson_stream(
3352 reader,
3353 JsonSource::default(),
3354 Arc::new(GreedyMemoryPool::new(64 * 1024 * 1024)),
3355 None,
3356 );
3357 while let Some(result) = output.next().await {
3358 if let Err(source) = result {
3359 assert!(output.next().await.is_none());
3360 return QueryError::from(DataFusionError::ObjectStore(Box::new(source))).select_error();
3361 }
3362 }
3363 panic!("compressed JSON DOCUMENT decoding must fail");
3364 }
3365
3366 #[tokio::test]
3367 async fn compressed_json_document_preserves_decoder_select_errors() {
3368 const INPUT: &[u8] = br#"[{"id":1}]"#;
3369
3370 for (format, compression) in [(CompressionFormat::Gzip, "GZIP"), (CompressionFormat::Bzip2, "BZIP2")] {
3371 assert_eq!(
3372 compressed_json_document_select_error(format, b"not compressed".to_vec(), u64::MAX).await,
3373 SelectError::InvalidCompressionFormatForObject { compression }
3374 );
3375
3376 let mut truncated = encode_compressed_fixture(format, INPUT).await;
3377 truncated.truncate(truncated.len() - 1);
3378 assert_eq!(
3379 compressed_json_document_select_error(format, truncated, u64::MAX).await,
3380 SelectError::TruncatedInput
3381 );
3382
3383 let compressed = encode_compressed_fixture(format, INPUT).await;
3384 let max_processed_bytes = u64::try_from(INPUT.len() - 1).expect("fixture length should fit in u64");
3385 assert_eq!(
3386 compressed_json_document_select_error(format, compressed, max_processed_bytes).await,
3387 SelectError::ResourceExhausted
3388 );
3389 }
3390 }
3391
3392 #[tokio::test]
3393 async fn json_document_input_record_limit_applies_after_decompression() {
3394 let at_limit = escaped_json_object_with_size(MAX_SELECT_RECORD_BYTES);
3395 let over_limit = escaped_json_object_with_size(MAX_SELECT_RECORD_BYTES + 1);
3396
3397 for format in [CompressionFormat::Gzip, CompressionFormat::Bzip2] {
3398 let compressed = encode_compressed_fixture(format, &at_limit).await;
3399 let compressed_len = u64::try_from(compressed.len()).expect("compressed fixture length should fit in u64");
3400 let reader = compressed_input_reader(
3401 Box::new(std::io::Cursor::new(compressed)),
3402 compressed_len,
3403 format,
3404 Arc::new(SelectInputMetrics::default()),
3405 u64::MAX,
3406 None,
3407 );
3408 compressed_json_document_ndjson_stream(
3409 reader,
3410 JsonSource::default(),
3411 Arc::new(GreedyMemoryPool::new(64 * 1024 * 1024)),
3412 None,
3413 )
3414 .try_collect::<Vec<_>>()
3415 .await
3416 .expect("one-megabyte compressed input record should be accepted");
3417
3418 let compressed = encode_compressed_fixture(format, &over_limit).await;
3419 assert_eq!(
3420 compressed_json_document_select_error(format, compressed, u64::MAX).await,
3421 SelectError::OverMaxRecordSize
3422 );
3423 }
3424 }
3425
3426 #[tokio::test]
3427 async fn test_json_document_stream_releases_memory_reservation() {
3428 let input = b"[1,2]".to_vec();
3429 let memory_pool = Arc::new(GreedyMemoryPool::new(JSON_DOCUMENT_TEST_MEMORY_BYTES));
3430 let input_metrics = Arc::new(SelectInputMetrics::default());
3431 let output: Vec<Bytes> = json_document_ndjson_stream(
3432 Box::new(std::io::Cursor::new(input.clone())),
3433 input.len() as u64,
3434 JsonSource::default(),
3435 Arc::clone(&input_metrics),
3436 memory_pool.clone(),
3437 None,
3438 )
3439 .expect("build JSON document stream")
3440 .try_collect()
3441 .await
3442 .expect("JSON conversion should fit the pool");
3443 let input_len = u64::try_from(input.len()).expect("fixture length should fit in u64");
3444 assert_eq!(input_metrics.snapshot().bytes_scanned, input_len);
3445 assert_eq!(input_metrics.snapshot().bytes_processed, input_len);
3446
3447 assert_eq!(output, vec![Bytes::from_static(b"{\"_1\":1}\n"), Bytes::from_static(b"{\"_1\":2}\n")]);
3448 assert_eq!(memory_pool.reserved(), 0);
3449 }
3450
3451 #[tokio::test]
3452 async fn test_json_document_stream_reports_early_eof_after_completed_rows() {
3453 let input = b"{}".to_vec();
3454 let input_len = u64::try_from(input.len()).expect("fixture length should fit in u64");
3455 let input_metrics = Arc::new(SelectInputMetrics::default());
3456 let memory_pool: Arc<dyn MemoryPool> = Arc::new(GreedyMemoryPool::new(JSON_DOCUMENT_TEST_MEMORY_BYTES));
3457 let mut output = json_document_ndjson_stream(
3458 Box::new(std::io::Cursor::new(input)),
3459 4,
3460 JsonSource::default(),
3461 Arc::clone(&input_metrics),
3462 memory_pool,
3463 None,
3464 )
3465 .expect("build short JSON document stream");
3466
3467 let row = output
3468 .next()
3469 .await
3470 .expect("completed row")
3471 .expect("completed rows may precede a terminal stream error");
3472 assert_eq!(row, Bytes::from_static(b"{}\n"));
3473
3474 let err = output
3475 .next()
3476 .await
3477 .expect("early EOF error")
3478 .expect_err("short JSON document must fail");
3479 let object_store::Error::Generic { source, .. } = err else {
3480 panic!("expected generic object store error");
3481 };
3482 let source = source.downcast_ref::<std::io::Error>().expect("I/O error source");
3483 assert_eq!(source.kind(), std::io::ErrorKind::UnexpectedEof);
3484 assert!(source.to_string().contains("2 bytes remaining"));
3485 assert_eq!(input_metrics.snapshot().bytes_scanned, input_len);
3486 assert_eq!(input_metrics.snapshot().bytes_processed, input_len);
3487 assert!(output.next().await.is_none());
3488 }
3489
3490 #[tokio::test]
3491 async fn malformed_json_document_stream_has_typed_select_error() {
3492 let input = b"{bad".to_vec();
3493 let memory_pool: Arc<dyn MemoryPool> = Arc::new(GreedyMemoryPool::new(JSON_DOCUMENT_TEST_MEMORY_BYTES));
3494 let mut output = json_document_ndjson_stream(
3495 Box::new(std::io::Cursor::new(input.clone())),
3496 input.len() as u64,
3497 JsonSource::default(),
3498 Arc::new(SelectInputMetrics::default()),
3499 memory_pool,
3500 None,
3501 )
3502 .expect("build malformed JSON document stream");
3503
3504 let source = output
3505 .next()
3506 .await
3507 .expect("malformed JSON should produce one stream error")
3508 .expect_err("malformed JSON DOCUMENT must fail");
3509 let error = QueryError::from(DataFusionError::ObjectStore(Box::new(source)));
3510
3511 assert_eq!(error.select_error(), SelectError::JsonParsingError);
3512 assert!(output.next().await.is_none());
3513 }
3514
3515 #[test]
3516 fn storage_error_mapper_preserves_protocol_classification() {
3517 let classify = |source| QueryError::from(DataFusionError::ObjectStore(Box::new(source))).select_error();
3518
3519 assert_eq!(
3520 classify(map_storage_error(
3521 "private-bucket",
3522 "private-object",
3523 SelectStorageError::BucketNotFound("private-bucket".to_string()),
3524 )),
3525 SelectError::BucketNotFound
3526 );
3527 assert_eq!(
3528 classify(map_storage_error(
3529 "private-bucket",
3530 "private-object",
3531 SelectStorageError::ObjectNotFound("private-bucket".to_string(), "private-object".to_string()),
3532 )),
3533 SelectError::ObjectNotFound
3534 );
3535 assert_eq!(
3536 classify(map_storage_error("private-bucket", "private-object", SelectStorageError::LessData)),
3537 SelectError::InternalError
3538 );
3539 assert_eq!(
3540 classify(scan_range_from_bounds(Some(10), None, 10).expect_err("out-of-bounds range must fail")),
3541 SelectError::InvalidScanRange
3542 );
3543 let parquet_source = map_storage_error(
3544 "private-bucket",
3545 "private-object",
3546 SelectStorageError::ObjectNotFound("private-bucket".to_string(), "private-object".to_string()),
3547 );
3548 let parquet_error = QueryError::from(DataFusionError::ParquetError(Box::new(
3549 datafusion::parquet::errors::ParquetError::External(Box::new(parquet_source)),
3550 )));
3551 assert_eq!(parquet_error.select_error(), SelectError::ObjectNotFound);
3552 }
3553
3554 #[test]
3555 fn test_json_document_size_error_is_resource_exhausted() {
3556 assert!(validate_json_document_size(super::MAX_JSON_DOCUMENT_BYTES).is_ok());
3557
3558 let err = validate_json_document_size(super::MAX_JSON_DOCUMENT_BYTES + 1).expect_err("oversized JSON document must fail");
3559 let object_store::Error::Generic { source, .. } = err else {
3560 panic!("expected generic object store error");
3561 };
3562 assert!(matches!(
3563 source.downcast_ref::<DataFusionError>(),
3564 Some(DataFusionError::ResourcesExhausted(_))
3565 ));
3566 }
3567
3568 #[test]
3569 fn test_json_document_parser_does_not_use_tokio_blocking_pool() {
3570 let runtime = tokio::runtime::Builder::new_multi_thread()
3571 .worker_threads(2)
3572 .max_blocking_threads(1)
3573 .enable_all()
3574 .build()
3575 .expect("build test runtime");
3576
3577 runtime.block_on(async {
3578 let (blocking_started_tx, blocking_started_rx) = tokio::sync::oneshot::channel();
3579 let (release_blocking_tx, release_blocking_rx) = std::sync::mpsc::channel();
3580 let blocker = tokio::task::spawn_blocking(move || {
3581 let _ = blocking_started_tx.send(());
3582 release_blocking_rx.recv().expect("release blocking worker");
3583 });
3584 blocking_started_rx.await.expect("blocking worker should start");
3585
3586 let admission = Arc::new(Semaphore::new(1));
3587 let permit = Arc::clone(&admission)
3588 .acquire_owned()
3589 .await
3590 .expect("query permit should be available");
3591 let query_guard: QueryExecutionGuard = Arc::new(permit);
3592 let query_tracker = QueryExecutionTracker::new(
3593 &QueryExecutionOwner::new(),
3594 query_guard,
3595 tokio::time::Instant::now() + std::time::Duration::from_secs(30),
3596 30,
3597 );
3598 let input = b"{}".to_vec();
3599 let (memory_pool, reservation_released) =
3600 AdmissionObservingMemoryPool::new(JSON_DOCUMENT_TEST_MEMORY_BYTES, Arc::clone(&admission));
3601 let memory_pool = Arc::new(memory_pool);
3602 let query_memory_pool: Arc<dyn MemoryPool> = memory_pool.clone();
3603 let mut output = json_document_ndjson_stream(
3604 Box::new(std::io::Cursor::new(input.clone())),
3605 input.len() as u64,
3606 JsonSource::default(),
3607 Arc::new(SelectInputMetrics::default()),
3608 query_memory_pool,
3609 Some(query_tracker),
3610 )
3611 .expect("build JSON document stream");
3612
3613 let row = tokio::time::timeout(std::time::Duration::from_secs(1), output.next())
3614 .await
3615 .expect("dedicated parser must not wait for Tokio's blocking pool")
3616 .expect("JSON document should produce one row")
3617 .expect("JSON document row should be valid");
3618 assert_eq!(row, Bytes::from_static(b"{}\n"));
3619 assert!(
3620 tokio::time::timeout(std::time::Duration::from_secs(1), output.next())
3621 .await
3622 .expect("parser should finish while the blocking pool is occupied")
3623 .is_none()
3624 );
3625 drop(output);
3626
3627 tokio::pin!(reservation_released);
3628 assert!(
3629 tokio::time::timeout(std::time::Duration::from_secs(1), &mut reservation_released)
3630 .await
3631 .expect("completed parser should release memory")
3632 .expect("memory reservation release observer should remain open"),
3633 "query admission must cover the memory reservation through teardown"
3634 );
3635 assert_eq!(memory_pool.reserved(), 0);
3636 let recovered_permit =
3637 tokio::time::timeout(std::time::Duration::from_secs(1), Arc::clone(&admission).acquire_owned())
3638 .await
3639 .expect("completed parser should release query admission")
3640 .expect("query admission should remain open");
3641 drop(recovered_permit);
3642
3643 release_blocking_tx.send(()).expect("release blocking worker");
3644 blocker.await.expect("blocking worker should finish");
3645 assert_eq!(admission.available_permits(), 1);
3646 });
3647 }
3648
3649 #[test]
3651 fn test_flatten_array_produces_one_line_per_element() {
3652 let input = br#"[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]"#;
3653 let result = flatten_json_document_to_ndjson(input, &[]).expect("should succeed");
3654 let text = std::str::from_utf8(&result).unwrap();
3655 let lines: Vec<&str> = text.lines().collect();
3656 assert_eq!(lines.len(), 2);
3657 for line in &lines {
3659 serde_json::from_str::<serde_json::Value>(line).expect("each line must be valid JSON");
3660 }
3661 let first: serde_json::Value = serde_json::from_str(lines[0]).unwrap();
3663 assert_eq!(first["id"], 1);
3664 assert_eq!(first["name"], "Alice");
3665 }
3666
3667 #[test]
3669 fn test_flatten_single_object_produces_one_line() {
3670 let input = br#"{"id":42,"value":"hello world"}"#;
3671 let result = flatten_json_document_to_ndjson(input, &[]).expect("should succeed");
3672 let text = std::str::from_utf8(&result).unwrap();
3673 let lines: Vec<&str> = text.lines().collect();
3674 assert_eq!(lines.len(), 1);
3675 let parsed: serde_json::Value = serde_json::from_str(lines[0]).unwrap();
3676 assert_eq!(parsed["id"], 42);
3677 assert_eq!(parsed["value"], "hello world");
3678 }
3679
3680 #[test]
3682 fn test_flatten_empty_array_produces_no_output() {
3683 let input = b"[]";
3684 let result = flatten_json_document_to_ndjson(input, &[]).expect("should succeed");
3685 assert!(result.is_empty(), "empty array should yield zero bytes");
3686 }
3687
3688 #[test]
3690 fn test_flatten_pretty_printed_document() {
3691 let input = b"[\n {\"a\": 1},\n {\"a\": 2},\n {\"a\": 3}\n]";
3692 let result = flatten_json_document_to_ndjson(input, &[]).expect("should succeed");
3693 let text = std::str::from_utf8(&result).unwrap();
3694 assert_eq!(text.lines().count(), 3);
3695 }
3696
3697 #[test]
3699 fn test_flatten_array_with_nested_objects() {
3700 let input = br#"[{"outer":{"inner":99}},{"outer":{"inner":100}}]"#;
3701 let result = flatten_json_document_to_ndjson(input, &[]).expect("should succeed");
3702 let text = std::str::from_utf8(&result).unwrap();
3703 let lines: Vec<&str> = text.lines().collect();
3704 assert_eq!(lines.len(), 2);
3705 for line in &lines {
3707 assert!(!line.is_empty());
3708 let v: serde_json::Value = serde_json::from_str(line).unwrap();
3709 assert!(v["outer"]["inner"].as_i64().unwrap() >= 99);
3710 }
3711 }
3712
3713 #[test]
3715 fn test_flatten_output_ends_with_newline_per_record() {
3716 let input = br#"[{"x":1},{"x":2}]"#;
3717 let result = flatten_json_document_to_ndjson(input, &[]).expect("should succeed");
3718 let text = std::str::from_utf8(&result).unwrap();
3719 assert_eq!(text.chars().filter(|&c| c == '\n').count(), 2);
3721 assert!(!text.starts_with('\n'));
3723 }
3724
3725 #[test]
3727 fn test_flatten_invalid_json_returns_error() {
3728 let input = b"{ not valid json }";
3729 let err = flatten_json_document_to_ndjson(input, &[]).expect_err("should fail on invalid JSON");
3730 assert_eq!(err.kind(), std::io::ErrorKind::InvalidData);
3731 }
3732
3733 #[test]
3734 fn json_document_logical_record_enforces_one_megabyte_limit() {
3735 const SCALAR_WRAPPER_BYTES: usize = br#"{"":0}"#.len();
3736 let input = br#"{"v":0}"#;
3737 let path = vec![source_key("v")];
3738
3739 let alias = "a".repeat(MAX_SELECT_RECORD_BYTES - SCALAR_WRAPPER_BYTES);
3740 let source = JsonSource::new(path.clone(), Some(alias));
3741 let line = super::parse_json_document_to_lines(input, &source).expect("one-megabyte logical record should be accepted");
3742 assert_eq!(line[0].len(), MAX_SELECT_RECORD_BYTES + 1);
3743
3744 let alias = "a".repeat(MAX_SELECT_RECORD_BYTES + 1 - SCALAR_WRAPPER_BYTES);
3745 let source = JsonSource::new(path.clone(), Some(alias));
3746 let error = super::parse_json_document_to_lines(input, &source).expect_err("oversized logical record must fail");
3747 assert_eq!(error.kind(), std::io::ErrorKind::InvalidData);
3748 assert!(error.get_ref().is_some_and(|source| {
3749 source
3750 .downcast_ref::<SelectError>()
3751 .is_some_and(|error| error == &SelectError::OverMaxRecordSize)
3752 }));
3753
3754 let escaped_alias = "\0".repeat(MAX_SELECT_RECORD_BYTES / 6);
3755 let source = JsonSource::new(path, Some(escaped_alias));
3756 let error = super::parse_json_document_to_lines(input, &source)
3757 .expect_err("escaped output must be bounded while it is serialized");
3758 assert!(error.get_ref().is_some_and(|source| {
3759 source
3760 .downcast_ref::<SelectError>()
3761 .is_some_and(|error| error == &SelectError::OverMaxRecordSize)
3762 }));
3763 }
3764
3765 #[test]
3767 fn test_flatten_empty_input_returns_error() {
3768 let err = flatten_json_document_to_ndjson(b"", &[]).expect_err("empty bytes are not valid JSON");
3769 assert_eq!(err.kind(), std::io::ErrorKind::InvalidData);
3770 }
3771
3772 #[test]
3773 fn key_path_expands_final_array_for_legacy_queries() {
3774 let input = br#"{"employees":[{"id":1,"name":"Alice","salary":75000},{"id":2,"name":"Bob","salary":65000}]}"#;
3775 let result = flatten_json_document_to_ndjson(input, &[source_key("employees")]).expect("key path should succeed");
3776 let text = std::str::from_utf8(&result).unwrap();
3777 let lines: Vec<&str> = text.lines().collect();
3778 assert_eq!(lines.len(), 2, "each employee should be its own NDJSON line");
3779 let first: serde_json::Value = serde_json::from_str(lines[0]).unwrap();
3780 assert_eq!(first["name"], "Alice");
3781 assert_eq!(first["salary"], 75000);
3782 let second: serde_json::Value = serde_json::from_str(lines[1]).unwrap();
3783 assert_eq!(second["name"], "Bob");
3784 }
3785
3786 #[test]
3787 fn nested_array_wildcards_expand_in_source_order() {
3788 let input = br#"{"departments":[{"employees":[{"id":1},{"id":2}]},{"employees":[{"id":3}]}]}"#;
3789 let path = [
3790 JsonPathSegment::ArrayWildcard,
3791 source_key("departments"),
3792 JsonPathSegment::ArrayWildcard,
3793 source_key("employees"),
3794 JsonPathSegment::ArrayWildcard,
3795 ];
3796
3797 let result = flatten_json_document_to_ndjson(input, &path).expect("nested wildcard path should succeed");
3798 let ids: Vec<i64> = std::str::from_utf8(&result)
3799 .unwrap()
3800 .lines()
3801 .map(|line| {
3802 serde_json::from_str::<serde_json::Value>(line).unwrap()["id"]
3803 .as_i64()
3804 .unwrap()
3805 })
3806 .collect();
3807
3808 assert_eq!(ids, vec![1, 2, 3]);
3809 }
3810
3811 #[test]
3812 fn explicit_array_wildcard_does_not_expand_nested_array_records_twice() {
3813 let input = br#"{"groups":[[1,2],[3,4]]}"#;
3814 let source = JsonSource::new(vec![source_key("groups"), JsonPathSegment::ArrayWildcard], Some("g".to_string()));
3815
3816 let result = super::parse_json_document_to_lines(input, &source).expect("explicit wildcard path should succeed");
3817
3818 assert_eq!(
3819 result,
3820 vec![Bytes::from_static(b"{\"g\":[1,2]}\n"), Bytes::from_static(b"{\"g\":[3,4]}\n")]
3821 );
3822 }
3823
3824 #[test]
3825 fn leading_array_wildcard_expands_a_root_array_before_nested_keys() {
3826 let input = br#"[{"employees":[{"id":1}]},{"employees":[{"id":2}]}]"#;
3827 let path = [
3828 JsonPathSegment::ArrayWildcard,
3829 source_key("employees"),
3830 JsonPathSegment::ArrayWildcard,
3831 ];
3832
3833 let result = flatten_json_document_to_ndjson(input, &path).expect("root array path should succeed");
3834 let ids: Vec<i64> = std::str::from_utf8(&result)
3835 .unwrap()
3836 .lines()
3837 .map(|line| {
3838 serde_json::from_str::<serde_json::Value>(line).unwrap()["id"]
3839 .as_i64()
3840 .unwrap()
3841 })
3842 .collect();
3843
3844 assert_eq!(ids, vec![1, 2]);
3845 }
3846
3847 #[test]
3848 fn root_array_index_selects_one_record() {
3849 let input = br#"[{"id":1},{"id":2}]"#;
3850
3851 let result = flatten_json_document_to_ndjson(input, &[JsonPathSegment::Index(1)]).expect("array index should succeed");
3852
3853 assert_eq!(result, Bytes::from_static(b"{\"id\":2}\n"));
3854 }
3855
3856 #[test]
3857 fn canonical_root_array_index_selects_one_record() {
3858 let input = br#"[{"id":1},{"id":2}]"#;
3859 let path = [JsonPathSegment::ArrayWildcard, JsonPathSegment::Index(0)];
3860
3861 let result = flatten_json_document_to_ndjson(input, &path).expect("canonical array index should succeed");
3862
3863 assert_eq!(result, Bytes::from_static(b"{\"id\":1}\n"));
3864 }
3865
3866 #[test]
3867 fn out_of_range_root_array_indexes_produce_no_records() {
3868 let input = br#"[{"id":1}]"#;
3869
3870 for path in [
3871 vec![JsonPathSegment::Index(1)],
3872 vec![JsonPathSegment::ArrayWildcard, JsonPathSegment::Index(1)],
3873 ] {
3874 let result = flatten_json_document_to_ndjson(input, &path).expect("out-of-range index should not fail");
3875 assert!(result.is_empty());
3876 }
3877 }
3878
3879 #[test]
3880 fn canonical_key_path_does_not_expand_an_array_without_a_wildcard() {
3881 let input = br#"{"rules":[{"id":1},{"id":2}]}"#;
3882 let source = JsonSource::new(vec![JsonPathSegment::ArrayWildcard, source_key("rules")], Some("r".to_string()));
3883
3884 let result = super::parse_json_document_to_lines(input, &source).expect("array-valued source path should remain one row");
3885
3886 assert_eq!(result, vec![Bytes::from_static(b"{\"r\":[{\"id\":1},{\"id\":2}]}\n")]);
3887 }
3888
3889 #[test]
3890 fn object_wildcard_expands_values_and_allows_continuation() {
3891 let input = br#"{"groups":{"first":{"id":1},"second":{"id":2}}}"#;
3892 let path = [
3893 JsonPathSegment::ArrayWildcard,
3894 source_key("groups"),
3895 JsonPathSegment::ObjectWildcard,
3896 source_key("id"),
3897 ];
3898
3899 let result = flatten_json_document_to_ndjson(input, &path).expect("object wildcard should succeed");
3900 let values: Vec<serde_json::Value> = std::str::from_utf8(&result)
3901 .unwrap()
3902 .lines()
3903 .map(|line| serde_json::from_str(line).unwrap())
3904 .collect();
3905
3906 assert_eq!(values, vec![serde_json::json!({"id": 1}), serde_json::json!({"id": 2})]);
3907 }
3908
3909 #[test]
3910 fn canonical_double_wildcard_expands_a_root_array() {
3911 let input = br#"[{"id":1},{"id":2}]"#;
3912 let path = [JsonPathSegment::ArrayWildcard, JsonPathSegment::ArrayWildcard];
3913
3914 let result = flatten_json_document_to_ndjson(input, &path).expect("root wildcard should succeed");
3915
3916 assert_eq!(result, Bytes::from_static(b"{\"id\":1}\n{\"id\":2}\n"));
3917 }
3918
3919 #[test]
3920 fn terminal_scalar_path_uses_the_terminal_key_as_its_column() {
3921 let input = br#"{"rules":[{"id":"one"},{"id":"two"}]}"#;
3922 let path = [
3923 JsonPathSegment::ArrayWildcard,
3924 source_key("rules"),
3925 JsonPathSegment::ArrayWildcard,
3926 source_key("id"),
3927 ];
3928
3929 let result = flatten_json_document_to_ndjson(input, &path).expect("scalar source path should succeed");
3930
3931 assert_eq!(result, Bytes::from_static(b"{\"id\":\"one\"}\n{\"id\":\"two\"}\n"));
3932 }
3933
3934 #[test]
3935 fn terminal_scalar_path_uses_the_explicit_source_alias() {
3936 let input = br#"{"rules":[{"id":"one"},{"id":"two"}]}"#;
3937 let source = JsonSource::new(
3938 vec![
3939 JsonPathSegment::ArrayWildcard,
3940 source_key("rules"),
3941 JsonPathSegment::ArrayWildcard,
3942 source_key("id"),
3943 ],
3944 Some("v".to_string()),
3945 );
3946
3947 let result =
3948 super::parse_json_document_to_lines(input, &source).expect("explicit scalar source alias should be preserved");
3949
3950 assert_eq!(
3951 result,
3952 vec![
3953 Bytes::from_static(b"{\"v\":\"one\"}\n"),
3954 Bytes::from_static(b"{\"v\":\"two\"}\n")
3955 ]
3956 );
3957 }
3958
3959 #[test]
3960 fn source_keys_follow_s3_case_sensitivity_rules() {
3961 let input = br#"{"Employees":[{"id":1}]}"#;
3962
3963 let unquoted = flatten_json_document_to_ndjson(input, &[source_key("employees")])
3964 .expect("unquoted source key should be case insensitive");
3965 let quoted_exact = flatten_json_document_to_ndjson(input, &[quoted_source_key("Employees")])
3966 .expect("exact quoted source key should match");
3967 let quoted = flatten_json_document_to_ndjson(input, &[quoted_source_key("employees")])
3968 .expect("missing quoted source key should not fail");
3969
3970 assert_eq!(unquoted, Bytes::from_static(b"{\"id\":1}\n"));
3971 assert_eq!(quoted_exact, Bytes::from_static(b"{\"id\":1}\n"));
3972 assert!(quoted.is_empty());
3973 }
3974
3975 #[test]
3976 fn ambiguous_unquoted_source_key_is_rejected() {
3977 let input = br#"{"Employees":[],"employees":[]}"#;
3978
3979 let error =
3980 flatten_json_document_to_ndjson(input, &[source_key("EMPLOYEES")]).expect_err("ambiguous source key should fail");
3981
3982 assert!(
3983 error
3984 .get_ref()
3985 .and_then(|source| source.downcast_ref::<SelectError>())
3986 .is_some_and(|error| *error == SelectError::AmbiguousFieldName)
3987 );
3988 }
3989
3990 #[test]
3991 fn unquoted_source_key_scan_honors_cancellation() {
3992 let mut object = serde_json::Map::new();
3993 for index in 0..=super::JSON_CANCELLATION_CHECK_KEYS {
3994 object.insert(format!("field-{index}"), serde_json::Value::Null);
3995 }
3996 let mut checkpoints = 0;
3997 let mut cancel_on_second_checkpoint = || {
3998 checkpoints += 1;
3999 if checkpoints == 2 {
4000 Err(std::io::Error::new(std::io::ErrorKind::Interrupted, SelectError::Canceled))
4001 } else {
4002 Ok(())
4003 }
4004 };
4005
4006 let error = remove_json_source_key_with_checkpoint(&mut object, "x", false, &mut cancel_on_second_checkpoint)
4007 .expect_err("key scan should stop at its second cancellation checkpoint");
4008
4009 assert_eq!(error.kind(), std::io::ErrorKind::Interrupted);
4010 assert_eq!(checkpoints, 2);
4011 assert!(
4012 error
4013 .get_ref()
4014 .and_then(|source| source.downcast_ref::<SelectError>())
4015 .is_some_and(|error| *error == SelectError::Canceled)
4016 );
4017 }
4018
4019 #[test]
4020 fn long_json_key_comparison_honors_cancellation() {
4021 let key = "x".repeat(super::JSON_CANCELLATION_CHECK_BYTES * 2);
4022 let mut checkpoints = 0;
4023 let mut cancel_on_second_checkpoint = || {
4024 checkpoints += 1;
4025 if checkpoints == 2 {
4026 Err(std::io::Error::new(std::io::ErrorKind::Interrupted, SelectError::Canceled))
4027 } else {
4028 Ok(())
4029 }
4030 };
4031
4032 let error = json_key_eq_ignore_ascii_case_with_checkpoint(&key, &key, &mut cancel_on_second_checkpoint)
4033 .expect_err("long-key comparison should stop at its second cancellation checkpoint");
4034
4035 assert_eq!(error.kind(), std::io::ErrorKind::Interrupted);
4036 assert_eq!(checkpoints, 2);
4037 }
4038
4039 #[test]
4040 fn missing_source_key_produces_no_records() {
4041 let input = br#"{"employees":[]}"#;
4042
4043 let result = flatten_json_document_to_ndjson(input, &[source_key("nonexistent")])
4044 .expect("missing source key should not fail the query");
4045
4046 assert!(result.is_empty());
4047 }
4048
4049 #[tokio::test]
4050 async fn source_path_type_mismatches_are_json_parsing_errors() {
4051 let cases: [(&str, &[u8], Vec<JsonPathSegment>); 4] = [
4052 ("key on array", b"[1]", vec![source_key("id")]),
4053 ("index on object", b"{}", vec![JsonPathSegment::Index(0)]),
4054 (
4055 "array wildcard on object",
4056 b"{}",
4057 vec![JsonPathSegment::ArrayWildcard, JsonPathSegment::ArrayWildcard],
4058 ),
4059 ("object wildcard on array", b"[1]", vec![JsonPathSegment::ObjectWildcard]),
4060 ];
4061
4062 for (case, input, path) in cases {
4063 let memory_pool: Arc<dyn MemoryPool> = Arc::new(GreedyMemoryPool::new(JSON_DOCUMENT_TEST_MEMORY_BYTES));
4064 let mut output = json_document_ndjson_stream(
4065 Box::new(std::io::Cursor::new(input.to_vec())),
4066 input.len() as u64,
4067 JsonSource::from_path(path),
4068 Arc::new(SelectInputMetrics::default()),
4069 memory_pool,
4070 None,
4071 )
4072 .expect("build source-path JSON document stream");
4073 let source = output
4074 .next()
4075 .await
4076 .unwrap_or_else(|| panic!("{case} should produce one stream error"))
4077 .unwrap_err();
4078 let error = QueryError::from(DataFusionError::ObjectStore(Box::new(source)));
4079
4080 assert_eq!(error.select_error(), SelectError::JsonParsingError, "{case}");
4081 assert!(output.next().await.is_none(), "{case}");
4082 }
4083 }
4084}