[Adapdev-commits] Adapdev/src/Adapdev.Data/Sql AccessCriteria.cs,1.4,1.5 AccessDeleteQuery.cs,1.4,1.

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

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

Added Files:
	AccessCriteria.cs AccessDeleteQuery.cs AccessInsertQuery.cs 
	AccessSelectQuery.cs AccessUpdateQuery.cs Criteria.cs 
	CriteriaFactory.cs DeleteQuery.cs DialectConstants.cs 
	ICriteria.cs IDeleteQuery.cs IInsertQuery.cs 
	INonSelectQuery.cs IQuery.cs ISelectQuery.cs IUpdateQuery.cs 
	InsertQuery.cs MySqlCriteria.cs MySqlDeleteQuery.cs 
	MySqlInsertQuery.cs MySqlSelectQuery.cs MySqlUpdateQuery.cs 
	OracleCriteria.cs OracleDeleteQuery.cs OracleInsertQuery.cs 
	OracleSelectQuery.cs OracleUpdateQuery.cs QueryConstants.cs 
	QueryFactory.cs QueryHelper.cs SelectQuery.cs 
	SqlDeleteQuery.cs SqlInsertQuery.cs SqlSelectQuery.cs 
	SqlServerCriteria.cs SqlUpdateQuery.cs UpdateQuery.cs 
Log Message:


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

	/// <summary>
	/// Summary description for ICriteria.
	/// </summary>
	public interface ICriteria
	{
		void AddAnd();
		void AddAndCriteria(ICriteria pc);
		void AddCriteriaSeparator(CriteriaType ct);
		void AddBetween(string columnName, object value1, object value2);
		void AddEqualTo(string columnName, object columnValue);
		void AddEqualTo(string tableName, string columnName, object columnValue);
		void AddEqualTo(string columnName);
		void AddExists(IQuery subQuery);
		void AddGreaterThanOrEqualTo(string columnName, object columnValue);
		void AddGreaterThan(string columnName, object columnValue);
		void AddIn(string columnName, IQuery subQuery);
		void AddIn(string columnName, ICollection values);
		void AddIsNull(string columnName);
		void AddLessThanOrEqualTo(string columnName, object columnValue);
		void AddLessThan(string columnName, object columnValue);
		void AddLike(string columnName, object columnValue);
		void AddNotBetween(string columnName, object value1, object value2);
		void AddNotEqualTo(string columnName, object columnValue);
		void AddNotExists(IQuery subQuery);
		void AddNotIn(string columnName, ICollection values);
		void AddNotIn(string columnName, IQuery subQuery);
		void AddNotLike(string columnName, object columnValue);
		void AddNotNull(string columnName);
		void AddOr();
		void AddOrCriteria(ICriteria pc);
		void AddSql(string sql);
		string GetText();
		DbProviderType DbProviderType { get; set; }
	}
}
--- NEW FILE: OracleCriteria.cs ---
namespace Adapdev.Data.Sql
{
	using System.Collections;
	using System.Text;
	using Adapdev.Text;

	/// <summary>
	/// Summary description for ICriteria.
	/// </summary>
	public class OracleCriteria : Criteria
	{
		public OracleCriteria() : base(DbType.ORACLE, DbProviderType.ORACLE)
		{
		}

		public OracleCriteria(string sql) : base(DbType.ORACLE, DbProviderType.ORACLE, sql)
		{
		}
	}
}
--- NEW FILE: QueryHelper.cs ---
namespace Adapdev.Data.Sql
{
	using System;
	using System.Data;
	using Adapdev.Text;

	/// <summary>
	/// Provides common routines for building queries
	/// </summary>
	public class QueryHelper
	{
		/// <summary>
		/// Surrounds the object with the proper, datastore-specific markup.
		/// </summary>
		/// <param name="o"></param>
		/// <param name="type"></param>
		/// <returns></returns>
		/// <example>
		/// If the passed in object is a date, and the DbType is Access, then the returned value would be #date#.
		/// In contrast, if the DbType is SqlServer, then the returned value would be 'date'.
		/// </example>
		public static string DressUp(object o, Adapdev.Data.DbType type)
		{
			string ro = "";
			if (Util.IsNumeric(o))
			{
				ro = o.ToString();
			}
			else if (Util.IsDateTime(o))
			{
				ro = QueryHelper.GetDateDelimeter(type) + o.ToString() + QueryHelper.GetDateDelimeter(type);
			}
//			else if(o is Boolean)
//			{
//				ro = o.ToString().ToLower();
//			}
			else
			{
				ro = QueryHelper.GetStringDelimeter(type) + o.ToString() + QueryHelper.GetStringDelimeter(type);
			}
			return ro;
		}

		/// <summary>
		/// Gets the proper date delimiter for the specified DbType
		/// </summary>
		/// <param name="type"></param>
		/// <returns></returns>
		public static char GetDateDelimeter(Adapdev.Data.DbType type)
		{
			switch (type)
			{
				case Adapdev.Data.DbType.ACCESS:
					return DialectConstants.ACCESS_DATE;
				case Adapdev.Data.DbType.SQLSERVER:
					return DialectConstants.SQLSERVER_DATE;
				case Adapdev.Data.DbType.ORACLE:
					return DialectConstants.ORACLE_DATE;
				case Adapdev.Data.DbType.MYSQL:
					return DialectConstants.MYSQL_DATE;
				default:
					throw new Exception("DbType " + type + " not supported currently.");
			}
		}

		/// <summary>
		/// Gets the specified
		/// </summary>
		/// <param name="type"></param>
		/// <returns></returns>
		public static char GetPreDelimeter(Adapdev.Data.DbType type)
		{
			switch (type)
			{
				case Adapdev.Data.DbType.ACCESS:
					return DialectConstants.ACCESS_PREDELIM;
				case Adapdev.Data.DbType.SQLSERVER:
					return DialectConstants.SQLSERVER_PREDELIM;
				case Adapdev.Data.DbType.ORACLE:
					return DialectConstants.ORACLE_PREDELIM;
				case Adapdev.Data.DbType.MYSQL:
					return DialectConstants.MYSQL_PREDELIM;
				default:
					throw new Exception("DbType " + type + " not supported currently.");
			}
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="type"></param>
		/// <returns></returns>
		public static char GetPostDelimeter(Adapdev.Data.DbType type)
		{
			switch (type)
			{
				case Adapdev.Data.DbType.ACCESS:
					return DialectConstants.ACCESS_POSTDELIM;
				case Adapdev.Data.DbType.SQLSERVER:
					return DialectConstants.SQLSERVER_POSTDELIM;
				case Adapdev.Data.DbType.ORACLE:
					return DialectConstants.ORACLE_POSTDELIM;
				case Adapdev.Data.DbType.MYSQL:
					return DialectConstants.MYSQL_POSTDELIM;
				default:
					throw new Exception("DbType " + type + " not supported currently.");
			}
		}

		/// <summary>
		/// Gets the datastore-specific string delimiter
		/// </summary>
		/// <param name="type"></param>
		/// <returns></returns>
		public static char GetStringDelimeter(Adapdev.Data.DbType type)
		{
			switch (type)
			{
				case Adapdev.Data.DbType.ACCESS:
					return DialectConstants.ACCESS_STRING;
				case Adapdev.Data.DbType.SQLSERVER:
					return DialectConstants.SQLSERVER_STRING;
				case Adapdev.Data.DbType.ORACLE:
					return DialectConstants.ORACLE_STRING;
				case Adapdev.Data.DbType.MYSQL:
					return DialectConstants.MYSQL_STRING;
				default:
					throw new Exception("DbType " + type + " not supported currently.");
			}
		}

		/// <summary>
		/// Gets the provider type specific parameter name
		/// </summary>
		/// <param name="columnName"></param>
		/// <param name="provider"></param>
		/// <returns></returns>
		public static string GetParameterName(string columnName, DbProviderType provider)
		{
			switch (provider)
			{
				case DbProviderType.SQLSERVER:
					columnName = StringUtil.RemoveSpaces(columnName);
					return "@" + columnName;
				case DbProviderType.ORACLE:
					columnName = StringUtil.RemoveSpaces(columnName);
					return ":" + columnName;
				case DbProviderType.OLEDB:
					return "?";
				case DbProviderType.MYSQL:
					columnName = StringUtil.RemoveSpaces(columnName);
					return "?" + columnName;
				default:
					throw new Exception("DbProviderType " + provider + " is not currently supported.");
			}
		}

		public static string GetSqlServerLastInsertedCommand(string table)
		{
			return "SELECT IDENT_CURRENT('" + table + "');";
		}

		public static string GetSqlServerLastInsertedScopeCommand()
		{
			return "SELECT SCOPE_IDENTITY();";
		}

		public static string GetAccessLastInsertedCommand(string table, string column)
		{
			string s = "SELECT MAX([" + column + "]) FROM [" + table + "];";
			Console.WriteLine(s);
			return s;
		}

		public static string GetOracleLastInsertedCommand(string table, string column) {
			string s = "SELECT MAX(" + column + ") FROM " + table + ";";
			Console.WriteLine(s);
			return s;
		}

		public static string GetMySqlLastInsertedCommand(string table, string column)
		{
			string s = "SELECT `" + column + "` FROM `" + table + "` ORDER BY `" + column + "` DESC LIMIT 1";
			Console.WriteLine(s);
			return s;
		}
	}
}
--- NEW FILE: DeleteQuery.cs ---
namespace Adapdev.Data.Sql
{
	using System.Text;

	public abstract class DeleteQuery : IDeleteQuery
	{
		protected string _table = "";
		protected StringBuilder sb = new StringBuilder();
		protected ICriteria criteria = null;
		protected DbType type = DbType.SQLSERVER;
		protected DbProviderType provider = DbProviderType.SQLSERVER;

		public DeleteQuery(DbType type, DbProviderType provider)
		{
			this.type = type;
			this.provider = provider;
		}

		public DeleteQuery(DbType type, DbProviderType provider, string tableName) : this(type, provider)
		{
			this.SetTable(tableName);
		}

		public void SetCriteria(ICriteria c)
		{
			criteria = c;
		}

		public void SetTable(string tableName)
		{
			this._table = QueryHelper.GetPreDelimeter(this.type) + tableName + QueryHelper.GetPostDelimeter(this.type);
		}

		public ICriteria CreateCriteria()
		{
			return CriteriaFactory.CreateCriteria(this.type);
		}

		public virtual string GetText()
		{
			return "DELETE FROM " + this._table + this.GetCriteria();
		}

		protected string GetCriteria()
		{
			if (this.criteria == null) return "";
			else return criteria.GetText();
		}

		public DbProviderType DbProviderType
		{
			get { return this.provider; }
			set { this.provider = value; }
		}
	}
}
--- NEW FILE: SqlInsertQuery.cs ---
namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for SqlInsertQuery.
	/// </summary>
	public class SqlInsertQuery : InsertQuery
	{
		public SqlInsertQuery() : base(DbType.SQLSERVER, DbProviderType.SQLSERVER)
		{
		}

		public SqlInsertQuery(string tableName) : base(DbType.SQLSERVER, DbProviderType.SQLSERVER, tableName)
		{
		}
	}
}
--- NEW FILE: MySqlSelectQuery.cs ---
using System;

namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for MySqlSelectQuery.
	/// </summary>
	public class MySqlSelectQuery : SelectQuery
	{
		public MySqlSelectQuery():base(DbType.MYSQL, DbProviderType.MYSQL){}
		public MySqlSelectQuery(string table):base(DbType.MYSQL, DbProviderType.MYSQL, table){}

		protected override string GetLimit()
		{
			if (maxRecords > 0)
			{
				return " LIMIT " + maxRecords;
			}
			return "";
		}

		public override string GetText()
		{
			return "SELECT " + this.GetColumns() + " FROM " + this._table + this._join + this.GetCriteria() + this.GetOrderBy() + this.GetGroupBy() + this.GetLimit();	
		}


	}
}

--- NEW FILE: SqlUpdateQuery.cs ---
namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for UpdateQuery.
	/// </summary>
	public class SqlUpdateQuery : UpdateQuery
	{
		public SqlUpdateQuery() : base(DbType.SQLSERVER, DbProviderType.SQLSERVER)
		{
		}

		public SqlUpdateQuery(string tableName) : base(DbType.SQLSERVER, DbProviderType.SQLSERVER, tableName)
		{
		}

	}
}
--- NEW FILE: OracleDeleteQuery.cs ---
namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for SqlDeleteQuery.
	/// </summary>
	public class OracleDeleteQuery : DeleteQuery
	{
		public OracleDeleteQuery() : base(DbType.ORACLE, DbProviderType.ORACLE)
		{
		}

		public OracleDeleteQuery(string tableName) : base(DbType.ORACLE, DbProviderType.ORACLE, tableName)
		{
		}
	}
}
--- NEW FILE: ISelectQuery.cs ---
namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for ISelectQuery.
	/// </summary>
	public interface ISelectQuery : IQuery
	{
		/// <summary>
		/// Adds the specified column
		/// </summary>
		/// <param name="columnName">The name of the column</param>
		void Add(string columnName);
		/// <summary>
		/// Adds the specified table.column
		/// </summary>
		/// <param name="tableName">Name of the table.</param>
		/// <param name="columnName">Name of the column.</param>
		void Add(string tableName, string columnName);
		/// <summary>
		/// Adds the column alias.
		/// </summary>
		/// <param name="tableName">Name of the table.</param>
		/// <param name="columnName">Name of the column.</param>
		/// <param name="alias">Alias.</param>
		void AddColumnAlias(string tableName, string columnName, string alias);
		/// <summary>
		/// Adds the column alias.
		/// </summary>
		/// <param name="columnName">Name of the column.</param>
		/// <param name="alias">Alias.</param>
		void AddColumnAlias(string columnName, string alias);
		/// <summary>
		/// Creates a SELECT * FROM statement, so that individual column names
		/// don't have to be added
		/// </summary>
		void AddAll();
		/// <summary>
		/// Adds a COUNT([columnName]) statement in the datastore specific format
		/// </summary>
		/// <param name="columnName"></param>
		void AddCount(string columnName);
		/// <summary>
		/// Adds a COUNT(*) statement in the datastore specific format
		/// </summary>
		void AddCountAll();
		/// <summary>
		/// Adds a ORDER BY [columnName] statement in the datastore specific format
		/// </summary>
		/// <param name="columnName"></param>
		void AddOrderBy(string columnName);
		/// <summary>
		/// Adds a ORDER BY [table].[column] statement in the datastore specific format
		/// </summary>
		/// <param name="tableName"></param>
		/// <param name="columnName"></param>
		void AddOrderBy(string tableName, string columnName);
		/// <summary>
		/// Adds a ORDER BY [column1], [column2]... statement in the datastore specific format
		/// </summary>
		/// <param name="columns"></param>
		void AddOrderBy(params string[] columns);
		/// <summary>
		/// Adds a GROUP BY [columnName] statement in the datastore specific format
		/// </summary>
		/// <param name="columnName"></param>
		void AddGroupBy(string columnName);
		/// <summary>
		/// Adds a GROUP BY [column1], [column2]... statement in the datastore specific format
		/// </summary>
		/// <param name="columns"></param>
		void AddGroupBy(params string[] columns);
		/// <summary>
		/// Adds a SELECT ... FROM [table] [JoinType] [secondTable] ON [firstTableColumn] = [secondTableColumn]
		/// </summary>
		/// <param name="secondTable">The name of the second table to join on</param>
		/// <param name="firstTableColumn">The name of the first table's join column</param>
		/// <param name="secondTableColumn">The name of the second table's join column</param>
		/// <param name="type">The join type</param>
		void AddJoin(string secondTable, string firstTableColumn, string secondTableColumn, JoinType type);
		/// <summary>
		/// Set's the maximum number of records to retrieve
		/// </summary>
		/// <param name="maxRecords"></param>
		void SetLimit(int maxRecords);
		OrderBy OrderBy { get; set; }
	}

	public enum OrderBy
	{
		ASCENDING,
		DESCENDING
	}

	public enum JoinType
	{
		LEFT,
		RIGHT,
		INNER
	}
}
--- NEW FILE: AccessUpdateQuery.cs ---
using System;

namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for AccessUpdateQuery.
	/// </summary>
	public class AccessUpdateQuery : UpdateQuery
	{
		public AccessUpdateQuery():base(DbType.ACCESS, DbProviderType.OLEDB){}
		public AccessUpdateQuery(string table):base(DbType.ACCESS, DbProviderType.OLEDB, table){}
	}
}

--- NEW FILE: SqlSelectQuery.cs ---
namespace Adapdev.Data.Sql
{
	public class SqlSelectQuery : SelectQuery
	{
		public SqlSelectQuery() : base(DbType.SQLSERVER, DbProviderType.SQLSERVER)
		{
		}

		public SqlSelectQuery(string tableName) : base(DbType.SQLSERVER, DbProviderType.SQLSERVER, tableName)
		{
		}

	}
}
--- NEW FILE: OracleUpdateQuery.cs ---
namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for UpdateQuery.
	/// </summary>
	public class OracleUpdateQuery : UpdateQuery
	{
		public OracleUpdateQuery() : base(DbType.ORACLE, DbProviderType.ORACLE)
		{
		}

		public OracleUpdateQuery(string tableName) : base(DbType.ORACLE, DbProviderType.ORACLE, tableName)
		{
		}

	}
}
--- NEW FILE: AccessCriteria.cs ---
namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for AccessCriteria.
	/// </summary>
	public class AccessCriteria : Criteria
	{
		public AccessCriteria() : base(DbType.ACCESS, DbProviderType.OLEDB)
		{
		}

		public AccessCriteria(string sql) : base(DbType.ACCESS, DbProviderType.OLEDB, sql)
		{
		}
	}
}
--- NEW FILE: CriteriaFactory.cs ---
namespace Adapdev.Data.Sql
{
	using System;

	/// <summary>
	/// Summary description for CriteriaFactory.
	/// </summary>
	public class CriteriaFactory
	{
		public static ICriteria CreateCriteria(DbType type)
		{
			switch (type)
			{
				case DbType.ACCESS:
					return new AccessCriteria();
				case DbType.SQLSERVER:
					return new SqlServerCriteria();
				case DbType.ORACLE:
					return new OracleCriteria();
				case DbType.MYSQL:
					return new MySqlCriteria();
				default:
					throw new Exception("DbType " + type + " not supported currently.");
			}
		}
	}
}
--- NEW FILE: INonSelectQuery.cs ---
namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Represents a query that does not return records
	/// </summary>
	public interface INonSelectQuery : IQuery
	{
	}
}
--- NEW FILE: SqlDeleteQuery.cs ---
namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for SqlDeleteQuery.
	/// </summary>
	public class SqlDeleteQuery : DeleteQuery
	{
		public SqlDeleteQuery() : base(DbType.SQLSERVER, DbProviderType.SQLSERVER)
		{
		}

		public SqlDeleteQuery(string tableName) : base(DbType.SQLSERVER, DbProviderType.SQLSERVER, tableName)
		{
		}
	}
}
--- NEW FILE: IUpdateQuery.cs ---
namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for IUpdateQuery.
	/// </summary>
	public interface IUpdateQuery : INonSelectQuery
	{
		/// <summary>
		/// Adds the columnName to the update query
		/// </summary>
		/// <param name="columnName"></param>
		/// <remarks>Since no value is passed in, the datastore specific parameter representation
		/// will be added</remarks>
		void Add(string columnName);
		/// <summary>
		/// Adds the column name and value to the update query
		/// </summary>
		/// <param name="columnName"></param>
		/// <param name="columnValue"></param>
		void Add(string columnName, object columnValue);
	}
}
--- NEW FILE: InsertQuery.cs ---
namespace Adapdev.Data.Sql
{
	using System.Text;
	using Adapdev.Text;

	/// <summary>
	/// Summary description for UpdateQuery.
	/// </summary>
	public abstract class InsertQuery : IInsertQuery
	{
		protected string _table = "";
		protected StringBuilder sbn = new StringBuilder();
		protected StringBuilder sbv = new StringBuilder();
		protected string[] cnames = new string[100];
		protected string[] cvalues = new string[100];
		protected int cindex = 0;
		protected ICriteria criteria = null;
		protected DbType type = DbType.SQLSERVER;
		protected DbProviderType provider = DbProviderType.SQLSERVER;

		public InsertQuery(DbType type, DbProviderType provider)
		{
			this.type = type;
			this.provider = provider;
		}

		public InsertQuery(DbType type, DbProviderType provider, string tableName) : this(type, provider)
		{
			this.SetTable(tableName);
		}

		public void SetCriteria(ICriteria c)
		{
			criteria = c;
		}

		public void Add(string columnName)
		{
			cnames[cindex] = columnName;
			cvalues[cindex] = QueryHelper.GetParameterName(columnName, this.provider);
			cindex++;
		}

		public void Add(string columnName, object columnValue)
		{
			cnames[cindex] = columnName;
			cvalues[cindex] = QueryHelper.DressUp(columnValue, this.type);
			cindex++;
		}

		public void SetTable(string tableName)
		{
			this._table = QueryHelper.GetPreDelimeter(this.type) + tableName + QueryHelper.GetPostDelimeter(this.type);
		}

		public ICriteria CreateCriteria()
		{
			return CriteriaFactory.CreateCriteria(this.type);
		}

		public virtual string GetText()
		{
			return "INSERT INTO " + this._table + " ( " + this.GetColumnNames() + " ) VALUES ( " + this.GetColumnValues() + " ) " + this.GetCriteria();
		}

		protected string GetColumnNames()
		{
			sbn.Remove(0, sbn.Length);
			for (int i = 0; i <= cindex; i++)
			{
				if (cnames[i] != null && cnames[i].Length > 0)
				{
					sbn.Append(QueryHelper.GetPreDelimeter(this.type) + cnames[i] + QueryHelper.GetPostDelimeter(this.type) + ", ");
				}
			}
			return StringUtil.RemoveFinalComma(this.sbn.ToString());
		}

		protected string GetColumnValues()
		{
			sbv.Remove(0, sbv.Length);
			for (int i = 0; i <= cindex; i++)
			{
				if (cnames[i] != null && cnames[i].Length > 0)
				{
					sbv.Append(cvalues[i] + ", ");
				}
			}
			return StringUtil.RemoveFinalComma(this.sbv.ToString());
		}

		protected string GetCriteria()
		{
			if (this.criteria == null) return "";
			else return criteria.GetText();
		}

		public DbProviderType DbProviderType
		{
			get { return this.provider; }
			set { this.provider = value; }
		}
	}
}
--- NEW FILE: SelectQuery.cs ---
namespace Adapdev.Data.Sql
{
	using System;
	using System.Collections;
	using System.Text;
	using Adapdev.Text;

	public abstract class SelectQuery : ISelectQuery
	{
		protected string _table = "";
		protected StringBuilder sb = new StringBuilder();
		protected Queue order = new Queue();
		protected Queue group = new Queue();
		protected OrderBy ob = OrderBy.ASCENDING;
		protected ICriteria criteria = null;
		protected DbType type = DbType.SQLSERVER;
		protected DbProviderType provider = DbProviderType.SQLSERVER;
		protected int maxRecords = 0;
		protected string _join = "";

		public SelectQuery(DbType type, DbProviderType provider)
		{
			this.type = type;
			this.provider = provider;
		}

		public SelectQuery(DbType type, DbProviderType provider, string tableName): this(type, provider)
		{
			this.SetTable(tableName);
		}

		public void SetCriteria(ICriteria c)
		{
			criteria = c;
		}

		public void Add(string columnName)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(",");
		}

		public void Add(string tableName, string columnName)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(tableName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(".");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(",");
		}

		public void AddColumnAlias(string columnName, string alias)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(" AS ");
			sb.Append(alias);
			sb.Append(",");
		}

		public void AddColumnAlias(string tableName, string columnName, string alias)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(tableName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(".");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(" AS ");
			sb.Append(alias);
			sb.Append(",");
		}

		public void AddAll()
		{
			sb.Append(" * ");
		}

		public virtual void AddCount(string columnName)
		{
			sb.Append(" COUNT(" + QueryHelper.GetPreDelimeter(this.type) + columnName + QueryHelper.GetPostDelimeter(this.type) + ") ");
		}

		public virtual void AddCountAll()
		{
			sb.Append(" COUNT(*) ");
		}

		public void AddOrderBy(string columnName)
		{
			order.Enqueue(QueryHelper.GetPreDelimeter(this.type) + columnName + QueryHelper.GetPostDelimeter(this.type));
		}

		public void AddOrderBy(string tableName, string columnName)
		{
			order.Enqueue(QueryHelper.GetPreDelimeter(this.type) + tableName + QueryHelper.GetPostDelimeter(this.type) + "." + QueryHelper.GetPreDelimeter(this.type) + columnName + QueryHelper.GetPostDelimeter(this.type));
		}

		public void AddOrderBy(string tableName, params string[] columns)
		{
			foreach (string s in columns)
			{
				this.AddOrderBy(tableName, s);
			}
		}

		public void AddOrderBy(params string[] columns)
		{
			foreach (string s in columns)
			{
				this.AddOrderBy(s);
			}
		}

		public void AddGroupBy(string columnName)
		{
			group.Enqueue(QueryHelper.GetPreDelimeter(this.type) + columnName + QueryHelper.GetPostDelimeter(this.type));
		}

		public void AddGroupBy(params string[] columns)
		{
			foreach (string s in columns)
			{
				this.AddGroupBy(s);
			}
		}

		public virtual void AddJoin(string secondTable, string firstTableColumn, string secondTableColumn, JoinType type)
		{
			this._join = String.Format(" {0} {1} ON {2}.{3} = {4}.{5} ",	this.GetJoinType(type), 
																			QueryHelper.GetPreDelimeter(this.type) + secondTable + QueryHelper.GetPostDelimeter(this.type), 
																			QueryHelper.GetPreDelimeter(this.type) + this._table + QueryHelper.GetPostDelimeter(this.type), 
																			QueryHelper.GetPreDelimeter(this.type) + firstTableColumn + QueryHelper.GetPostDelimeter(this.type),
																			QueryHelper.GetPreDelimeter(this.type) + secondTable + QueryHelper.GetPostDelimeter(this.type),
																			QueryHelper.GetPreDelimeter(this.type) + secondTableColumn + QueryHelper.GetPostDelimeter(this.type));
		}

		public void SetTable(string tableName)
		{
			this._table = QueryHelper.GetPreDelimeter(this.type) + tableName + QueryHelper.GetPostDelimeter(this.type);
		}

		public virtual string GetText()
		{
			return "SELECT " + this.GetLimit() + this.GetColumns() + " FROM " + this._table + this._join + this.GetCriteria() + this.GetOrderBy() + this.GetGroupBy();
		}

		/// <summary>
		/// The DbProviderType for this query.  Necessary to determine how to
		/// represent dates, parameters, etc.
		/// </summary>
		public DbProviderType DbProviderType
		{
			get { return this.provider; }
			set { this.provider = value; }
		}

		public OrderBy OrderBy
		{
			get { return this.ob; }
			set { this.ob = value; }
		}

		public void SetLimit(int maxRecords)
		{
			this.maxRecords = maxRecords;
		}

		public ICriteria CreateCriteria()
		{
			return CriteriaFactory.CreateCriteria(this.type);
		}

		protected string GetColumns()
		{
			return StringUtil.RemoveFinalComma(this.sb.ToString());
		}

		protected virtual string GetOrderBy()
		{
			StringBuilder sbo = new StringBuilder();
			if (order.Count > 0)
			{
				sbo.Append(" ORDER BY ");
				IEnumerator enumerator = order.GetEnumerator();
				while (enumerator.MoveNext())
				{
					sbo.Append(enumerator.Current + ", ");
				}
				string s = StringUtil.RemoveFinalComma(sbo.ToString());
				s += this.TranslateOrderBy();
				return s;
			}
			return "";
		}

		protected virtual string GetGroupBy()
		{
			StringBuilder sbo = new StringBuilder();
			if (group.Count > 0)
			{
				sbo.Append(" GROUP BY ");
				IEnumerator enumerator = group.GetEnumerator();
				while (enumerator.MoveNext())
				{
					sbo.Append(enumerator.Current + ", ");
				}
				return StringUtil.RemoveFinalComma(sbo.ToString());
			}
			return "";
		}

		protected virtual string GetLimit()
		{
			if (this.maxRecords > 0)
			{
				return " TOP " + this.maxRecords;
			}
			return "";
		}

		protected string GetCriteria()
		{
			if (this.criteria == null) return "";
			else return criteria.GetText();
		}

		protected string GetJoinType(JoinType type)
		{
			switch (type)
			{
				case JoinType.INNER:
					return "INNER JOIN";
				case JoinType.LEFT:
					return "LEFT OUTER JOIN";
				case JoinType.RIGHT:
					return "RIGHT OUTER JOIN";
				default:
					throw new Exception("JoinType " + type + " not supported.");
			}
		}

		protected virtual string TranslateOrderBy()
		{
			if (this.ob == OrderBy.DESCENDING)
			{
				return " DESC ";
			}
			else
			{
				return " ASC ";
			}
		}
	}

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

	/// <summary>
	/// Creates datastore specific query implementations
	/// </summary>
	public class QueryFactory
	{
		public QueryFactory()
		{
		}

		public static IUpdateQuery CreateUpdateQuery(string db)
		{
			return CreateUpdateQuery(DbTypeConverter.Convert(db));
		}

		public static IUpdateQuery CreateUpdateQuery(string db, DbProviderType provider)
		{
			IUpdateQuery query = QueryFactory.CreateUpdateQuery(db);
			query.DbProviderType = provider;
			return query;
		}

		public static IUpdateQuery CreateUpdateQuery(DbType db)
		{
			switch (db)
			{
				case DbType.ACCESS:
					return new AccessUpdateQuery();
				case DbType.SQLSERVER:
					return new SqlUpdateQuery();
				case DbType.ORACLE:
					return new OracleUpdateQuery();
				case DbType.MYSQL:
					return new MySqlUpdateQuery();
				default:
					throw new System.NotImplementedException("DbType " + db + " not supported currently.");
			}
		}

		public static IUpdateQuery CreateUpdateQuery(DbType db, DbProviderType provider)
		{
			IUpdateQuery query = QueryFactory.CreateUpdateQuery(db);
			query.DbProviderType = provider;
			return query;
		}

		public static ISelectQuery CreateSelectQuery(string db)
		{
			return CreateSelectQuery(DbTypeConverter.Convert(db));
		}

		public static ISelectQuery CreateSelectQuery(DbType db)
		{
			switch (db)
			{
				case DbType.ACCESS:
					return new AccessSelectQuery();
				case DbType.SQLSERVER:
					return new SqlSelectQuery();
				case DbType.ORACLE:
					return new OracleSelectQuery();
				case DbType.MYSQL:
					return new MySqlSelectQuery();
				default:
					throw new System.NotImplementedException("DbType " + db + " not supported currently.");			
			}
		}

		public static ISelectQuery CreateSelectQuery(DbType db, DbProviderType provider)
		{
			ISelectQuery query = QueryFactory.CreateSelectQuery(db);
			query.DbProviderType = provider;
			return query;
		}

		public static IDeleteQuery CreateDeleteQuery(string db)
		{
			return CreateDeleteQuery(DbTypeConverter.Convert(db));
		}

		public static IDeleteQuery CreateDeleteQuery(string db, DbProviderType provider)
		{
			IDeleteQuery query = QueryFactory.CreateDeleteQuery(db);
			query.DbProviderType = provider;
			return query;
		}

		public static IDeleteQuery CreateDeleteQuery(DbType db)
		{
			switch (db)
			{
				case DbType.ACCESS:
					return new AccessDeleteQuery();
				case DbType.SQLSERVER:
					return new SqlDeleteQuery();
				case DbType.ORACLE:
					return new OracleDeleteQuery();
				case DbType.MYSQL:
					return new MySqlDeleteQuery();
				default:
					throw new System.NotImplementedException("DbType " + db + " not supported currently.");
			}
		}

		public static IDeleteQuery CreateDeleteQuery(DbType db, DbProviderType provider)
		{
			IDeleteQuery query = QueryFactory.CreateDeleteQuery(db);
			query.DbProviderType = provider;
			return query;
		}

		public static IInsertQuery CreateInsertQuery(string db)
		{
			return CreateInsertQuery(DbTypeConverter.Convert(db));
		}

		public static IInsertQuery CreateInsertQuery(string db, DbProviderType provider)
		{
			IInsertQuery query = QueryFactory.CreateInsertQuery(db);
			query.DbProviderType = provider;
			return query;
		}

		public static IInsertQuery CreateInsertQuery(DbType db)
		{
			switch (db)
			{
				case DbType.ACCESS:
					return new AccessInsertQuery();
				case DbType.SQLSERVER:
					return new SqlInsertQuery();
				case DbType.ORACLE:
					return new OracleInsertQuery();
				case DbType.MYSQL:
					return new MySqlInsertQuery();
				default:
					throw new System.NotImplementedException("DbType " + db + " not supported currently.");
			}
		}

		public static IInsertQuery CreateInsertQuery(DbType db, DbProviderType provider)
		{
			IInsertQuery query = QueryFactory.CreateInsertQuery(db);
			query.DbProviderType = provider;
			return query;
		}
	}
}
--- NEW FILE: MySqlCriteria.cs ---
namespace Adapdev.Data.Sql
{
	using System.Collections;
	using System.Text;
	using Adapdev.Text;

	/// <summary>
	/// Summary description for MySqlCriteria.
	/// </summary>
	public class MySqlCriteria : Criteria
	{
		public MySqlCriteria() : base(DbType.MYSQL, DbProviderType.MYSQL)
		{
		}

		public MySqlCriteria(string sql) : base(DbType.MYSQL, DbProviderType.MYSQL, sql)
		{
		}
	}
}
--- NEW FILE: MySqlInsertQuery.cs ---
using System;

namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for MySqlInsertQuery.
	/// </summary>
	public class MySqlInsertQuery : InsertQuery
	{
		public MySqlInsertQuery():base(DbType.MYSQL, DbProviderType.MYSQL){}
		public MySqlInsertQuery(string table):base(DbType.MYSQL, DbProviderType.MYSQL, table){}
	}
}

--- NEW FILE: AccessInsertQuery.cs ---
using System;

namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for AccessInsertQuery.
	/// </summary>
	public class AccessInsertQuery : InsertQuery
	{
		public AccessInsertQuery():base(DbType.ACCESS, DbProviderType.OLEDB){}
		public AccessInsertQuery(string table):base(DbType.ACCESS, DbProviderType.OLEDB, table){}
	}
}

--- NEW FILE: Criteria.cs ---
namespace Adapdev.Data.Sql
{
	using System.Collections;
	using System.Text;
	using Adapdev.Text;

	/// <summary>
	/// Summary description for Criteria.
	/// </summary>
	public abstract class Criteria : ICriteria
	{
		protected StringBuilder sb = new StringBuilder();
		protected DbType type = DbType.SQLSERVER;
		protected DbProviderType provider = DbProviderType.SQLSERVER;

		public Criteria(DbType type, DbProviderType provider)
		{
			this.type = type;
			this.provider = provider;
		}

		public Criteria(DbType type, DbProviderType provider, string sql): this(type, provider)
		{
			sql = sql.Replace("WHERE", "");
			this.AddSql(sql);
		}

		public void AddAnd()
		{
			this.AddCriteriaSeparator(CriteriaType.AND);
		}

		public virtual void AddAndCriteria(ICriteria c)
		{
			this.AddAnd();
			sb.Append("(");
			sb.Append(c.GetText());
			sb.Append(") ");
		}

		public virtual void AddCriteriaSeparator(CriteriaType ct)
		{
			if (ct == CriteriaType.AND) sb.Append(" AND ");
			else sb.Append(" OR ");
		}

		public virtual void AddBetween(string columnName, object value1, object value2)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(" BETWEEN ");
			sb.Append(QueryHelper.DressUp(value1,this.type));
			sb.Append(" AND ");
			sb.Append(QueryHelper.DressUp(value2,this.type));
			sb.Append(" ");
		}

		public virtual void AddEqualTo(string columnName, object columnValue)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(" = ");
			sb.Append(QueryHelper.DressUp(columnValue,this.type));
			sb.Append(" ");
		}

		public virtual void AddEqualTo(string tableName, string columnName, object columnValue)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(tableName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(".");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(" = ");
			sb.Append(QueryHelper.DressUp(columnValue,this.type));
			sb.Append(" ");
		}

		public void AddEqualTo(string columnName)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(" = ");
			sb.Append(QueryHelper.GetParameterName(columnName, this.DbProviderType));
			sb.Append(" ");
		}

		public virtual void AddExists(IQuery subQuery)
		{
		}

		public virtual void AddGreaterThanOrEqualTo(string columnName, object columnValue)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(" >= ");
			sb.Append(QueryHelper.DressUp(columnValue,this.type));
			sb.Append(" ");
		}

		public virtual void AddGreaterThan(string columnName, object columnValue)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(" > ");
			sb.Append(QueryHelper.DressUp(columnValue,this.type));
			sb.Append(" ");
		}

		public virtual void AddIn(string columnName, IQuery subQuery)
		{
			sb.Append(" IN (");
			sb.Append(subQuery.GetText());
			sb.Append(") ");
		}

		public virtual void AddIn(string columnName, ICollection values)
		{
			StringBuilder sbo = new StringBuilder();
			sb.Append(columnName);
			sb.Append(" IN (");
			IEnumerator enumerator = values.GetEnumerator();
			while (enumerator.MoveNext())
			{
				sbo.Append(QueryHelper.DressUp(enumerator.Current, this.type) + ", ");
			}
			sb.Append(StringUtil.RemoveFinalComma(sbo.ToString()));
			sb.Append(") ");
		}

		public virtual void AddIsNull(string columnName)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(" IS NULL ");
		}

		public virtual void AddLessThanOrEqualTo(string columnName, object columnValue)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(" <= ");
			sb.Append(QueryHelper.DressUp(columnValue,this.type));
			sb.Append(" ");
		}

		public virtual void AddLessThan(string columnName, object columnValue)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(" < ");
			sb.Append(QueryHelper.DressUp(columnValue,this.type));
			sb.Append(" ");
		}

		public virtual void AddLike(string columnName, object columnValue)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(" LIKE ");
			sb.Append(QueryHelper.DressUp(columnValue,this.type));
			sb.Append(" ");
		}

		public virtual void AddNotBetween(string columnName, object value1, object value2)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(" NOT BETWEEN ");
			sb.Append(QueryHelper.DressUp(value1, this.type));
			sb.Append(" AND ");
			sb.Append(QueryHelper.DressUp(value2, this.type));
			sb.Append(" ");
		}

		public virtual void AddNotEqualTo(string columnName, object columnValue)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(" <> ");
			sb.Append(QueryHelper.DressUp(columnValue,this.type));
			sb.Append(" ");
		}

		public virtual void AddNotExists(IQuery subQuery)
		{
			sb.Append(" EXISTS (" + subQuery.GetText() + ") ");
		}

		public virtual void AddNotIn(string columnName, ICollection values)
		{
			StringBuilder sbo = new StringBuilder();
			sb.Append(" NOT IN (");
			IEnumerator enumerator = values.GetEnumerator();
			while (enumerator.MoveNext())
			{
				sbo.Append(QueryHelper.DressUp(enumerator.Current, this.type) + ", ");
			}
			sb.Append(StringUtil.RemoveFinalComma(sbo.ToString()));
			sb.Append(")");
		}

		public virtual void AddNotIn(string columnName, IQuery subQuery)
		{
			sb.Append(" NOT IN (" + subQuery.GetText() + ") ");
		}

		public virtual void AddNotLike(string columnName, object columnValue)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(" NOT LIKE ");
			sb.Append(QueryHelper.DressUp(columnValue,this.type));
			sb.Append(" ");
		}

		public virtual void AddNotNull(string columnName)
		{
			sb.Append(" ");
			sb.Append(QueryHelper.GetPreDelimeter(this.type));
			sb.Append(columnName);
			sb.Append(QueryHelper.GetPostDelimeter(this.type));
			sb.Append(" NOT IS NULL ");
		}

		public void AddOr()
		{
			this.AddCriteriaSeparator(CriteriaType.OR);
		}

		public void AddOrCriteria(ICriteria c)
		{
			this.AddOr();
			sb.Append("(" + c.GetText() + ")");
		}

		public virtual void AddSql(string sql)
		{
			sb.Append(sql);
		}

		public virtual string GetText()
		{
			if (sb.Length > 2)
			{
				return " WHERE " + sb.ToString();
			}
			else
			{
				return "";
			}
		}

		public DbProviderType DbProviderType
		{
			get { return this.provider; }
			set { this.provider = value; }
		}

	}

	public enum CriteriaType
	{
		AND,
		OR
	}
}

--- NEW FILE: IQuery.cs ---
namespace Adapdev.Data.Sql
{
	using System;

	/// <summary>
	/// Represents a query
	/// </summary>
	public interface IQuery
	{
		/// <summary>
		/// Sets the criteria to use for the query
		/// </summary>
		/// <param name="c"></param>
		void SetCriteria(ICriteria c);
		/// <summary>
		/// Specifies the table to use for the query
		/// </summary>
		/// <param name="tableName"></param>
		void SetTable(string tableName);
		/// <summary>
		/// Returns a datastore specific ICriteria implementation
		/// </summary>
		/// <returns></returns>
		ICriteria CreateCriteria();
		/// <summary>
		/// Returns the text form of the query
		/// </summary>
		/// <returns></returns>
		string GetText();
		/// <summary>
		/// The DbProviderType for this query.  Necessary to determine how to
		/// represent dates, parameters, etc.
		/// </summary>
		DbProviderType DbProviderType { get; set; }
	}
}
--- NEW FILE: AccessSelectQuery.cs ---
using System;

namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for AccessSelectQuery.
	/// </summary>
	public class AccessSelectQuery : SelectQuery
	{
		public AccessSelectQuery():base(DbType.ACCESS, DbProviderType.OLEDB){}
		public AccessSelectQuery(string table):base(DbType.ACCESS, DbProviderType.OLEDB, table){}
	}
}

--- NEW FILE: QueryConstants.cs ---
namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for Constants.
	/// </summary>
	public class Constants
	{
		private Constants()
		{
		}

		public const char SQLSERVER_STRING = '\'';
		public const char SQLSERVER_DATE = '\'';

		public const char ACCESS_STRING = '\'';
		public const char ACCESS_DATE = '#';

		public const char ORACLE_STRING = '\'';
		public const char ORACLE_DATE = '\'';

		public const char MYSQL_STRING = '\'';
		public const char MYSQL_DATE = '\'';

	}
}
--- NEW FILE: AccessDeleteQuery.cs ---
using System;

namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for AccessDeleteQuery.
	/// </summary>
	public class AccessDeleteQuery : DeleteQuery
	{
		public AccessDeleteQuery():base(DbType.ACCESS, DbProviderType.OLEDB){}
		public AccessDeleteQuery(string table):base(DbType.ACCESS, DbProviderType.OLEDB, table){}
	}
}

--- NEW FILE: UpdateQuery.cs ---
namespace Adapdev.Data.Sql
{
	using System.Text;
	using Adapdev.Text;

	/// <summary>
	/// Summary description for UpdateQuery.
	/// </summary>
	public abstract class UpdateQuery : IUpdateQuery
	{
		protected string _table = "";
		protected StringBuilder sb = new StringBuilder();
		protected ICriteria criteria = null;
		protected DbType type = DbType.SQLSERVER;
		protected DbProviderType provider = DbProviderType.SQLSERVER;

		public UpdateQuery(DbType type, DbProviderType provider)
		{
			this.type = type;
			this.provider = provider;
		}

		public UpdateQuery(DbType type, DbProviderType provider, string tableName) : this(type, provider)
		{
			this.SetTable(tableName);
		}

		public void SetCriteria(ICriteria c)
		{
			criteria = c;
		}

		public void Add(string columnName)
		{
			sb.Append(" " + QueryHelper.GetPreDelimeter(this.type) + columnName + QueryHelper.GetPostDelimeter(this.type) + " = " + QueryHelper.GetParameterName(columnName, this.provider) + ",");
		}

		public void Add(string columnName, object columnValue)
		{
			sb.Append(" " + QueryHelper.GetPreDelimeter(this.type) + columnName + QueryHelper.GetPostDelimeter(this.type) + " = " + QueryHelper.DressUp(columnValue, this.type) + ",");
		}

		public void SetTable(string tableName)
		{
			this._table = QueryHelper.GetPreDelimeter(this.type) + tableName + QueryHelper.GetPostDelimeter(this.type);
		}

		public ICriteria CreateCriteria()
		{
			return CriteriaFactory.CreateCriteria(this.type);
		}

		public virtual string GetText()
		{
			return "UPDATE " + this._table + " SET " + this.GetColumns() + this.GetCriteria();
		}

		protected string GetColumns()
		{
			return StringUtil.RemoveFinalComma(this.sb.ToString());
		}

		protected string GetCriteria()
		{
			if (this.criteria == null) return "";
			else return criteria.GetText();
		}

		public DbProviderType DbProviderType
		{
			get { return this.provider; }
			set { this.provider = value; }
		}
	}
}
--- NEW FILE: MySqlUpdateQuery.cs ---
using System;

namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for MySqlUpdateQuery.
	/// </summary>
	public class MySqlUpdateQuery : UpdateQuery
	{
		public MySqlUpdateQuery():base(DbType.MYSQL, DbProviderType.MYSQL){}
		public MySqlUpdateQuery(string table):base(DbType.MYSQL, DbProviderType.MYSQL, table){}
	}
}

--- NEW FILE: SqlServerCriteria.cs ---
namespace Adapdev.Data.Sql
{
	using System.Collections;
	using System.Text;
	using Adapdev.Text;

	/// <summary>
	/// Summary description for ICriteria.
	/// </summary>
	public class SqlServerCriteria : Criteria
	{
		public SqlServerCriteria() : base(DbType.SQLSERVER, DbProviderType.SQLSERVER)
		{
		}

		public SqlServerCriteria(string sql) : base(DbType.SQLSERVER, DbProviderType.SQLSERVER, sql)
		{
		}
	}
}
--- NEW FILE: IInsertQuery.cs ---
namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for IInsertQuery.
	/// </summary>
	public interface IInsertQuery : INonSelectQuery
	{
		/// <summary>
		/// Adds the columnName to the insert query
		/// </summary>
		/// <param name="columnName"></param>
		/// <remarks>Since no value is passed in, the datastore specific parameter representation
		/// will be added</remarks>
		void Add(string columnName);
		/// <summary>
		/// Adds the column name and value to the insert query
		/// </summary>
		/// <param name="columnName"></param>
		/// <param name="columnValue"></param>
		void Add(string columnName, object columnValue);
	}
}
--- NEW FILE: IDeleteQuery.cs ---
namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for IDeleteQuery.
	/// </summary>
	public interface IDeleteQuery : INonSelectQuery
	{
	}
}
--- NEW FILE: MySqlDeleteQuery.cs ---
using System;

namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for MySqlDeleteQuery.
	/// </summary>
	public class MySqlDeleteQuery : DeleteQuery
	{
		public MySqlDeleteQuery():base(DbType.MYSQL, DbProviderType.MYSQL){}
		public MySqlDeleteQuery(string table):base(DbType.MYSQL, DbProviderType.MYSQL, table){}
	}
}

--- NEW FILE: DialectConstants.cs ---
namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for DialectConstants.
	/// </summary>
	public class DialectConstants
	{
		public const char ACCESS_PREDELIM = '[';
		public const char ACCESS_POSTDELIM = ']';
		public const char ACCESS_DATE = '#';
		public const char ACCESS_STRING = '\'';

		public const char SQLSERVER_PREDELIM = '[';
		public const char SQLSERVER_POSTDELIM = ']';
		public const char SQLSERVER_DATE = '\'';
		public const char SQLSERVER_STRING = '\'';

		public const char ORACLE_PREDELIM = ' ';
		public const char ORACLE_POSTDELIM = ' ';
		public const char ORACLE_DATE = '\'';
		public const char ORACLE_STRING = '\'';

		public const char MYSQL_PREDELIM = '`';
		public const char MYSQL_POSTDELIM = '`';
		public const char MYSQL_DATE = '\'';
		public const char MYSQL_STRING = '\'';
	}
}
--- NEW FILE: OracleInsertQuery.cs ---
namespace Adapdev.Data.Sql
{
	/// <summary>
	/// Summary description for SqlInsertQuery.
	/// </summary>
	public class OracleInsertQuery : InsertQuery
	{
		public OracleInsertQuery() : base(DbType.ORACLE, DbProviderType.ORACLE)
		{
		}

		public OracleInsertQuery(string tableName) : base(DbType.ORACLE, DbProviderType.ORACLE, tableName)
		{
		}
	}
}
--- NEW FILE: OracleSelectQuery.cs ---
namespace Adapdev.Data.Sql
{
	public class OracleSelectQuery : SelectQuery
	{
		public OracleSelectQuery() : base(DbType.ORACLE, DbProviderType.ORACLE)
		{
		}

		public OracleSelectQuery(string tableName) : base(DbType.ORACLE, DbProviderType.ORACLE, tableName)
		{
		}

		protected override string GetLimit()
		{
			if(this.maxRecords > 0)
			{
				return " ROWNUM <= " + this.maxRecords;
			}
			return "";
		}

		public override string GetText()
		{
			string sql = "SELECT " + this.GetColumns() + " FROM " + this._table + this._join + this.GetCriteria();
			if(this.maxRecords > 0)
			{
				if(sql.ToLower().IndexOf("where") < 1) sql+= " WHERE ";
				else sql += " AND ";

				sql += this.GetLimit();
			}
			sql += this.GetOrderBy() + this.GetGroupBy();
			return sql;
		}
	}
}