statementbase.cs

.net的数据持久层

using System;
using System.Data;
using System.Text;

namespace Platform.Data {

	public abstract class StatementBase : ISqlStatement, ICloneable {

		public static readonly int DEFAULT_STRING_SIZE = 256;
		
		private string _TableName;
		private string _IdField;
		private string _FieldString;
		private string _KeyFieldString;
		private string _SqlClause;
		private string _WhereString;

		private CommandType _CommandType;
		private FieldPropCollection _Fields;
		private DataParameterCollection _Parameters;
		
		protected  StringBuilder _CriteriaString;
		protected  StringBuilder CriteriaString 
		{
			get 
			{
				if( _CriteriaString == null )
				{
					_CriteriaString = new StringBuilder();
				}
				return _CriteriaString;
			}
		}

		
		protected  int _ParameterCount;
		protected  string NewParameterName 
		{
			get { return String.Format("PARA__{0}_1", _ParameterCount++ ); }
		}

		public StatementBase() {
			this.CommandType = CommandType.Text;
			_Parameters = new DataParameterCollection();
		}

		public StatementBase( object obj ) : this() {
			_Fields = OpBroker.Instance.GetFields( obj );
			_TableName = OpBroker.Instance.GetTableName( obj );
			_SqlClause = String.Empty;
			this.BuildSqlClause();
		}
		
		public StatementBase( object obj ,string _TName) : this() 
		{
			_Fields = OpBroker.Instance.GetFields( obj );
			_TableName = _TName;
			_SqlClause = String.Empty;
			this.BuildSqlClause();
		}

		public CommandType CommandType {
			get { return _CommandType; }
			set { _CommandType = value; }
		}
		
		public string WhereString {
			get { return _WhereString; }
			set { _WhereString = value; }
		}

		public string SqlClause {
			get { return _SqlClause; }
			set { _SqlClause = value; }
		}

		protected string TableName {
			get { return _TableName; }
			set { _TableName = value; }
		}

		protected string IdField{
			get { return _IdField; }
			set { _IdField = value; }
		}


		protected FieldPropCollection Fields{
			get { return _Fields; }
			set { _Fields = value; }
		}

		protected string FieldString{
			get { return _FieldString; }
			set { _FieldString = value; }
		}

		protected string KeyFieldsString {
			get { return _KeyFieldString; }
			set { _KeyFieldString = value; }
		}

		public DataParameterCollection Parameters{
			get { return _Parameters; }
		}

		public abstract void BuildSqlClause();
		
		public abstract void FillDataParameter( object obj );

		public abstract StatementBase Create();

		public virtual object Clone(){
			StatementBase sql = this.Create();
			sql.SqlClause = this.SqlClause;
			sql.Fields = this.Fields;
			sql.TableName = this.TableName;
			foreach(DataParameter dp in this.Parameters){
				sql.Parameters.Add((DataParameter)dp.Clone());
			}
			return sql;
		}

		protected string BuildFieldString(){
			StringBuilder sel = new StringBuilder();
			foreach( FieldProp fp in this.Fields){				
				if( sel.Length > 0 ){
					sel.Append( ",");
				}
				sel.Append( fp.FieldName );
			}
			return sel.ToString();
		}

		protected string BuildKeyFieldString(){
			StringBuilder sb = new StringBuilder();
			foreach( FieldProp fp in this.Fields){				
				if( fp.IsKeyField ){
					if( sb.Length > 0 ){
						sb.Append( ",");
					}
					sb.Append( fp.FieldName );
				}
			}
			return sb.ToString();
		}

		protected DataParameter MakeDataParameter( FieldProp fp ){
			DataParameter dp = new DataParameter(fp.FieldName,  null);
			if( fp.Property.PropertyType == typeof(string) ){
				if( fp.Size == 0 ){
					dp.Size = DEFAULT_STRING_SIZE;
				}
				else{
					dp.Size = fp.Size;
				}
			}
			return dp;
		}

		protected string BuildWhereString(){
			StringBuilder sb = new StringBuilder();
			foreach(FieldProp fp in this.Fields){
				if( fp.IsKeyField ){
					if( sb.Length > 0 ){
						sb.Append( " AND " );
					}
					sb.Append( String.Format( "{0}={1}{0}", fp.FieldName, DataHelper.DataDriver.ParameterPrix ) );
					this.Parameters.Add( this.MakeDataParameter( fp ) );
				}
			}
			return sb.ToString();
		}

		protected virtual string GetTypeString( CriteriaType type )
		{
			switch( type )
			{
				case CriteriaType.NotEquals:
					return "<>";

				case CriteriaType.LessThan:
					return "<";

				case CriteriaType.LessThanEquals:
					return "<=";

				case CriteriaType.MoreThan :
					return ">";

				case CriteriaType.MoreThanEquals:
					return ">=";

				case CriteriaType.Like:
					return "LIKE";

				case CriteriaType.NotLike:
					return "NOT LIKE";

				case CriteriaType.Equals:
				default:
					return "=";
			}
		}

		protected virtual void AddCriterias(CriteriaCollection cts )
		{
			foreach(Criteria ct in cts )
			{
				this.AddCriteria( this.GetTypeString(ct.Type), ct.Name, ct.Value);
			}
		}
		protected virtual  void AddCriteria( string type, string prop, object value)
		{
			if( this.CriteriaString.Length > 0 ) 
			{
				this.CriteriaString.Append( " AND " );
			}
			string fn = this.Fields[prop].FieldName;
			string pn = this.NewParameterName;
			this.CriteriaString.Append( String.Format("{0} {1} {2}{3}", fn, type, DataHelper.DataDriver.ParameterPrix, pn));
			this.Parameters.Add( new DataParameter( pn, value ) );
		}


	}
}