Skip to main content

rustfs_s3select_api/
object_store.rs

1// Copyright 2024 RustFS Team
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use 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
87/// Maximum decoded input accepted for JSON DOCUMENT mode.
88///
89/// Root arrays are parsed incrementally, while a root object or scalar must fit
90/// in the query memory pool as one logical record. The hard cap also bounds
91/// compressed input after decompression.
92pub 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
104/// Returns true for the MinIO-compatible full-scan range marker.
105pub 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    /// True when the JSON input type is DOCUMENT (multi-line formatted JSON).
114    /// In that case the input is incrementally framed into NDJSON rows before
115    /// being handed to DataFusion's Arrow JSON reader.
116    is_json_document: bool,
117    /// JSON source path produced by the SQL compatibility analyzer.
118    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        // Detect JSON DOCUMENT type: the entire file is a single (possibly
301        // multi-line) JSON object/array, NOT newline-delimited JSON.
302        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
510/// Preserves the pre-typed-path single-key behavior of public legacy constructors.
511pub(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        // SelectObjectContent has no version-id input. For direct ObjectStore
803        // compatibility, a version supplied on the first operation defines
804        // this instance's immutable snapshot; later operations reuse it.
805        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            // Size validation is eager; input and row production remain lazy.
925            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    // DataFusion's CSV reader treats CRLF as a record terminator.
1121    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(&quoted_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                // The range reader includes one byte of delimiter context and a
2960                // separate header read; offsets always refer to the original CSV.
2961                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    /// A JSON array is split into one NDJSON line per element.
3650    #[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        // Each line must be valid JSON
3658        for line in &lines {
3659            serde_json::from_str::<serde_json::Value>(line).expect("each line must be valid JSON");
3660        }
3661        // Spot-check field values
3662        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    /// A single JSON object emits exactly one NDJSON line.
3668    #[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    /// An empty JSON array produces empty output (zero bytes).
3681    #[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    /// A multi-line (pretty-printed) JSON document is flattened correctly.
3689    #[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    /// Nested objects inside array elements are preserved as compact single-line JSON.
3698    #[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        // Each line must not contain a newline mid-value
3706        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    /// Each output line ends with exactly one newline (no blank lines between records).
3714    #[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        // Exactly 2 newlines for 2 records
3720        assert_eq!(text.chars().filter(|&c| c == '\n').count(), 2);
3721        // No leading blank line
3722        assert!(!text.starts_with('\n'));
3723    }
3724
3725    /// Invalid JSON returns an `InvalidData` IO error.
3726    #[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    /// Completely empty input returns an error (not valid JSON).
3766    #[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}