Well the current project which im working on is the ASSETTE Presentations. for more information on the project you can see the above link. but the project uses alot of binary data transfered back and forth to the server and the client thorugh our web services, and most of these binary files are stored in SQL Server 2005 Database. storing binary files inside the database really slows down retrieval of the files when we need them and there are several other desadvantages also. specially  rapidly growing size of the database,taking backups, and maintainance of the database. 

But now with SQL Server 2008 we have a new data type called FILESTREAM , to solve all the above issues.

What is FILESTREAM?

FILESTREAM is a new datatype in SQL SERVER 2008. To use FILESTREAM, a database needs to contain a FILESTREAM filegroup and a table which contains a varbinary(max) column with the FILESTREAM attribute set. This causes the Database Engine to store all data for that column in the file system, but not in the database file. A FILESTREAM filegroup is a special folder that contains file system directories known as data containers. These data containers are the interface between Database Engine storage and file system storage through which files in these data containers are maintained by Database Engine.

What FILESTREAM does?

By creating a FILESTREAM filegroup and setting a FILESTREAM attribute on the column of a table, a data container is created which will take care of DML statements.

FILESTREAM will use Windows API for streaming the files so that files can be accessed faster. Also instead of using SQL SERVER cache it will use Windows cache for caching the files accessed.

When you use FILESTREAM storage, consider the following:

• When a table contains a FILESTREAM column, each row must have a unique row ID.
• FILESTREAM data containers cannot be nested.
• When you are using failover clustering, the FILESTREAM filegroups must be on shared disk resources.
• FILESTREAM filegroups can be on compressed volumes.

And I was trying out visual studio 2008 and SQL server 2008 these days. And last night I found out that SQL server now support Tabled valued Parameters which allow us to send data tables as parameters to stored procedures. It still uses the same ADO.Net API.

Now I’m going to show how it works. For this I’m using the same scenario which I used in my previous post (reading contents of a folder and saving their information). here i have used sql server 2008 november ctp and visual c# 2008 express edition.

 First create the table given below:

CREATE TABLE FileDetails(
FileName varchar(50) PRIMARY KEY,
CreatedDate varchar(50) ,
Size decimal(18, 0) )

Then, we should declare a new Table User Defined Type in the database:

create type FileDetailsType as table
(
    FileName        varchar(50),
    CreatedDate        varchar(50),
    Size       decimal(18,0)
)

Then create a stored procedure that gets a parameter of the above type, and inserts many rows in a single command.

create procedure InsertFileDetails
(
    @FileDetails FileDetailsType readonly
)
as

    insert
    into   FileDetails (FileName, CreatedDate, Size)
    select FileName, CreatedDate, Size
    from   @FileDetails;

Then to execute this procedure, we can create a data table and add the rows in to it. And then pass this data table as parameter to the database.

private static void SaveFileDetail(List<FileInfo> info)

 {

  Console.WriteLine(“**********updating with tablevalued parameters****”);

  DataTable dt = preparedatatable();

  foreach (FileInfo file in info)

     {

       DataRow dr = dt.NewRow();

       dr[0] = file.Name;

       dr[1] = file.CreationTime.ToShortDateString();

       dr[2] = (decimal)file.Length;

       dt.Rows.Add(dr);

     }

 

           

 using (SqlConnection conn = new SqlConnection(“your connection string”))

    {

       SqlCommand cmd = conn.CreateCommand();

       cmd.CommandType = System.Data.CommandType.StoredProcedure;

       cmd.CommandText = “dbo.InsertFileDetails”;

       SqlParameter param = cmd.Parameters.AddWithValue(“@FileDetails”, dt);                              

       conn.Open();

       cmd.ExecuteNonQuery();

       Console.WriteLine(“Completed Updating the database”);

     }

Now that’s cool isn’t it????

Download the code 

And few more minutes of research I found out how to perform bulk operations against the databases using OPENXML and stored procedures.

What is OPENXML?

OPENXML is a function added to SQL Server 2000 that provides a row set view over an XML document. Since a row set is simply a set of rows that contain columns of data, OPENXML is the function that allows an XML document to be treated in the familiar relational database format. It allows for the passing of an XML document to a T-SQL stored procedure for updating the data.

OPENXML- Summery

• It extends the SQL Language
• It is used within T-SQL Stored Procedures
  • XML Document passed as parameter
• It uses row and column selectors utilizing XPath
• It supports the following:
  • Attribute and element-centric mappings.
  • Edge table row set.
  • XML annotation/overflow column.
  • Hierarchy support.

OPENXML and ADO.Net

This code block explains the usage of OPENXML to insert bulk data to database. It simulates the actual process I wanted ( processing .eml files) by reading files in a folder and saving their names, created date and size in bytes.

1. First create the table below:
   

   CREATE TABLE FileDetails(

   FileName varchar(50) PRIMARY KEY,

   CreatedDate varchar(50) ,

   Size decimal(18, 0) )

2. And then create the stored procedure below:
   

   CREATE PROC sp_bulkinsert @xmldata varchar(max)

   AS

   DECLARE @hDoc int

   exec sp_xml_preparedocument @hDoc OUTPUT,@xmldata

   –inserting data

   Insert Into FileDetails

   SELECT FileName, CreatedDate, Size

   FROM OPENXML (@hdoc, ‘/ds/fileDetails’,2)

   WITH (FileName varchar(50), CreatedDate Datetime, Size decimal) XMLFileDetails

   Where XMLFileDetails.FileName Not IN (Select FileName from FileDetails)

   EXEC sp_xml_removedocument @hDoc

   GO

3. The below sample code snippet shows how to call this stored procedure to insert bulk data to database at once.

We can retrieve the file details using FileInfo() objects and create a Dataset of the file details and then we can convert this Dataset to xml using WriteXml() Method of the Dataset.

private static string preparexml(DataSet ds)

{

StringBuilder sb = new StringBuilder();

StringWriter sw = new StringWriter(sb);

ds.WriteXml(sw, XmlWriteMode.WriteSchema);

return sb.ToString();

}

This xml representation of the data can be passed as the parameter to the stored procedure as given below :

private static void bulkInsert(string xml)

{

try{

SqlConnection con = creatCon();

con.Open();

SqlCommand cmd = new SqlCommand(”sp_bulkinsert”, con);

cmd.CommandType = CommandType.StoredProcedure;

cmd.Parameters.Add(new SqlParameter(”@xmldata”,SqlDbType.VarChar));

cmd.Parameters["@xmldata"].Value=xml;

cmd.ExecuteNonQuery();

Console.WriteLine(”Completed inserting file informations to database”);

con.Close();

}

catch(Exception ex)

{

Console.WriteLine(ex.Message);

}

}

That’s all simple isn’t it? You can see the performance of this method by writing another code to insert the same fields using the traditional 1 at a time way. Which surprisingly will show a huge difference in performance and time.

You can use the same way to update, delete records in bulk.

The complete code can be downloaded and tested in the below link :

Complete Source Code