/// <summary>
		/// Initializes a new instance of the <see cref="IDbCommandCreatorFactory"/> class.
        /// </summary>
	    public IDbCommandCreatorFactory(IDbProvider dbProvider, CommandType commandType, string sql, IDbParameters declaredParameters)
	    {
            this.dbProvider = dbProvider;
            this.sql = sql;	
		    this.commandType = commandType;
		    this.declaredParameters = declaredParameters;
	    }

 /// <summary>
 /// Copies the parameters from IDbParameters to the parameter collection in IDbCommand
 /// </summary>
 /// <param name="command">The command.</param>
 /// <param name="springParamCollection">The spring param collection.</param>
 public static void CopyParameters(IDbCommand command, IDbParameters springParamCollection)
 {
     if (springParamCollection != null)
     {
         IDataParameterCollection collection = springParamCollection.DataParameterCollection;
         
         foreach (IDbDataParameter parameter in collection)
         {
             IDbDataParameter pClone = (IDbDataParameter)((ICloneable)parameter).Clone();
             command.Parameters.Add(pClone);
         }
     }
 }

        public DataTable ExecuteQueryAll(string tableName, IDbParameters parameters,string paramMark)
        {
            string query = "SELECT * FROM " + tableName;
            if(parameters.Count > 0)
            {
                query += " WHERE ";
            }
            int countParams = 0;
            foreach (IDataParameter dbParameter in parameters.DataParameterCollection)
            {
                countParams++;
                if (countParams > 1) query += " AND ";
                string columnName = dbParameter.ParameterName;
                if(columnName.StartsWith("@")) columnName = columnName.Substring(1);
                query += " " + columnName + "=" + paramMark + dbParameter.ParameterName;

            }
            return AdoTemplate.DataTableCreateWithParams(CommandType.Text, query, parameters);
        }

 public DataAdapterFillCallback(DataTable dataTable,
                                CommandType commandType,
                                string sql,
                                ITableMappingCollection mappingCollection,
                                IDataAdapterSetter dataAdapterSetter,
                                IDataSetFillLifecycleProcessor fillLifecycleProcessor,
                                IDbParameters parameters)
 {
     containsDataSet = false;
     this.dataTable = dataTable;
     this.commandType = commandType;
     this.sql = sql;
     this.mappingCollection = mappingCollection;
     this.dataAdapterSetter = dataAdapterSetter;
     this.fillLifecycleProcessor = fillLifecycleProcessor;
     this.parameters = parameters;
 }

 public virtual int DataTableUpdate(DataTable dataTable,
                                    string tableName,
                                    CommandType insertCommandtype, string insertSql, IDbParameters insertParameters,
                                    CommandType updateCommandtype, string updateSql, IDbParameters updateParameters,
                                    CommandType deleteCommandtype, string deleteSql, IDbParameters deleteParameters,
                                    IDataAdapterSetter dataAdapterSetter)
 {
     ValidateUpdateArguments(dataTable, tableName);
     ITableMappingCollection mappingCollection = DoCreateMappingCollection(new string[] { tableName });
     return DataTableUpdate(dataTable, mappingCollection,
                            insertCommandtype, insertSql, insertParameters,
                            updateCommandtype, updateSql, updateParameters,
                            deleteCommandtype, deleteSql, deleteParameters,
                            dataAdapterSetter);
 }

 /// <summary>
 /// Execute a query with the specified command text and parameters, mapping a single result row
 /// to an object via a RowMapper.
 /// </summary>
 /// <param name="cmdType">The command type.</param>
 /// <param name="cmdText">The command text to execute.</param>
 /// <param name="rowMapperDelegate">delegate that will map one object per row</param>
 /// <param name="parameters">The parameter collection to use in the query.</param>
 /// <returns>The single mapped object.</returns>
 /// <exception cref="Spring.Dao.IncorrectResultSizeDataAccessException">
 /// If the query does not return exactly one row.
 /// </exception>
 /// <exception cref="Spring.Dao.DataAccessException">
 /// If there is any problem executing the query.
 /// </exception>
 public virtual object QueryForObjectDelegate(CommandType cmdType, string cmdText, RowMapperDelegate rowMapperDelegate, IDbParameters parameters)
 {
     IList results = QueryWithRowMapperDelegate(cmdType, cmdText, rowMapperDelegate, parameters);
     return DataAccessUtils.RequiredUniqueResultSet(results);
 }

 public virtual IList QueryWithRowMapperDelegate(CommandType cmdType, string cmdText, RowMapperDelegate rowMapperDelegate,
                                                 IDbParameters parameters)
 {
     return (IList)QueryWithResultSetExtractor(cmdType, cmdText, new RowMapperResultSetExtractor(rowMapperDelegate), parameters);
 }

 public virtual void QueryWithRowCallback(CommandType cmdType, string cmdText, IRowCallback rowCallback, IDbParameters parameters)
 {
     QueryWithResultSetExtractor(cmdType, cmdText, new RowCallbackResultSetExtractor(rowCallback), parameters);
 }

        /// <summary>
        /// Executes a non query returning the number of rows affected.
        /// </summary>
        /// <param name="cmdType">The command type.</param>
        /// <param name="cmdText">The command text to execute.</param>
        /// <param name="parameters">The parameter collection to map.</param>
        /// <returns>The number of rows affected.</returns>
        public virtual int ExecuteNonQuery(CommandType cmdType, string cmdText,
                                           IDbParameters parameters)
        {
            #region Instrumentation
            if (LOG.IsDebugEnabled)
            {
                LOG.Debug("Executing NonQuery.  " + cmdType + "[" + cmdText + "]");
            }
            #endregion

            return (int)Execute(new ExecuteNonQueryCallbackWithParameters(cmdType, cmdText, parameters));

        }

 public ExecuteScalarCallbackWithParameters(CommandType cmdType, string cmdText, IDbParameters dbParameters)
 {
     commandType = cmdType;
     commandText = cmdText;
     parameters = dbParameters;
 }

 public virtual int DataSetFillWithParameters(DataSet dataSet, CommandType commandType, string sql,
                                              IDbParameters parameters,
                                              ITableMappingCollection tableMapping,
                                              IDataAdapterSetter dataAdapterSetter,
                                              IDataSetFillLifecycleProcessor fillLifecycleProcessor)
 {
     ValidateFillWithParameterArguments(dataSet, sql, parameters, tableMapping);
     return (int)Execute(new DataAdapterFillCallback(dataSet,
                                                     commandType, sql,
                                                     tableMapping, dataAdapterSetter, fillLifecycleProcessor, parameters));
 }

 public virtual DataSet DataSetCreateWithParams(CommandType commandType, string sql,
                                                IDbParameters parameters,
                                                ITableMappingCollection tableMapping,
                                                IDataAdapterSetter dataAdapterSetter,
                                                IDataSetFillLifecycleProcessor fillLifecycleProcessor)
 {
     DataSet dataSet = CreateDataSet();
     DataSetFillWithParameters(dataSet, commandType, sql, parameters, tableMapping, dataAdapterSetter, fillLifecycleProcessor);
     return dataSet;
 }

 public DataAdapterUpdateWithCommandBuilderCallback(DataTable dataTable,
                                                    object commandBuilder,
                                                    ITableMappingCollection mappingCollection,
                                                    CommandType selectCommandType,
                                                    string selectSql,
                                                    IDbParameters selectParameters,
                                                    IDataAdapterSetter dataAdapterSetter)
 {
     containsDataSet = false;
     this.dataTable = dataTable;
     this.commandBuilder = commandBuilder;
     this.mappingCollection = mappingCollection;
     this.selectCommandType = selectCommandType;
     this.selectSql = selectSql;
     this.selectParameters = selectParameters;
     this.dataAdapterSetter = dataAdapterSetter;
 }

 public ExecuteNonQueryCallbackWithParameters(CommandType commandType, string commandText, IDbParameters dbParameters)
 {
     this.commandType = commandType;
     this.commandText = commandText;
     parameters = dbParameters;
 }

 public virtual int DataSetUpdateWithCommandBuilder(DataSet dataSet,
                                                    CommandType commandType,
                                                    string selectSql,
                                                    IDbParameters selectParameters,
                                                    string tableName)
 {
     ValidateUpdateWithCommandBuilderArguments(dataSet, tableName, selectSql);
     ITableMappingCollection mappingCollection = DoCreateMappingCollection(new string[] { tableName });
     return (int)Execute(new DataAdapterUpdateWithCommandBuilderCallback(dataSet,
                                                                         DbProvider.CreateCommandBuilder(),
                                                                         mappingCollection,
                                                                         commandType,
                                                                         selectSql,
                                                                         selectParameters,
                                                                         null));
 }

 public QueryCallback(AdoTemplate adoTemplate, CommandType cmdType, string cmdText, ResultSetExtractorDelegate resultSetExtractorDelegate, IDbParameters dbParameters)
 {
     this.adoTemplate = adoTemplate;
     commandType = cmdType;
     commandText = cmdText;
     this.resultSetExtractorDelegate = resultSetExtractorDelegate;
     parameters = dbParameters;
 }

        /// <summary>
        /// Execute the query with the specified command text and parameters returning a scalar result
        /// </summary>
        /// <param name="cmdType">The command type</param>
        /// <param name="cmdText">The command text to execute.</param>
        /// <param name="parameters">The parameter collection to map.</param>
        /// <returns>The first column of the first row in the result set</returns>
        public virtual object ExecuteScalar(CommandType cmdType, string cmdText,
                                    IDbParameters parameters)
        {
            return Execute(new ExecuteScalarCallbackWithParameters(cmdType, cmdText, parameters));

        }

        public virtual int DataSetUpdate(DataSet dataSet,
                                         string tableName,
                                         CommandType insertCommandtype, string insertSql, IDbParameters insertParameters,
                                         CommandType updateCommandtype, string updateSql, IDbParameters updateParameters,
                                         CommandType deleteCommandtype, string deleteSql, IDbParameters deleteParameters)
        {
            ValidateUpdateArguments(dataSet, tableName);
            IDbCommand insertCommand = null;
            if (insertSql != null)
            {
                insertCommand = DbProvider.CreateCommand();
                insertCommand.CommandType = insertCommandtype;
                insertCommand.CommandText = insertSql;
                ParameterUtils.CopyParameters(insertCommand, insertParameters);
            }
            IDbCommand updateCommand = null;
            if (updateSql != null)
            {
                updateCommand = DbProvider.CreateCommand();
                updateCommand.CommandType = updateCommandtype;
                updateCommand.CommandText = updateSql;
                ParameterUtils.CopyParameters(updateCommand, updateParameters);
            }
            IDbCommand deleteCommand = null;
            if (deleteSql != null)
            {
                deleteCommand = DbProvider.CreateCommand();
                deleteCommand.CommandType = deleteCommandtype;
                deleteCommand.CommandText = deleteSql;
                ParameterUtils.CopyParameters(deleteCommand, deleteParameters);
            }
            ITableMappingCollection mappingCollection = DoCreateMappingCollection(new string[] { tableName });

            int returnVal = (int)Execute(new DataAdapterUpdateCallback(dataSet, mappingCollection,
                                                                       insertCommand, updateCommand, deleteCommand, null));

            if (insertSql != null)
            {
                ParameterUtils.CopyParameters(insertParameters, insertCommand);
            }
            if (updateSql != null)
            {
                ParameterUtils.CopyParameters(updateParameters, updateCommand);
            }
            if (deleteSql != null)
            {
                ParameterUtils.CopyParameters(deleteParameters, deleteCommand);
            }
            return returnVal;
        }

        public virtual void QueryWithRowCallbackDelegate(CommandType cmdType, string sql, RowCallbackDelegate rowCallbackDelegate, IDbParameters parameters)
        {
            QueryWithResultSetExtractor(cmdType, sql, new RowCallbackResultSetExtractor(rowCallbackDelegate), parameters);

        }

 public virtual object QueryWithResultSetExtractorDelegate(CommandType cmdType, string cmdText, ResultSetExtractorDelegate resultSetExtractorDelegate,
                                                           IDbParameters parameters)
 {
     AssertUtils.ArgumentNotNull(resultSetExtractorDelegate, "resultSetExtractorDelegate", "Result set extractor delegate must not be null");
     return Execute(new QueryCallback(this, cmdType, cmdText, resultSetExtractorDelegate, parameters));
 }