SqlStatement.cs :  » Persistence-Frameworks » Persist.NET » Persist » Sql » C# / CSharp Open Source

// Persist library : Persistence layer
// Copyright (C) 2003 Vincent Daron
// 
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

using System;
using System.Data;
using System.Text;
using System.Collections;
using System.Collections.Specialized;

namespace Persist.Sql{
  /// <summary>
  /// A Generic class to encappsulate a SQL Statement
  /// </summary>
  public class SqlStatement : System.IDisposable
  {
      private IDbCommand theCommand;
      private StringBuilder theStringBuilder;
      private RelationalDatabase theRelationalDatabase;
      private ArrayList theParameterNames = new ArrayList();
      private int theLastParameterNameRequestedIndex = 0;

      /// <summary>
      /// Create a SQLStatement
      /// </summary>
      /// <param name="relationalDatabase">the Database where the statement will be executed</param>
    public SqlStatement(RelationalDatabase relationalDatabase)
    {
         theRelationalDatabase = relationalDatabase;
         theCommand = relationalDatabase.GetNewCommand();
         theStringBuilder = new StringBuilder();
    }

      /// <summary>
      /// Return the Command associated with this SQLStatement
      /// </summary>
      public IDbCommand DbCommand
      {
         get
         {
            theCommand.CommandText = theStringBuilder.ToString();
            return theCommand;
         }
      }

      /// <summary>
      /// Add a parameter to the statement
      /// </summary>
      /// <param name="paramValue">the parameter name</param>
      /// <param name="paramDbType">the parameter DbType</param>
      public void AddParameter(object paramValue,DbType paramDbType)
      {
         theCommand.Parameters.Add(theRelationalDatabase.GetNewParameter(paramValue,paramDbType,GetLastParameterName()));
      }
      /// <summary>
      /// Copy the SqlStatement
      /// </summary>
      /// <returns>the copy of the SqlStatement</returns>
      public SqlStatement Copy()
      {
         SqlStatement copyObject = new SqlStatement(theRelationalDatabase);
         copyObject.theStringBuilder = theStringBuilder;
         copyObject.theParameterNames = (ArrayList)theParameterNames.Clone();
         return copyObject;
      }
      /// <summary>
      /// Dispose the Statement
      /// Rmq : Dispose is called on the included IDbCommand. But if this command is a OleDbCommand, an exception is thrown so Dispose is'nt called...
      /// </summary>
      public void Dispose()
      {
         if(theCommand != null)
         {
            System.Diagnostics.Debug.WriteLine("Dispose Command");
            if(theCommand is System.Data.OleDb.OleDbCommand)
            {
               System.Diagnostics.Debug.WriteLine("Dispose Cancelled, OleDbCommand detected");
            }
            else
            {
               theCommand.Dispose();
            }
         }
      }
      /// <summary>
      /// Add an SQL clause as text to the Query.
      /// </summary>
      /// <param name="sqlClause"></param>
      public void AddSqlClause(string sqlClause)
      {
         theStringBuilder.Append(sqlClause);
      }
      /// <summary>
      /// Add an SQLStatement to the Query
      /// </summary>
      /// <param name="sqlStatement">the Statement</param>
      public void AddSqlStatement(SqlStatement sqlStatement)
      {
         AddSqlClause(sqlStatement.CommandText);

         for(int i = 0; i < sqlStatement.ParameterCount; i++)
         {
            theCommand.Parameters.Add(sqlStatement.GetParameter(i));
         }

         theParameterNames.AddRange(sqlStatement.theParameterNames);
      }
      /// <summary>
      /// Add a Parameter to the Query
      /// </summary>
      public void AddSqlParameter()
      {
         AddSqlClause(GetNextParameterName());
      }
      private IDataParameter GetParameter(int index)
      {
         return (IDbDataParameter)theCommand.Parameters[index];
      }
      private int ParameterCount
      {
         get
         {
            return theCommand.Parameters.Count;
         }
      }
      private string CommandText
      {
         get
         {
            return theStringBuilder.ToString();
         }
      }

      private string GetNextParameterName()
      {
         string parameterName = theRelationalDatabase.ParameterNamePrefix+"PARAM_"+theParameterNames.Count;
         theParameterNames.Add(parameterName);
         return parameterName;
      }
      private string GetLastParameterName()
      {
         return (string)theParameterNames[theLastParameterNameRequestedIndex++];
      }
  }
}