Dynamic Data Store

The Optimizely Dynamic Data Store (DDS) is essentially an Object-Relational mapper. When used with compile time data types (.NET classes), properties with a public getter and a setter (setter does not need to be public) are mapped to a column in a database table. For runtime data types, each property added to a PropertyBag is also mapped in the same way.

DDS is a component offering an API and infrastructure for the saving, loading, and searching of compile time data types (.NET object instances) and runtime data types (property bags) in shared tables in SQL Server. The component is shipped as part of the Framework package.

DDS has the following advantages:

You should not use DDS for high performance and scalability requirements or when storing very large object graphs (there is no lazy loading support, for example). The dynamic nature of DDS might become a bottleneck rather than working to your advantage in these situations. You should store this data in custom tables where the table design and API can be optimized for a specific use case. Alternative technologies for working with database tables in SQL Server include Microsoft’s Entity Framework and NHibernate for .NET.

In Dynamic Data Store, data types are stored in one database table. This table contains many columns, several of each data type that the Dynamic Data Store supports. When a data structure is saved, the .NET CLR type of each property is mapped against an internal list of supported types.

The following types of mapping are supported:

Inline mapping is where a property of a class or PropertyBag can be mapped directly against one of the supported database columns. The following types can be mapped inline:

A property is mapped as a collection if it implements the System.IEnumerable interface. In this case, elements of the collection (keys and values in the case of System.IDictionary) are stored in a special reference table.

Even though the EPiServer.Data.Dynamic.PropertyBag implements System.IEnumerable, it is treated as a reference type (see below).

Properties that cannot be mapped inline or as a collection (plus the EPiServer.Data.Dynamic.PropertyBag type) are mapped as references. This means their properties are mapped as a sub-type, and a link row is added in the reference table to link the parent data structure with the child data structure. This allows for complex trees of data structures (object graphs) to be saved in DDS.

The default DDS table is called tblBigTable, which contains the following fixed columns (meaning mandatory columns):

The default big table also contains the following optional columns:

The columns whose names start with Indexed have database indexes created on them.

You may want to add and remove columns in this table to suit the type of data you are saving. This is particularly useful if you store a data type with more than, for example, 10 strings. By default, the 11th to 20th strings would be stored in a 2nd row for the type, which means a join has to be done at runtime when reading the data. Adding String11, String12, and so on to the big table limits the chance of a row overspill and increases performance. If you require more indexes, add columns with names starting with Indexed and make sure an index is created on them.

You can also add your table. This is particularly useful if you store a type that only contains strings, for example. Along with the mandatory columns (pkId, Row, StoreName, ItemType), you can add about 20 StringXX columns.

Add the EPiServerDataTableAttribute with the TableName property given as the name of the custom table to use the custom big table.

This table lists the database columns types in the default big table and the .NET CLR “inline” types they are mapped to:

Each store is represented in the database by a view. The views can be used as normal, including cross-joining with other tables and views in the database.

The EPiServer.Data assembly contains the following main namespaces:

Use the DynamicDataStoreFactory class to create, obtain, and delete stores. The class has a single instance obtained from the static Instance property. Alternatively, stores can be automatically created for .NET classes by decorating them with the EPiServerDataStoreAttribute and setting the AutomaticallyCreateStore property to true.

Data can be saved and loaded using compile-time data types (.NET classes) and runtime data types with the EPiServer.Data.Dynamic.PropertyBag class. The Dynamic Data Store is divided into logical stores identified by name. Stores are not polymorphic, meaning only one property set may be saved in a store, although you can re-map stores and achieve a level of polymorphism through interfaces and template types.

You can search data in the Dynamic Data Store in the following ways: