fn get_statistics()

in rust/driver/dummy/src/lib.rs [637:747]
105 lines of code
1 McCabe index (conditional complexity)

    fn get_statistics(
        &self,
        _catalog: Option<&str>,
        _db_schema: Option<&str>,
        _table_name: Option<&str>,
        _approximate: bool,
    ) -> Result<impl RecordBatchReader> {
        let statistic_value_int64_array = Int64Array::from(Vec::<i64>::new());
        let statistic_value_uint64_array = UInt64Array::from(vec![42]);
        let statistic_value_float64_array = Float64Array::from(Vec::<f64>::new());
        let statistic_value_binary_array = BinaryArray::from(Vec::<&[u8]>::new());
        let type_id_buffer = [1_i8].into_iter().collect::<ScalarBuffer<i8>>();
        let value_offsets_buffer = [0_i32].into_iter().collect::<ScalarBuffer<i32>>();
        let statistic_value_array = UnionArray::try_new(
            UnionFields::new(
                [0, 1, 2, 3],
                [
                    Field::new("int64", DataType::Int64, true),
                    Field::new("uint64", DataType::UInt64, true),
                    Field::new("float64", DataType::Float64, true),
                    Field::new("binary", DataType::Binary, true),
                ],
            ),
            type_id_buffer,
            Some(value_offsets_buffer),
            vec![
                Arc::new(statistic_value_int64_array),
                Arc::new(statistic_value_uint64_array),
                Arc::new(statistic_value_float64_array),
                Arc::new(statistic_value_binary_array),
            ],
        )?;

        let db_schema_statistics_array_inner = StructArray::from(vec![
            (
                Arc::new(Field::new("table_name", DataType::Utf8, false)),
                Arc::new(StringArray::from(vec!["default"])) as ArrayRef,
            ),
            (
                Arc::new(Field::new("column_name", DataType::Utf8, true)),
                Arc::new(StringArray::from(vec!["my_column"])) as ArrayRef,
            ),
            (
                Arc::new(Field::new("statistic_key", DataType::Int16, false)),
                Arc::new(Int16Array::from(vec![Into::<i16>::into(
                    Statistics::AverageByteWidth,
                )])) as ArrayRef,
            ),
            (
                Arc::new(Field::new(
                    "statistic_value",
                    schemas::STATISTIC_VALUE_SCHEMA.clone(),
                    false,
                )),
                Arc::new(statistic_value_array) as ArrayRef,
            ),
            (
                Arc::new(Field::new(
                    "statistic_is_approximate",
                    DataType::Boolean,
                    false,
                )),
                Arc::new(BooleanArray::from(vec![false])) as ArrayRef,
            ),
        ]);

        let db_schema_statistics_array = ListArray::new(
            Arc::new(Field::new("item", schemas::STATISTICS_SCHEMA.clone(), true)),
            OffsetBuffer::new(ScalarBuffer::from(vec![0, 1])),
            Arc::new(db_schema_statistics_array_inner),
            None,
        );

        let catalog_db_schemas_array_inner = StructArray::from(vec![
            (
                Arc::new(Field::new("db_schema_name", DataType::Utf8, true)),
                Arc::new(StringArray::from(vec!["default"])) as ArrayRef,
            ),
            (
                Arc::new(Field::new_list(
                    "db_schema_statistics",
                    Arc::new(Field::new("item", schemas::STATISTICS_SCHEMA.clone(), true)),
                    false,
                )),
                Arc::new(db_schema_statistics_array) as ArrayRef,
            ),
        ]);

        let catalog_name_array = StringArray::from(vec!["default"]);
        let catalog_db_schemas_array = ListArray::new(
            Arc::new(Field::new(
                "item",
                schemas::STATISTICS_DB_SCHEMA_SCHEMA.clone(),
                true,
            )),
            OffsetBuffer::new(ScalarBuffer::from(vec![0, 1])),
            Arc::new(catalog_db_schemas_array_inner),
            None,
        );

        let batch = RecordBatch::try_new(
            schemas::GET_STATISTICS_SCHEMA.clone(),
            vec![
                Arc::new(catalog_name_array),
                Arc::new(catalog_db_schemas_array),
            ],
        )?;

        let reader = SingleBatchReader::new(batch);
        Ok(reader)
    }