abstractsharpqueryconnectionwrapper.cs

全功能c#编译器

// created on 11/11/2003 at 14:06
namespace SharpQuery.Connection
{	
	
	using System;
	using System.Collections;
	using System.Data;
	using System.Data.OleDb;
	
	using ICSharpCode.Core.Services;
	using ICSharpCode.SharpDevelop.Services;
	using System.Reflection;	
	
	using ICSharpCode.Core.AddIns.Conditions;
	using ICSharpCode.Core.AddIns.Codons;
	using ICSharpCode.Core.AddIns;

	using SharpQuery.Collections;
	using SharpQuery.SchemaClass;
	using SharpQuery.Codons;	
	using SharpQuery.Exceptions;
	
	///<summary>
	/// this is a wrapper abstract class for connection with a database server.
	///</summary>
	public abstract class AbstractSharpQueryConnectionWrapper : IConnection
	{		
		
		///<summary>
		/// SharpQuery schema enumeration.
		///</summary>		
		public enum SharpQuerySchemaEnum {
			
			Asserts,
			Catalogs, 
			CharacterSets,
			CheckConstraints,
			Collations,
			ColumnPrivileges,
			Columns,
			ColumnsDomainUsage,
			ConstraintColumnUsage,
			ConstaintTableUsage,
			Cubes,
			DBInfoKeyWords,
			DBInfoLiterals,
			Dimensions,
			ForeignKeys,
			Hierarchies,
			Indexes,
			KeyColumnUsage,
			Levels,
			Measures,
			Members,
			Null, // ask for an empty list
			PrimaryKeys,
			ProcedureColumns,
			ProcedureParameters,
			Procedures,
			Properties,
			ProviderSpecific,
			ProviderTypes,
			ReferentialConstraints,
			Schemata,
			SQLLanguages,
			Statistics,
			TableConstraints,
			TablePrivileges,
			Tables,
			Tanslations,
			Trustees,
			UsagePrivileges,
			ViewColumnUsage,
			Views,
			ViewColumns,
			ViewTableUsage			
		} 
		
		///<summary>
		/// Connection properties
		///</summary>		
		public enum SharpQueryPropertyEnum
		{	
			Catalog,
			ConnectionString,
			DataSource,
			DataSourceName,
			DBMSName,
			ProviderName
		}

		//constants
		internal string SELECT		= "SELECT";
		internal string FROM		= "FROM";
		internal string WHERE		= "WHERE";
		internal string UPDATE		= "UPDATE";
		internal string SET			= "SET";
		internal string DELETE		= "DELETE";
		internal string INSERINTO	= "INSERT INTO";
		internal string VALUES		= "VALUES";
		internal string AND			= "AND";
				
		protected bool wrongConnectionString = false;
		static StringParserService stringParserService = (StringParserService)ServiceManager.Services.GetService(typeof(StringParserService));		
		protected SharpQueryListDictionary pEntities = null;										


		///<summary>
		/// return <c>true</c> if the connection string is invalid.
		///</summary>
		public bool IsConnectionStringWrong
		{
			get
			{
				return this.wrongConnectionString;
			}
		}
		///<summary>return the catalog name. If there aren't a ctalog name
		/// in the <see cref=".ConnectionString">ConnectionString</see>, return "".
		/// </summary>
		public virtual string CatalogName
		{
			get
			{
				object returnValue = this.GetProperty( SharpQueryPropertyEnum.Catalog);
				
				if ( returnValue == null )
				{
					returnValue = ""; 
				}
				
				return returnValue.ToString();
			}			
		}
	
		public virtual string SchemaName
		{
			get
			{
				return "";//"INFORMATION_SCHEMA";
			}
		}			
		
		public string Name
		{
			get
			{
				string Datasource;
				
				object returnValue = null;
								
				Datasource = this.GetProperty( SharpQueryPropertyEnum.DBMSName ).ToString();				
				if ( Datasource == null )
				{
					Datasource = ""; 
				}				
								
				if ( Datasource != "" )
				{
					returnValue += Datasource + ".";
				}
				
				Datasource = this.GetProperty( SharpQueryPropertyEnum.DataSource ).ToString();				
				if ( Datasource == null )
				{
					Datasource = ""; 
				}				
								
				if ( Datasource != "" )
				{
					returnValue += Datasource + ".";
				}				
				
				if ( this.CatalogName != "" )
				{
					returnValue +=  this.CatalogName + ".";
				}									
								
				return returnValue.ToString();
			}			
		}
		
		///<summary>return  : <see cref=".Name">Name</see>.<see cref=".ConnectionString"></see></summary>
		public string NormalizedName
		{
			get
			{
				return this.Name + "." + this.ConnectionString;
			}
		}
		
		public SharpQueryListDictionary Entities 
		{ 
			get
			{
				return this.pEntities;
			}
		}
		
		///<summary>
		///  OLEDB connection String.	
		/// i use this for speed up the code writing ...
		///</summary>
		public virtual string ConnectionString  
		{
		   get
		   {
		   	 return this.GetProperty( SharpQueryPropertyEnum.ConnectionString ).ToString();
		   }
		   
		   set
		   {		   	
		   }
		}	
				
		public virtual string Provider
		{
			get
			{
				return this.GetProperty( SharpQueryPropertyEnum.ProviderName ).ToString();
			}
		}
		
		public abstract bool IsOpen
		{
			get;
		}	
		
		
		public abstract object GetProperty( AbstractSharpQueryConnectionWrapper.SharpQueryPropertyEnum property );
				
		/// <summary>
		/// Creates a new DataConnection object
		/// </summary>		
		public AbstractSharpQueryConnectionWrapper()
		{					
			this.pEntities = new SharpQueryListDictionary();
		}		
		
		/// <summary>
		/// Creates a new DataConnection object from a connection string
		/// </summary>		
		public AbstractSharpQueryConnectionWrapper( string connectionString ) : this()
		{				
		}						
		
		static private IConnection CreateConnectionObject( string connectionstring )
		{	
			//try
			//{
				Assembly ass = System.Reflection.Assembly.GetExecutingAssembly();
				
				IAddInTreeNode AddinNode;
				IAddInTreeNode ChildNode = null;
				
				string ClassWrapper = "";
				
				AddinNode = (IAddInTreeNode)AddInTreeSingleton.AddInTree.GetTreeNode("/SharpQuery/Connection");
				ChildNode = (IAddInTreeNode)AddinNode.ChildNodes["ConnectionWrapper"];
				ClassWrapper = ChildNode.Codon.Class;
				
				if ( (ClassWrapper != null) && (ClassWrapper != "") )
				{								
					IConnection conn = (IConnection)ass.CreateInstance( ClassWrapper,
					                                       	false,
					                                       	BindingFlags.CreateInstance,
					                                       	null,
					                                       	//new object[] {connectionstring},
										null,
					                                       	null,
					                                       	null
					                                       );
					conn.ConnectionString = connectionstring;
					return conn;
				}
				else
				{
					return null;
				}			
			//}
			//catch ( System.Exception e )
			//{
			//	throw new ConnectionStringException( e.Message );
			//}		   					
		}
		
		static public IConnection CreateFromDataConnectionLink()
		{
				ADODB._Connection AdoConnection;
				MSDASC.DataLinks dataLink = new MSDASC.DataLinks();			
				IConnection connection = null;
				
				AdoConnection = null;			
				AdoConnection = (ADODB._Connection) dataLink.PromptNew();						
				
				if ( ( AdoConnection != null ) && ( AdoConnection.ConnectionString != "" ) )
				{												
					connection = CreateConnectionObject( AdoConnection.ConnectionString );
				}
				
				return connection;
		}
		
		static  public IConnection UpDateFromDataConnectionLink( IConnection oldConnection )
		{
				object AdoConnection;			
				MSDASC.DataLinks dataLink = new MSDASC.DataLinks();
				IConnection connection = null;
				
				AdoConnection = new ADODB.Connection();
				(AdoConnection as ADODB.Connection).ConnectionString = oldConnection.ConnectionString;
				
				if ( dataLink.PromptEdit( ref AdoConnection ) )
				{
					connection = CreateConnectionObject( (AdoConnection as ADODB.Connection).ConnectionString );								
				}
				
				return connection;
		}
		
		static  public IConnection CreateFromConnectionString( string stringConnection )		
		{
				IConnection connection = null;
				
				if ( ( stringConnection != null ) && ( stringConnection != "" ) )
				{
					connection = CreateConnectionObject( stringConnection );
				}
				
				return connection;
		}
																				
		public abstract bool Open();
		public abstract void Close();
				
		///<summary>
		/// called by <see cref=".Refresh()">Refresh</see> just after the <see cref=".Clear()">Clear</see> and before <see cref=".Refresh()">childs'refresh</see>.
		/// In this, you could change the <see cref=".Entities">Entities dicntionnary.</see>
		///</summary>
		protected virtual void OnRefresh()
		{
			if (this.pEntities != null )
			{