# IDataView Type System¶

## Overview¶

The IDataView system consists of a set of interfaces and classes that provide efficient, compositional transformation of and cursoring through schematized data, as required by many machine-learning and data analysis applications. It is designed to gracefully and efficiently handle both extremely high dimensional data and very large data sets. It does not directly address distributed data, but is suitable for single node processing of data partitions belonging to larger distributed data sets.

While IDataView is one interface in this system, colloquially, the term IDataView is frequently used to refer to the entire system. In this document, the specific interface is written using fixed pitch font as IDataView.

IDataView is the data pipeline machinery for ML.NET. The ML.NET codebase has an extensive library of IDataView related components (loaders, transforms, savers, trainers, predictors, etc.). More are being worked on.

The name IDataView was inspired from the database world, where the term table typically indicates a mutable body of data, while a view is the result of a query on one or more tables or views, and is generally immutable. Note that both tables and views are schematized, being organized into typed columns and rows conforming to the column types. Views differ from tables in several ways:

• Views are immutable; tables are mutable.
• Views are composable – new views can be formed by applying transformations (queries) to other views. Forming a new table from an existing table involves copying data, making them decoupled—the new table is not linked to the original table in any way.
• Views are virtual; tables are fully realized/persisted.

Note that immutability and compositionality are critical enablers of technologies that require reasoning over transformation, like query optimization and remoting. Immutability is also key for concurrency and thread safety.

This document includes a very brief introduction to some of the basic concepts of IDataView, but then focuses primarily on the IDataView type system.

Why does IDataView need a special type system? The .NET type system is not well suited to machine-learning and data analysis needs. For example, while one could argue that typeof(double[]) indicates a vector of double values, it explicitly does not include the dimensionality of the vector/array. Similarly, there is no good way to indicate a subset of an integer type, for example integers from 1 to 100, as a .NET type. In short, there is no reasonable way to encode complete range and dimensionality information in a System.Type.

In addition, a well-defined type system, including complete specification of standard data types and conversions, enables separately authored components to seamlessly work together without surprises.

### Basic Concepts¶

IDataView, in the narrow sense, is an interface implemented by many components. At a high level, it is analogous to the .Net interface IEnumerable<T>, with some very significant differences.

While IEnumerable<T> is a sequence of objects of type T, IDataView is a sequence of rows. An IDataView object has an associated ISchema object that defines the IDataView’s columns, including their names, types, indices, and associated metadata. Each row of the IDataView has a value for each column defined by the schema.

Just as IEnumerable<T> has an associated enumerator interface, namely IEnumerator<T>, IDataView has an associated cursor interface, namely IRowCursor. In the enumerable world, an enumerator object implements a Current property that returns the current value of the iteration as an object of type T. In the IDataView world, an IRowCursor object encapsulates the current row of the iteration. There is no separate object that represents the current row. Instead, the cursor implements methods that provide the values of the current row, when requested. Additionally, the methods that serve up values do not require memory allocation on each invocation, but use sharable buffers. This scheme significantly reduces the memory allocations needed to cursor through data.

Both IDataView and IEnumerable<T> present a read-only view on data, in the sense that a sequence presented by each is not directly mutable. “Modifications” to the sequence are accomplished by additional operators or transforms applied to the sequence, so do not modify any underlying data. For example, to normalize a numeric column in an IDataView object, a normalization transform is applied to the sequence to form a new IDataView object representing the composition. In the new view, the normalized values are contained in a new column. Often, the new column has the same name as the original source column and “replaces” the source column in the new view. Columns that are not involved in the transformation are simply “passed through” from the source IDataView to the new one.

Detailed specifications of the IDataView, ISchema, and IRowCursor interfaces are in other documents.

### Column Types¶

Each column in an IDataView has an associated column type. The collection of column types is open, in the sense that new code can introduce new column types without requiring modification of all IDataView related components. While introducing new types is possible, we expect it will also be relatively rare.

All column type implementations derive from the abstract class ColumnType. Primitive column types are those whose implementation derives from the abstract class PrimitiveType, which derives from ColumnType.

### Representation Type¶

A column type has an associated .Net type, known as its representation type or raw type.

Note that a column type often contains much more information than the associated .Net representation type. Moreover, many distinct column types can use the same representation type. Consequently, code should not assume that a particular .Net type implies a particular column type.

### Standard Column Types¶

There is a set of predefined standard column types, divided into standard primitive types and vector types. Note that there can be types that are neither primitive nor vector types. These types are not standard types and may require extra care when handling them. For example, a PictureType value might require disposing when it is no longer needed.

Standard primitive types include the text type, the boolean type, numeric types, and key types. Numeric types are further split into floating-point types, signed integer types, and unsigned integer types.

A vector type has an associated item type that must be a primitive type, but need not be a standard primitive type. Note that vector types are not primitive types, so vectors of vectors are not supported. Note also that vectors are homogeneous—all elements are of the same type. In addition to its item type, a vector type contains dimensionality information. At the basic level, this dimensionality information indicates the length of the vector type. A length of zero means that the vector type is variable length, that is, different values may have different lengths. Additional detail of vector types is in a subsequent section. Vector types are instances of the sealed class VectorType, which derives from ColumnType.

This document uses convenient shorthand for standard types:

• TX: text
• BL: boolean
• R4, R8: single and double precision floating-point
• I1, I2, I4, I8: signed integer types with the indicated number of bytes
• U1, U2, U4, U8: unsigned integer types with the indicated number of bytes
• UG: unsigned type with 16-bytes, typically used as a unique ID
• TS: timespan, a period of time
• DT: datetime, a date and time but no timezone
• DZ: datetime zone, a date and time with a timezone
• U4[100-199]: A key type based on U4 representing legal values from 100 to 199, inclusive
• V<R4,3,2>: A vector type with item type R4 and dimensionality information [3,2]

See the sections on the specific types for more detail.

The IDataView system includes many standard conversions between standard primitive types. A later section contains a full specification of these conversions.

### Default Value¶

Each column type has an associated default value corresponding to the default value of its representation type, as defined by the .Net (C# and CLR) specifications.

The standard conversions map source default values to destination default values. For example, the standard conversion from TX to R8 maps the empty text value to the value zero. Note that the empty text value is distinct from the missing text value, as discussed next.

### Missing Value¶

Most of the standard primitive types support the notion of a missing value. In particular, the text type, floating-point types, signed integer types, and key types all have an internal representation of missing. We follow R’s lead and denote such values as NA.

Unlike R, the standard primitive types do not distinguish between missing and invalid. For example, in floating-point arithmetic, computing zero divided by zero, or infinity minus infinity, produces an invalid value known as a NaN (for Not-a-Number). R uses a specific NaN value to represent its NA value, with all other NaN values indicating invalid. The IDataView standard floating-point types do not distinguish between the various NaN values, treating them all as missing/invalid.

A standard conversion from a source type with NA to a destination type with NA maps NA to NA. A standard conversion from a source type with NA to a destination type without NA maps NA to the default value of the destination type. For example, converting a text NA value to R4 produces a NaN, but converting a text NA to U4 results in zero. Note that this specification does not address diagnostic user messages, so, in certain environments, the latter situation may generate a warning to the user.

Note that a vector type does not support a representation of missing, but may contain NA values of its item type. Generally, there is no standard mechanism faster than O(N) for determining whether a vector with N items contains any missing values.

For further details on missing value representations, see the sections detailing the particular standard primitive types.

### Vector Representations¶

Values of a vector type may be represented either sparsely or densely. A vector type does not mandate denseness or sparsity, nor does it imply that one is favored over the other. A sparse representation is semantically equivalent to a dense representation having the suppressed entries filled in with the default value of the item type. Note that the values of the suppressed entries are emphatically not the missing/NA value of the item type, unless the missing and default values are identical, as they are for key types.

A column in an ISchema can have additional column-wide information, known as metadata. For each string value, known as a metadata kind, a column may have a value associated with that metadata kind. The value also has an associated type, which is a compatible column type.

For example:

• A column may indicate that it is normalized, by providing a BL valued piece of metadata named IsNormalized.
• A column whose type is V<R4,17>, meaning a vector of length 17 whose items are single-precision floating-point values, might have SlotNames metadata of type V<TX,17>, meaning a vector of length 17 whose items are text.
• A column produced by a scorer may have several pieces of associated metadata, indicating the “scoring column group id” that it belongs to, what kind of scorer produced the column (for example, binary classification), and the precise semantics of the column (for example, predicted label, raw score, probability).

The ISchema interface, including the metadata API, is fully specified in another document.

## Text Type¶

The text type, denoted by the shorthand TX, represents text values. The TextType class derives from PrimitiveType and has a single instance, exposed as TextType.Instance. The representation type of TX is an immutable struct known as DvText. A DvText value represents a sequence of characters whose length is contained in its Length field. The missing/NA value has a Length of -1, while all other values have a non-negative Length. The default value has a Length of zero and represents an empty sequence of characters.

In text processing transformations, it is very common to split text into pieces. A key advantage of using DvText instead of System.String for text values is that these splits require no memory allocation—the derived DvText references the same underlying System.String as the original DvText does. Another reason that System.String is not ideal for text is that we want the default value to be empty and not NA. For System.String, the default value is null, which would be a more natural representation for NA than for empty text. By using a custom struct wrapper around a portion (or span) of a System.String, we address both the memory efficiency and default value problems.

## Boolean Type¶

The standard boolean type, denoted by the shorthand BL, represents true/false values. The BooleanType class derives from PrimitiveType and has a single instance, exposed as BooleanType.Instance. The representation type of BL is the DvBool enumeration type, logically stored as sbyte:

DvBool | sbyte Value ——–:|:————- NA | -128 False | 0 True | 1

The default value of BL is DvBool.False and the NA value of BL is DvBool.NA. Note that the underlying type of the DvBool enum is signed byte and the default and NA values of BL align with the default and NA values of I1.

There is a standard conversion from TX to BL. There are standard conversions from BL to all signed integer and floating point numeric types, with DvBool.False mapping to zero, DvBool.True mapping to one, and DvBool.NA mapping to NA.

## Number Types¶

The standard number types are all instances of the sealed class NumberType, which is derived from PrimitiveType. There are two standard floating-point types, four standard signed integer types, and four standard unsigned integer types. Each of these is represented by a single instance of NumberType and there are static properties of NumberType to access each instance. For example, to test whether a variable type represents I4, use the C# code type == NumberType.I4.

Floating-point arithmetic has a well-deserved reputation for being troublesome. This is primarily because it is imprecise, in the sense that the result of most operations must be rounded to the nearest representable value. This rounding means, among other side effects, that floating-point addition and multiplication are not associate, nor satisfy the distributive property.

However, in many ways, floating-point arithmetic is the best-suited system for arithmetic computation. For example, the IEEE 754 specification mandates precise graceful overflow behavior—as results grow, they lose resolution in the least significant digits, and eventually overflow to a special infinite value. In contrast, when integer arithmetic overflows, the result is a non- sense value. Trapping and handling integer overflow is expensive, both in runtime and development costs.

The IDataView system supports integer numeric types mostly for data interchange convenience, but we strongly discourage performing arithmetic on those values without first converting to floating-point.

### Floating-point Types¶

The floating-point types, R4 and R8, have representation types System.Single and System.Double. Their default values are zero. Any NaN is considered an NA value, with the specific Single.NaN and Double.NaN values being the canonical NA values.

There are standard conversions from each floating-point type to the other floating-point type. There are also standard conversions from text to each floating-point type and from each integer type to each floating-point type.

### Signed Integer Types¶

The signed integer types, I1, I2, I4, and I8, have representation types Sytem.SByte, System.Int16, System.Int32, and System.Int64. The default value of each of these is zero. Each of these has a non-zero value that is its own additive inverse, namely (-2)^^{8n-1}, where n is the number of bytes in the representation type. This is the minimum value of each of these types. We follow R’s lead and use these values as the NA values.

There are standard conversions from each signed integer type to every other signed integer type. There are also standard conversions from text to each signed integer type and from each signed integer type to each floating-point type.

Note that we have not defined standard conversions from floating-point types to signed integer types.

### Unsigned Integer Types¶

The unsigned integer types, U1, U2, U4, and U8, have representation types Sytem.Byte, System.UInt16, System.UInt32, and System.UInt64, respectively. The default value of each of these is zero. These types do not have an NA value.

There are standard conversions from each unsigned integer type to every other unsigned integer type. There are also standard conversions from text to each unsigned integer type and from each unsigned integer type to each floating- point type.

Note that we have not defined standard conversions from floating-point types to unsigned integer types, or between signed integer types and unsigned integer types.

## Key Types¶

Key types are used for data that is represented numerically, but where the order and/or magnitude of the values is not semantically meaningful. For example, hash values, social security numbers, and the index of a term in a dictionary are all best modeled with a key type.

The representation type of a key type, also called its underlying type, must be one of the standard four .Net unsigned integer types. The NA and default values of a key type are the same value, namely the representational value zero.

Key types are instances of the sealed class KeyType, which derives from PrimitiveType.

In addition to its underlying type, a key type specifies:

• A count value, between 0 and int.MaxValue, inclusive
• A “minimum” value, between 0 and ulong.MaxValue, inclusive
• A Boolean value indicating whether the values of the key type are contiguous

Regardless of the minimum and count values, the representational value zero always means NA and the representational value one is always the first valid value of the key type.

Notes:

• The Count property returns the count of the key type. This is of type int, but is required to be non-negative. When Count is zero, the key type has no known or useful maximum value. Otherwise, the legal representation values are from one up to and including Count. The Count is required to be representable in the underlying type, so, for example, the Count value of a key type based on System.Byte must not exceed 255. As an example of the usefulness of the Count property, consider the KeyToVector transform implemented as part of ML.NET. It maps from a key type value to an indicator vector. The length of the vector is the Count of the key type, which is required to be positive. For a key value of k, with 1 ≤ k ≤ Count, the resulting vector has a value of one in the (k-1)th slot, and zero in all other slots. An NA value (with representation zero) is mapped to the all- zero vector of length Count.
• For a key type with positive Count, a representation value should be between 0 and Count, inclusive, with 0 meaning NA. When processing values from an untrusted source, it is best to guard against values bigger than Count and treat such values as equivalent to NA.
• The Min property returns the minimum semantic value of the key type. This is used exclusively for transforming from a representation value, where the valid values start at one, to user facing values, which might start at any non-negative value. The most common values for Min are zero and one.
• The boolean Contiguous property indicates whether values of the key type are generally contiguous in the sense that a complete sampling of representation values of the key type would cover most, if not all, values from one up to their max. A true value indicates that using an array to implement a map from the key type values is a reasonable choice. When false, it is likely more prudent to use a hash table.
• A key type can be non-Contiguous only if Count is zero. The converse however is not true. A key type that is contiguous but has Count equal to zero is one where there is a reasonably small maximum, but that maximum is unknown. In this case, an array might be a good choice for a map from the key type.
• The shorthand for a key type with representation type U1, and semantic values from 1000 to 1099, inclusive, is U1[1000-1099]. Note that the Min value of this key type is outside the range of the underlying type, System.Byte, but the Count value is only 100, which is representable in a System.Byte. Recall that the representation values always start at 1 and extend up to Count, in this case 100.
• For a key type with representation type System.UInt32 and semantic values starting at 1000, with no known maximum, the shorthand is U4[1000-*].

There are standard conversions from text to each key type. This conversion parses the text as a standard non-negative integer value and honors the Min and Count values of the key type. If a parsed numeric value falls outside the range indicated by Min and Count, or if the text is not parsable as a non-negative integer, the result is NA.

There are standard conversions from one key type to another, provided:

• The source and destination key types have the same Min and Count values.
• Either the number of bytes in the destination’s underlying type is greater than the number of bytes in the source’s underlying type, or the Count value is positive. In the latter case, the Count is necessarily less than 2k, where k is the number of bits in the destination type’s underlying type. For example, U1[1-*] can be converted to U2[1-*], but U2[1-*] cannot be converted to U1[1-*]. Also, U1[1-100] and U2[1-100] can be converted in both directions.

## Vector Types¶

### Introduction¶

Vector types are one of the key innovations of the IDataView system and are critical for high dimensional machine-learning applications.

For example, when processing text, it is common to hash all or parts of the text and encode the resulting hash values, first as a key type, then as indicator or bag vectors using the KeyToVector transform. Using a k-bit hash produces a key type with Count equal to 2^^k, and vectors of the same length. It is common to use 20 or more hash bits, producing vectors of length a million or more. The vectors are typically very sparse. In systems that do not support vector-valued columns, each of these million or more values is placed in a separate (sparse) column, leading to a massive explosion of the column space. Most tabular systems are not designed to scale to millions of columns, and the user experience also suffers when displaying such data. Moreover, since the vectors are very sparse, placing each value in its own column means that, when a row is being processed, each of those sparse columns must be queried or scanned for its current value. Effectively the sparse matrix of values has been needlessly transposed. This is very inefficient when there are just a few (often one) non-zero entries among the column values. Vector types solve these issues.

A vector type is an instance of the sealed VectorType class, which derives from ColumnType. The vector type contains its ItemType, which must be a PrimitiveType, and its dimensionality information. The dimensionality information consists of one or more non-negative integer values. The VectorSize is the product of the dimensions. A dimension value of zero means that the true value of that dimension can vary from value to value.

For example, tokenizing a text by splitting it into multiple terms generates a vector of text of varying/unknown length. The result type shorthand is V<TX,*>. Hashing this using 6 bits then produces the vector type V<U4[0-63],*>. Applying the KeyToVector transform then produces the vector type V<R4,*,64>. Each of these vector types has a VectorSize of zero, indicating that the total number of slots varies, but the latter still has potentially useful dimensionality information: the vector slots are partitioned into an unknown number of runs of consecutive slots each of length 64.

As another example, consider an image data set. The data starts with a TX column containing URLs for images. Applying an ImageLoader transform generates a column of a custom (non-standard) type, Picture<*,*,4>, where the asterisks indicate that the picture dimensions are unknown. The last dimension of 4 indicates that there are four channels in each pixel: the three color components, plus the alpha channel. Applying an ImageResizer transform scales and crops the images to a specified size, for example, 100x100, producing a type of Picture<100,100,4>. Finally, applying a ImagePixelExtractor transform (and specifying that the alpha channel should be dropped), produces the vector type V<R4,3,100,100>. In this example, the ImagePixelExtractor re-organized the color information into separate planes, and divided each pixel value by 256 to get pixel values between zero and one.

### Equivalence¶

Note that two vector types are equivalent when they have equivalent item types and have identical dimensionality information. To test for compatibility, instead of equivalence, in the sense that the total VectorSize should be the same, use the SameSizeAndItem method instead of the Equals method (see the ColumnType code below).

### Representation Type¶

The representation type of a vector type is the struct VBuffer<T>, where T is the representation type of the item type. For example, the representation type of V<R8,10> is VBuffer<double>. When the vector type’s VectorSize is positive, each value of the type will have length equal to the VectorSize.

The struct VBuffer<T>, sketched below, provides both dense and sparse representations and encourages cooperative buffer sharing. A complete discussion of VBuffer<T> and associated coding idioms is in another document.

Notes:

• VBuffer<T> contains four public readonly fields: Length, Count, Values, and Indices.
• Length is the logical length of the vector, and must be non-negative.
• Count is the number of items explicitly represented in the vector. Count is non-negative and less than or equal to Length.
• When Count is equal to Length, the vector is dense. Otherwise, the vector is sparse.
• The Values array contains the explicitly represented item values. The length of the Values array is at least Count, but not necessarily equal to Count. Only the first Count items in Values are part of the vector; any remaining items are garbage and should be ignored. Note that when Count is zero, Values may be null.
• The Indices array is only relevant when the vector is sparse. In the sparse case, Indices is parallel to Values, only the first Count items are meaningful, the indices must be non-negative and less than Length, and the indices must be strictly increasing. Note that when Count is zero, Indices may be null. In the dense case, Indices is not meaningful and may or may not be null.
• It is very common for the arrays in a VBuffer<T> to be larger than needed for their current value. A special case of this is when a dense VBuffer<T> has a non-null Indices array. The extra items in the arrays are not meaningful and should be ignored. Allowing these buffers to be larger than currently needed reduces the need to reallocate buffers for different values. For example, when cursoring through a vector valued column with VectorSize of 100, client code could pre-allocate values and indices arrays and seed a VBuffer<T> with those arrays. When fetching values, the client code passes the VBuffer<T> by reference. The called code can re-use those arrays, filling them with the current values.
• Generally, vectors should use a sparse representation only when the number of non-default items is at most half the value of Length. However, this guideline is not a mandate.

See the full IDataView technical specification for additional details on VBuffer<T>, including complete discussion of programming idioms, and information on helper classes for building and manipulating vectors.

## Standard Conversions¶

The IDataView system includes the definition and implementation of many standard conversions. Standard conversions are required to map source default values to destination default values. When both the source type and destination type have an NA value, the conversion must map NA to NA. When the source type has an NA value, but the destination type does not, the conversion must map NA to the default value of the destination type.

Most standard conversions are implemented by the singleton class Conversions in the namespace Microsoft.MachineLearning.Data.Conversion. The standard conversions are exposed by the ConvertTransform.

### From Text¶

There are standard conversions from TX to the standard primitive types, R4, R8, I1, I2, I4, I8, U1, U2, U4, U8, and BL. For non- empty, non-missing TX values, these conversions use standard parsing of floating-point and integer values. For BL, the mapping is case insensitive, maps text values { true, yes, t, y, 1, +1, + } to DvBool.True, and maps the values { false, no, f, n, 0, -1, - } to DvBool.False.

If parsing fails, the result is the NA value for floating-point, signed integer types, and boolean, and zero for unsigned integer types. Note that overflow of an integer type is considered failure of parsing, so produces an NA (or zero for unsigned). These conversions map missing/NA text to NA, for floating-point and signed integer types, and to zero for unsigned integer types.

These conversions are required to map empty text (the default value of TX) to the default value of the destination, which is zero for all numeric types and DvBool.False for BL. This may seem unfortunate at first glance, but leads to some nice invariants. For example, when loading a text file with sparse row specifications, it’s desirable for the result to be the same whether the row is first processed entirely as TX values, then parsed, or processed directly into numeric values, that is, parsing as the row is processed. In the latter case, it is simple to map implicit items (suppressed due to sparsity) to zero. In the former case, these items are first mapped to the empty text value. To get the same result, we need empty text to map to zero.

### Floating Point¶

There are standard conversions from R4 to R8 and from R8 to R4. These are the standard IEEE 754 conversions (using unbiased round-to-nearest in the case of R8 to R4).

### Signed Integer¶

There are standard conversions from each signed integer type to each other signed integer type. These conversions map NA to NA, map any other numeric value that fits in the destination type to the corresponding value, and maps any numeric value that does not fit in the destination type to NA. For example, when mapping from I1 to I2, the source NA value, namely 0x80, is mapped to the destination NA value, namely 0x8000, and all other numeric values are mapped as expected. When mapping from I2 to I1, any value that is too large in magnitude to fit in I1, such as 312, is mapped to NA, namely 0x80.

### Signed Integer to Floating Point¶

There are standard conversions from each signed integer type to each floating- point type. These conversions map NA to NA, and map all other values according to the IEEE 754 specification using unbiased round-to-nearest.

### Unsigned Integer¶

There are standard conversions from each unsigned integer type to each other unsigned integer type. These conversions map any numeric value that fits in the destination type to the corresponding value, and maps any numeric value that does not fit in the destination type to zero. For example, when mapping from U2 to U1, any value that is too large in magnitude to fit in U1, such as 312, is mapped to zero.

### Unsigned Integer to Floating Point¶

There are standard conversions from each unsigned integer type to each floating-point type. These conversions map all values according to the IEEE 754 specification using unbiased round-to-nearest.

### Key Types¶

There are standard conversions from one key type to another, provided:

• The source and destination key types have the same Min and Count values.
• Either the number of bytes in the destination’s underlying type is greater than the number of bytes in the source’s underlying type, or the Count value is positive. In the latter case, the Count is necessarily less than 2^^k, where k is the number of bits in the destination type’s underlying type. For example, U1[1-*] can be converted to U2[1-*], but U2[1-*] cannot be converted to U1[1-*]. Also, U1[1-100] and U2[1-100] can be converted in both directions.

The conversion maps source representation values to the corresponding destination representation values. There are no special cases, because of the requirements above.

### Boolean to Numeric¶

There are standard conversions from BL to each of the signed integer and floating point numeric. These map DvBool.True to one, DvBool.False to zero, and DvBool.NA to the numeric type’s NA value.

## Type Classes¶

This chapter contains information on the C# classes used to represent column types. Since the IDataView type system is extensible this list describes only the core data types.

### ColumnType Abstract Class¶

The IDataView system includes the abstract class ColumnType. This is the base class for all column types. ColumnType has several convenience properties that simplify testing for common patterns. For example, the IsVector property indicates whether the ColumnType is an instance of VectorType.

In the following notes, the symbol type is a variable of type ColumnType.

• The type.RawType property indicates the representation type of the column type. Its use should generally be restricted to constructing generic type and method instantiations. In particular, testing whether type.RawType == typeof(int) is not sufficient to test for the standard U4 type. The proper test is type == NumberType.I4, since there is a single universal instance of the I4 type.
• Certain .Net types have a corresponding DataKind enum value. The value of the type.RawKind property is consistent with type.RawType. For .Net types that do not have a corresponding DataKind value, the type.RawKind property returns zero. The type.RawKind property is particularly useful when switching over raw type possibilities, but only after testing for the broader kind of the type (key type, numeric type, etc.).
• The type.IsVector property is equivalent to type is VectorType.
• The type.IsNumber property is equivalent to type is NumberType.
• The type.IsText property is equivalent to type is TextType. There is a single instance of the TextType, so this is also equivalent to type == TextType.Instance.
• The type.IsBool property is equivalent to type is BoolType. There is a single instance of the BoolType, so this is also equivalent to type == BoolType.Instance.
• Type type.IsKey property is equivalent to type is KeyType.
• If type is a key type, then type.KeyCount is the same as ((KeyType)type).Count. If type is not a key type, then type.KeyCount is zero. Note that a key type can have a Count value of zero, indicating that the count is unknown, so type.KeyCount being zero does not imply that type is not a key type. In summary, type.KeyCount is equivalent to: type is KeyType ? ((KeyType)type).Count : 0.
• The type.ItemType property is the item type of the vector type, if type is a vector type, and is the same as type otherwise. For example, to test for a type that is either TX or a vector of TX, one can use type.ItemType.IsText.
• The type.IsKnownSizeVector property is equivalent to type.VectorSize > 0.
• The type.VectorSize property is zero if either type is not a vector type or if type is a vector type of unknown/variable length. Otherwise, it is the length of vectors belonging to the type.
• The type.ValueCount property is one if type is not a vector type and the same as type.VectorSize if type is a vector type.
• The Equals method returns whether the types are semantically equivalent. Note that for vector types, this requires the dimensionality information to be identical.
• The SameSizeAndItemType method is the same as Equals for non-vector types. For vector types, it returns true iff the two types have the same item type and have the same VectorSize values. For example, for the two vector types V<R4,3,2> and V<R4,6>, Equals returns false but SameSizeAndItemType returns true.

### PrimitiveType Abstract Class¶

The PrimitiveType abstract class derives from ColumnType and is the base class of all primitive type implementations.

### TextType Sealed Class¶

The TextType sealed class derives from PrimitiveType and is a singleton- class for the standard text type. The instance is exposed by the static TextType.Instance property.

### BooleanType Sealed Class¶

The BooleanType sealed class derives from PrimitiveType and is a singleton-class for the standard boolean type. The instance is exposed by the static BooleanType.Instance property.

### NumberType Sealed Class¶

The NumberType sealed class derives from PrimitiveType and exposes single instances of each of the standard numeric types, R4, R8, I1, I2, I4, I8, U1, U2, U4, U8, and UG.

### DateTimeType Sealed Class¶

The DateTimeType sealed class derives from PrimitiveType and is a singleton-class for the standard datetime type. The instance is exposed by the static DateTimeType.Instance property.

### DateTimeZoneType Sealed Class¶

The DateTimeZoneType sealed class derives from PrimitiveType and is a singleton-class for the standard datetime timezone type. The instance is exposed by the static DateTimeType.Instance property.

### TimeSpanType Sealed Class¶

The TimeSpanType sealed class derives from PrimitiveType and is a singleton-class for the standard datetime timezone type. The instance is exposed by the static TimeSpanType.Instance property.

### KeyType Sealed Class¶

The KeyType sealed class derives from PrimitiveType and instances represent key types.

Notes:

• Two key types are considered equal iff their kind, min, count, and contiguous values are the same.
• The static IsValidDataKind method returns true iff kind is U1, U2, U4, or U8. These are the only valid underlying data kinds for key types.
• The inherited KeyCount property returns the same value as the Count property.

### VectorType Sealed Class¶

The VectorType sealed class derives from ColumnType and instances represent vector types. The item type is specified as the first parameter to each constructor and the dimension information is inferred from the additional parameters.

• The DimCount property indicates the number of dimensions and the GetDim method returns a particular dimension value. All dimension values are non- negative integers. A dimension value of zero indicates unknown (or variable) in that dimension.
• The VectorSize property returns the product of the dimensions.
• The IsSubtypeOf(VectorType other) method returns true if this is a subtype of other, in the sense that they have the same item type, and either have the same VectorSize or other.VectorSize is zero.
• The inherited Equals method returns true if the two types have the same item type and the same dimension information.
• The inherited SameSizeAndItemType(ColumnType other) method returns true if other is a vector type with the same item type and the same VectorSize value.