[Adapdev-commits] Adapdev/src/Adapdev.Data AbstractDAO.cs,1.6,1.7 Adapdev.Data.csproj,1.16,1.17 Comm

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/adapdev/Adapdev/src/Adapdev.Data
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv909/src/Adapdev.Data

Added Files:
	AbstractDAO.cs Adapdev.Data.csproj CommandTextViewer.cs 
	ConnectionStringBuilder.cs DataReaderDebugger.cs 
	DataSetDebugger.cs DbConnectionProvider.cs 
	DbConnectionProviders.cs DbConnectionType.cs 
	DbConnectionTypes.cs DbConstants.cs DbProviderFactory.cs 
	DbProviderType.cs DbProviderTypeConverter.cs DbType.cs 
	DbTypeConverter.cs IDataAccessObject.cs IDataReaderMapper.cs 
	IDataSetAccessObject.cs IDataSetMapper.cs 
	IDbDataAccessObject.cs IDbDataSetAccessObject.cs 
	ITransferObject.cs ProviderInfoManager.cs 
Log Message:


--- NEW FILE: DataReaderDebugger.cs ---
using System;
using System.Data;
using System.Text;

namespace Adapdev.Data
{
	/// <summary>
	/// Summary description for DataReaderDebugger.
	/// </summary>
	public class DataReaderDebugger
	{
		private IDataReader _reader = null;

		public DataReaderDebugger(IDataReader reader)
		{
			this._reader = reader;
		}

		public string Text
		{
			get
			{
				StringBuilder sb = new StringBuilder();
				do
				{
					int i = _reader.FieldCount;
					for(int j = 0; j < i; j++)
					{
						sb.Append(this._reader.GetName(j) + "|");
					}
					sb.Append(Environment.NewLine);


					while(this._reader.Read())
					{
						for(int j = 0; j < i; j++)
						{
							sb.Append(this._reader.GetValue(j).ToString() + "|");
						}
						sb.Append(Environment.NewLine);
					}
					sb.Append(Environment.NewLine);
				}
				while(this._reader.NextResult());

				return sb.ToString();
			}
		}
	}
}

--- NEW FILE: DbProviderFactory.cs ---
namespace Adapdev.Data
{
	using System;
	using System.Data;
	using System.Data.Common;
	using System.Data.OleDb;
	using System.Data.SqlClient;
	using System.Data.OracleClient;
	using MySql.Data.MySqlClient;

	/// <summary>
	/// Provides database neutral access to ADO.NET classes
	/// </summary>
	public class DbProviderFactory
	{
		#region IDbCommand

		/// <summary>
		/// Creates an IDbCommand implementation for the specified DbProviderType
		/// </summary>
		/// <param name="DbProviderType">The DbProviderType to use</param>
		/// <returns></returns>
		public static IDbCommand CreateCommand(DbProviderType DbProviderType)
		{
			switch (DbProviderType)
			{
				case DbProviderType.SQLSERVER:
					return new SqlCommand();
				case DbProviderType.ORACLE:
					return new OracleCommand();
				case DbProviderType.MYSQL:
					return new MySqlCommand();
				default:
					return new OleDbCommand();
			}
		}

		#endregion

		#region IDbConnection

		/// <summary>
		/// Creates an IDbConnection implementation for the specified DbProviderType
		/// </summary>
		/// <param name="DbProviderType"></param>
		/// <returns></returns>
		public static IDbConnection CreateConnection(DbProviderType DbProviderType)
		{
			switch (DbProviderType)
			{
				case DbProviderType.SQLSERVER:
					return new SqlConnection();
				case DbProviderType.ORACLE:
					return new OracleConnection();
				case DbProviderType.MYSQL:
					return new MySqlConnection();
				default:
					return new OleDbConnection();
			}
		}

		#endregion

		#region DbDataAdapter

		public static DbDataAdapter CreateDataAdapter(DbProviderType DbProviderType, IDbCommand command, IDbConnection connection)
		{
			switch (DbProviderType)
			{
				case DbProviderType.SQLSERVER:
					SqlDataAdapter sqlda = new SqlDataAdapter();
					sqlda.SelectCommand = (SqlCommand) command;
					command.Connection = connection;
					return sqlda;
				case DbProviderType.ORACLE:
					OracleDataAdapter orada = new OracleDataAdapter();
					orada.SelectCommand = (OracleCommand) command;
					command.Connection = connection;
					return orada;
				case DbProviderType.MYSQL:
					MySqlDataAdapter mysqlda = new MySqlDataAdapter();
					mysqlda.SelectCommand = (MySqlCommand) command;
					command.Connection = connection;
					return mysqlda;
				default:
					OleDbDataAdapter oleda = new OleDbDataAdapter();
					oleda.SelectCommand = (OleDbCommand) command;
					command.Connection = connection;
					return oleda;
			}
		}

		#endregion

		#region IDataReader

		public static IDataReader CreateDataReader(string connectionString, IDbCommand command, DbProviderType DbProviderType)
		{
			IDbConnection connection = DbProviderFactory.CreateConnection(DbProviderType);
			connection.ConnectionString = connectionString;

			return CreateDataReader(connection, command, DbProviderType);
		}

		public static IDataReader CreateDataReader(string connectionString, string command, DbProviderType DbProviderType)
		{
			IDbConnection connection = DbProviderFactory.CreateConnection(DbProviderType);
			connection.ConnectionString = connectionString;

			IDbCommand cmd = DbProviderFactory.CreateCommand(DbProviderType);
			cmd.CommandText = command;

			return CreateDataReader(connection, cmd, DbProviderType);
		}

		public static IDataReader CreateDataReader(IDbConnection connection, string command, DbProviderType DbProviderType)
		{
			IDbCommand cmd = DbProviderFactory.CreateCommand(DbProviderType);
			cmd.CommandText = command;

			return CreateDataReader(connection, cmd, DbProviderType);
		}

		public static IDataReader CreateDataReader(IDbConnection connection, IDbCommand command, DbProviderType DbProviderType)
		{
			return CreateDataReader(connection, command, CommandBehavior.Default, DbProviderType);
		}

		public static IDataReader CreateDataReader(IDbConnection connection, IDbCommand command, CommandBehavior behavior, DbProviderType DbProviderType)
		{
			IDataReader reader = null;
			command.Connection = connection;
			reader = command.ExecuteReader(behavior);

			return reader;
		}

		#endregion

		#region DataSet

		public static DataSet CreateDataSet(string connectionString, IDbCommand command, DbProviderType DbProviderType)
		{
			IDbConnection connection = DbProviderFactory.CreateConnection(DbProviderType);
			connection.ConnectionString = connectionString;
			return CreateDataSet(connection, command, DbProviderType);
		}

		public static DataSet CreateDataSet(IDbConnection connection, IDbCommand command, DbProviderType DbProviderType)
		{
			DataSet ds = new DataSet();
			DbDataAdapter da = DbProviderFactory.CreateDataAdapter(DbProviderType, command, connection);
			connection.Open();
			da.Fill(ds);
			connection.Close();
			return ds;
		}

		#endregion

		#region DataTable

		public static DataTable CreateDataTable(string connection, IDbCommand command, DbProviderType DbProviderType)
		{
			throw new NotImplementedException();
		}

		#endregion
	}
}
--- NEW FILE: AbstractDAO.cs ---
namespace Adapdev.Data
{
	using System;
	using System.Collections;
	using System.Data;
	using System.Data.Common;
	using System.Data.OleDb;
	using System.Data.SqlClient;
	using Adapdev.Data.Sql;

	/// <summary>
	/// AbstractDAO provides the required base functionality to create a full-featured
	/// Data Access Object.
	/// </summary>
	/// 
	public abstract class AbstractDAO : IDbDataAccessObject, IDbDataSetAccessObject, IDataReaderMapper
	{
		private DbProviderType provider = DbProviderType.SQLSERVER;
		private DbType db = DbType.SQLSERVER;
		private string connectionString = "";
		private string table = "";

		#region Constructors

		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="providerType">The specified provider type</param>
		/// <param name="databaseType">The specified database type</param>
		/// <param name="tableName">The table being accessed</param>
		/// <param name="connectionString">The specified connection string</param>
		public AbstractDAO(DbProviderType providerType, DbType databaseType, string tableName, string connectionString)
		{
			this.provider = providerType;
			this.db = databaseType;
			this.table = tableName;
			this.connectionString = connectionString;
		}

		#endregion

		#region IDataAccessObject Members

		/// <summary>
		/// Saves the specified object to the datastore
		/// </summary>
		/// <param name="o"></param>
		/// 
		public void Save(object o)
		{
			using(IDbConnection connection = this.CreateConnection())
			{
				connection.Open();
				this.ExecuteNonQuery(this.CreateInsertCommand(o), connection);
				this.CustomSave(o, connection);
			}
		}

		/// <summary>
		/// Saves the specified object to the datastore, using the specified open connection
		/// </summary>
		/// <param name="o">The object to save</param>
		/// <param name="conn">The open connection to use</param>
		/// <remarks>The IDbConnection must already be open</remarks>
		public void Save(object o, IDbConnection conn)
		{
			this.ExecuteNonQuery(this.CreateInsertCommand(o), conn);
			this.CustomSave(o, conn);
		}

		/// <summary>
		/// Saves the specified object to the datastore, using the specified open connection
		/// </summary>
		/// <param name="o">The object to save</param>
		/// <param name="conn">The open connection to use</param>
		/// <param name="transaction">The transaction to execute under</param>
		/// <remarks>The IDbConnection must already be open</remarks>
		public void Save(object o, IDbConnection conn, IDbTransaction transaction)
		{
			this.ExecuteNonQuery(this.CreateInsertCommand(o), conn, transaction);
			this.CustomSave(o, conn, transaction);
		}

		/// <summary>
		/// Deletes the specified object by its id
		/// </summary>
		/// <param name="id">The id for the object to delete</param>
		public void Delete(object id)
		{
			this.ExecuteNonQuery(this.CreateDeleteOneCommand(id));
		}

		/// <summary>
		/// Deletes the specified object by its id
		/// </summary>
		/// <param name="id">The id for the object to delete</param>
		/// <param name="conn">The open connection to use</param>
		/// <remarks>The IDbConnection must already be open</remarks>
		public void Delete(object id, IDbConnection conn)
		{
			this.ExecuteNonQuery(this.CreateDeleteOneCommand(id), conn);
		}

		/// <summary>
		/// Deletes the specified object by its id
		/// </summary>
		/// <param name="id">The id for the object to delete</param>
		/// <param name="conn">The open connection to use</param>
		/// <param name="transaction">The transaction to execute under</param>
		/// <remarks>The IDbConnection must already be open</remarks>
		public void Delete(object id, IDbConnection conn, IDbTransaction transaction)
		{
			this.ExecuteNonQuery(this.CreateDeleteOneCommand(id), conn, transaction);
		}

		/// <summary>
		/// Updates the underlying datastore
		/// </summary>
		/// <param name="o">The object to use for the update</param>
		public void Update(object o)
		{
			this.ExecuteNonQuery(this.CreateUpdateCommand(o));
		}

		/// <summary>
		/// Updates the underlying datastore
		/// </summary>
		/// <param name="o">The object to use for the update</param>
		/// <param name="conn">The open connection to use</param>
		/// <remarks>The IDbConnection must already be open</remarks>
		public void Update(object o, IDbConnection conn)
		{
			this.ExecuteNonQuery(this.CreateUpdateCommand(o), conn);
		}

		/// <summary>
		/// Updates the underlying datastore
		/// </summary>
		/// <param name="o">The object to use for the update</param>
		/// <param name="conn">The open connection to use</param>
		/// <param name="transaction">The transaction to execute under</param>
		/// <remarks>The IDbConnection must already be open</remarks>
		public void Update(object o, IDbConnection conn, IDbTransaction transaction)
		{
			this.ExecuteNonQuery(this.CreateUpdateCommand(o), conn, transaction);
		}


		/// <summary>
		/// Selects all records in the underlying datastore
		/// </summary>
		/// <returns></returns>
		public IList SelectAll()
		{
			IList c;
			using (IDbConnection conn = this.CreateConnection())
			{
				conn.Open();
				c = this.SelectAll(conn);
			}
			return c;
		}

		/// <summary>
		/// Selects all records in the underlying datastore, using the specified open IDbConnection
		/// </summary>
		/// <param name="conn">The open IDbConnection to use</param>
		/// <returns></returns>
		public IList SelectAll(IDbConnection conn)
		{
			IList c;
			IDataReader dr = DbProviderFactory.CreateDataReader(conn, this.CreateSelectAllCommand(), this.provider);
			c = this.MapObjects(dr);
			dr.Close();
			return c;
		}

		/// <summary>
		/// Selects a set number of records in the underlying datastore
		/// </summary>
		/// <param name="maxRecords">The number of records to return</param>
		/// <returns></returns>
		public IList SelectAllWithLimit(int maxRecords)
		{
			return this.SelectAllWithLimit(maxRecords, OrderBy.ASCENDING);
		}

		/// <summary>
		/// Selects a set number of records in the underlying datastore, 
		/// using the specified open IDbConnection
		/// </summary>
		/// <param name="maxRecords">The number of records to return</param>
		/// <param name="connection">The open IDbConnection to use</param>
		/// <returns></returns>
		public IList SelectAllWithLimit(int maxRecords, IDbConnection connection)
		{
			return this.SelectAllWithLimit(maxRecords, OrderBy.ASCENDING, connection);
		}

		/// <summary>
		/// Selects a set number of records in the underlying datastore
		/// </summary>
		/// <param name="maxRecords">The number of records to return</param>
		/// <param name="order">The order the records should be returned</param>
		/// <param name="orderColumns">The columns to order by</param>
		/// <returns></returns>
		public IList SelectAllWithLimit(int maxRecords, OrderBy order, params string[] orderColumns)
		{
			ISelectQuery query = QueryFactory.CreateSelectQuery(this.db);
			query.SetTable(this.table);
			query.SetLimit(maxRecords);
			query.OrderBy = order;
			query.AddAll();

			foreach (string s in orderColumns)
			{
				query.AddOrderBy(s);
			}

			return this.Select(query);
		}

		/// <summary>
		/// Selects a set number of records in the underlying datastore
		/// </summary>
		/// <param name="maxRecords">The number of records to return</param>
		/// <param name="order">The order the records should be returned</param>
		/// <param name="connection">The open IDbConnection to use</param>
		/// <param name="orderColumns">The columns to order by</param>
		/// <returns></returns>
		public IList SelectAllWithLimit(int maxRecords, OrderBy order, IDbConnection connection, params string[] orderColumns)
		{
			ISelectQuery query = QueryFactory.CreateSelectQuery(this.db);
			query.SetTable(this.table);
			query.SetLimit(maxRecords);
			query.OrderBy = order;
			query.AddAll();

			foreach (string s in orderColumns)
			{
				query.AddOrderBy(s);
			}

			return this.Select(query, connection);
		}

		/// <summary>
		/// Selects records using the specified query
		/// </summary>
		/// <param name="query">The query to use</param>
		/// <returns></returns>
		public IList Select(ISelectQuery query)
		{
			return this.Select(this.CreateCommand(query.GetText()));
		}

		/// <summary>
		/// Selects records using the specified query
		/// </summary>
		/// <param name="query">The query to use</param>
		/// <param name="connection">The open IDbConnection</param>
		/// <returns></returns>
		public IList Select(ISelectQuery query, IDbConnection connection)
		{
			return this.Select(this.CreateCommand(query.GetText()), connection);
		}

		/// <summary>
		/// Selects records using the specified command
		/// </summary>
		/// <param name="cmd">The command to use</param>
		/// <returns></returns>
		public IList Select(IDbCommand cmd)
		{
			IList c;
			using (IDbConnection conn = this.CreateConnection())
			{
				conn.Open();
				c = this.Select(cmd, conn);
			}
			return c;
		}

		/// <summary>
		/// Selects records using the specified command
		/// </summary>
		/// <param name="cmd">The command to use</param>
		/// <param name="conn">The open IDbConnection to use</param>
		/// <returns></returns>
		public IList Select(IDbCommand cmd, IDbConnection conn)
		{
			IList c;
			IDataReader dr = DbProviderFactory.CreateDataReader(conn, cmd, this.provider);
			c = this.MapObjects(dr);
			dr.Close();

			return c;
		}

		/// <summary>
		/// Selects records using the specified command
		/// </summary>
		/// <param name="command">The command to use</param>
		/// <returns></returns>
		public IList Select(string command)
		{
			return this.Select(this.CreateCommand(command));
		}

		/// <summary>
		/// Selects records using the specified command
		/// </summary>
		/// <param name="command">The command to use</param>
		/// <param name="conn">The open IDbConnection to use</param>
		/// <returns></returns>
		public IList Select(string command, IDbConnection conn)
		{
			return this.Select(this.CreateCommand(command), conn);
		}

		/// <summary>
		/// Selects a specific record, using the passed in id
		/// </summary>
		/// <param name="id">The id for the record to select</param>
		/// <returns></returns>
		public object SelectById(object id)
		{
			return this.SelectOne(id);
		}

		/// <summary>
		/// Selects a specific record, using the passed in id
		/// </summary>
		/// <param name="id">The id for the record to select</param>
		/// <param name="connection">The open IDbConnection to use</param>
		/// <returns></returns>
		public object SelectById(object id, IDbConnection connection)
		{
			return this.SelectOne(id, connection);
		}

		/// <summary>
		/// Selects a specific record, using the passed in id
		/// </summary>
		/// <param name="id">The id for the record to select</param>
		/// <returns></returns>
		/// 
		[Obsolete("Deprecated.  Please use SelectById")]
		public object SelectOne(object id)
		{
			object o;
			using (IDbConnection conn = this.CreateConnection())
			{
				conn.Open();
				o = this.SelectOne(id, conn);
			}
			return o;
		}

		/// <summary>
		/// Selects a specific record, using the passed in id
		/// </summary>
		/// <param name="id">The id for the record to select</param>
		/// <param name="conn">The open IDbConnection to use</param>
		/// <returns></returns>
		[Obsolete("Deprecated.  Please use SelectById")]
		public object SelectOne(object id, IDbConnection conn)
		{
			object o = null;
			IDataReader dr = DbProviderFactory.CreateDataReader(conn, this.CreateSelectOneCommand(id), this.provider);
			while (dr.Read())
			{
				o = this.MapObject(dr);
				break;
			}
			dr.Close();

			return o;
		}

		/// <summary>
		/// Executes the specified command
		/// </summary>
		/// <param name="cmd">The command to use</param>
		public void ExecuteNonQuery(IDbCommand cmd)
		{
			using (IDbConnection conn = this.CreateConnection())
			{
				cmd.Connection = conn;
				conn.Open();
				cmd.ExecuteNonQuery();
			}
		}

		/// <summary>
		/// Executes the specified command
		/// </summary>
		/// <param name="cmd">The command to use</param>
		/// <param name="conn">The open IDbConnection to use</param>
		public void ExecuteNonQuery(IDbCommand cmd, IDbConnection conn)
		{
			cmd.Connection = conn;
			cmd.ExecuteNonQuery();
		}

		/// <summary>
		/// Executes the specified command
		/// </summary>
		/// <param name="cmd">The command to use</param>
		/// <param name="conn">The open IDbConnection to use</param>
		/// <param name="transaction">The transaction to execute under</param>
		public void ExecuteNonQuery(IDbCommand cmd, IDbConnection conn, IDbTransaction transaction)
		{
			cmd.Connection = conn;
			cmd.Transaction = transaction;
			cmd.ExecuteNonQuery();
		}

		/// <summary>
		/// Executes the specified query
		/// </summary>
		/// <param name="query">The query to use</param>
		public void ExecuteNonQuery(INonSelectQuery query)
		{
			this.ExecuteNonQuery(this.CreateCommand(query.GetText()));
		}

		/// <summary>
		/// Executes the specified query
		/// </summary>
		/// <param name="query">The query to use</param>
		/// <param name="connection">The open IDbConnection to use</param>
		public void ExecuteNonQuery(INonSelectQuery query, IDbConnection connection)
		{
			this.ExecuteNonQuery(this.CreateCommand(query.GetText()), connection);
		}

		/// <summary>
		/// Executse the specified command
		/// </summary>
		/// <param name="command">The command to use</param>
		public void ExecuteNonQuery(string command)
		{
			this.ExecuteNonQuery(this.CreateCommand(command));
		}

		/// <summary>
		/// Executes the specified command
		/// </summary>
		/// <param name="command">The command to use</param>
		/// <param name="connection">The open IDbConnection to use</param>
		public void ExecuteNonQuery(string command, IDbConnection connection)
		{
			this.ExecuteNonQuery(this.CreateCommand(command), connection);
		}

		/// <summary>
		/// Executes the specified command
		/// </summary>
		/// <param name="command">The command to use</param>
		/// <param name="connection">The open IDbConnection to use</param>
		/// <param name="transaction">The transaction to execute under</param>
		public void ExecuteNonQuery(string command, IDbConnection connection, IDbTransaction transaction)
		{
			this.ExecuteNonQuery(this.CreateCommand(command), connection, transaction);
		}

		#endregion

		#region IDataSetAccessObject Members

		/// <summary>
		/// Saves the specified DataSet
		/// </summary>
		/// <param name="ds">The DataSet to save</param>
		/// <returns>Number of modified records</returns>
		public int SaveDS(DataSet ds)
		{
			int i;
			using (IDbConnection conn = this.CreateConnection())
			{
				conn.Open();
				i = this.SaveDS(ds, conn);
			}
			return i;
		}

		/// <summary>
		/// Saves the specified DataSet
		/// </summary>
		/// <param name="ds">The DataSet to save</param>
		/// <param name="conn">The open IDbConnection to use</param>
		/// <returns>Number of modified records</returns>
		public virtual int SaveDS(DataSet ds, IDbConnection conn)
		{
			DbDataAdapter da = DbProviderFactory.CreateDataAdapter(this.Provider, this.CreateSelectAllCommand(), conn);
			int modified = 0;
			DataSet modifiedDS = ds.GetChanges();

			if (modifiedDS != null)
			{
				if (this.Provider == DbProviderType.SQLSERVER)
				{
					SqlCommandBuilder cb = new SqlCommandBuilder((SqlDataAdapter) da);
					foreach (DataTable dt in modifiedDS.Tables)
					{
						modified += da.Update(modifiedDS, dt.TableName);
					}
				}
				else
				{
					OleDbCommandBuilder cb = new OleDbCommandBuilder((OleDbDataAdapter) da);
					foreach (DataTable dt in modifiedDS.Tables)
					{
						modified += da.Update(modifiedDS, dt.TableName);
					}
				}
				return modified;
			}
			else
			{
				return 0;
			}
		}

		/// <summary>
		/// Selects all records
		/// </summary>
		/// <returns></returns>
		public DataSet SelectAllDS()
		{
			return this.CreateDataSet(this.CreateSelectAllCommand());
		}

		/// <summary>
		/// Selects all records
		/// </summary>
		/// <param name="conn">The open IDbConnection to use</param>
		/// <returns></returns>
		public DataSet SelectAllDS(IDbConnection conn)
		{
			return this.GetDataSet(this.CreateSelectAllCommand(), conn);
		}

		/// <summary>
		/// Creates a DataSet using the given command
		/// </summary>
		/// <param name="cmd">The command to execute</param>
		/// <returns></returns>
		public DataSet SelectDS(IDbCommand cmd)
		{
			return this.CreateDataSet(cmd);
		}

		/// <summary>
		/// Creates a DataSet using the given command
		/// </summary>
		/// <param name="sql">The sql command to execute</param>
		/// <returns></returns>
		public DataSet SelectDS(string sql)
		{
			return this.SelectDS(this.CreateCommand(sql));
		}

		/// <summary>
		/// Creates a DataSet using the given command
		/// </summary>
		/// <param name="sql">The sql command to execute</param>
		/// <param name="conn">The open IDbConnection to use</param>
		/// <returns></returns>
		public DataSet SelectDS(string sql, IDbConnection conn)
		{
			return this.GetDataSet(this.CreateCommand(sql), conn);
		}

		/// <summary>
		/// Creates a DataSet using the given command
		/// </summary>
		/// <param name="cmd">The command to execute</param>
		/// <param name="conn">The open IDbConnection to use</param>
		/// <returns></returns>
		public DataSet SelectDS(IDbCommand cmd, IDbConnection conn)
		{
			return this.GetDataSet(cmd, conn);
		}

		/// <summary>
		/// Returns one record wrapped in a DataSet
		/// </summary>
		/// <param name="id">The id of the record to select</param>
		/// <returns></returns>
		public DataSet SelectDatasetById(object id)
		{
			return this.SelectOneDS(id);
		}

		/// <summary>
		/// Returns one record wrapped in a DataSet
		/// </summary>
		/// <param name="id">The id of the record to select</param>
		/// <param name="conn">The open IDbConnection to use</param>
		/// <returns></returns>
		public DataSet SelectDatasetById(object id, IDbConnection conn)
		{
			return this.SelectOneDS(id, conn);
		}

		/// <summary>
		/// Returns one record wrapped in a DataSet
		/// </summary>
		/// <param name="id">The id of the record to select</param>
		/// <returns></returns>
		/// 
		[Obsolete("Deprecated.  Please use SelectDataSetById")]
		public DataSet SelectOneDS(object id)
		{
			return this.CreateDataSet(this.CreateSelectOneCommand(id));
		}

		/// <summary>
		/// Returns one record wrapped in a DataSet
		/// </summary>
		/// <param name="id">The id of the record to select</param>
		/// <param name="conn">The open IDbConnection to use</param>
		/// <returns></returns>
		[Obsolete("Deprecated.  Please use SelectDataSetById")]
		public DataSet SelectOneDS(object id, IDbConnection conn)
		{
			return this.GetDataSet(this.CreateSelectOneCommand(id), conn);
		}

		#endregion

		#region IDataReaderMapper Members

		/// <summary>
		/// Maps a collection of objects, using the specified DataReader
		/// </summary>
		/// <param name="dr">The DataReader to use for the object mapping</param>
		/// <returns></returns>
		public IList MapObjects(IDataReader dr)
		{
			ArrayList al = new ArrayList();
			while (dr.Read())
			{
				al.Add(this.MapObject(dr));
			}
			return al;
		}

		#endregion

		#region Other Members

		/// <summary>
		/// Gets the total count of records
		/// </summary>
		/// <returns></returns>
		public int GetCount()
		{
			return this.GetCount(null);
		}

		/// <summary>
		/// Gets the total count of records
		/// </summary>
		/// <param name="criteria">The criteria to query with</param>
		/// <returns></returns>
		public int GetCount(ICriteria criteria)
		{
			int count = 0;

			ISelectQuery query = QueryFactory.CreateSelectQuery(this.db);
			query.SetTable(this.table);
			query.AddCountAll();

			if (criteria != null)
			{
				query.SetCriteria(criteria);
			}

			using (IDbConnection conn = this.CreateConnection())
			{
				conn.Open();

				IDataReader dr = DbProviderFactory.CreateDataReader(conn, this.CreateCommand(query.GetText()), this.provider);
				if (dr.Read())
				{
					count = dr.GetInt32(0);
				}
				dr.Close();
			}
			return count;
		}


		/// <summary>
		/// Creates the correct ISelectQuery implementation for the specified database
		/// </summary>
		/// <returns></returns>
		public ISelectQuery CreateSelectQuery()
		{
			ISelectQuery query = QueryFactory.CreateSelectQuery(this.db, this.provider);
			query.SetTable(this.Table);
			return query;
		}

		/// <summary>
		/// Creates the correct IDeleteQuery implementation for the specified database
		/// </summary>
		/// <returns></returns>
		public IDeleteQuery CreateDeleteQuery()
		{
			IDeleteQuery query = QueryFactory.CreateDeleteQuery(this.db, this.provider);
			query.SetTable(this.Table);
			return query;
		}

		/// <summary>
		/// Creates the correct IInsertQuery implementation for the specified database
		/// </summary>
		/// <returns></returns>
		public IInsertQuery CreateInsertQuery()
		{
			IInsertQuery query = QueryFactory.CreateInsertQuery(this.db, this.provider);
			query.SetTable(this.Table);
			return query;
		}

		/// <summary>
		/// Creates the correct IUpdateQuery implementation for the specified database
		/// </summary>
		/// <returns></returns>
		public IUpdateQuery CreateUpdateQuery()
		{
			IUpdateQuery query = QueryFactory.CreateUpdateQuery(this.db, this.provider);
			query.SetTable(this.Table);
			return query;
		}

		#endregion

		#region Properties

		/// <summary>
		/// The connection string
		/// </summary>
		public string ConnectionString
		{
			get { return this.connectionString; }
			set { this.connectionString = value; }
		}

		/// <summary>
		/// The database provider type
		/// </summary>
		public DbProviderType Provider
		{
			get { return this.provider; }
			set { this.provider = value; }
		}

		/// <summary>
		/// The database type
		/// </summary>
		public DbType Db
		{
			get { return this.db; }
			set { this.db = value; }
		}

		/// <summary>
		/// The name of the table
		/// </summary>
		public string Table
		{
			get { return this.table; }
			set { this.table = value; }
		}

		#endregion

		#region Helper Methods

		/// <summary>
		/// Creates a DataSet, using the given command
		/// </summary>
		/// <param name="cmd">The command to execute</param>
		/// <returns></returns>
		protected DataSet CreateDataSet(IDbCommand cmd)
		{
			return DbProviderFactory.CreateDataSet(this.connectionString, cmd, this.provider);
		}

		/// <summary>
		/// Creates a DataSet, using the given command
		/// </summary>
		/// <param name="cmd">The command to execute</param>
		/// <returns></returns>
		protected DataSet CreateDataSet(string cmd)
		{
			return DbProviderFactory.CreateDataSet(this.connectionString, this.CreateCommand(cmd), this.provider);
		}

		/// <summary>
		/// Creates a DataSet, using the given command
		/// </summary>
		/// <param name="cmd">The command to execute</param>
		/// <param name="conn">The open connection to use</param>
		/// <returns></returns>
		protected DataSet GetDataSet(IDbCommand cmd, IDbConnection conn)
		{
			return DbProviderFactory.CreateDataSet(conn, cmd, this.provider);
		}

		/// <summary>
		/// Creates a connection with the proper connection string filled in
		/// </summary>
		/// <returns></returns>
		public IDbConnection CreateConnection()
		{
			IDbConnection connection = DbProviderFactory.CreateConnection(this.provider);
			connection.ConnectionString = this.connectionString;
			return connection;
		}

		/// <summary>
		/// Creates a command for the correct database provider
		/// and sets the connection
		/// </summary>
		/// <param name="command">The command to execute</param>
		/// <returns></returns>
		public IDbCommand CreateCommand(string command)
		{
			IDbCommand cmd = DbProviderFactory.CreateCommand(this.provider);
			cmd.CommandText = command;
			cmd.Connection = this.CreateConnection();
			return cmd;
		}

		/// <summary>
		/// Creates a command to select all records
		/// </summary>
		/// <returns></returns>
		protected IDbCommand CreateSelectAllCommand()
		{
			IDbCommand command = DbProviderFactory.CreateCommand(this.provider);
			ISelectQuery s = QueryFactory.CreateSelectQuery(this.db);
			s.AddAll();
			s.SetTable(this.Table);
			command.CommandText = s.GetText();
			return command;
		}

		/// <summary>
		/// Creates a command to delete all records
		/// </summary>
		/// <returns></returns>
		protected IDbCommand CreateDeleteAllCommand()
		{
			IDbCommand command = DbProviderFactory.CreateCommand(this.provider);
			IDeleteQuery s = QueryFactory.CreateDeleteQuery(this.db, this.provider);
			s.SetTable(this.Table);
			command.CommandText = s.GetText();
			return command;
		}

		#endregion

		#region Custom Items

		/// <summary>
		/// Used for custom actions when Save is called.  Allows for retrieval
		/// of autoinsert fields, etc. using the open connection.
		/// </summary>
		/// <param name="o"></param>
		/// <param name="connection"></param>
		protected virtual void CustomSave(object o, IDbConnection connection){}

		protected virtual void CustomSave(object o, IDbConnection connection, IDbTransaction transaction){}

		#endregion

		#region Abstract Items

		/// <summary>
		/// Maps an individual object to a DataReader row
		/// </summary>
		/// <param name="dr"></param>
		/// <returns></returns>
		protected abstract object MapObject(IDataReader dr);

		/// <summary>
		/// Selects one record, using the specified id
		/// </summary>
		/// <param name="id">The id of the record to select</param>
		/// <returns></returns>
		protected abstract IDbCommand CreateSelectOneCommand(object id);

		/// <summary>
		/// Updates a record, using the values from the specified object
		/// </summary>
		/// <param name="o"></param>
		/// <returns></returns>
		protected abstract IDbCommand CreateUpdateCommand(object o);

		/// <summary>
		/// Inserts a record, using the values from the specified object
		/// </summary>
		/// <param name="o"></param>
		/// <returns></returns>
		protected abstract IDbCommand CreateInsertCommand(object o);

		/// <summary>
		/// Deletes one record, using the specified id
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		protected abstract IDbCommand CreateDeleteOneCommand(object id);

		#endregion

	}
}
--- NEW FILE: ITransferObject.cs ---
namespace Adapdev.Data
{
	/// <summary>
	/// Represents a Transfer Object (an object that can be passed between
	/// application layers and between remote applications, and is focused purely
	/// on holding data).
	/// </summary>
	/// <remarks>See Martin Fowler's Patterns of Enterprise Applications, or the J2EE
	/// Core Patterns for more information</remarks>
	public interface ITransferObject
	{
	}
}
--- NEW FILE: DbConstants.cs ---
namespace Adapdev.Data
{
	/// <summary>
	/// Provides string representation of database names
	/// </summary>
	public class DbConstants
	{
		public const string SQLSERVER = "sqlserver";
		public const string ORACLE = "oracle";
		public const string ACCESS = "access";
		public const string MYSQL = "mysql";
		public const string DB2 = "db2";

	}
}
--- NEW FILE: DbProviderTypeConverter.cs ---
namespace Adapdev.Data
{
	using System;

	/// <summary>
	/// Summary description for DbProviderTypeConverter.
	/// </summary>
	public class DbProviderTypeConverter
	{
		public static DbProviderType Convert(string s)
		{
			switch (s.Trim().ToLower())
			{
				case "unknown":
					return DbProviderType.UNKNOWN;
				case "db2":
					return DbProviderType.DB2;
				case "mysql":
					return DbProviderType.MYSQL;
				case "odbc":
					return DbProviderType.ODBC;
				case "oledb":
					return DbProviderType.OLEDB;
				case "oracle":
					return DbProviderType.ORACLE;
				case "sqlserver":
				case "sqlclient":
					return DbProviderType.SQLSERVER;
				default:
					throw new Exception("DbProviderType " + s + " not found.");
			}
		}

		public static string Convert(DbProviderType t) {

			switch (t) {
				case DbProviderType.UNKNOWN:
					return "UNKNOWN";
				case DbProviderType.ODBC:
					return "ODBC";
				case DbProviderType.OLEDB:
					return "OLEDB";
				case DbProviderType.ORACLE:
					return "ORACLE";
				case DbProviderType.SQLSERVER:
					return "SQLSERVER";
				case DbProviderType.MYSQL:
					return "MYSQL";
				case DbProviderType.DB2:
					return "DB2";
				default:
					throw new Exception("DbProviderType " + t.ToString() + " not found.");
			}
		}

	}
}
--- NEW FILE: DbTypeConverter.cs ---
namespace Adapdev.Data
{
	using System;

	/// <summary>
	/// Converts strings to their corresponding DbType
	/// </summary>
	public class DbTypeConverter
	{
		public static DbType Convert(string s)
		{
			switch (s.Trim().ToLower())
			{
				case "unknown":
					return DbType.UNKNOWN;
				case "access":
					return DbType.ACCESS;
				case "db2":
					return DbType.DB2;
				case "mysql":
					return DbType.MYSQL;
				case "oracle":
					return DbType.ORACLE;
				case "sqlserver":
				case "sqlclient":
					return DbType.SQLSERVER;
				default:
					throw new Exception("DbType " + s + " not found.");
			}
		}

		public static string Convert(DbType t) {
			switch (t) {
				case DbType.UNKNOWN:
					return "UNKNOWN";
				case DbType.ACCESS:
					return "ACCESS";
				case DbType.DB2:
					return "DB2";
				case DbType.MYSQL:
					return "MYSQL";
				case DbType.ORACLE:
					return "ORACLE";
				case DbType.SQLSERVER:
					return "SQLSERVER";
				default:
					throw new Exception("DbType " + t.ToString() + " not found.");
			}
		}

	}
}

--- NEW FILE: IDataReaderMapper.cs ---
namespace Adapdev.Data
{
	using System.Collections;
	using System.Data;

	/// <summary>
	/// Summary description for IDataReaderMapper.
	/// </summary>
	public interface IDataReaderMapper
	{
		IList MapObjects(IDataReader dr);
	}
}
--- NEW FILE: IDataSetAccessObject.cs ---
namespace Adapdev.Data
{
	using System.Data;

	/// <summary>
	/// Provides DataSet-centric data access
	/// </summary>
	public interface IDataSetAccessObject
	{
		/// <summary>
		/// Persists a DataSet to the underlying datastore
		/// </summary>
		/// <param name="ds">The DataSet to persist</param>
		/// <returns></returns>
		int SaveDS(DataSet ds);
		/// <summary>
		/// Returns a DataSet populated with the record that matches the passed in id
		/// </summary>
		/// <param name="id">The id of the record to retrieve</param>
		/// <returns></returns>
		DataSet SelectOneDS(object id);
		/// <summary>
		/// Returns a DataSet populated with all records from the underlying datastore
		/// </summary>
		/// <returns></returns>
		DataSet SelectAllDS();
	}
}
--- NEW FILE: IDataAccessObject.cs ---
namespace Adapdev.Data
{
	using System.Collections;

	/// <summary>
	/// Provides access to an underlying datastore
	/// </summary>
	public interface IDataAccessObject
	{
		/// <summary>
		/// Saves the specified object to the underlying datastore
		/// </summary>
		/// <param name="o">The object to persist</param>
		void Save(object o);
		/// <summary>
		/// Deletes the specified object from the underlying datastore, using
		/// the passed in id
		/// </summary>
		/// <param name="id">The id of the object to delete</param>
		void Delete(object id);
		/// <summary>
		/// Updates the specified object in the underlying datastore
		/// </summary>
		/// <param name="o">The object to update</param>
		void Update(object o);
		/// <summary>
		/// Selects an IList of objects that match the specified string criteria
		/// </summary>
		/// <param name="s">The criteria to use (for example, an XPath statement, SQL query, etc.)</param>
		/// <returns></returns>
		IList Select(string s);
		/// <summary>
		/// Retrieves all objects in the underlying datastore
		/// </summary>
		/// <returns></returns>
		IList SelectAll();
		/// <summary>
		/// Retrieves an object with the matching id
		/// </summary>
		/// <param name="id">The id of the object to retrieve</param>
		/// <returns></returns>
		object SelectOne(object id);
		/// <summary>
		/// Gets the number of persisted objects in the underlying datastore
		/// </summary>
		/// <returns></returns>
		int GetCount();
	}
}
--- NEW FILE: ProviderInfoManager.cs ---
namespace Adapdev.Data
{
	using System;
	using System.Collections;
	using System.Data;
	using System.IO;
	using System.Reflection;
	using Adapdev.Data.Mappings;
	using Adapdev.Data;
	using Adapdev.Data.Xml;

	/// <summary>
	/// Provides provider specific information related to data types
	/// and their corresponding object types
	/// </summary>
	public class ProviderInfoManager
	{
		private static ProviderInfoManager instance;
		private static readonly Hashtable ht = new Hashtable();
		private static readonly ProvidersInfo ds = new ProvidersInfo();

		/// <summary>
		/// Creates a new <see cref="ProviderInfoManager"/> instance.
		/// </summary>
		private ProviderInfoManager()
		{
			Stream s =Assembly.GetExecutingAssembly().GetManifestResourceStream("Adapdev.Data.Xml.ProviderInfo.xml");
			ds.ReadXml(s);
			this.LoadTypes();
			if (ht.Count == 0)
			{
				throw new Exception("DatabaseProviders contains no information.");
			}
		}

		/// <summary>
		/// Gets the instance.
		/// </summary>
		/// <returns></returns>
		public static ProviderInfoManager GetInstance()
		{
			if (instance == null)
			{
				instance = new ProviderInfoManager();
			}
			return instance;
		}

		/// <summary>
		/// Loads the types.
		/// </summary>
		private void LoadTypes()
		{
			foreach (ProvidersInfo.ProviderInfoRow dr in ds.ProviderInfo.Rows)
			{
				Hashtable tht = new Hashtable();
				ht.Add(dr.Name.Trim().ToLower(), tht);
			}

			foreach (ProvidersInfo.TypeRow tr in ds.Type.Rows)
			{
				Hashtable tht = (Hashtable) ht[tr.ProviderInfoRow.Name.Trim().ToLower()];
				tht.Add(tr.Name.ToLower(), tr);
			}
		}

		/// <summary>
		/// Gets the prefix by name
		/// </summary>
		/// <param name="name">Name.</param>
		/// <param name="typeName">Name of the type.</param>
		/// <returns></returns>
		public string GetPrefixByName(string name, string typeName)
		{
			return this.GetTypeRowByName(name, typeName).Prefix;
		}

		/// <summary>
		/// Gets the prefix by name
		/// </summary>
		/// <param name="ct">Ct.</param>
		/// <param name="typeName">Name of the type.</param>
		/// <returns></returns>
		public string GetPrefixByName(DbProviderType ct, string typeName)
		{
			return this.GetPrefixByName(ct.ToString(), typeName);
		}

		/// <summary>
		/// Gets the postfix by name
		/// </summary>
		/// <param name="name">Name.</param>
		/// <param name="typeName">Name of the type.</param>
		/// <returns></returns>
		public string GetPostfixByName(string name, string typeName)
		{
			return this.GetTypeRowByName(name, typeName).Postfix;
		}

		/// <summary>
		/// Gets the postfix by name
		/// </summary>
		/// <param name="ct">Ct.</param>
		/// <param name="typeName">Name of the type.</param>
		/// <returns></returns>
		public string GetPostfixByName(DbProviderType ct, string typeName)
		{
			return this.GetPostfixByName(ct.ToString(), typeName);
		}

		/// <summary>
		/// Gets the postfix by name
		/// </summary>
		/// <param name="name">Name.</param>
		/// <param name="typeName">Name of the type.</param>
		/// <returns></returns>
		public string GetObjectByName(string name, string typeName)
		{
			return this.GetTypeRowByName(name, typeName).Object;
		}

		/// <summary>
		/// Gets the object by name
		/// </summary>
		/// <param name="providerType">Provider type</param>
		/// <param name="typeName">Name of the type.</param>
		/// <returns></returns>
		public string GetObjectByName(DbProviderType providerType, string typeName)
		{
			return this.GetObjectByName(providerType.ToString(), typeName);
		}

		/// <summary>
		/// Gets the object by id.
		/// </summary>
		/// <param name="name">Name.</param>
		/// <param name="id">Id.</param>
		/// <returns></returns>
		public string GetObjectById(string name, int id)
		{
			ProviderInfo p = this.GetTypeRowById(name, id);
			if (p != null)
				return p.Object;
			else
				return "";
		}

		/// <summary>
		/// Gets the object by id.
		/// </summary>
		/// <param name="ct">Ct.</param>
		/// <param name="id">Id.</param>
		/// <returns></returns>
		public string GetObjectById(DbProviderType ct, int id)
		{
			return this.GetObjectById(ct.ToString(), id);
		}

		/// <summary>
		/// Gets the name by id.
		/// </summary>
		/// <param name="name">Name.</param>
		/// <param name="id">Id.</param>
		/// <returns></returns>
		public string GetNameById(string name, int id)
		{
			ProviderInfo p = this.GetTypeRowById(name, id);
			if (p != null)
				return p.Name;
			else
				return "";
		}

		/// <summary>
		/// Gets the name by id.
		/// </summary>
		/// <param name="providerType">Provider type.</param>
		/// <param name="id">Id.</param>
		/// <returns></returns>
		public string GetNameById(DbProviderType providerType, int id)
		{
			return this.GetNameById(providerType.ToString(), id);
		}

		/// <summary>
		/// Gets the default by id.
		/// </summary>
		/// <param name="name">Name.</param>
		/// <param name="id">Id.</param>
		/// <returns></returns>
		public string GetDefaultById(string name, int id)
		{
			ProviderInfo p = this.GetTypeRowById(name, id);
			if (p != null)
				return p.Default;
			else
				return "";
		}

		/// <summary>
		/// Gets the default by id.
		/// </summary>
		/// <param name="providerType">Provider type.</param>
		/// <param name="id">Id.</param>
		/// <returns></returns>
		public string GetDefaultById(DbProviderType providerType, int id)
		{
			return this.GetDefaultById(providerType.ToString(), id);
		}

		/// <summary>
		/// Gets the test default by id.
		/// </summary>
		/// <param name="name">Name.</param>
		/// <param name="id">Id.</param>
		/// <returns></returns>
		public string GetTestDefaultById(string name, int id)
		{
			ProviderInfo p = this.GetTypeRowById(name, id);
			if (p != null)
				return p.TestDefault;
			else
				return "";
		}

		/// <summary>
		/// Gets the test default by id.
		/// </summary>
		/// <param name="providerType">Provider type.</param>
		/// <param name="id">Id.</param>
		/// <returns></returns>
		public string GetTestDefaultById(DbProviderType providerType, int id)
		{
			return this.GetTestDefaultById(providerType.ToString(), id);
		}

		/// <summary>
		/// Gets the name of the id by.
		/// </summary>
		/// <param name="name">Name.</param>
		/// <param name="typeName">Name of the type.</param>
		/// <returns></returns>
		public int GetIdByName(string name, string typeName)
		{
			return Convert.ToInt32(this.GetTypeRowByName(name, typeName).Id);
		}

		/// <summary>
		/// Gets the name of the id by.
		/// </summary>
		/// <param name="providerType">Provider type.</param>
		/// <param name="typeName">Name of the type.</param>
		/// <returns></returns>
		public int GetIdByName(DbProviderType providerType, string typeName)
		{
			return this.GetIdByName(providerType.ToString(), typeName);
		}

		/// <summary>
		/// Gets the name of the type row by.
		/// </summary>
		/// <param name="name">Name.</param>
		/// <param name="typeName">Name of the type.</param>
		/// <returns></returns>
		protected ProviderInfo GetTypeRowByName(string name, string typeName)
		{
			string _name = name.Trim().ToLower();
			string _typeName = typeName.Trim().ToLower();

			if (ht.Contains(_name))
			{
				Hashtable tht = (Hashtable) ht[_name];
				if (tht.Contains(_typeName))
				{
					ProvidersInfo.TypeRow tr = (ProvidersInfo.TypeRow) tht[_typeName];
					return this.BuildProviderInfo(tr);
				}
			}
			else
			{
				throw new Exception(String.Format("TypeRow not found. name: {0}, typeName: {1}", name, typeName));
			}
			return null;
		}

		/// <summary>
		/// Gets the type row by id.
		/// </summary>
		/// <param name="name">Name.</param>
		/// <param name="id">Id.</param>
		/// <returns></returns>
		protected ProviderInfo GetTypeRowById(string name, int id)
		{
			string _name = name.Trim().ToLower();
			if (ht.Contains(_name))
			{
				Hashtable tht = (Hashtable) ht[_name];
				foreach (DictionaryEntry d in tht)
				{
					ProvidersInfo.TypeRow tr = (ProvidersInfo.TypeRow) d.Value;
					if (tr.Id.Equals(id.ToString())) return this.BuildProviderInfo(tr);
				}
			}
			else
			{
				throw new Exception(String.Format("TypeRow not found. name: {0}, id: {1}", name, id));
			}
			return null;
		}

		/// <summary>
		/// Builds the provider info.
		/// </summary>
		/// <param name="r">Row.</param>
		/// <returns></returns>
		protected ProviderInfo BuildProviderInfo(ProvidersInfo.TypeRow r)
		{
			ProviderInfo pr = new ProviderInfo();
			pr.Default = r.Default;
			pr.Id = r.Id;
			pr.Name = r.Name;
			pr.Object = r.Object;
			pr.Postfix = r.Postfix;
			pr.Prefix = r.Prefix;
			pr.TestDefault = r.TestDefault;

			return pr;
		}
	}

}
--- NEW FILE: IDbDataSetAccessObject.cs ---
namespace Adapdev.Data
{
	using System.Data;

	/// <summary>
	/// Provides DataSet-centric operations
	/// </summary>
	public interface IDbDataSetAccessObject : IDataSetAccessObject
	{
		/// <summary>
		/// Saves a DataSet to the underlying datastore
		/// </summary>
		/// <param name="ds">The dataset to save</param>
		/// <param name="conn">The connection to use</param>
		/// <returns>Number of records affected</returns>
		int SaveDS(DataSet ds, IDbConnection conn);
		/// <summary>
		/// Returns a DataSet, most likely with one DataTable DataRow.  It fills
		/// the DataSet by grabbing a record with a matching id
		/// </summary>
		/// <param name="id">The id of the record to retrieve</param>
		/// <param name="conn">The connection to use</param>
		/// <returns></returns>
		DataSet SelectOneDS(object id, IDbConnection conn);
		/// <summary>
		/// Returns a DataSet populated with all records
		/// </summary>
		/// <param name="conn">The connection to use</param>
		/// <returns></returns>
		DataSet SelectAllDS(IDbConnection conn);
		/// <summary>
		/// Returns a DataSet with records that match the command
		/// </summary>
		/// <param name="cmd">The command to use</param>
		/// <returns></returns>
		DataSet SelectDS(IDbCommand cmd);
		/// <summary>
		/// Returns a DataSet with records that match the command
		/// </summary>
		/// <param name="cmd">The command to use</param>
		/// <param name="conn">The connection to use</param>
		/// <returns></returns>
		DataSet SelectDS(IDbCommand cmd, IDbConnection conn);
		/// <summary>
		/// Executes the specified command
		/// </summary>
		/// <param name="cmd">The command to use</param>
		void ExecuteNonQuery(IDbCommand cmd);
		/// <summary>
		/// Executes the specified command
		/// </summary>
		/// <param name="cmd">The command to use</param>
		/// <param name="conn">The connection to use</param>
		void ExecuteNonQuery(IDbCommand cmd, IDbConnection conn);
	}
}
--- NEW FILE: DbType.cs ---
namespace Adapdev.Data
{
	/// <summary>
	/// Summary description for DbType.
	/// </summary>
	public enum DbType
	{
		UNKNOWN, 
		ACCESS,
		SQLSERVER,
		MYSQL,
		ORACLE,
		DB2
	}
}
--- NEW FILE: CommandTextViewer.cs ---
namespace Adapdev.Data
{
	using System;
	using System.Data;
	using System.Text;

	/// <summary>
	/// CommandStringBuilder takes an IDbCommand and creates a fully filled in sql text, replacing
	/// parameter designations with their actual values
	/// </summary>
	public class CommandTextViewer
	{
		private static readonly ProviderInfoManager dp = ProviderInfoManager.GetInstance();

		/// <summary>
		/// Returns the fully filled-in sql text for a specified IDbCommand
		/// </summary>
		/// <param name="cmd"></param>
		/// <param name="providerType"></param>
		/// <returns></returns>
		public static string Parse(IDbCommand cmd, DbProviderType providerType)
		{
			if (providerType == DbProviderType.OLEDB) 
			{
				return ParseOleDbCommand(cmd);
			}
			else if (providerType == DbProviderType.SQLSERVER)
			{
				return ParseSqlCommand(cmd);
			}
			else if (providerType == DbProviderType.ORACLE) {
				return ParseOracleCommand(cmd);
			}
			else 
				throw new NotImplementedException(providerType.ToString() + " is not currently supported.");
		}

		/// <summary>
		/// This is a worker method, which takes an OleDbCommand and builds the sql text, with the parameter values added into it.
		/// </summary>
		/// <param name="cmd">The command.</param>
		/// <returns>A sql string with all of the parameter values filled in.</returns>
		public static string ParseOleDbCommand(IDbCommand cmd)
		{
			string cmds = cmd.CommandText.ToString().Trim();
			StringBuilder scmds = new StringBuilder(cmds);

			if (cmd.CommandType == CommandType.Text)
			{
				for (int i = cmd.Parameters.Count - 1; i >= 0; i--)
				{
					string pvalue = "";

					string pname = ((IDataParameter) cmd.Parameters[i]).ParameterName;
					if (((IDataParameter) cmd.Parameters[i]).Value == null)
					{
						pvalue = DBNull.Value.ToString();
					}
					else
					{
						pvalue = ((IDataParameter) cmd.Parameters[i]).Value.ToString();
					}
					string ptype = ((IDataParameter) cmd.Parameters[i]).DbType.ToString();

					string prefix = dp.GetPrefixByName("dbtype_oledb", ptype);
					string newValue = prefix + pvalue + prefix;
					//					Console.WriteLine(newValue);

					int qindex = scmds.ToString().LastIndexOf("?");
					//Console.WriteLine(qindex + " : " + scmds.ToString().Length);
					//if(qindex == scmds.ToString().Length - 1) qindex = qindex - 1;
					if (qindex > 0) scmds.Replace("?", newValue, qindex, 1);
				}

				cmds = scmds.ToString();
			}
			else if (cmd.CommandType == CommandType.StoredProcedure)
			{
				StringBuilder sb = new StringBuilder();
				sb.Append("{call ");
				sb.Append(cmds + "(");
				for (int i = 0; i < cmd.Parameters.Count; i++)
				{
					string pvalue = "";

					string pname = ((IDataParameter) cmd.Parameters[i]).ParameterName;
					if (((IDataParameter) cmd.Parameters[i]).Value == null)
					{
						pvalue = DBNull.Value.ToString();
					}
					else
					{
						pvalue = ((IDataParameter) cmd.Parameters[i]).Value.ToString();
					}
					string ptype = ((IDataParameter) cmd.Parameters[i]).DbType.ToString();

					string prefix = dp.GetPrefixByName("dbtype_oledb", ptype);
					string newValue = prefix + pvalue + prefix;
					string comma = ",";

					if (i >= cmd.Parameters.Count - 1)
					{
						comma = "";
					}

					sb.Append(" " + newValue + comma);
				}
				sb.Append(" )}");
				cmds = sb.ToString();
			}

			return cmds;
		}

		/// <summary>
		/// This is a worker method, which takes an SqlCommand and builds the sql text, with the parameter values added into it.
		/// </summary>
		/// <param name="cmd">The command.</param>
		/// <returns>A sql string with all of the parameter values filled in.</returns>
		public static string ParseSqlCommand(IDbCommand cmd)
		{
			string cmds = cmd.CommandText.ToString().Trim();

			if (cmd.CommandType == CommandType.Text)
			{
				for (int i = 0; i < cmd.Parameters.Count; i++)
				{
					string pvalue = "";

					string pname = ((IDataParameter) cmd.Parameters[i]).ParameterName;
					if (((IDataParameter) cmd.Parameters[i]).Value == null)
					{
						pvalue = DBNull.Value.ToString();
					}
					else
					{
						pvalue = ((IDataParameter) cmd.Parameters[i]).Value.ToString();
					}
					string ptype = ((IDataParameter) cmd.Parameters[i]).DbType.ToString();

					string prefix = dp.GetPrefixByName("dbtype_sqlclient", ptype);
					string newValue = prefix + pvalue + prefix;

					cmds = cmds.Replace(pname, newValue);
				}
			}
			else if (cmd.CommandType == CommandType.StoredProcedure)
			{
				StringBuilder sb = new StringBuilder();
				sb.Append("EXEC ");
				sb.Append(cmds);
				for (int i = 0; i < cmd.Parameters.Count; i++)
				{
					string pvalue = "";

					string pname = ((IDataParameter) cmd.Parameters[i]).ParameterName;
					if (((IDataParameter) cmd.Parameters[i]).Value == null)
					{
						pvalue = DBNull.Value.ToString();
					}
					else
					{
						pvalue = ((IDataParameter) cmd.Parameters[i]).Value.ToString();
					}
					string ptype = ((IDataParameter) cmd.Parameters[i]).DbType.ToString();

					string prefix = dp.GetPrefixByName("dbtype_sqlclient", ptype);
					string newValue = prefix + pvalue + prefix;
					string comma = ",";

					if (i >= cmd.Parameters.Count - 1)
					{
						comma = "";
					}

					sb.Append(" " + newValue + comma);
				}
				cmds = sb.ToString();
			}

			return cmds;
		}

		/// <summary>
		/// This is a worker method, which takes an OracleCommand and builds the sql text, 
		/// with the parameter values added into it.
		/// </summary>
		/// <param name="cmd">The command.</param>
		/// <returns>A sql string with all of the parameter values filled in.</returns>
		public static string ParseOracleCommand(IDbCommand cmd) {
			string cmds = cmd.CommandText.ToString().Trim();

			if (cmd.CommandType == CommandType.Text) {
				for (int i = 0; i < cmd.Parameters.Count; i++) {
					string pvalue = "";

					string pname = ((IDataParameter) cmd.Parameters[i]).ParameterName;
					if (((IDataParameter) cmd.Parameters[i]).Value == null) {
						pvalue = DBNull.Value.ToString();
					}
					else {
						pvalue = ((IDataParameter) cmd.Parameters[i]).Value.ToString();
					}
					string ptype = ((IDataParameter) cmd.Parameters[i]).DbType.ToString();

					string prefix = dp.GetPrefixByName("oracle", ptype);
					string newValue = prefix + pvalue + prefix;

					cmds = cmds.Replace(pname, newValue);
				}
			}
			else if (cmd.CommandType == CommandType.StoredProcedure) {
				StringBuilder sb = new StringBuilder();
				sb.Append("CREATE OR REPLACE");
				sb.Append(cmds);
				for (int i = 0; i < cmd.Parameters.Count; i++) {
					string pvalue = "";

					string pname = ((IDataParameter) cmd.Parameters[i]).ParameterName;
					if (((IDataParameter) cmd.Parameters[i]).Value == null) {
						pvalue = DBNull.Value.ToString();
					}
					else {
						pvalue = ((IDataParameter) cmd.Parameters[i]).Value.ToString();
					}
					string ptype = ((IDataParameter) cmd.Parameters[i]).DbType.ToString();

					string prefix = dp.GetPrefixByName("oracle", ptype);
					string newValue = prefix + pvalue + prefix;
					string comma = ",";

					if (i >= cmd.Parameters.Count - 1) {
						comma = "";
					}
					sb.Append(" " + newValue + comma);
				}
				cmds = sb.ToString();
			}
			return cmds;
		}

	}
}
--- NEW FILE: Adapdev.Data.csproj ---
<VisualStudioProject>
    <CSHARP
        ProjectType = "Local"
        ProductVersion = "7.10.3077"
        SchemaVersion = "2.0"
        ProjectGuid = "{08C5794D-44ED-4E75-A1C1-48A28C3D0044}"
    >
        <Build>
            <Settings
                ApplicationIcon = ""
                AssemblyKeyContainerName = ""
                AssemblyName = "Adapdev.Data"
                AssemblyOriginatorKeyFile = ""
                DefaultClientScript = "JScript"
                DefaultHTMLPageLayout = "Grid"
                DefaultTargetSchema = "IE50"
                DelaySign = "false"
                OutputType = "Library"
                PreBuildEvent = ""
                PostBuildEvent = ""
                RootNamespace = "Adapdev.Data"
                RunPostBuildEvent = "OnBuildSuccess"
                StartupObject = ""
            >
                <Config
                    Name = "Debug"
                    AllowUnsafeBlocks = "false"
                    BaseAddress = "285212672"
                    CheckForOverflowUnderflow = "false"
                    ConfigurationOverrideFile = ""
                    DefineConstants = "DEBUG;TRACE"
                    DocumentationFile = ""
                    DebugSymbols = "true"
                    FileAlignment = "4096"
                    IncrementalBuild = "false"
                    NoStdLib = "false"
                    NoWarn = ""
                    Optimize = "false"
                    OutputPath = "bin\Debug\"
                    RegisterForComInterop = "false"
                    RemoveIntegerChecks = "false"
                    TreatWarningsAsErrors = "false"
                    WarningLevel = "4"
                />
                <Config
                    Name = "Release"
                    AllowUnsafeBlocks = "false"
                    BaseAddress = "285212672"
                    CheckForOverflowUnderflow = "false"
                    ConfigurationOverrideFile = ""
                    DefineConstants = "TRACE"
                    DocumentationFile = ""
                    DebugSymbols = "false"
                    FileAlignment = "4096"
                    IncrementalBuild = "false"
                    NoStdLib = "false"
                    NoWarn = ""
                    Optimize = "true"
                    OutputPath = "bin\Release\"
                    RegisterForComInterop = "false"
                    RemoveIntegerChecks = "false"
                    TreatWarningsAsErrors = "false"
                    WarningLevel = "4"
                />
            </Settings>
            <References>
                <Reference
                    Name = "System"
                    AssemblyName = "System"
                    HintPath = "C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.dll"
                />
                <Reference
                    Name = "System.Data"
                    AssemblyName = "System.Data"
                    HintPath = "C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.Data.dll"
                />
                <Reference
                    Name = "System.XML"
                    AssemblyName = "System.Xml"
                    HintPath = "C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.XML.dll"
                />
                <Reference
                    Name = "Adapdev"
                    Project = "{CC30A321-2569-4B1F-8E1A-781B5509B56D}"
                    Package = "{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}"
                />
                <Reference
                    Name = "System.Data.OracleClient"
                    AssemblyName = "System.Data.OracleClient"
                    HintPath = "..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.Data.OracleClient.dll"
                />
    ...
 
[truncated message content]