Jeff's thoughts on Software Architecture, Large Scale Services and the Technical world at large : Services

SQL Azure talks are now available online

jcurrier — Sat, 21 Nov 2009 20:54:00 GMT

Hey all,

My, "SQL Azure: Under the hood" talk is available for viewing now here. During the talk, I referred to GopalK's earlier under the hood talk in mine so I've attached a link to this here for those that are interested.

You can also find some of the other talks for SQL Azure here as well:

Development Best Practices and Patterns for Using Microsoft SQL Azure Databases

SQL Azure Database: Present and Future

Scaling out Web Applications with Microsoft SQL Azure Databases

The Future of Database Development with SQL Azure

Hope you find them interesting

--Jeff--

SQL Azure PDC talks

jcurrier — Wed, 30 Sep 2009 07:19:00 GMT

So, a number of us are doing talks this year for PDC (myself included!). You can find the full list here. So, if you're going to be in LA for PDC this be sure to check out the sessions. Having seen, and helped author, the content I know you'll enjoy it!

--Jeff--

SQL Azure: Invite codes, traffic patterns and feedback.

jcurrier — Sat, 22 Aug 2009 06:02:00 GMT

We've sent out the first couple batches of invite codes this week for SQL Azure (apologies if you haven't yet received yours). It's important to keep in mind that in general services tend to do this kind of thing for good reason. So, what are the reasons? There are many but these are the two that I look at the most:

1) Traffic patterns - How are the newly on-boarded people using the service. Are they using it in the manner that we thought they would or are they doing things we totally didn't expect. Is there some constraint that we hadn't previously observed in our own in-house load/stress testing? Thus far, this hasn't been the case for us :-)

2) Load - The second thing we're trying to understand how many people that we send invite codes to are actually using the service (thereby increasing the load on the system). People consume resources in the system which, ultimately, there is a finite amount of. Therefore, this needs to be monitored carefully.

So far, we're looking good in these departments but my bet, if folks are like me, that we will see an increase in both of these things this weekend as people get more play time with the service.

Now, for those of you presently using the service. The team would love to hear any feedback that you have on the primary service as well as the Portal experiences. If you like you can comment here or better yet on the forums. All feedback is appreciated and important for us as we figure out where we need to improve things in the service. So, if you have 1 big grip (or several) please do drop a message. It will be looked at.

Finally, for those of you who haven't yet received a code. Please hang in there. We are picking up the pace that we're sending these things out. I know it's tough to wait (trust me) but we're getting out as fast as we can.

--Jeff--

SDS coding examples – Part 1 (C# & ADO.NET)

jcurrier — Sun, 29 Mar 2009 23:16:00 GMT

So, as I did with the original SDS I want to outline some code examples that other developers can use to get a sense of how to interact with the service. In general, this will be much easier now that we have shifted more to the relational model as some of the more abstract (okay maybe not sooo abstract) concepts don’t necessarily need to be explained from scratch. Having said that, there are a few concepts that are worth covering before we dive into the code.

Servers, and Masters, and User Databases, oh my!

There are really two different types of databases that we have present in SDS now. The first, and the one that you’ll generally interact with the most, is the user database. This is really where your user data resides. You’re in charge in this space. You define the tables, schemas and what have you that appear in this database. We may insert some data into locked down tables (and present them to you with views) here to help assist you with debugging and provide some metrics data but by in large this is your house. NOTE: The name you choose here for your user database (“mydatabase” in the example below) is the name of the database you specify in the connection string.

connStringBuilder.InitialCatalog = "mydatabase"; // Specify your user database to connect to.

The second type of database is really what we refer to as the logical master database (or server database) but it actually encapsulates two different things. The first thing is that the server represents a logical master database. This is the database where we keep track of all of the user databases that you have on this logical server. It’s important to note that this is *not* a real server and is more logical in nature. We will also store things your metrics here as well as login information NOTE: Because we store login information here this is why you have specify your server name in the user id as certain elements don’t come across in the initial TDS packets we receive.

The second important thing to note about the server database is that is associated (along with each of the user databases managed by it) with a particular geo-location. You will pick the geo-location when you go through the provisioning process and requests will be routed to your servers by taking advantage of the DNS system as once done previously. The code snippet below illustrates how the server presents itself in the connection string.

connStringBuilder.DataSource = "myserver.data.dev.mscds.com"; // Specify the DNS name of my SDS server (which holds my master db).
connStringBuilder.UserID = "jeff@myserver";                   // Specify my user id (and the server name which holds my master db)

On to the code

So now with no further delay is some sample code. It’s simple (on purpose) but it illustrates the types of operations that you’ll be able to do (DDL & DML). In this example, I simply create a table, insert some rows, select some rows from that table, and finally drop the table in the end. Here you go! If you have other questions around the code please feel free to comment and I’ll try to reply as soon as I can.

        static void Main(string[] args)
        {
            // Begin, by constructing the connection string using the SqlConnectionStringBuilder class for
            // simplicity.  I could just use String.Format but this makes it a bit easier to explain what
            // we're doing with each parameter.

            SqlConnectionStringBuilder connStringBuilder = new SqlConnectionStringBuilder();
            connStringBuilder.DataSource = "myserver.data.dev.mscds.com"; // Specify the DNS name of my SDS server (which holds my master db).
            connStringBuilder.InitialCatalog = "mydatabase";              // Specify your user database to connect to.
            connStringBuilder.Encrypt = true;                             // Specify that I would like the channel to be encrypted.
            connStringBuilder.UserID = "jeff@myserver";                   // Specify my user id (and the server name which holds my master db)
            connStringBuilder.Password = "****";                          // Finally, specify my password.

            string createTableSql =
                @"CREATE TABLE [dbo].[tbl_Person]
                (
                     [FirstName] NVARCHAR(64) NOT NULL,
	             [LastName] NVARCHAR(64) NOT NULL
                    CONSTRAINT [personName_PK] PRIMARY KEY CLUSTERED
                    (
                        [FirstName] ASC,
                        [LastName] ASC
                    )
                )";

            string insertSql =
                @"INSERT INTO dbo.tbl_Person(FirstName, LastName) VALUES ('Jeff', 'Currier');
                  INSERT INTO dbo.tbl_Person(FirstName, LastName) VALUES ('Nigel', 'Ellis');
                  INSERT INTO dbo.tbl_Person(FirstName, LastName) VALUES ('David', 'Robinson');
                  INSERT INTO dbo.tbl_Person(FirstName, LastName) VALUES ('Jeff', 'Smith');";
            try
            {
                // New up a connection to my previously provisioned user database just as I would to any other database.
                // and then open it.
                using (SqlConnection conn = new SqlConnection(connStringBuilder.ToString()))
                {
                    conn.Open();

                    // Construct a new SqlCommand object that we'll use to execute execute our Sql code.
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        // Use the above defined SQL to create a simple table that we'll to construct a table for this
                        // example
                        cmd.CommandText = createTableSql;
                        cmd.CommandType = CommandType.Text;
                        cmd.ExecuteNonQuery();

                        // Insert some simple data into that table.
                        cmd.CommandText = insertSql;
                        cmd.CommandType = CommandType.Text;
                        cmd.ExecuteNonQuery();

                        // Next, perform a simple select finding all of the persons in the table whose first name is Jeff.
                        cmd.CommandText = "select FirstName, LastName from dbo.tbl_Person where FirstName = 'Jeff'";
                        cmd.CommandType = CommandType.Text;
                        using (SqlDataReader reader = cmd.ExecuteReader())
                        {
                            while (reader.Read())
                            {
                                Console.WriteLine("First Name: {0} LastName: {1}", reader["FirstName"],
                                                  reader["LastName"]);
                            }

                            reader.Close();
                        }

                        // Finally, drop the table since we no longer need it.
                        cmd.CommandText = "Drop table dbo.tbl_Person";
                        cmd.CommandType = CommandType.Text;
                        cmd.ExecuteNonQuery();
                    }

                    conn.Close();
                }
            }
            catch (SqlException ex)
            {
                Console.WriteLine(ex);
            }
        }

Now, this example was in C# and used SqlClient (ADO.NET) but my next example will use Java & JDBC. If there are other languages (toolkits) you would like to see us illustrate please comment here or on the main SDS blog and we’ll try to get them out as soon as we can.

Enjoy!

--Jeff--

Check out Nigel's Talk on SDS from MIX09

jcurrier — Mon, 23 Mar 2009 05:09:56 GMT

Looks like the MIX folks have posted up Nigel's talk on the newly revamped SDS from MIX. You can watch it now here.

It’s been awhile…

jcurrier — Sat, 14 Mar 2009 23:51:06 GMT

So, it’s been quite awhile since I’ve posted but with the recent SDS announcement I trust you now know why that is. While I’ll be posting some code samples shortly for accessing the new SDS service via ADO.NET as well as with Java I’d like to give a plug for Nigel’s upcoming MIX09 talk on SDS.

I don’t want to steal any thunder from the talk next week so I’m going to hold off on talking much more about the service until after Nigel’s talk is completed. Keep posted though as you will see more details coming out from the team post MIX.

Finally, I’ve seen quite a bit of traffic in the blog community recently with concern that our new model doesn’t scale. I’ll just say this, we are all familiar with CAP conjecture, we do know what it takes to scale a relational store. We’ve done this once (with the initial version of Sitka which was built on the same technology) we will do it again. The larger question is getting the right application patterns in place so apps perform well on the system. That’s it for now but stay tuned.

SDS Channel 9 Video is up

jcurrier — Tue, 28 Oct 2008 06:27:00 GMT

A little while ago Jason and I recorded a Channel 9 video to discuss some of the newer features in SDS (SQL Data Services). Now that all the Azure components have been announced this is now available up at the Channel 9 site. You can view it here.

Good overview of using threads for multi container query in SSDS

jcurrier — Tue, 15 Apr 2008 06:30:18 GMT

Eugenio has a good blog entry today describing using multiple threads to execute multi-container query. Well worth the read.

Interested in partaking in a design review for SQL Server Data Services?

jcurrier — Sun, 13 Apr 2008 09:54:00 GMT

Are you interested in taking part in a design review of SQL Server Data Services? Are you located in Silicon Valley? If you answered yes to both of these questions then you're going to want check out Ryan's blog here to find out details for attending. Space is limited so act fast!

--Jeff--

cURL'ing up with SQL Server Data Services

jcurrier — Sun, 13 Apr 2008 09:47:59 GMT

We've begun working with some external customers (and a considerable number of internal ones) on the project and one of the first requests that came up was regarding the use of cURL.

cURL, as many of you already know, is a pretty cool command line utility which can be used to issue HTTP requests. However we haven't, until this point, documented exactly how you can use the service from cURL. This post will address that.

Enumerating your Authority

In this example I'll illustrate how you can query an authority for all of the containers that are located within it. Before we get to this however I'll explain a bit more about how cURL functions.

cURL uses various command line parameters to construct the HTTP request on your behalf. As you might guess the -X parameter is used to specify the verb (HTTP method) that you wish to use on the request. The -u parameter is used to specify the credentials to use and finally the last parameter is the URL you want to use.

Command line syntax to query the authority:

curl -X GET -u "<userid>:<password>" http://<authority-id>.data.beta.mssds.com/v1/?q=''

Output

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

Creating Containers and Entities

As I've mentioned previously here we use the POST verb to create entities within SSDS. Now, because specifying the entire payload for a POST could be cumbersome cURL allows you to specify the filename where the payload can be found. This done use the, "--data" parameter and the, "@" symbol.

We'll begin with creating a container with cURL. We'll start by creating a simple file called, "CurlContainer" containing the following XML payload:

<s:Container xmlns:s="http://schemas.microsoft.com/sitka/2008/03/">
<s:Id>CurlContainer</s:Id>
</s:Container>

Now that this is complete we can construct the command line syntax that we'll need to send the request to the service.

Command line syntax to create the container:

curl -X POST --data @CurlContainer -H "Content-Type: application/xml" -u "<userid>:<password>" http://<authority-id>.data.beta.mssds.com/v1/

A couple of things that you might notice here that are different from our prior syntax. The first is that the verb has changed (that's pretty obvious). The second item is that we've used the, "--data" parameter to specify the payload. We didn't need to use that before since we were only querying the service.

Finally, and perhaps most importantly, is that we specify the content type of data in the request. This is done using the, "-H" parameter along with the header data. If this isn't specified then the request will be denied with a 400 so do remember to use it.

Now, when we query the authority as we did earlier I get the following output returned to me.

<s:EntitySet 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:Container>
    <s:Id>CurlContainer</s:Id>
    <s:Version>1</s:Version>
</s:Container>
<s:Container>
    <s:Id>testcontainer</s:Id>
    <s:Version>1</s:Version>
</s:Container>
<s:Container>
    <s:Id>testcontainer2</s:Id>
    <s:Version>1</s:Version>
</s:Container>
</s:EntitySet>

Switching to entity creation we find that not a lot has changed. The only meaningful difference is the URL that we provide and the payload content. Following the steps just described I can create a new entity, "CurlEntity" within the CurlContainer I just created. Listed below is the payload I've created as well as the syntax used to create the entity.

Payload

<CurlEntity 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>CurlEntity</s:Id>
<Name xsi:type="x:string">Jeff Currier</Name>
</CurlEntity>

Command line syntax to create the entity:

curl -X POST -H "Content-Type: application/xml" --data @CurlEntity.xml -u "<userid>:<password>" http://<authority-id>.data.beta.mssds.com/v1/CurlContainer

Finally, let's just query the container to see my new data.

Command line syntax to query the container:

curl -G -u "<userid>:<password>" http://<authority-id>.data.beta.mssds.com/v1/CurlContainer?q=''

Output

<s:EntitySet xmlns:s="http://schemas.microsoft.com/sitka/2008/03/" xmlns:xsi="http://www.w3.org/2001/XMLSc
hema-instance" xmlns:x="http://www.w3.org/2001/XMLSchema">
<CurlEntity>
    <s:Id>CurlEntity</s:Id>
    <s:Version>1</s:Version>
    <Name xsi:type="x:string">Jeff Currier</Name>
</CurlEntity>
</s:EntitySet>

Updating Entities

Now that we can create and query things we need to have a way of updating them otherwise things just aren't that interesting. We do this, as always in a RESTful service, using the PUT verb. In this case I'm going to change the, "Name" property on my newly created entity to another name.

Like we did previously we'll create a file which will contain the payload definition for the request. I've created this file, "CurlEntity2.xml" and will provide this on the command line. Listed below is both the payload as well as the command line syntax for updating.

Update Payload:

Command line syntax for updating an entity:

curl -X PUT --data @CurlEntity2.xml -H "Content-Type: application/xml" -u "<userid>:<password>" http://<authority-id>.data.beta.mssds.com/v1/CurlContainer/CurlEntity

Output from listing the contents of the container

<s:EntitySet xmlns:s="http://schemas.microsoft.com/sitka/2008/03/" xmlns:xsi="http://www.w3.org/2001/XMLSc
hema-instance" xmlns:x="http://www.w3.org/2001/XMLSchema">
<CurlEntity>
    <s:Id>CurlEntity</s:Id>
    <s:Version>2</s:Version>
    <Name xsi:type="x:string">Jason Hunter</Name>
</CurlEntity>
</s:EntitySet>

Deleteing Entities

All things must come to an end even when it comes to entities. We do this in RESTful services using the Delete verb. Notice here that there is no need to specify a payload or a content-type header. None of this is required as the service will determine what to delete based upon the URL.

Command line syntax:

curl -X DELETE -u "<userid>:<password>" http://<authority-id>.data.beta.mssds.com/v1/CurlContainer/CurlEntity

Output from listing the contents of our container:

<s:EntitySet 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"/>

That wraps up our cURL example for this evening. If there are other languages or tools that you would be interested in seeing examples in please do let us know!

--Jeff--

Check out Nigel & Istvan over at Channel 9

jcurrier — Tue, 08 Apr 2008 07:08:34 GMT

You can watch a good interview with Istvan and Nigel over on Channel 9. The talk covers some of the interesting architecture, security and other topics. Well worth the watch!

Some SQL Server Data Services Coding Examples

jcurrier — Mon, 17 Mar 2008 20:30:00 GMT

Since my last post (just after we released the service) several others have written some really great stuff on SSDS. I've listed these below for reference.

Overview of the ACE model from Ryan

SSDS Query Syntax (also from Ryan)

However, most of the content has been focused on either conceptual material or our basic query syntax. So, I wanted this post to be more on how to use our service from C# (I'll do a Java example next time around). I'm only going to cover the REST head in this example but future examples will illustrate the use of our service from the SOAP head.

In this example, I'll construct a general purpose class to generate a WebRequest in C# and also another to read in the value. Once this is complete we'll attempt to use these to do something interesting.

Knowing your verbs

The first thing we're going to do in this example is to define an enumeration which we we can use with our utility class to specify the HTTP verb that we want to use. Listed below is a enumeration which we can use to do this.

    public enum HttpMethods
    {
        GET = 0,
        PUT,
        POST,
        DELETE,
        HEAD,
        OPTIONS,
        LIST,
        UNKNOWN
    }

Generating Requests

So, now that we have our HTTP vocabulary down let's proceed in writing a simple method that we can use to create our WebRequest objects for us. This should take care of setting things like the encoding, content-length and these sorts of details for us automatically so that we don't have to worry about this.

/// <summary>
/// This helper method can be used to create WebRequests for the caller.
/// It will populate the ContentType, ContentLength and Body for the caller.
/// </summary>
/// <param name="uri">Target URI of the request.</param>
/// <param name="method">The HTTP method to use.</param>
/// <param name="data">The body of the request.</param>
/// <param name="contentType">The content type.</param>
/// <returns>The created WebRequest.</returns>
public static HttpWebRequest CreateRequest(string uri, 
                                           HttpMethods method, 
                                           string data, 
                                           string contentType)
{
    // Begin by validating our inbound parameters.
    if (String.IsNullOrEmpty(uri))
    {
        throw new ArgumentOutOfRangeException("uri", "Value cannot be null or empty.");
    }

    // Then, go ahead and create the request using the parameters that were passed in.
    WebRequest request = HttpWebRequest.Create(uri);
    request.Method = Enum.GetName(typeof(HttpMethods), method);
    request.Credentials = new NetworkCredential("Your User Id", "Your Password");

    if (method != HttpMethods.GET && 
        method != HttpMethods.DELETE)
    {
        // Next, based on the encoding calculate the
        // content length, type and populate the body of the request.
        Encoding encoding = Encoding.UTF8;
        request.ContentLength = encoding.GetByteCount(data);
        request.ContentType = contentType;

        request.GetRequestStream().Write(
            encoding.GetBytes(data), 0, (int)request.ContentLength);
        request.GetRequestStream().Close();
    }
    else
    {
        // If we're doing a GET or DELETE don't bother with this as all 
        // the interesting bits will be on the response.
        request.ContentLength = 0;
    }

    // Finally, return the newly created request to the caller.
    return request as HttpWebRequest;
}

Reading Responses

Now that we can create requests easily enough let's go ahead and create something that will read them in just as easily for us. I'm going to make a simplifying assumption here to make this a bit easier. I'm always just going to read in the response into a string. Now, there are cases where you might not want to do this (say in the case of chunked responses) but this should work fine for what we want to do.

/// <summary>
/// This method can be used to read the response body from a given response.
/// </summary>
/// <param name="response">The response to read.</param>
/// <returns>String representation of the HTTP response.</returns>
public string ReadResponse(HttpWebResponse response)
{
    // Begin by validating our inbound parameters.
    if (response == null)
    {
        throw new ArgumentNullException("response", "Value cannot be null");
    }

    // Then, open up a reader to the response and read the contents to a string
    // and return that to the caller.
    string responseBody = String.Empty;
    using (Stream stm = response.GetResponseStream())
    {
        using (StreamReader reader = new StreamReader(stm))
        {
            // Simply read in the entire response to our string.
            responseBody = reader.ReadToEnd();
            reader.Close();
        }
    }

    return responseBody;
}

Putting it together

Okay, now that we have these simple tools in place let's try to construct something that's a bit interesting. In this case a simple ASP.NET page which has several data bound controls (where the data comes from SSDS).

Now, I've created several containers which logically represent customers in my application (recall that a container is our partitioning unit so this data will now reside in a different partition from other customers). Then, within each of these containers are entities of type Customer, Order and finally OrderDetail (You might recognize some of these from the Northwind DB).

Now, there is only 1 customer entity within any Customer Container (and this simply contains more detailed information about that customer). The Order and OrderDetails entities capture information about the orders that this customer currently has. The image below illustrates what this looks like conceptually.

So, the first I thing I'm going to write is a bit of code which simply retrieves the total set of customers that I have. We'll use this information to bind the customer id's to a drop down list so that we can easily select the customer whose orders we would like to view.

try
{
    const String XmlContentType = @"application/xml";

    // Read in authority ID from web.config.
    String authId = WebConfigurationManager.AppSettings["AuthId"];

    // Then, formulate our URI using the authority and the service
    // address we read in.
    String allCustomersQuery = String.Format("http://{0}.data.sitka.microsoft.com/v1/?q=''",
                               			m_authId);

    // Next, create the request object using the utility method we defined earlier.
    HttpWebRequest request = CreateRequest(allCustomersQuery, HttpMethods.GET,
                                           String.Empty, XmlContentType);

    // Now, attempt to read in the data.
    using(HttpWebResponse response = (HttpWebResponse) request.GetResponse())
    {
        string responseXml = ReadResponse(response);
                        
        // After reading in the response parse the response into a XDocument.
        XDocument customerDoc = XDocument.Parse(responseXml);
        XNamespace ssdsNamespace = "http://schemas.microsoft.com/sitka/2008/03/";
                        
        // Then, using XLinq, select all the customer containers projecting out their Id
        // to a new object which has a single property value called, "CustomerId"
        var customerIdList =
        	from c in customerDoc.Descendants(ssdsNamespace + "Container")
            select new
            	{
                  	CustomerId = c.Element(ssdsNamespace + "Id").Value
                  };

         // Then, bind the datasource to our drop down list.
         this.ddlCustomers.DataTextField = "CustomerId";
         this.ddlCustomers.DataSource = customerIdList;
         this.DataBind();
     }

}
catch(WebException ex)
{
    if (ex.Response != null)
    {
        // Alert the user that something happened bad happened here.  
        // I'm just capturing the string here for debugging purposes.
        string errorMsg = ReadResponse((HttpWebResponse)ex.Response);
        
    }
}

Before we move on you may be wondering what this actually looks like on the wire so here it is.

<s:EntitySet 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:Container> 
        <s:Id>Customer000000</s:Id> 
        <s:Version>1</s:Version> 
    </s:Container> 
    <s:Container> 
        <s:Id>Customer000001</s:Id> 
        <s:Version>1</s:Version> 
    </s:Container> 
    <s:Container> 
        <s:Id>Customer000002</s:Id> 
        <s:Version>1</s:Version> 
    </s:Container> 
    <s:Container> 
        <s:Id>Customer000003</s:Id> 
        <s:Version>1</s:Version> 
    </s:Container> 
    <!-- more data here but omitted...  --> 
</s:EntitySet>

In the prior example we operated exclusively over the containers in the service. This time we're going to query within a particular container for Order information and project out a new class which can be used for data binding. Now, this is only one way we could approach the problem. Another, and one that I'll post on as well soon, would be to use XmlSerializer (or something like JAXB if you're using Java) and create a general purpose object to represent orders which we could use all over our application.

However, in this case I'm really interested in focusing in on using XLinq with our service so I'm going to stay with the use of Anonymous classes as they are a nice for these sort of build to order classes that one sometimes needs for these kinds of DataBinding scenarios.

try
{

      // First, read in the authority id to use from our web.config.
      String authId = WebConfigurationManager.AppSettings["AuthId"];

      const String XmlContentType = @"application/xml";

      // Next, define the query that will select only those entities which have a kind value
      // of Order.
      String query = String.Format(@"from e in entities where e.Kind == ""Order"" select e");

      // Then, construct the URI that we'll use to make the request.  In this case, I've retrieved
      // the container id to use from a drop down list (this list was actually the one populated 
      // from our last code sample).
	String allOrdersQuery =  
          String.Format(@"http://{0}.data.sitka.microsoft.com/v1/{1}?q='{2}'",
                        authId, ddlCustomers.SelectedValue, query);

      HttpWebRequest request = CreateRequest(allOrdersQuery, HttpMethods.GET,
                                              String.Empty, XmlContentType);

      using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
      {
           string responseXml = ReadResponse(response);

           // After reading in the response parse the response into a XDocument.
           XDocument ordersDoc = XDocument.Parse(responseXml);
           XNamespace ssdsNamespace = "http://schemas.microsoft.com/sitka/2008/03/";

           // Then, select all the customer containers projecting out their Id
           // to a new object which has a single property value called, "CustomerId"
           var orderList =
                    from o in ordersDoc.Descendants("Order")
                    select new
                    {
                        OrderId = o.Element(ssdsNamespace + "Id").Value,
                        DateOrdered = Convert.ToDateTime(o.Element("OrderDate").Value),
                        Total = Convert.ToDecimal(o.Element("Total").Value)
                    };

            // Then, bind the grid to the dataset values.
            this.grdDataBinding.DataSource = orderList;
            this.grdDataBinding.DataBind();
            }

       }
}
catch (WebException ex)
{
    if(ex.Response != null)
    {
        // Read in the error message and alert the user.
        // For now, I'm just keeping this here for debugging purposes.
        string errorMsg = ReadResponse((HttpWebResponse) ex.Response);
    }
}

In this last code example we've constructed a query over a specific container. This query places a restriction over the output such that only entities that match the Kind predicate that we've setup are returned to us. Listed below is an example of what this looks like on the wire.

<s:EntitySet 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"> 
   <Order> 
       <s:Id>2001-11-02T01:01:01Z-O044501</s:Id> 
       <s:Version>5</s:Version> 
       <HighPriority xsi:type="x:boolean">true</HighPriority> 
       <OrderId xsi:type="x:string">O044501</OrderId> 
       <OrderDate xsi:type="x:dateTime">2001-11-02T01:01:01 </OrderDate> 
       <Total xsi:type="x:decimal">26128.8674</Total> 
   </Order> 
   <Order> 
       <s:Id>2002-02-02T01:01:01Z-O045283</s:Id> 
       <s:Version>5</s:Version> 
       <HighPriority xsi:type="x:boolean">true</HighPriority> 
       <OrderId xsi:type="x:string">O045283</OrderId> 
       <OrderDate xsi:type="x:dateTime">2002-02-02T01:01:01</OrderDate> 
       <Total xsi:type="x:decimal">37643.1378</Total> 
   </Order> 
   <Order> 
       <s:Id>2002-05-02T01:01:01Z-O046042</s:Id> 
       <s:Version>5</s:Version> 
       <HighPriority xsi:type="x:boolean">true</HighPriority> 
       <OrderId xsi:type="x:string">O046042</OrderId> 
       <OrderDate xsi:type="x:dateTime">2002-05-02T01:01:01</OrderDate> 
       <Total xsi:type="x:decimal">34722.9906</Total> 
    </Order> 
    <!-- Omitting other orders for simplicity. -->
</s:EntitySet>

Now, we have a very simple data bound ASP.NET application which shows you can do data binding very simply using SSDS.

--Jeff--

Dryad - a more generalized version of MapReduce

jcurrier — Sat, 10 Nov 2007 00:48:00 GMT

It looks we've presented Dryad to the folks over at Google. The actual video from the talk is available here.

If you aren't aware of waht Dryad is exactly you can think of it as a more generalized version of Google's MapReduce. The nice thing about Dryad is that it really bake in any semantics into what the architecture. This leaves the framework considerbly more adaptable (IMO).

Enjoy.