Method infer_schema

datafusion/datasource-json/src/file_format.rs:255–332

(
        &self,
        _state: &dyn Session,
        store: &Arc<dyn ObjectStore>,
        objects: &[ObjectMeta],
    )

    }

    async fn infer_schema(
        &self,
        _state: &dyn Session,
        store: &Arc<dyn ObjectStore>,
        objects: &[ObjectMeta],
    ) -> Result<SchemaRef> {
        let mut schemas = Vec::new();
        let mut records_to_read = self
            .options
            .schema_infer_max_rec
            .unwrap_or(DEFAULT_SCHEMA_INFER_MAX_RECORD);
        let file_compression_type = FileCompressionType::from(self.options.compression);
        let newline_delimited = self.options.newline_delimited;

        for object in objects {
            // Early exit if we've read enough records
            if records_to_read == 0 {
                break;
            }

            let r = store.as_ref().get(&object.location).await?;

            let (schema, records_consumed) = match r.payload {
                #[cfg(not(target_arch = "wasm32"))]
                GetResultPayload::File(file, _) => {
                    let decoder = file_compression_type.convert_read(file)?;
                    let reader = BufReader::new(decoder);

                    if newline_delimited {
                        // NDJSON: use ValueIter directly
                        let iter = ValueIter::new(reader, None);
                        let mut count = 0;
                        let schema =
                            infer_json_schema_from_iterator(iter.take_while(|_| {
                                let should_take = count < records_to_read;
                                if should_take {
                                    count += 1;
                                }
                                should_take
                            }))?;
                        (schema, count)
                    } else {
                        // JSON array format: use streaming converter
                        infer_schema_from_json_array(reader, records_to_read)?
                    }
                }
                GetResultPayload::Stream(_) => {
                    let data = r.bytes().await?;
                    let decoder = file_compression_type.convert_read(data.reader())?;
                    let reader = BufReader::new(decoder);

                    if newline_delimited {
                        let iter = ValueIter::new(reader, None);
                        let mut count = 0;
                        let schema =
                            infer_json_schema_from_iterator(iter.take_while(|_| {
                                let should_take = count < records_to_read;
                                if should_take {