Method config_entries

datafusion/execution/src/runtime_env.rs:236–322

Returns the current runtime configuration entries

(&self)

    /// Returns the current runtime configuration entries
    pub fn config_entries(&self) -> Vec<ConfigEntry> {
        use crate::memory_pool::MemoryLimit;

        /// Convert bytes to a human-readable format
        fn format_byte_size(size: u64) -> String {
            const GB: u64 = 1024 * 1024 * 1024;
            const MB: u64 = 1024 * 1024;
            const KB: u64 = 1024;

            match size {
                s if s >= GB => format!("{}G", s / GB),
                s if s >= MB => format!("{}M", s / MB),
                s if s >= KB => format!("{}K", s / KB),
                s => format!("{s}"),
            }
        }

        fn format_duration(duration: Duration) -> String {
            let total = duration.as_secs();
            let mins = total / 60;
            let secs = total % 60;

            format!("{mins}m{secs}s")
        }

        let memory_limit_value = match self.memory_pool.memory_limit() {
            MemoryLimit::Finite(size) => Some(format_byte_size(
                size.try_into()
                    .expect("Memory limit size conversion failed"),
            )),
            MemoryLimit::Infinite => Some("unlimited".to_string()),
            MemoryLimit::Unknown => None,
        };

        let max_temp_dir_size = self.disk_manager.max_temp_directory_size();
        let max_temp_dir_value = format_byte_size(max_temp_dir_size);

        let temp_paths = self.disk_manager.temp_dir_paths();
        let temp_dir_value = if temp_paths.is_empty() {
            None
        } else {
            Some(
                temp_paths
                    .iter()
                    .map(|p| p.display().to_string())
                    .collect::<Vec<_>>()
                    .join(","),
            )
        };

        let metadata_cache_limit = self.cache_manager.get_metadata_cache_limit();
        let metadata_cache_value = format_byte_size(
            metadata_cache_limit
                .try_into()
                .expect("Metadata cache size conversion failed"),
        );

        let list_files_cache_limit = self.cache_manager.get_list_files_cache_limit();