adoconnectionwrapper.cs

来自「SharpDevelop2.0.0 c#开发免费工具」· CS 代码 · 共 554 行 · 第 1/2 页

// <file>
//     <copyright see="prj:///doc/copyright.txt"/>
//     <license see="prj:///doc/license.txt"/>
//     <owner name="Luc Morin" email=""/>
//     <version>$Revision: 993 $</version>
// </file>

using System;
using System.Data.OleDb;
using System.Data;
using SharpQuery.Collections;
using SharpQuery.SchemaClass;
using SharpQuery.Exceptions;

namespace SharpQuery.Connection
{

	//
	// ADO .NET Wrapper (better than OleDB)
	//
	///<summary>
	/// This class is associated with a class <see cref="ICSharpCode.SharpDevelop.Gui.SharpQuery.TreeView.SharpQueryNodeConnection"/>
	///</summary>
	public class ADOConnectionWrapper : AbstractSharpQueryConnectionWrapper
	{
		protected ADODB.ConnectionClass pADOConnection;

		///<summary>
		///  OLEDB connection String.
		/// i use this for speed up the code writing ...
		///</summary>
		public override string ConnectionString
		{
			get
			{
				return base.ConnectionString;
			}

			set
			{
				if (IsOpen == true)
				{
					this.Close();
				}
				try
				{
					this.pADOConnection.ConnectionString = value;
					wrongConnectionString = false;
				}
				catch (System.Exception)
				{
					string mes = this.ConnectionString + "\n\r";
					wrongConnectionString = true;

					foreach (ADODB.Error err in this.pADOConnection.Errors)
					{
						mes += "-----------------\n\r";
						mes += err.Description + "\n\r";
						mes += err.NativeError + "\n\r";
					}
					throw new ConnectionStringException(mes);
				}
			}
		}

		public override bool IsOpen
		{
			get
			{
				return (pADOConnection.State == (int)ADODB.ObjectStateEnum.adStateOpen);
			}
		}

		public override object GetProperty(AbstractSharpQueryConnectionWrapper.SharpQueryPropertyEnum property)
		{
			object returnValue = null;
			string Key = null;

			switch (property)
			{
				case SharpQueryPropertyEnum.Catalog:
					Key = "Current Catalog";
					break;
				case SharpQueryPropertyEnum.ConnectionString:
					returnValue = this.pADOConnection.ConnectionString.ToString();
					break;
				case SharpQueryPropertyEnum.DataSource:
					Key = "Data Source";
					break;
				case SharpQueryPropertyEnum.DataSourceName:
					Key = "Data Source Name";
					break;
				case SharpQueryPropertyEnum.DBMSName:
					Key = "DBMS Name";
					break;
				case SharpQueryPropertyEnum.ProviderName:
					returnValue = this.pADOConnection.Provider.ToString();
					break;
				default:
					Key = null;
					break;
			}

			try
			{
				if (Key != null)
				{
					if (this.pADOConnection.Properties[Key].Value != null)
					{
						returnValue = this.pADOConnection.Properties[Key].Value;
					}
				}
			}
			catch (System.Exception)
			{
				returnValue = null;
			}

			return returnValue;
		}

		/// <summary>
		/// Creates a new DataConnection object
		/// </summary>
		public ADOConnectionWrapper()
			: base()
		{
			this.pADOConnection = new ADODB.ConnectionClass();
		}

		public ADOConnectionWrapper(string connectionString)
			: this()
		{
			this.ConnectionString = connectionString;
		}

		protected override void OnRefresh()
		{
			this.pADOConnection.Properties.Refresh();

			base.OnRefresh();
		}

		public override bool Open()
		{
			try
			{
				if (this.IsOpen == false && wrongConnectionString == false)
				{
					this.pADOConnection.GetType().InvokeMember(
					                                           "Open",
					                                           System.Reflection.BindingFlags.InvokeMethod,
					                                           null,
					                                           this.pADOConnection,
					                                           null);
				}
			}
			catch (System.Exception)
			{
				string mes = this.ConnectionString + "\n\r";
				wrongConnectionString = true;

				foreach (ADODB.Error err in this.pADOConnection.Errors)
				{
					mes += "-----------------\n\r";
					mes += err.Description + "\n\r";
					mes += err.NativeError + "\n\r";
				}
				throw new OpenConnectionException(mes);
			}

			return this.IsOpen;
		}

		public override void Close()
		{
			if (this.IsOpen == true)
			{
				this.pADOConnection.Close();
			}
		}

		///<summary>
		/// Execute a SQL command
		/// <param name="SQLText">
		/// SQL command to execute
		/// </param>
		/// <param name="rows">
		/// Maximum number of row to extract. If is "0" then all rows are extracted.
		/// </param>
		/// <returns> return a <see cref="System.Data.DataTable">DataTable</see>
		///or a <see cref="System.Data.DataSet">DataSet</see> object.
		/// </returns>
		/// </summary>
		public override object ExecuteSQL(string SQLText, int rows)
		{
			ADODB.Recordset record = new ADODB.Recordset();
			DataTable table = null;

			this.pADOConnection.BeginTrans();

			try
			{
				record.MaxRecords = rows;
				record.Open((object)SQLText,
				            (object)this.pADOConnection,
				            ADODB.CursorTypeEnum.adOpenDynamic,
				            ADODB.LockTypeEnum.adLockPessimistic,
				            (int)ADODB.CommandTypeEnum.adCmdText
				           );

				table = RecordSetToDataTable(record);
			}
			catch (System.Exception)
			{
				this.pADOConnection.RollbackTrans();

				string mes = SQLText + "\n\r";

				foreach (ADODB.Error err in this.pADOConnection.Errors)
				{
					mes += "-----------------\n\r";
					mes += err.Description + "\n\r";
					mes += err.NativeError + "\n\r";
				}
				throw new ExecuteSQLException(mes);
			}
			finally
			{
				this.pADOConnection.CommitTrans();
			}

			return table;
		}


		protected ADODB.ParameterDirectionEnum ParamDirectionToADODirection(ParameterDirection dir)
		{
			ADODB.ParameterDirectionEnum ret = ADODB.ParameterDirectionEnum.adParamInput;

			switch (dir)
			{
					case ParameterDirection.Input: ret = ADODB.ParameterDirectionEnum.adParamInput; break;
					case ParameterDirection.InputOutput: ret = ADODB.ParameterDirectionEnum.adParamInputOutput; break;
					case ParameterDirection.Output: ret = ADODB.ParameterDirectionEnum.adParamOutput; break;
					case ParameterDirection.ReturnValue: ret = ADODB.ParameterDirectionEnum.adParamReturnValue; break;
					default: throw new ArgumentOutOfRangeException("dir");
			}

			return ret;
		}


		protected ADODB.DataTypeEnum DbTypeToDataType(DbType t)
		{
			ADODB.DataTypeEnum ret = ADODB.DataTypeEnum.adChar;

			switch (t)
			{
					case DbType.AnsiString: ret = ADODB.DataTypeEnum.adChar; break;
					case DbType.Binary: ret = ADODB.DataTypeEnum.adBinary; break;
					case DbType.Boolean: ret = ADODB.DataTypeEnum.adBoolean; break;
					case DbType.Byte: ret = ADODB.DataTypeEnum.adUnsignedTinyInt; break;
					case DbType.Currency: ret = ADODB.DataTypeEnum.adCurrency; break;
					case DbType.Date: ret = ADODB.DataTypeEnum.adDate; break;
					case DbType.DateTime: ret = ADODB.DataTypeEnum.adDBTimeStamp; break;
					case DbType.Decimal: ret = ADODB.DataTypeEnum.adDecimal; break;
					case DbType.Double: ret = ADODB.DataTypeEnum.adDouble; break;
					case DbType.Guid: ret = ADODB.DataTypeEnum.adGUID; break;
					case DbType.Int16: ret = ADODB.DataTypeEnum.adSmallInt; break;
					case DbType.Int32: ret = ADODB.DataTypeEnum.adInteger; break;
					case DbType.Int64: ret = ADODB.DataTypeEnum.adBigInt; break;
					case DbType.Object: ret = ADODB.DataTypeEnum.adUserDefined; break;
					case DbType.SByte: ret = ADODB.DataTypeEnum.adTinyInt; break;
					case DbType.Single: ret = ADODB.DataTypeEnum.adSingle; break;
					case DbType.String: ret = ADODB.DataTypeEnum.adVarWChar; break;
					case DbType.StringFixedLength: ret = ADODB.DataTypeEnum.adWChar; break;