- **Array types**: ordered lists of any primitive type, e.g. `Array(Int64)`, `Array(String)`.

- **Set types**: unordered collections of unique values for any primitive type, e.g. `Set(String)`, `Set(Int64)`.

- **Map types**: dictionary-like structures with string keys and values that can be any supported Feast type (including nested maps), e.g. `Map`, `Array(Map)`.

For a complete reference with examples, see [Type System](../../reference/type-system.md).

Each feature or schema field in Feast is associated with a data type, which is stored in Feast's [registry](registry.md). These types are also used to ensure that Feast operates on values correctly (e.g. making sure that timestamp columns used for [point-in-time correct joins](point-in-time-joins.md) actually have the timestamp type).

As a result, each system that Feast interacts with needs a way to translate data types from the native platform into a Feast type. E.g., Snowflake SQL types are converted to Feast types [here](https://rtd.feast.dev/en/master/feast.html#feast.type_map.snowflake_python_type_to_feast_value_type). The onus is therefore on authors of offline or online store connectors to make sure that this type mapping happens correctly.

| Backend | Native Type | Feast Type |

|---------|-------------|------------|

| PostgreSQL | `jsonb[]` | `Array(Map)` |

| Snowflake | `VARIANT`, `OBJECT` | `Map` |

| Redshift | `SUPER` | `Map` |

| Spark | `map<string,string>` | `Map` |

| Spark | `array<map<string,string>>` | `Array(Map)` |

**Note**: Feast currently does *not* support a null type in its type system.

from feast import FeatureView, Field

validated_fv = FeatureView(

name="validated_features",

Field(name="trips_today", dtype=Int64),

Field(name="rating", dtype=Float32),

Field(name="preferences", dtype=Map),

],

source=my_source,

enable_validation=True, # enables schema checks

)

Validation is supported in all compute engines (Local, Spark, and Ray). When a required column is missing, a `ValueError` is raised. Type mismatches are logged as warnings but do not block execution, allowing for safe gradual adoption.

The `enable_validation` parameter is also available on `BatchFeatureView` and `StreamFeatureView`, as well as their respective decorators (`@batch_feature_view` and `@stream_feature_view`).

| `TIMESTAMP`, `DATETIME` | `UnixTimestamp` |

| `BYTES`, `BINARY` | `Bytes` |

| `ARRAY<type>` | `Array(type)` |

| `VARIANT`, `OBJECT` | `Map` |

| `SUPER` | `Map` |

| `MAP<string,string>` | `Map` |

Snowflake `NUMBER(precision, scale)` types are handled specially:

- Scale > 0: `Float64`

| BOOL\_LIST | `list[bool]`|

| MAP | `dict` (`Dict[str, Any]`)|

| MAP\_LIST | `list[dict]` (`List[Dict[str, Any]]`)|

Note that this mapping is non-injective, that is more than one Pandas type may corresponds to one Feast type (but not vice versa). In these cases, when converting Feast values to Pandas, the **first** Pandas type in the table above is used.

| BOOL\_LIST | `ARRAY<BOOL>`|

| MAP | `JSON` / `STRUCT` |

| MAP\_LIST | `ARRAY<JSON>` / `ARRAY<STRUCT>` |

Values that are not specified by the table above will cause an error on conversion.

| INT64 | `INT64 / UINT64` |

| DOUBLE | `FLOAT64` |

| MAP | `VARIANT` / `OBJECT` |

Here's how Feast types map to Redshift types when using Redshift for offline storage:

| FLOAT | `FLOAT4` / `REAL` |

| BOOL | `BOOL` |

| MAP | `SUPER` |

Note: Redshift's `SUPER` type stores semi-structured JSON data. During materialization, Feast automatically handles `SUPER` columns that are exported as JSON strings by parsing them back into Python dictionaries before converting to `MAP` proto values.

FeatureViewMeta meta = 2;

}

message FeatureViewSpec {

// Name of the feature view. Must be unique. Not updated.

// The transformation mode (e.g., "python", "pandas", "spark", "sql", "ray")

string mode = 16;

}

message FeatureViewMeta {

FeatureViewMeta meta = 2;

}

message StreamFeatureViewSpec {

// Name of the feature view. Must be unique. Not updated.

string name = 1;

// Hop size for tiling (e.g., 5 minutes). Determines the granularity of pre-aggregated tiles.

// If not specified, defaults to 5 minutes. Only used when enable_tiling is true.

google.protobuf.Duration tiling_hop_size = 19;

}

FLOAT_SET = 27;

BOOL_SET = 28;

UNIX_TIMESTAMP_SET = 29;

}

}

FloatSet float_set_val = 27;

BoolSet bool_set_val = 28;

Int64Set unix_timestamp_set_val = 29;

}

}

online=self.online,

offline=self.offline,

sink_source=self.batch_source if self.source_views else None,

)

# This is deliberately set outside of the FV initialization as we do not have the Entity objects.

else self.mode

)

return FeatureViewSpecProto(

name=self.name,

entities=self.entities,

entity_columns=[field.to_proto() for field in self.entity_columns],

features=[feature.to_proto() for feature in self.features],

description=self.description,

owner=self.owner,

ttl=(ttl_duration if ttl_duration is not None else None),

online=self.online,

source_views=source_view_protos,

feature_transformation=feature_transformation_proto,

mode=mode_str,

)

def to_proto_meta(self):

f"Entities: {feature_view.entities} vs Entity Columns: {feature_view.entity_columns}"

)

# FeatureViewProjections are not saved in the FeatureView proto.

# Create the default projection.

from typing import Dict, Optional

from typeguard import typechecked

from feast.feature import Feature

from feast.protos.feast.core.Feature_pb2 import FeatureSpecV2 as FieldProto

from feast.value_type import ValueType

class Field:

"""Converts a Field object to its protobuf representation."""

value_type = self.dtype.to_value_type()

vector_search_metric = self.vector_search_metric or ""

return FieldProto(

name=self.name,

value_type=value_type.value,

description=self.description,

vector_index=self.vector_index,

vector_length=self.vector_length,

vector_search_metric=vector_search_metric,

value_type = ValueType(field_proto.value_type)

vector_search_metric = getattr(field_proto, "vector_search_metric", "")

vector_index = getattr(field_proto, "vector_index", False)

vector_length = getattr(field_proto, "vector_length", 0)

return cls(

name=field_proto.name,

description=field_proto.description,

vector_index=vector_index,

vector_length=vector_length,

description=feature.description,

tags=feature.labels,

)