adoconnectionwrapper.cs

全功能c#编译器

// created on 11/11/2003 at 14:07
namespace SharpQuery.Connection
{	
	using System;
	using System.Data.OleDb;
	using System.Data;
	
	using SharpQuery.Collections;	
	using ICSharpCode.Core.Services;
	using ICSharpCode.SharpDevelop.Services;
	
	using SharpQuery.SchemaClass;
	using SharpQuery.Gui.DataView;
	using SharpQuery.Exceptions;
	
//
// 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;
				case DbType.Time				: ret = ADODB.DataTypeEnum.adDBTime; break;
				case DbType.UInt16				: ret = ADODB.DataTypeEnum.adUnsignedSmallInt; break;
				case DbType.UInt32				: ret = ADODB.DataTypeEnum.adUnsignedInt; break;