Struct datafusion::common::DFSchema

pub struct DFSchema { /* private fields */ }

DFSchema wraps an Arrow schema and adds relation names.

The schema may hold the fields across multiple tables. Some fields may be qualified and some unqualified. A qualified field is a field that has a relation name associated with it.

Unqualified fields must be unique not only amongst themselves, but also must have a distinct name from any qualified field names. This allows finding a qualified field by name to be possible, so long as there aren’t multiple qualified fields with the same name.

There is an alias to Arc<DFSchema> named DFSchemaRef.

Creating qualified schemas

Use DFSchema::try_from_qualified_schema to create a qualified schema from an Arrow schema.

use datafusion_common::{DFSchema, Column};
use arrow_schema::{DataType, Field, Schema};

let arrow_schema = Schema::new(vec![
   Field::new("c1", DataType::Int32, false),
]);

let df_schema = DFSchema::try_from_qualified_schema("t1", &arrow_schema).unwrap();
let column = Column::from_qualified_name("t1.c1");
assert!(df_schema.has_column(&column));

// Can also access qualified fields with unqualified name, if it's unambiguous
let column = Column::from_qualified_name("c1");
assert!(df_schema.has_column(&column));

Creating unqualified schemas

Create an unqualified schema using TryFrom:

use datafusion_common::{DFSchema, Column};
use arrow_schema::{DataType, Field, Schema};

let arrow_schema = Schema::new(vec![
   Field::new("c1", DataType::Int32, false),
]);

let df_schema = DFSchema::try_from(arrow_schema).unwrap();
let column = Column::new_unqualified("c1");
assert!(df_schema.has_column(&column));

Converting back to Arrow schema

Use the Into trait to convert DFSchema into an Arrow schema:

use datafusion_common::{DFSchema, DFField};
use arrow_schema::Schema;
use std::collections::HashMap;

let df_schema = DFSchema::new_with_metadata(vec![
   DFField::new_unqualified("c1", arrow::datatypes::DataType::Int32, false),
], HashMap::new()).unwrap();
let schema = Schema::from(df_schema);
assert_eq!(schema.fields().len(), 1);

Implementations

impl DFSchema

pub fn empty() -> DFSchema

Creates an empty DFSchema

pub fn new_with_metadata( fields: Vec<DFField>, metadata: HashMap<String, String> ) -> Result<DFSchema, DataFusionError>

Create a new DFSchema

pub fn try_from_qualified_schema<'a>( qualifier: impl Into<TableReference<'a>>, schema: &Schema ) -> Result<DFSchema, DataFusionError>

Create a DFSchema from an Arrow schema and a given qualifier

To create a schema from an Arrow schema without a qualifier, use DFSchema::try_from.

pub fn with_functional_dependencies( self, functional_dependencies: FunctionalDependencies ) -> Result<DFSchema, DataFusionError>

Assigns functional dependencies.

pub fn join(&self, schema: &DFSchema) -> Result<DFSchema, DataFusionError>

Create a new schema that contains the fields from this schema followed by the fields from the supplied schema. An error will be returned if there are duplicate field names.

pub fn merge(&mut self, other_schema: &DFSchema)

Modify this schema by appending the fields from the supplied schema, ignoring any duplicate fields.

pub fn fields(&self) -> &Vec<DFField>

Get a list of fields

pub fn field(&self, i: usize) -> &DFField

Returns an immutable reference of a specific Field instance selected using an offset within the internal fields vector

pub fn index_of_column_by_name( &self, qualifier: Option<&TableReference<'_>>, name: &str ) -> Result<Option<usize>, DataFusionError>

pub fn index_of_column(&self, col: &Column) -> Result<usize, DataFusionError>

Find the index of the column with the given qualifier and name

pub fn is_column_from_schema( &self, col: &Column ) -> Result<bool, DataFusionError>

Check if the column is in the current schema

pub fn field_with_name( &self, qualifier: Option<&TableReference<'_>>, name: &str ) -> Result<&DFField, DataFusionError>

Find the field with the given name

pub fn fields_with_qualified( &self, qualifier: &TableReference<'_> ) -> Vec<&DFField>

Find all fields having the given qualifier

pub fn fields_indices_with_qualified( &self, qualifier: &TableReference<'_> ) -> Vec<usize>

Find all fields indices having the given qualifier

pub fn fields_with_unqualified_name(&self, name: &str) -> Vec<&DFField>

Find all fields match the given name

pub fn field_with_unqualified_name( &self, name: &str ) -> Result<&DFField, DataFusionError>

Find the field with the given name

pub fn field_with_qualified_name( &self, qualifier: &TableReference<'_>, name: &str ) -> Result<&DFField, DataFusionError>

Find the field with the given qualified name

pub fn field_from_column( &self, column: &Column ) -> Result<&DFField, DataFusionError>

Find the field with the given qualified column

pub fn has_column_with_unqualified_name(&self, name: &str) -> bool

Find if the field exists with the given name

pub fn has_column_with_qualified_name( &self, qualifier: &TableReference<'_>, name: &str ) -> bool

Find if the field exists with the given qualified name

pub fn has_column(&self, column: &Column) -> bool

Find if the field exists with the given qualified column

pub fn matches_arrow_schema(&self, arrow_schema: &Schema) -> bool

Check to see if unqualified field names matches field names in Arrow schema

pub fn check_arrow_schema_type_compatible( &self, arrow_schema: &Schema ) -> Result<(), DataFusionError>

Check to see if fields in 2 Arrow schemas are compatible

pub fn logically_equivalent_names_and_types(&self, other: &DFSchema) -> bool

Returns true if the two schemas have the same qualified named fields with logically equivalent data types. Returns false otherwise.

Use DFSchema::equivalent_names_and_types for stricter semantic type equivalence checking.

pub fn equivalent_names_and_types(&self, other: &DFSchema) -> bool

Returns true if the two schemas have the same qualified named fields with the same data types. Returns false otherwise.

This is a specialized version of Eq that ignores differences in nullability and metadata.

Use DFSchema::logically_equivalent_names_and_types for a weaker logical type checking, which for example would consider a dictionary encoded UTF8 array to be equivalent to a plain UTF8 array.

pub fn strip_qualifiers(self) -> DFSchema

Strip all field qualifier in schema

pub fn replace_qualifier( self, qualifier: impl Into<TableReference<'static>> ) -> DFSchema

Replace all field qualifier with new value in schema

pub fn field_names(&self) -> Vec<String>

Get list of fully-qualified field names in this schema

pub fn metadata(&self) -> &HashMap<String, String>

Get metadata of this schema

pub fn functional_dependencies(&self) -> &FunctionalDependencies

Get functional dependencies

Trait Implementations

impl Clone for DFSchema

fn clone(&self) -> DFSchema

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DFSchema

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Display for DFSchema

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl ExprSchema for DFSchema

fn nullable(&self, col: &Column) -> Result<bool, DataFusionError>

Is this column reference nullable?

fn data_type(&self, col: &Column) -> Result<&DataType, DataFusionError>

What is the datatype of this column?

fn metadata( &self, col: &Column ) -> Result<&HashMap<String, String>, DataFusionError>

Returns the column’s optional metadata.

fn data_type_and_nullable( &self, col: &Column ) -> Result<(&DataType, bool), DataFusionError>

Return the coulmn’s datatype and nullability

impl From<&DFSchema> for Schema

fn from(df_schema: &DFSchema) -> Schema

Convert DFSchema reference into a Schema

impl From<DFSchema> for Arc<Schema>

fn from(df_schema: DFSchema) -> Arc<Schema>

Converts to this type from the input type.

impl From<DFSchema> for Schema

fn from(df_schema: DFSchema) -> Schema

Convert DFSchema into a Schema

impl Hash for DFSchema

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DFSchema

fn eq(&self, other: &DFSchema) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<Schema> for DFSchema

Create a DFSchema from an Arrow schema

type Error = DataFusionError

The type returned in the event of a conversion error.

fn try_from( schema: Schema ) -> Result<DFSchema, <DFSchema as TryFrom<Schema>>::Error>

Performs the conversion.

impl Eq for DFSchema

impl StructuralPartialEq for DFSchema