The SSDS data model offers a three-level containment model that includes authorities, containers and entities.

Authority

mydomain.data.beta.mssds.com

Container

Entity

Each entity inside a container can store any number of user-defined properties and corresponding values.

An entity is the smallest object that can be updated, that is, you can retrieve an entire entity; add, update, delete properties; and then replace the original entity with the updated one. Partial updates are not supported.

Note:
A container can store zero or more entities, but nested containers (containers within a container) are not supported.

This hierarchical structure of authorities, containers, and entities forms a three-level containment model. This containment model is illustrated in the diagram below:

Blobs

Depending on your application needs, you container can be a homogeneous or heterogeneous.

In the homogeneous model, a container stores entities of the same kind. In this model, a container is like a table in a database. Some of the examples of homogeneous containers are as follows:

• In an Employee table, you store employee records. These are all records of the same kind. In SSDS, you would create an Employee container that stores Employee entities. These entities can have different properties, but they are all Employee entities.
  
• In a sample authority, books-docsamples (DNS name books-docsamples.data.beta.mssds.com), you can create containers such as ChildrensBooks and TechnicalBooks. You then store book entities in appropriate containers.
  

In a heterogeneous containment model, a container is like a database that stores entities of all kinds. For example, a database can have Orders, Employees, and OrderDetails tables. In SSDS, you can create a single container to store orders, employees, and order details entities. The advantage in this case is that you can query across heterogeneous entities within the same container.

In SQL Server Data Services, the flexible entity is a key concept. Each of these entities is a set of metadata properties and a bag of flexible properties.

You can think of flexible entities as sparse tables in the relational data model or an XML fragment with one element per property value. Each property has a name and a value. The value can only be a simple scalar type. The simple scalar types supported in this release are string, binary, Boolean, decimal, and datetime.

Whether you use the REST or SOAP interface discussed below, the XML payload format uses the following standard XSD types to encode scalar values:

• string
  
• base64Binary
  
• boolean
  
• decimal
  
• dateTime
  

Metadata Properties

Flexible Properties

When you program with SSDS, there are four kinds of URIs that you will work with if you are using the REST head. These URI types are described in the following table.

You can think of these URIs as setting a scope over which a set of operations can be performed. URI examples are given in the following sections.

Service URI

https://data.beta.mssds.com/v1/

Authority URI

https://<authority_id>.data.beta.mssds.com/v1/ 

<s:Authority xmlns:s="http://schemas.microsoft.com/sitka/2008/03/" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xmlns:x="http://www.w3.org/2001/XMLSchema">
  <s:Id>books-docsamples</s:Id>
  <s:Version>2</s:Version>
</s:Authority>

https://<authority_id>.data.beta.mssds.com/v1/q='<your query>' 

Container URI

https://<authority_id>.data.beta.mssds.com/v1/<container_id>

<s:Container xmlns:s="http://schemas.microsoft.com/sitka/2008/03/" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xmlns:x="http://www.w3.org/2001/XMLSchema">
  <s:Id>UsedBooks</s:Id>
  <s:Version>1</s:Version>
</s:Container>

https://<authority_id>.data.beta.mssds.com/v1/<container_id>?q='<your query>'

Entity URI

https://<authority_id>.data.beta.mssds.com/v1/<container_id>/<entity_id>

<UsedBookKind xmlns:s="http://schemas.microsoft.com/sitka/2008/03/"        
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
              xmlns:x="http://www.w3.org/2001/XMLSchema">
  <s:Id>MySampleBook</s:Id>
  <s:Version>1</s:Version>
  <Title xsi:type="x:string">My Book</Title>
  <ISBN xsi:type="x:string">1-57880-066-36</ISBN>
  <Author xsi:type="x:string">Mr. Author</Author>
  <Publisher xsi:type="x:string">Mr. Publisher</Publisher>
  <InPrint xsi:type="x:boolean">false</InPrint>
  <NumberOfCopiesSold xsi:type="x:decimal">250</NumberOfCopiesSold>
  <PublicationDate xsi:type="x:dateTime">2004-01-27T00:00:00</PublicationDate>
  <CoverPhoto xsi:type="x:base64Binary">AQID</CoverPhoto>
</UsedBookKind>

SSDS supports simple text based queries. The general syntax supported in this release is as follows:

from e in entities [where condition] select e

The query iterates over the set of flexible entities in the specified scope and returns only those that satisfy the specified condition in the optional where clause. In the optional where clause, you can specify simple or compound conditions (multiple conditions that are combined by using logical operators). The following table lists the operators that are supported in this release.

The query expression can be compared to the C# foreach or LINQ (Language Integrated Query) constructs:

• C# foreach construct.
  
  foreach entity e in entities
  {
     if (e satisfies a condition)
     {           yield return e;
     }
  }

• C# LINQ constructs.
  
  IEnumerable<FlexibleEntities> results = from e in scope.Entities where condition select e;

The three-level containment model, discussed earlier, influences how we specify the query. The appropriate authority, container, or entity must be in scope during the query. For example:

• When you query for containers in an authority, the specific authority must be in scope.
  
• When you query for entities in a container, the specific container must be in scope.
  

Here are some query examples:

• Find an entity given an Id value. In the query, Id is a metadata property, and so the query uses the "." notation.
  
  from e in entities 
  where e.Id=="MySampleBook1"
  select e

• Find books where the number of copies sold is less than 1000. This query shows use of a comparison operator.
  
  from e in entities 
  where e["NumberOfCopiesSold"] < 1000 
  select e

• For a given publisher, find all books that are out of print. This query illustrates the use of the AND operator (&&).
  
  from e in entities 
  where e["InPrint"] == false && e["Publisher"] == "Mr. Publisher" 
  select e