Its me again after 4 long year. I have decided to start blogging agian. From the last time I wrote in 2005, there have been multitude of things I have been working. I was working on JDBC driver for SQL Server in 2005-06 and then moved to Entity Framework, which had its first release as part of .Net Framework 3.5 SP1. Currently, I am working on Entity Framework 4.0 and LINQ to SQL. With the public release of Visual Studio 2010 Beta1 and Entity Framework 4.0 Beta1, I think it is an opportune time for me to start with my ramblings about Entity Framework, in general.
Hope you will find something useful here in the future,
Sushil.
Yes, we have done it! SQL Server 2005 and Visual Studio 2005 are now released to manufacturing. What this means that we are done with both the products, you can even download the official bits if you have MSDN subscription. More information can be found at http://msdn.microsoft.com/subscriptions/ . The official launch of these products will happen on Nov. 7 2005 in San Francisco. You can find more information about the Launch at http://msdn.microsoft.com/Launch2005/
Looking forward to your feedback and comments.
I just posted a blog on our team webpage on the changes in new SqlDependency feature from Beta 2 to RTM. There have been a lot of changes since we shipped in Beta 2. Do let us know what you think of the new changes. We are looking forward to hear about this.
I am here at PDC05, LA represeting the SQL Server team as part of staffing the product pavillion. There is just one word to sum up the level of excitment/ enthusiasm that I feel in the air - WOW! And I have been told that its just starting, with more people coming in for the main event that starts tomorrow, it going to get even better. Imagine that!
This being my first PDC, I am fired up to meet customers and partners. I just wanted to share some of the DataWorks (my team) activities at PDC:
- As part of the staff duties, here is the schedule of where you can find me at PDC.
- Pablo Castro (ADO.Net, technical lead) will be giving an advance talk on ADO.Net. Here is a brief summary of his talk. I did get a sneak peak to his talk and it definetly gives lot of good information. The talk focusses on how the some of the new features in 2.0 can be used in "real" apps when it comes to large data that would make it more performant and scalable.
If you need more information, just drop me a line or see you in LA!
Do you want to know more about ConnectionStringBuilder feature in ADO.Net v2.0? If yes, then look up our team site where I posted a short introduction.
The team in which I work is called DataWorks. I am excited to announce that we as a team have our own Web Log at http://blogs.msdn.com/dataaccess. Check out the message from our PUM (Product Unit Manager) - Alyssa. Via this blog, we look forward to get feedback from you for the components we release. Check it out!
With good things said about Notification in my previous blog, I will like to take a step further to walk you through some common issues in setting up this feature. We would need to undestand how notifications internally work to track some of these issues. Lets start with the SqlDependency object. When we create a SqlDependency object we are creating a listener on the client to track notifications sent by the server. There are two types of protocol options that SqlDependency supports – HTTP and TCP when creating a listener. The HTTP listener uses the HTTP.SYS functionality to create a listener. By default when no protocol option is specified, we try to create an HttpListener; if that for some reason fails, we create a TCPListener. When a change occurs, the server then dispatches notification messages via a .Net Procedure to the client listener. Now, let’s go over some common issues.
- My Application doesn’t get Notification messages at all:
There could be many reasons why we could end up with this. Here are some reasons.
- Is CLR enabled on SQL Server?
Cause: Since the code on the SQL server that dispatches notification messaged to the client is a .Net Procedure, you will have to enable CLR on Server. We are working on not requiring this restriction.:)
Solution: Here is way to do this for now,
EXEC sp_configure 'show advanced options', '1'
go
RECONFIGURE
go
EXEC sp_configure 'clr enabled', 1
go
RECONFIGURE
- Does the SQL user have permissions on the Queue and/or the Service
Cause: Since this feature uses the SQL Server Service Broker (aka SSB) infrastructure to get notification, the user has to have the permissions on the Notification Service.
Solution: To grant the permission to user ‘Willy’ on the Service and queue use:
GRANT SEND on service::SqlQueryNotificationService to Willy
GRAND RECEIVE on SqlQueryNotificationService_DefaultQueue to Willy
Also the user needs permission to subscribe to notification. To do this use:
GRANT SUBSCRIBE QUERY NOTIFICATIONS TO Willy
- Is it an XPSP2 machine and/or you using a firewall to block ports?
Cause: As said above, Notifications are dispatched from the server to the client via listener that sits on the client. With XPSP2 we have firewall enabled by default. Since the firewall will block any message sent to your TCP/HTTP ports, this may not generate Notification event.
Solution: Make sure these are open for the application.
- I get an instantaneous notification telling that the Subscription failed.
Cause: There are set of requirements that are placed on the queries for which are notifiable . Basically, the restrictions are quite similar to restrictions for Indexed Views in SQL Server 2000. More information on these requirements can be found at http://msdn.microsoft.com/library/default.asp?url=/library/en-us/createdb/cm_8_des_06_9jnb.asp
Solution: Queries that pass the above requirements can only be used.
Disclaimer: This posting is provided "AS IS" with no warranties, and confers no rights
I happened to go to one of the class from a mentoring company. It was presented by Bob Beauchemin-Niels Berglund-Dan Sullivan. Boy! they were great!
I was just in time for the ADO.Net presentation that Bob made. He talked about top 3 features that he liked in ADO.Net
1. Provider Factory - He talked at great lengths about how easy it was to use provider factory to write generic code
2. Meta Data/GetSchema - The easy way to get meta data Schema. More information in his article in MSDN - (link)
3. Tracing - Yes, we shipped a way for you to get trace output from System.Data internal code. Now this is the feature that was not that well documented in Beta docs, but this article (written by bob, grin) does a very good job explaining the internals and how to get it working.
It was great to see these guys present. They were awesome and great! (Oh, did I already say that :))
After a brief hiatus, let me start with blogging the new Notification support in SqlClient MP that is introduced in Whidbey. There are scenarios in which an application would store a cache of data obtain from a DB Server and then re-query from the same cache to save round-trips to the server (for better performance). Typically, the app would want some mechanism to be notified when this very cache was changed by some one. In short, this feature allows you to monitor a specified result-set (collection on table rows, as defined by your select statement.) and then notify you when something is changed in the monitored result-set.
In this blog, I will just post a sample illustrating on how easy it is to set a result-set for Notification. In the upcoming blogs, I will get into more details with some gotchas, tips and tricks with Notifications. Lets see how simple its to get this working. Lets say way, create a table test with following TSQL
create table test (i int)
go
insert into test values (1)
insert into test values (2)
insert into test values (3)
insert into test values (4)
go
The following sample shows how a console application that reads data from the 'test' table into its cache and will get notified if some one has made changes to this cache on the server.
using System;
using System.Data;
using System.Data.SqlClient;
class QuikExe
{
string connectionstring = "Put you connection string here";
public void DoDependency()
{
using (SqlConnection conn = new SqlConnection (connectionstring))
{
conn.Open();
Console.WriteLine("Connection Opened...");
SqlCommand cmd = conn.CreateCommand();
cmd.CommandText = "Select i from dbo.test";
//Notification specific code
SqlDependency dep = new SqlDependency (cmd);
dep.OnChanged += new OnChangedEventHandler(TestEvent);
SqlDataReader r = cmd.ExecuteReader();
//Read the data here and close the reader
r.Close();
Console.WriteLine("DataReader Read...");
}
}
void TestEvent(Object o,SqlNotificationEventArgs args)
{
Console.WriteLine("Event Recd");
Console.WriteLine("Info:" + args.Info );
Console.WriteLine("Source:"+args.Source );
Console.WriteLine("Type:"+args.Type );
}
public static void Main()
{
QuikExe q = new QuikExe();
q.DoDependency();
Console.WriteLine("Wait for Notification Event...");
Console.Read();
}
}
Run the above application and you will see the following output
Connection Opened...
DataReader Read...
Wait for Notification Event...
To verify that we indeed get a notification when the test table is change. Now invalidate the cache that we read using the following T-SQL statement (using any client tools-Workbench or another console Application :))
insert into test values (5)
Now, you will see the following Notification message from the above application
Event Recd
Info:Insert
Source:Data
Type:Change
Great! All we did here was to create a SqlDependency object and associate the Command to it before executing.
SqlDependency dep = new SqlDependency (cmd);
Also, to get notified we added a call-back event.
dep.OnChange += new OnChangeEventHandler(TestEvent);
The SqlNotificationEventArgs in turn has three properties which are enums:
1. Info - Gives information on what caused the notification.
2. Source - Gives the source of this notification.
3. Type - Type of notification.
Since in our case an Insert statement caused a Change in Data. The args properties are set as Info=Insert;Source=Data;Type=Change;
Note: Since the supporting functionality that makes this happen (SSB) is only available in SQL Server 2005 (Yukon), the above code will only work with SQL Server 2005.
So how did all this happen? In SQL Server 2005, we have a SSB service running in the MSDB database (called the SqlQueryNotificationService). When a command associated with a SqlDependency executes; it makes a request to this service for being notified if there occurred any change in the obtained result set. When a change occurs, the SSB service then puts a notification message in a specified Queue. The server then send the message from the queue to the client. The client then calls the call-back Event appropriately.
Tips and tricks to be aware while using SqlDependency is coming soon,
Stay posted.
Continuing with the discussion on enumeration, I will go over ways to enumerate active SQL servers on the network in this blog. Pre-Whidbey, to get list of active servers on the network, we could have done Inter-Op calls to server enumeration APIs in OleDb. If we wanted to write only managed code,we could have broad-casted a carefully crafted UDP packet to the network on port 1434 and waited for response from active SQL Servers and then list them.
In Whidbey, there is an API provided to do the server enumeration. It allows to list active servers on the network. Here is the sample code:
using System.Data;
using System.Data.Sql;
using System;
public class Repro
{
public static int Main(string[] args)
{
SqlDataSourceEnumerator sqldatasourceenumerator1 = SqlDataSourceEnumerator.Instance;
DataTable datatable1 = sqldatasourceenumerator1.GetDataSources();
foreach (DataRow row in datatable1.Rows)
{
Console.WriteLine("****************************************");
Console.WriteLine("Server Name:"+row["ServerName"]);
Console.WriteLine("Instance Name:"+row["InstanceName"]);
Console.WriteLine("Is Clustered:"+row["IsClustered"]);
Console.WriteLine("Version:"+row["Version"]);
Console.WriteLine("****************************************");
}
return 1;
}
}
Output:
****************************************
Server Name:TESTSERVER-D1
Instance Name:
Is Clustered:No
Version:8.00.194
****************************************
****************************************
Server Name:TESTSERVER01
Instance Name:INST2
Is Clustered:No
Version:8.00.194
****************************************
****************************************
Server Name:TESTSERVER3
Instance Name:
Is Clustered:No
Version:8.00.194
****************************************
What did we do here? SqlDataSourceEnumerator has a public static property that returns an instance of SqlDataSourceEnumerator . The GetDataSources() method on the Enumerator returns a datatable that returns list of active Servers on the network. Following information about the server is included in the table:
1.Server Name: Name of the server.
2.Instance Name: Name of the SQL Server instance. If its a default instance then this is DBNull.
3.Is Clustered: returns Yes, if Server is clustered, else No.
4.Version: returns the full version number of the server listed.
Q:Why do we have a static property Instance on SqlDataSourceEnumerator ?
A:The Instance property is a result of the factorization of the class. The base class, DbDataSourceEnumerator, defines the abstract GetDataSources method. This way, all derived enumerators have to implement it. This implies the method has to be instance method and cannot be static. To make it easy to write code we just added a static property on SqlDataSourceEnumerator that gives its instance.
Q:Why are some values for InstanceName, IsClustered and Version DBNull?
A:The Enumeration API that SQL Client Managed Provider calls, first broadcasts the 'special' packet on port 1434 and waits for a timeout. The replies that it receives with-in the timeout contain all the required information to populate the DataTable. In addition to this,the API looks at the Active Directory (AD) to list the other servers that did not reply for the broadcast packet. There is no way to know the values for InstanceName, IsClustered and Version when listed via AD and hence they are DBNull.
Q:Why are all servers on the network not listed in the list?
A:Since we wait for a time-out it is not guaranteed that we return all the active servers on the network. In fact, the list is most likely to give a different list depending on the network I/O, server performance and other time-depending constraints.
Disclaimer: This posting is provided "AS IS" with no warranties, and confers no rights
There are situation in real world; when you dont want to write code, dependent on just one of the managed provider. This also helps to easily move from using one provider to another if the code design changes in the future. Pre-Whidbey, the only way to do this was to write your own wrapper classes for the providers. In whidbey this can be done usign ProviderFactories. Here is a sample code:
using System.Data.Common;
using System.Data;
using System;
using System.Data.SqlClient;
namespace DataViewer.Repro
{
public class Repro
{
public static int Main(string[] args)
{
string conString = "ConnectionString here";
string cmdText = "CommandText here";
//Select SQL Client factory - Can change to use any provider later
DbProviderFactory factory = DbProviderFactories.GetFactory("System.Data.SqlClient");
//Create Connection from the factory
DbConnection cn = factory.CreateConnection();
cn.ConnectionString = conString;
cn.Open();
//Create Command from the factory
DbCommand cmd = factory.CreateCommand();
//Execute a command from the conneciton
cmd.Connection = cn;
cmd.CommandText = cmdText;
DbDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
Console.WriteLine(reader.GetValue(0));
}
return 1;
}
}
}
After the provider is selected, there is no reference to any of the managed providers in the above code. The above code infact uses the SqlClient MP. In similar way, you can then use the factories to create Parameter, ConnectionStringBuilder, DataSourceEnumerator, Adapter, CommandBuilder and Permissions classes. Caution:
1. Generalization might also cause an extra overhead.
2. When writing genralized code, you will not be able to use features that are provider specific. You would have to special case them.
Disclaimer: This posting is provided "AS IS" with no warranties, and confers no rights
I have been wanting to post for a long time now, and have finally decided to FIGHT my slackness. I will continue with my views on some of the new features in ADO.Net for Whidbey. I will start with talking about a new feature in Whidbey - Provider Enumeration.
Pre-Whidbey there was no way to know if a particular provider is available on your computer. In addition there was no API from ADO.Net that allowed you to choose a provider at execution time (by some cool looking UI) and then run the Application, written in a provider-independent way with the selected provider. There could be scenarios in which getting this list of providers seamlessly from the API could be useful.
In Whidbey, there is a way to enumerate the providers on the computer. Here is a sample program that does just that:
using System.Data;
using System.Data.Common;
using System;
public class Repro
{
public static int Main(string[] args)
{
DataTable datatable1 = DbProviderFactories.GetFactoryClasses(); // DbProviderFactories
foreach (DataRow row in datatable1.Rows) {
Console.WriteLine("Provider Name:"+row["Name"]);
Console.WriteLine("Provider Description:"+row["Description"]);
Console.WriteLine("Provider Invariant Name:"+ row["InvariantName"]);
Console.WriteLine("**************************************************************");
}
return 1;
}
}
Output:Provider Name:Odbc Data Provider
Provider Description:.Net Framework Data Provider for Odbc
Provider Invariant Name:System.Data.Odbc
**************************************************************
Provider Name:OleDb Data Provider
Provider Description:.Net Framework Data Provider for OleDb
Provider Invariant Name:System.Data.OleDb
**************************************************************
Provider Name:OracleClient Data Provider
Provider Description:.Net Framework Data Provider for Oracle
Provider Invariant Name:System.Data.OracleClient
**************************************************************
Provider Name:SqlClient Data Provider
Provider Description:.Net Framework Data Provider for SqlServer
Provider Invariant Name:System.Data.SqlClient
**************************************************************
What did I just do? The DbProviderFactories has a static method GetFactoryClasses that enumerates through all the providers that are on my system and returns it as a DataTable. Then I iterate throw all the rows in the DataTable in the foreach statement and print the output. The returned table has 5 columns with the following Column Names
- Name: this has the Name of the provider
- Description: describes what the provider does
- InVariantName: returns the invariant name of the assembly
- AssemblyQualifiedName: a fully qualified assembly name
- Supported classes: Gets the value of DbProviderSupportedClasses, which tells the set of of classes (Connection, Command, DataReader, Adapter) that this provider supports.
Q: Where is the information about the provider got from?
A: All this information about the provider is received from the Configuration file. (This could be any of the config file- machine-level, app-level or user-level)
Q: Why doesn't a third party provider does not feature in the list even when the provider is installed on my machine?
A: There is no standard way to know if a 3rd party provider is installed on the system. Since the enumeration shows only the information available in the configuration file, to make it appear in the list the information pertaining to the provider should be mentioned in the config file.
In the next blog, I will post how you can use the Factory classes to build provider independent code. Disclaimer: This posting is provided "AS IS" with no warranties, and confers no rights
In the earlier sections, we have been looking at Untyped XML which are different from Typed XML. Typed XML data type is an XML defined with an associated xml schema in Sql Server 2005. You may ask if there is anything different on how Typed XML are exposed via ADO.Net 2.0. The answer is a heart-warming NO!. Typed XML are exposed the same way that any untyped XML does through SqlDataReader and SqlParameter. Please note that the check to see if the given XML adheres to the give schema is not done on the client side. This check is done when the statement is executed on the server side.
There are new set of columns added to the DataTable returned from SqlDataReader.GetSchemaTable() method that give extra information pertaining to the associated XML Schema. The three columns that are added are:
- XmlSchemaCollectionDatabase:Provides the database in which the schema for this XML type exists.
- XmlSchemaCollectionOwningSchema:Provides the owning relational schema where the schema for this XML instance is located
- XmlSchemaCollectionName: Provides the name of the schema for this XML type.
Consider the typed XML is defined with the following TSQL:
-- Change to Library database
USE Library
-- OrderSchema is defined using the CREATE XML SCHEMA COLLECTION statement
CREATE XML SCHEMA COLLECTION OrderSchema AS
N'XSD_DEFINITION_HERE'--Consider the Schema/namespace
-- Customer table is created with a Typed XML column name OrderXml
CREATE TABLE Customer (CustomerId int, CustomerName varchar(40), OrderXml xml(OrderSchema))
The three-part name of the embedded XML schema can be got as follows:
sqlcommand1.CommandText = "SELECT OrderXml from Customer";
SqlDataReader sqldatareader1 = sqlcommand1.ExecuteReader();
DataTable datatable1 = sqldatareader1.GetSchemaTable(); // SchemaTable
Console.WriteLine(datatable1.Rows[0]["XmlSchemaCollectionDatabase"]); //returns Library
Console.WriteLine(datatable1.Rows[0]["XmlSchemaCollectionOwningSchema"]); //returns dbo
Console.WriteLine(datatable1.Rows[0]["XmlSchemaCollectionName"]); //retuns OrderSchema
Disclaimer: This posting is provided "AS IS" with no warranties, and confers no rights
In this section we will look at ways ADO.Net v2.0 (Code named 'Whidbey') allows us to insert/delete/update Xml data values in a table containing Xml column in SQL Server 2005 (Code named 'Yukon'). With earlier versions of the .Net Framework (1.0 and 1.1) the System.Data.SqlClient namespace will consume and emit XML as String values.Because of this, it should not be a surprise that they would behave the same way with Whidbey. This was made so as to not break customers using this new datatype of the Server with older versions of the framework. Note: The examples below use the Customer table defined in the Part I of the blog.
Xml Values from DataReader: XML values in SqlDataReader are surfaced like any other type. The GetValue() method will get the Xml Value as String where as the GetSqlValue() method will get the value as an instance of SqlString. The following examples show both of the retrieval methods.
Get Value as XmlReader
using (SqlCommand Cmd = Conn.CreateCommand())
{
Cmd.CommandText= "SELECT OrderXml FROM Customer WHERE CustomerId = 2";
SqlDataReader Reader = Cmd.ExecuteReader();
if (Reader.Read())
{
string XmlValue = (string) Reader.GetValue(0); //Gets the XML value as string
}
}
Get Value as SqlXml: With ADO.Net 2.0, we have introduced a new class SqlXml. This new class adds SQL-specific feature like null semantics to the XML type. This is consistent with other SqlTypes (like SqlString for VARCHAR, SqlInt16 for Integer). This class allows the user to create an XmlReader (not to be confused with DataReader) on the SqlXml value using the SqlXml.CreateReader method. An example is shown below:
using (SqlCommand Cmd = Conn.CreateCommand())
{
Cmd.CommandText= "SELECT OrderXml FROM Customer WHERE CustomerId = 2";
SqlDataReader Reader = Cmd.ExecuteReader();
if (Reader.Read())
{
SqlXml SqlXmlValue = Reader.GetSqlXml(0);
PrintXmlReader(SqlXmlValue.CreateReader()); //Gets the XmlReader from SqlXml object and prints it using a Helper function
}
}
Note:
1. In the above examples, SqlClient Managed Provider internally converts the Binary formatted XML that it receives from the server into string representation.
2. To get the XmlReader object for the XML data type, use the SqlXml.CreateReader method.
Parameterized Xml Values
XML values can also be used in parameters. The value itself can be expressed as a string, an XmlReader-derived type instance or a SqlXml object. Examples below show how to set the parameters for each of these values.
Xml Value as String In this example, the string is directly used to set the Parameter's Value
using (SqlConnection Conn = new SqlConnection (ConnectionString))
{
Conn.Open();
using (SqlCommand Cmd = Conn.CreateCommand())
{
//INSERT VALUES using PARAMS
XmlReader XmlValue = new XmlTextReader("Sample.Xml");
Cmd.CommandText = "INSERT INTO Customer VALUES (4,'Chris Andrews',@XmlFile)";
Cmd.Parameters.AddWithValue("@XmlFile", "<order><item><id>20</id><name>Widgets</name><units>3</units></item></order>");
Cmd.ExecuteNonQuery();
}
}
Xml Value as SqlXml
Just like other types, SQL-specific type for XML can be used to set the Parameter's value for XML. SqlXml ctor() takes XmlReader or a Stream. The following example creates an instance of XmlTextReader and then sets the value of the parameter. An instance of XmlTextReader is created by opening a file with name:"Sample.Xml".
using (SqlConnection Conn = new SqlConnection (ConnectionString))
{
Conn.Open();
using (SqlCommand Cmd = Conn.CreateCommand())
{
//INSERT VALUES using PARAMS
Cmd.CommandText = "INSERT INTO Customer VALUES (4,'Chris Andrews',@XmlFile)";
SqlXml SqlXmlValue = new SqlXml( new XmlTextReader ("SampleInfo.Xml")); // This passes the file SampleInfo.Xml as the parameter's value
Cmd.Parameters.AddWithValue("@XmlFile", SqlXmlValue);
Cmd.ExecuteNonQuery();
}
}
Note: You have to make sure that the XmlReader that is passed as an argument is on the top most node, else partial results will be inserted in the table, depending on the current position of the XmlReader.
Disclaimer: This posting is provided "AS IS" with no warranties, and confers no rights
After a long hiatus, let me start with how the new XML data type in SQL Server 2005 is exposed via ADO.Net 2.0. I will discuss this new data type in following parts:
- XML data type in SQL Server 2005 – A brief Introduction : You can consider this as a crash course on XML data type in SQL Server 2005.
- ADO.Net 2.0 and XML DataType
- Getting XML values from SqlDataReader.
- Passing XML values as Parameters
The following is section 1 of the 2 part series:
XML data type in SQL Server 2005 – A brief Introduction
A new scalar data type is introduced in SQL Server 2005 for storage and retrieval of XML data. XML value that is stored in the column is basically an XML fragment like single root, multiple roots, text nodes, empty string, text nodes at the top. Consider you want to create a Customer table with the following Columns:
CustomerId int,
CustomerName varchar(40),
OrderXml xml
Here is an example showing how to create such a table and insert some values as literals using TSQL
Untyped XML
CREATE TABLE Customer (CustomerId int, CustomerName varchar(40), OrderXml xml)
go
INSERT INTO Customer VALUES (1,'Allison Gray',
'<order>
<item>
<id>20</id>
<name>Widgets</name>
<units>3</units>
</item>
</order>')
go
Fact: If the string character is Unicode then the XML values is always parsed in as UTF-16.
Typed XML
The above XML data type is untyped meaning it is not associated with any schema. If we know that OrderXML adheres to one specific XML Schema, we can associate it to a previously loaded XML schema with the following syntax:
-- Consider the Schema/namespace - OrderSchema is defined using the CREATE XML SCHEMA COLLECTION statement
CREATE TABLE Customer (CustomerId int, CustomerName varchar(40), OrderXml xml(OrderSchema))
go
XML Methods
In addition to the above, XML data type has some methods. Some of them are:
- Query method: Given a XQUERY as an argument, this method performs that query on the XML data type.
- Value method: Given a XQUERY as an argument, this method runs the query and returns a scalar value.
- Exist method: Given an XQUERY as an argument, this method returns 1 if the XQuery expression returns a non-empty result from the XML column else it returns 1.
- Modify method: Used to modify XML data. Basically this performs XML data manipulation as specified in the arguments.
Since our goal is to see the interaction of XML data type with ADO.Net, the above introduction would suffice. There are other awesome features on XML data type on the server and are not discussed here due to the scope of the article.
Disclaimer: This posting is provided "AS IS" with no warranties, and confers no rights
