Export SQL Server tables to Excel in c#

This piece of code executes a sql query on a sql server database and returns the result into a excel workbook (with column headings included).

Remember to add the following references (Project > Add Reference > COM)

Microsoft Excel 12.0 Object Library (or an older version)

using System;
using System.Collections.Generic;

using System.Linq;
using System.Text;
using System.Data.SqlClient;

using Excel = Microsoft.Office.Interop.Excel;
using System.Reflection;

namespace ExportDBTablesToExcel
{
 class ExportToExcel
 {

     private Excel.Application app ;

     private Excel.Workbook workbook;
     private Excel.Worksheet previousWorksheet;

     private Excel.Range workSheet_range;

     private string folder;

     private static string CONNECTION_STR = "Data Source=(local);Database=DATABASE_NAME;"
                                                      + "Integrated Security=SSPI;";


     public ExportToExcel(string folder)
     {

         this.folder = folder;

          this.app = null;
          this.workbook = null;

          this.previousWorksheet = null;
          this.workSheet_range = null;

       

          createDoc();
     }

     private void createDoc()

     {
         try
         {
             app = new Excel.Application();

             app.Visible = false;
             workbook = app.Workbooks.Add(1);

          
         }
         catch (Exception e)
         {
             Console.Write(e.ToString());

         }
         finally
         {
         }
     }

     public void shutDown()

     {
         try
         {
             workbook = null;

             app.Quit();
         }
         catch (Exception e)

         {
             Console.Write(e.ToString());
         }

         finally
         {
         }
     }

     public void ExportTable(string query,string sheetName)

     {
         SqlConnection myConnection = new SqlConnection(CONNECTION_STR);

         SqlDataReader myReader = null;

         try
         {

             Excel.Worksheet worksheet = (Excel.Worksheet)workbook.Sheets.Add(Missing.Value, Missing.Value, 1, Excel.XlSheetType.xlWorksheet);

             worksheet.Name = sheetName;

             previousWorksheet = worksheet;



             myConnection.Open();

         
             SqlCommand myCommand = new SqlCommand(query,
                                                      myConnection);

             myReader = myCommand.ExecuteReader();

             int columnCount = myReader.FieldCount;

             for (int n = 0; n < columnCount; n++)

             {
                 Console.Write(myReader.GetName(n) + "\t");

                 createHeaders(worksheet, 1, n + 1, myReader.GetName(n));

             }

             int rowCounter = 2;
             while (myReader.Read())

             {
                 for (int n = 0; n < columnCount; n++)

                 {
                     Console.WriteLine();
                     Console.Write(myReader[myReader.GetName(n)].ToString() + "\t");

                     addData(worksheet, rowCounter, n + 1, myReader[myReader.GetName(n)].ToString());

                 }
                 rowCounter++;
             }


         }

         catch (Exception e)
         {
             Console.WriteLine(e.ToString());

         }
         finally
         {
             if (myReader!=null && !myReader.IsClosed)

             {
                 myReader.Close();
             }

             if (myConnection != null)

             {
                 myConnection.Close();
             }

             myReader = null;
             myConnection = null;
         }

     }


     public void createHeaders(Excel.Worksheet worksheet,int row, int col, string htext)

     {
         worksheet.Cells[row, col] = htext;

     
     }

     public void addData(Excel.Worksheet worksheet,int row, int col, string data)

     {
         worksheet.Cells[row, col] = data;

     } 


     public void SaveWorkbook(){
      
         String folderPath = "C:\\My Files\\" + this.folder ;

         if (!System.IO.Directory.Exists(folderPath)) {

             System.IO.Directory.CreateDirectory(folderPath);

         }

         string fileNameBase = "db" ;
         String fileName = fileNameBase;
         string ext = ".xlsx" ;
         int counter = 1 ;

         while (System.IO.File.Exists(folderPath+fileName+ext)){

             fileName = fileNameBase + counter;
             counter++ ;
         }

         fileName = fileName +ext ;

         string filePath = folderPath + fileName ;

         try
         {
             workbook.SaveAs(filePath, Excel.XlFileFormat.xlWorkbookDefault, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Excel.XlSaveAsAccessMode.xlNoChange, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value);

         }
         catch (Exception e)
         {
             Console.WriteLine(e.ToString());

         }
     }


     static void Main(string[] args)

     {

         ExportToExcel export = new ExportToExcel(args[0]);

         export.ExportTable("SELECT * FROM t_table1","t_table1");
         export.ExportTable("SELECT * FROM t_table2","t_table2");
         export.ExportTable("SELECT * FROM t_table3","t_table3");
         export.SaveWorkbook() ;

         export.shutDown();
     }





 }

}

This code is based on the following links:

http://www.codeproject.com/KB/cs/Excel_and_C_.aspx
and
http://www.codeproject.com/KB/database/sql_in_csharp.aspx?fid=16002&df=90&mpp=25&noise=3&sort=Position&view=Quick&fr=26&select=1490011

SQL Server Cascade Delete

Just came across one of the most useful scripts ever! It can be a real pain in the arse when you need to delete some data from a table , then find out that some data somewhere else depends upon what you want to delete, and some data somewhere else relies on that, and so on and so on.

Well this script from Tim Young, creates a stored procedure that does everything for you. You just pass it the name of your table and some criteria (like user='bob') and it will delete all the referencing data and also print out the DELETE statements it created.

See the link below for a full example and explanation
http://www.sqlteam.com/article/performing-a-cascade-delete-in-sql-server-7

But if you can't wait and just want to see the store procedure, here you go



P.S. I got this to work on SQLServer 2005.

Here’s the code for the procedure:

CREATE Procedure spDeleteRows
/* 
Recursive row delete procedure. 

It deletes all rows in the table specified that conform to the criteria selected, 
while also deleting any child/grandchild records and so on.  This is designed to do the 
same sort of thing as Access's cascade delete function. It first reads the sysforeignkeys 
table to find any child tables, then deletes the soon-to-be orphan records from them using 
recursive calls to this procedure. Once all child records are gone, the rows are deleted 
from the selected table.   It is designed at this time to be run at the command line. It could 
also be used in code, but the printed output will not be available.
*/
 (
 @cTableName varchar(50), /* name of the table where rows are to be deleted */
 @cCriteria nvarchar(1000), /* criteria used to delete the rows required */
 @iRowsAffected int OUTPUT /* number of records affected by the delete */
 )
As
set nocount on
declare  @cTab varchar(255), /* name of the child table */
 @cCol varchar(255), /* name of the linking field on the child table */
 @cRefTab varchar(255), /* name of the parent table */
 @cRefCol varchar(255), /* name of the linking field in the parent table */
 @cFKName varchar(255), /* name of the foreign key */
 @cSQL nvarchar(1000), /* query string passed to the sp_ExecuteSQL procedure */
 @cChildCriteria nvarchar(1000), /* criteria to be used to delete 
                                           records from the child table */
 @iChildRows int /* number of rows deleted from the child table */

/* declare the cursor containing the foreign key constraint information */
DECLARE cFKey CURSOR LOCAL FOR 
SELECT SO1.name AS Tab, 
       SC1.name AS Col, 
       SO2.name AS RefTab, 
       SC2.name AS RefCol, 
       FO.name AS FKName
FROM dbo.sysforeignkeys FK  
INNER JOIN dbo.syscolumns SC1 ON FK.fkeyid = SC1.id 
                              AND FK.fkey = SC1.colid 
INNER JOIN dbo.syscolumns SC2 ON FK.rkeyid = SC2.id 
                              AND FK.rkey = SC2.colid 
INNER JOIN dbo.sysobjects SO1 ON FK.fkeyid = SO1.id 
INNER JOIN dbo.sysobjects SO2 ON FK.rkeyid = SO2.id 
INNER JOIN dbo.sysobjects FO ON FK.constid = FO.id
WHERE SO2.Name = @cTableName

OPEN cFKey
FETCH NEXT FROM cFKey INTO @cTab, @cCol, @cRefTab, @cRefCol, @cFKName
WHILE @@FETCH_STATUS = 0
     BEGIN
 /* build the criteria to delete rows from the child table. As it uses the 
           criteria passed to this procedure, it gets progressively larger with 
           recursive calls */
 SET @cChildCriteria = @cCol + ' in (SELECT [' + @cRefCol + '] FROM [' + 
                              @cRefTab +'] WHERE ' + @cCriteria + ')'
 print 'Deleting records from table ' + @cTab
 /* call this procedure to delete the child rows */
 EXEC spDeleteRows @cTab, @cChildCriteria, @iChildRows OUTPUT
 FETCH NEXT FROM cFKey INTO @cTab, @cCol, @cRefTab, @cRefCol, @cFKName
     END
Close cFKey
DeAllocate cFKey
/* finally delete the rows from this table and display the rows affected  */
SET @cSQL = 'DELETE FROM [' + @cTableName + '] WHERE ' + @cCriteria
print @cSQL
EXEC sp_ExecuteSQL @cSQL
print 'Deleted ' + CONVERT(varchar, @@ROWCOUNT) + ' records from table ' + @cTableName

In the above scenario, we were trying to perform the following :

    DELETE FROM X WHERE field1 = '234'

Using this procedure, we would use the following command:

    exec spDeleteRows 'X', 'field1 = ''234''', 0