分享+开源：持久性数据访问层

最新推荐文章于 2024-02-07 22:09:49 发布
最新推荐文章于 2024-02-07 22:09:49 发布
阅读量1.7k 收藏
点赞数
文章标签： object database string null dataset table
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/athossmth/article/details/364905
版权

微软的DAAB（现在叫Enterprise Library了）cache了stored procedure的parameter list，但是，实现一个功能完整的O/R mapping，还需要扩充到对数据库结构的cache，这样才能创建dynamic sql commands。

网上没有找到合适的代码，就自己写了一个，根据连接字符串，cache相应数据库，不过目前只做了工作中用到的部分，即Sql Server的table和column。

分享一下，也希望大家来完善它，方便我们的工作。若有意共享代码请赐函amy_seahawk@yahoo.com（也是msn），谢谢。

代码如下：

using System.Collections;

using System.ComponentModel;
      
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;

using System.Reflection;

using System.Web;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.SessionState;

namespace Athos.Data
{
  
  #region class SpiColumn
  public class SpiColumn: IStateManager
  {
    private bool marked;
    private SpiTable table;
    private StateBag statebag;
    protected StateBag ViewState 
    {
      get
      {
        return this.statebag; 
      } 
    }


    #region IStateManager
    public bool IsTrackingViewState 
    {
      get
      {
        return this.marked;
      }
    }


    void System.Web.UI.IStateManager.LoadViewState(object state)
    {
      this.LoadViewState(state); 
    } 

    protected virtual void LoadViewState(object savedState)
    {
      object[] arrViewState;
      if (savedState != null)
      {
        arrViewState = ((object[]) savedState);
        if (arrViewState[0] != null)
        {
          ((IStateManager)ViewState).LoadViewState(arrViewState[0]); 
        }
      } 
    }


    object System.Web.UI.IStateManager.SaveViewState()
    {
      return this.SaveViewState(); 
    }
    public virtual object SaveViewState()
    {
      object obj1;
      object[] arrViewState;
      obj1 = ((IStateManager)ViewState).SaveViewState();
      if (obj1 != null) 
      {
        arrViewState = new object[1];
        arrViewState[0] = obj1;
        return arrViewState; 
      }
      return null; 
    } 


    void System.Web.UI.IStateManager.TrackViewState()
    {
      this.TrackViewState(); 
    }
    public virtual void TrackViewState()
    {
      this.marked = true;
      ((IStateManager)ViewState).TrackViewState(); 
    } 

    #endregion

    public SpiColumn()
    {
      this.statebag = new StateBag();
    }

    internal void SetTable(SpiTable table)
    {
      this.table = table;
    } 


    #region Column properties from SQL Database
    private string m_Description;
    public string Description 
    { 
      get 
      {
        return m_Description;
      }
      set
      {
        m_Description=value;
      }
    }

    private string m_defaultValue;
    public string DefaultValue 
    { 
      get 
      {
        return m_defaultValue;
      }
      set
      {
        m_defaultValue=value;
      }
    }


    private int m_identityseed;
    public int IdentitySeed
    { 
      get 
      {
        return m_identityseed;
      }
      set
      {
        m_identityseed = value;
      }
    }

    private int m_identityincrement;
    public int IdentityIncrement
    { 
      get 
      {
        return m_identityincrement;
      }
      set
      {
        m_identityincrement = value;
      }
    }



    private bool m_isidentity;
    public bool IsIdentity
    {
      get
      {
        return m_isidentity;
      }
      set
      {
        m_isidentity = value;
      }
    }
    private bool m_isidnotforrepl;
    public bool IsIDNotForRepl
    {
      get
      {
        return m_isidnotforrepl;
      }
      set
      {
        m_isidnotforrepl = value;
      }
    }
    private bool m_isnullable;
    public bool IsNullAble 
    { 
      get 
      {
        return m_isnullable;
      }
      set
      {
        m_isnullable = value;
      }
    }    

    private bool m_isprimarykey;
    public bool IsPrimaryKey
    { 
      get 
      {
        return m_isprimarykey;
      }
      set
      {
        m_isprimarykey = value;
      }
    }    

    private int m_key_seq;
    public int Key_Seq 
    { 
      get 
      {
        return m_key_seq;
      }
      set
      {
        m_key_seq = value;
      }
    }

    private int m_length;
    public int Length 
    { 
      get 
      {
        return m_length;
      }
      set
      {
        m_length = value;
      }
    }    
    private string m_name;
    public string Name 
    { 
      get 
      {
        return m_name;
      }
      set
      {
        m_name = value;
      }
    }

    private string m_type;
    public string Type 
    { 
      get 
      {
        return m_type;
      }
      set
      {
        m_type = value;
      }
    }

    private int m_xprec;
    public int Xprec 
    { 
      get 
      {
        return m_xprec;
      }
      set
      {
        m_xprec = value;
      }
    }

    private int m_xscale;
    public int Xscale 
    { 
      get 
      {
        return m_xscale;
      }
      set
      {
        m_xscale = value;
      }
    }

    #endregion
  }
 
  #endregion
  #region class SpiColumnCollection
  public sealed class SpiColumnCollection : ICollection, IStateManager
  {
    private SpiTable table;
    private ArrayList columns;
    private bool marked;
    #region .ctor()
    public SpiColumnCollection(SpiTable table, ArrayList columns)
    {
      this.table = table;
      this.columns = columns; 
    }

    #endregion
    #region properties
    #region  ICollection: Count
    public int Count 
    { 
      get
      {
        return this.columns.Count; 
      }
    }
    #endregion
    public bool IsReadOnly 
    { 
      get
      {
        return false;
      }
    }
    #region  ICollection: IsSynchronized
    public bool IsSynchronized
    { 
      get
      {
        return false;
      }
    }
    #endregion
    public SpiColumn this[int index] 
    { 
      get
      {
        return ((SpiColumn) this.columns[index]); 
      } 
    }
    internal int indexof(string columnname)
    {
      for(int i=0;i<this.columns.Count;i++)
      {
        if(((SpiColumn) columns[i]).Name == columnname)
          return i;
      }
      return -1;
    }
    public SpiColumn this[String columnname] 
    { 
      get
      {
        int columnindex = indexof(columnname);
        if (columnindex < 0)
          return null;
        else
          return ((SpiColumn) this.columns[columnindex]); 
      } 
    }
    #region ICollection: SyncRoot
    public object SyncRoot 
    { 
      get
      {
        return this; 
      } 
    }

    #endregion 

    #region  IStateManager: LoadViewState/SaveViewState/TrackViewState/IsTrackingViewState
    bool System.Web.UI.IStateManager.IsTrackingViewState 
    {
      get
      {
        return this.marked; 
      }
    }
 
    #endregion

    #endregion 


    public void Add(SpiColumn column)
    {
      this.AddAt(-1, column);
 
    }
    public void AddAt(int index, SpiColumn column)
    {
      if (index == -1)
      {
        this.columns.Add(column); 
      }
      else
      {
        this.columns.Insert(index, column); 
      }
      column.SetTable(this.table);
      if (this.marked)
      {
        column.TrackViewState(); 
      } 
    }
    public void Clear()
    {
      this.columns.Clear(); 
    }
    #region ICollection: SyncRoot
    public void CopyTo(Array array, int index)
    {
      IEnumerator enumerator1;
      enumerator1 = this.GetEnumerator();
      while (enumerator1.MoveNext())
      {
        index = (index + 1);
        array.SetValue(enumerator1.Current, index); 
      } 
    }
    #endregion
    #region  IStateManager: LoadViewState/SaveViewState/TrackViewState/IsTrackingViewState
    void System.Web.UI.IStateManager.LoadViewState(object state)
    {
      object[] arrViewState;
      int i;
      if (state != null)
      {
        arrViewState = ((object[]) state);
        if (arrViewState.Length == this.columns.Count)
        {
          for (i = 0; (i < arrViewState.Length); i = (i + 1))
          {
            if (arrViewState[i] != null)
            {
              ((IStateManager) this.columns[i]).LoadViewState(arrViewState[i]); 
            } 
          } 
        } 
      } 
    }
    object System.Web.UI.IStateManager.SaveViewState()
    {
      int intCount;
      object[] arrViewState;
      bool blOK;
      int i;

      intCount = this.columns.Count;
      arrViewState = new object[((uint) intCount)];
      blOK = false;
      for (i = 0; (i < intCount); i++)
      {
        arrViewState[i] = ((IStateManager) this.columns[i]).SaveViewState();
        if (arrViewState[i] != null)
        {
          blOK = true; 
        } 
      }
      if (!blOK)
      {
        return null; 
      }
      return arrViewState; 
    }
    void System.Web.UI.IStateManager.TrackViewState()
    {
      int intCount;
      int i;
      this.marked = true;
      intCount = this.columns.Count;
      for (i = 0; (i < intCount); i = (i + 1))
      {
        ((IStateManager) this.columns[i]).TrackViewState(); 
      } 
    }
    
    #endregion
    #region IEnumerable: GetEnumerator
    public IEnumerator GetEnumerator()
    {
      return this.columns.GetEnumerator(); 
    }
    #endregion 
    public int IndexOf(SpiColumn column)
    {
      if (column != null)
      {
        return this.columns.IndexOf(column); 
      }
      return -1; 
    }
    public void Remove(SpiColumn column)
    {
      int num1;
      num1 = this.IndexOf(column);
      if (num1 >= 0)
      {
        this.RemoveAt(num1);
 
      }
 
    }
    public void RemoveAt(int index)
    {
      if ((index >= 0) && (index < this.Count))
      {
        this.columns.RemoveAt(index);
        
        return; 
      }
      throw new ArgumentOutOfRangeException("index");
 
    }

    
    
  }
 
  #endregion
  #region class SpiTable
  public class SpiTable: IStateManager
  {    

    #region  properties
    
    private bool marked;
    private string tablename;
    public String TableName
    {
      get
      {
        return tablename;
      }
      set
      {
        tablename = value;
      }
    }
    private int keycount;
    public int KeyCount
    {
      get
      {
        return keycount;
      }
      set
      {
        keycount = value;
      }
    }
    private StateBag statebag;
    protected StateBag ViewState 
    {
      get
      {
        return this.statebag; 
      } 
    }

    #endregion

    public SpiTable(String tablename)
    {
      this.statebag = new StateBag();
      this.tablename = tablename;
    }  
    #region IStateManager
    public bool IsTrackingViewState 
    {
      get
      {
        return this.marked;
      }
    }


    void System.Web.UI.IStateManager.LoadViewState(object state)
    {
      this.LoadViewState(state); 
    } 

    protected virtual void LoadViewState(object savedState)
    {
      object[] arrViewState;
      if (savedState != null)
      {
        arrViewState = ((object[]) savedState);
        if (arrViewState[0] != null)
        {
          ((IStateManager)ViewState).LoadViewState(arrViewState[0]); 
        }
      } 
    }


    object System.Web.UI.IStateManager.SaveViewState()
    {
      return this.SaveViewState(); 
    }
    public virtual object SaveViewState()
    {
      object obj1;
      object[] arrViewState;
      obj1 = ((IStateManager)ViewState).SaveViewState();
      if (obj1 != null) 
      {
        arrViewState = new object[1];
        arrViewState[0] = obj1;
        return arrViewState; 
      }
      return null; 
    } 


    void System.Web.UI.IStateManager.TrackViewState()
    {
      this.TrackViewState(); 
    }
    public virtual void TrackViewState()
    {
      this.marked = true;
      ((IStateManager)ViewState).TrackViewState(); 
    } 

    #endregion


    private SpiDatabase database;
    internal void SetDatabase(SpiDatabase database)
    {
      this.database = database;
    } 


    private SpiColumnCollection ColumnsCollection;
    private ArrayList fields;

    public virtual SpiColumnCollection Columns 
    {
      get
      {
        if (this.ColumnsCollection == null)
        {
          this.fields = new ArrayList();
          this.ColumnsCollection = new SpiColumnCollection(this, this.fields);
          if (true) //athos: later need to change to if(base.IsTrackingViewState)...
          {
            ((IStateManager)ColumnsCollection).TrackViewState(); 
          } 
        }
        return this.ColumnsCollection; 
      }
    }
 

    /// <summary>
    /// Resolve at run time the appropriate set of SqlParameters for a stored procedure
    /// </summary>
    /// <param name="connection">A valid SqlConnection object</param>
    /// <param name="spName">The name of the stored procedure</param>
    /// <param name="includeReturnValueParameter">Whether or not to include their return value parameter</param>
    /// <returns>The parameter array discovered.</returns>
    public void DiscoverTableSchema()
    {
      #region get column list
      DataSet dsColumnList = Athos.Data.SqlHelper.ExecuteDataset
        (
        database.ConnectionString, CommandType.Text,
        string.Concat
        (
        @"SELECT c.[id], c.colid, c.[name], t.[name] type, c.length, c.isnullable, c.xprec, c.xscale, 
(select m.[text] from dbo.syscomments m where m.[id]=c.cdefault) defaultvalue,
(select p.[value] from dbo.sysproperties p where p.id=c.id and p.smallid=c.colid) description
FROM dbo.syscolumns c, dbo.systypes t
WHERE 
(c.id = OBJECT_ID('",
        TableName,
        @"')) AND (c.name <> 'dtproperties') 
AND c.xusertype = t.xusertype
ORDER BY c.colid"

        )
        );
      SpiColumn column;
      foreach(DataRow dr in  dsColumnList.Tables[0].Rows)
      {
        column = new SpiColumn();
        Columns.Add(column);
        column.DefaultValue = dr["defaultvalue"].ToString();
        column.Description = dr["description"].ToString();
        column.IsNullAble = Convert.ToBoolean(dr["isnullable"]);
        column.Length = Convert.ToInt32(dr["length"]);
        column.Name = dr["name"].ToString();
        column.Type = dr["type"].ToString();
        column.Xprec = Convert.ToInt32(dr["xprec"]);
        column.Xscale = Convert.ToInt32(dr["xscale"]);
      }
      #endregion
      #region get primary keys
      DataSet dsPKeys = Athos.Data.SqlHelper.ExecuteDataset
        (
        database.ConnectionString, CommandType.Text,
        string.Concat("sp_pkeys '", TableName, "'")
        );
      String strColName; 
      foreach(DataRow dr in dsPKeys.Tables[0].Rows)
      {
        strColName = dr["COLUMN_NAME"].ToString();
        foreach(SpiColumn col in Columns)
        {
          if(col.Name == strColName)
          {
            col.IsPrimaryKey = true;
            col.Key_Seq = Convert.ToInt32(dr["KEY_SEQ"]);
          }
        }
      }
      this.KeyCount = dsPKeys.Tables[0].Rows.Count;
      #endregion
      #region get identity column, if any
      DataSet dsIdentity = Athos.Data.SqlHelper.ExecuteDataset
        (
        database.ConnectionString, CommandType.Text,
        string.Concat(
        @"declare  @objname as nvarchar(776) 
set @objname = '",
        TableName, 
        @"'

declare @objid int
select @objid = id from sysobjects where id = object_id(@objname)

declare @colname sysname
select @colname = name from syscolumns where id = @objid and colstat & 1 = 1
    
select
'Identity' = isnull(@colname,'No identity column defined.'),
'IdentitySeed' = ident_seed(@objname),
'IdentityIncrement' = ident_incr(@objname),
'NotForReplication'  = ColumnProperty(@objid, @colname, 'IsIDNotForRepl')"
        )
        );
      
      String strIdentityCol = dsIdentity.Tables[0].Rows[0]["Identity"].ToString();
      if(strIdentityCol != "No identity column defined.")
      {
        foreach(SpiColumn col in Columns)
        {
          if(col.Name == strIdentityCol)
          {
            col.IsIdentity = true;
            col.IdentityIncrement = 
              Convert.ToInt32(dsIdentity.Tables[0].Rows[0]["IdentityIncrement"]);
            col.IdentitySeed = 
              Convert.ToInt32(dsIdentity.Tables[0].Rows[0]["IdentitySeed"]);
            col.IsIDNotForRepl =
              (Convert.ToInt32(dsIdentity.Tables[0].Rows[0]["NotForReplication"])==1);
          }
        }
      }
      #endregion
    }


  }
  #endregion
  #region class SpiTableCollection
  public sealed class SpiTableCollection : ICollection, IStateManager
  {
    private SpiDatabase database;
    private ArrayList tables;
    private bool marked;

    #region .ctor()
    public SpiTableCollection(SpiDatabase database, ArrayList tables)
    {
      this.database = database;
      this.tables = tables; 
    }

    #endregion
    #region properties
    #region  ICollection: Count
    public int Count 
    { 
      get
      {
        return this.tables.Count; 
      }
    }
    #endregion
    public bool IsReadOnly 
    { 
      get
      {
        return false;
      }
    }
    #region  ICollection: IsSynchronized
    public bool IsSynchronized
    { 
      get
      {
        return false;
      }
    }
    #endregion
    public SpiTable this[int index] 
    { 
      get
      {
        return ((SpiTable) this.tables[index]); 
      } 
    }
    internal int indexof(string tablename)
    {
      for(int i=0;i<this.tables.Count;i++)
      {
        if(((SpiTable) tables[i]).TableName == tablename)
          return i;
      }
      return -1;
    }
    public SpiTable this[String tablename] 
    { 
      get
      {
        int tableindex = indexof(tablename);
        if (tableindex < 0)
          return null;
        else
          return ((SpiTable) this.tables[tableindex]); 
      } 
    }
    #region ICollection: SyncRoot
    public object SyncRoot 
    { 
      get
      {
        return this; 
      } 
    }

    #endregion 

    #region  IStateManager: LoadViewState/SaveViewState/TrackViewState/IsTrackingViewState
    bool System.Web.UI.IStateManager.IsTrackingViewState 
    {
      get
      {
        return this.marked; 
      }
    }
 
    #endregion

    #endregion 


    public void Add(SpiTable table)
    {
      this.AddAt(-1, table);
 
    }
    public void AddAt(int index, SpiTable table)
    {
      if (index == -1)
      {
        this.tables.Add(table); 
      }
      else
      {
        this.tables.Insert(index, table); 
      }
      table.SetDatabase(this.database);
      if (this.marked)
      {
        table.TrackViewState(); 
      } 
    }
    public void Clear()
    {
      this.tables.Clear(); 
    }
    #region ICollection: SyncRoot
    public void CopyTo(Array array, int index)
    {
      IEnumerator enumerator1;
      enumerator1 = this.GetEnumerator();
      while (enumerator1.MoveNext())
      {
        index = (index + 1);
        array.SetValue(enumerator1.Current, index); 
      } 
    }
    #endregion
    #region  IStateManager: LoadViewState/SaveViewState/TrackViewState/IsTrackingViewState
    void System.Web.UI.IStateManager.LoadViewState(object state)
    {
      object[] arrViewState;
      int i;
      if (state != null)
      {
        arrViewState = ((object[]) state);
        if (arrViewState.Length == this.tables.Count)
        {
          for (i = 0; (i < arrViewState.Length); i = (i + 1))
          {
            if (arrViewState[i] != null)
            {
              ((IStateManager) this.tables[i]).LoadViewState(arrViewState[i]); 
            } 
          } 
        } 
      } 
    }
    object System.Web.UI.IStateManager.SaveViewState()
    {
      int intCount;
      object[] arrViewState;
      bool blOK;
      int i;

      intCount = this.tables.Count;
      arrViewState = new object[((uint) intCount)];
      blOK = false;
      for (i = 0; (i < intCount); i++)
      {
        arrViewState[i] = ((IStateManager) this.tables[i]).SaveViewState();
        if (arrViewState[i] != null)
        {
          blOK = true; 
        } 
      }
      if (!blOK)
      {
        return null; 
      }
      return arrViewState; 
    }
    void System.Web.UI.IStateManager.TrackViewState()
    {
      int intCount;
      int i;
      this.marked = true;
      intCount = this.tables.Count;
      for (i = 0; (i < intCount); i = (i + 1))
      {
        ((IStateManager) this.tables[i]).TrackViewState(); 
      } 
    }
    
    #endregion
    #region IEnumerable: GetEnumerator
    public IEnumerator GetEnumerator()
    {
      return this.tables.GetEnumerator(); 
    }
    #endregion 
    public int IndexOf(SpiTable table)
    {
      if (table != null)
      {
        return this.tables.IndexOf(table); 
      }
      return -1; 
    }
    public void Remove(SpiTable table)
    {
      int num1;
      num1 = this.IndexOf(table);
      if (num1 >= 0)
      {
        this.RemoveAt(num1);
 
      }
 
    }
    public void RemoveAt(int index)
    {
      if ((index >= 0) && (index < this.Count))
      {
        this.tables.RemoveAt(index);
        
        return; 
      }
      throw new ArgumentOutOfRangeException("index");
 
    }

    
    
  }
 
  #endregion
  #region class SpiDatabase
  public class SpiDatabase: IStateManager
  {

    #region  private members: marked, stagebag, ViewState, ConnectionString
    
    private bool marked;

    private StateBag statebag;
    protected StateBag ViewState 
    {
      get
      {
        return this.statebag; 
      } 
    }


    private string connectionstring;
    public String ConnectionString
    {
      get
      {
        return connectionstring;
      }
      set
      {
        connectionstring = value;
      }
    }
    #endregion

    public SpiDatabase(string connectionstring)
    {
      this.statebag = new StateBag();
      this.connectionstring = connectionstring;
    }  
    #region IStateManager
    public bool IsTrackingViewState 
    {
      get
      {
        return this.marked;
      }
    }


    void System.Web.UI.IStateManager.LoadViewState(object state)
    {
      this.LoadViewState(state); 
    } 

    protected virtual void LoadViewState(object savedState)
    {
      object[] arrViewState;
      if (savedState != null)
      {
        arrViewState = ((object[]) savedState);
        if (arrViewState[0] != null)
        {
          ((IStateManager)ViewState).LoadViewState(arrViewState[0]); 
        }
      } 
    }


    object System.Web.UI.IStateManager.SaveViewState()
    {
      return this.SaveViewState(); 
    }
    public virtual object SaveViewState()
    {
      object obj1;
      object[] arrViewState;
      obj1 = ((IStateManager)ViewState).SaveViewState();
      if (obj1 != null) 
      {
        arrViewState = new object[1];
        arrViewState[0] = obj1;
        return arrViewState; 
      }
      return null; 
    } 


    void System.Web.UI.IStateManager.TrackViewState()
    {
      this.TrackViewState(); 
    }
    public virtual void TrackViewState()
    {
      this.marked = true;
      ((IStateManager)ViewState).TrackViewState(); 
    } 

    #endregion


    private SpiDatabase database;
    internal void SetDatabase(SpiDatabase database)
    {
      this.database = database;
    } 


    private SpiTableCollection TablesCollection;
    private ArrayList tables;

    public virtual SpiTableCollection Tables 
    {
      get
      {
        if (this.TablesCollection == null)
        {
          this.tables = new ArrayList();
          this.TablesCollection = new SpiTableCollection(this, this.tables);
          if (true) //athos: later need to change to if(base.IsTrackingViewState)...
          {
            ((IStateManager)TablesCollection).TrackViewState(); 
          } 
        }
        return this.TablesCollection; 
      }
    }
 

  }
  #endregion
  #region class SpiDatabaseCache
  /// <summary>
  /// SpiDatabaseCache provides functions to leverage a static cache of procedure parameters, and the
  /// ability to discover parameters for stored procedures at run-time.
  /// </summary>
  public sealed class SpiDatabaseCache
  {
    #region private methods, variables, and constructors

    //Since this class provides only static methods, make the default constructor private to prevent 
    //instances from being created with "new SpiDatabaseCache()"
    private SpiDatabaseCache() {}

    private static Hashtable schemaCache = Hashtable.Synchronized(new Hashtable());

    public static bool CheckConnectionString(String strConnectionString)
    {
      SqlConnection sqlConn = new SqlConnection(strConnectionString);
      try
      {
        sqlConn.Open();
        sqlConn.Close();
        return true;
      }
      catch(Exception ex)
      {
        String strEx = ex.Message, strEy;
        strEy = strEx;
        strEx = strEy;
        return false;
      }
    }

    /// <summary>
    /// Resolve at run time the appropriate set of SqlParameters for a stored procedure
    /// </summary>
    /// <param name="connection">A valid SqlConnection object</param>
    /// <param name="spName">The name of the stored procedure</param>
    /// <param name="includeReturnValueParameter">Whether or not to include their return value parameter</param>
    /// <returns>The parameter array discovered.</returns>
    public static SpiDatabase DiscoverDatabaseSchema(SqlConnection sqlConn)
    {
      SpiDatabase database = new SpiDatabase(sqlConn.ConnectionString);

      DataSet dsTableList = Athos.Data.SqlHelper.ExecuteDataset(sqlConn, CommandType.Text,
        "SELECT name FROM sysobjects WHERE xtype='u' and name<>'dtproperties' ORDER BY name");
      String strTableName = "";
      SpiTable table;

      foreach(DataRow dr in  dsTableList.Tables[0].Rows)
      {
        strTableName = dr["name"].ToString();
        table = new SpiTable(strTableName);
        database.Tables.Add(table);
        table.DiscoverTableSchema();
      }

      return database;
    }


    #endregion private methods, variables, and constructors

    #region caching functions

    /// <summary>
    /// Add Database Schema to the cache
    /// </summary>
    /// <param name="connectionString">A valid connection string for a SqlConnection</param>
    /// <param name="dsDatabaseSchema">A Database containing Database schema</param>
    public static void CacheDatabaseSchema(string connectionString, SpiDatabase dsDatabaseSchema)
    {
      if( connectionString == null || connectionString.Length == 0 ) 
        throw new ArgumentNullException( "connectionString" );
      string hashKey = connectionString;
      schemaCache[hashKey] = dsDatabaseSchema;
    }

    /// <summary>
    /// Retrieve a parameter array from the cache
    /// </summary>
    /// <param name="connectionString">A valid connection string for a SqlConnection</param>
    /// <param name="commandText">The stored procedure name or T-SQL command</param>
    /// <returns>An array of SqlParamters</returns>
    public static SpiDatabase GetCachedDatabaseSchema(string connectionString)
    {
      if( connectionString == null || connectionString.Length == 0 ) 
        throw new ArgumentNullException( "connectionString" );
      
      string hashKey = connectionString ;
      SpiDatabase cachedDatabaseSchema = schemaCache[hashKey] as SpiDatabase;
      if (cachedDatabaseSchema == null)
      {  
        return null;
      }
      else
      {          
        return (cachedDatabaseSchema);
      }
    }

    #endregion caching functions

    #region Database Schema Discovery Functions

    /// <summary>
    /// Retrieves the Database Schema 
    /// </summary>
    /// <remarks>
    /// This method will query the database for this information, and then store it in a cache for future requests.
    /// </remarks>
    /// <param name="connectionString">A valid connection string for a SqlConnection</param>
    /// <returns>An DataSet showing Database Schema</returns>
    public static SpiDatabase GetDatabaseSchema(string connectionString)
    {
      if( connectionString == null || connectionString.Length == 0 ) throw new ArgumentNullException( "connectionString" );

      using(SqlConnection connection = new SqlConnection(connectionString))
      {
        return GetDatabaseSchemaInternal(connection);
      }
    }

    /// <summary>
    /// Retrieves the set of SqlParameters appropriate for the stored procedure
    /// </summary>
    /// <remarks>
    /// This method will query the database for this information, and then store it in a cache for future requests.
    /// </remarks>
    /// <param name="connection">A valid SqlConnection object</param>
    /// <param name="spName">The name of the stored procedure</param>
    /// <returns>An array of SqlParameters</returns>
    internal static SpiDatabase GetDatabaseSchema(SqlConnection connection)
    {
      if( connection == null ) throw new ArgumentNullException( "connection" );
      using (SqlConnection clonedConnection = (SqlConnection)((ICloneable)connection).Clone())
      {
        return GetDatabaseSchemaInternal(clonedConnection);
      }
    }

    /// <summary>
    /// Retrieves the DataSet of Database Schema appropriate
    /// </summary>
    /// <param name="connection">A valid SqlConnection object</param>
    /// <returns>An DataSet of Database Schema</returns>
    private static SpiDatabase GetDatabaseSchemaInternal(SqlConnection connection)
    {
      if( connection == null ) throw new ArgumentNullException( "connection" );

      string hashKey = connection.ConnectionString;

      SpiDatabase cachedDatabaseSchema;
          
      cachedDatabaseSchema = schemaCache[hashKey] as SpiDatabase;
      if (cachedDatabaseSchema == null)
      {  
        SpiDatabase dsDatabaseSchema = DiscoverDatabaseSchema(connection);
        schemaCache[hashKey] = dsDatabaseSchema;
        cachedDatabaseSchema = dsDatabaseSchema;
      }
          
      return cachedDatabaseSchema;
    }
        
    #endregion Database Schema Discovery Functions

  }
  #endregionusing System;

}


athossmth原创，转载请注明。

athossmth
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
大众点评开源的数据库访问层中间件 Zebra.zip
07-19
Zebra是点评内部使用的数据库访问层中间件，它具有以下的功能点：配置集中管理，动态刷新支持读写分离、分库分表丰富的监控信息在CAT上展现其中的三个组件的功能分别是：zebra-api : 最主要的访问层中间件zebra-ds-monitor-client：基于CAT的监控(可选)zebra-dao：基于MyBatis的异步化的DAO组件(可选)编译1. git clone https://github.com/dianping/zebra.git 2. git checkout mvn-repo 3. 拷贝里面的mvn依赖到本地仓库（第2和3步骤主要是为了使用zebra-ds-monitor-client中的CAT监控） 4. mvn clean install -DskipTests使用zebra-api : 文档zebra-ds-monitor-clientzebra-dao：文档 标签：大众点评  数据库访问
推荐开源数据库访问组件 - DapperEx
叮当的博客
03-16 644
DapperEx 是一款数据库访问组件，支持 Sqlserver 和 PostgreSql。她提供了 Lambda 表达式方式的操作。她以 Dapper 作为底层，提供更方便快捷的数据库访问方式。 适用平台： .Net Framework 4.5.1 及以上 .Net Standard 2.0 及以上。 项目地址：https://github.com/zl33842901/DapperEx ...
基于iBatis的开源分布式数据访问层
以简始，以简终 Always Keep Child-Like Wonder
03-28 144
[url]http://code.alibabatech.com/wiki/display/cobarclient/Home[/url] 这个东西其实已经出来很长时间了，思路和成型也比其它相似的东西要早一些，公司近期才准备开源，所以就放出来了，　当然，不一定完美，东西比较简单,　所以开源出来希望能集思广益，　欢迎使用，拍砖，提意见 主要features： 1- data access...
java 数据访问层_数据访问层 - Java垒墙工程师的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_36443241的博客
02-15 205
单机数据库 数据库减压：硬件升级(简单粗暴、效果明显、很快进入瓶颈，解决不了)其他三思路：优化应用(是否给了数据库不必要的压力)是否有其他办法减轻数据库的压力(引入缓存、搜索引擎)把数据库的数据和访问分布多台机器上垂直拆分(不同业务单元拆分到不同的库里)带来影响：单机ACID 变得复杂Jion操作变得困难靠外键约束场景受影响水平拆分(按照一定规则，把统一业务单元数据拆分到不同库里面)带来影响：单机...
Java持久层框架之争
01-18
持久层框架可以帮助我们管理数据访问、数据库连接、事务处理等复杂的数据库操作，从而提升开发效率和代码质量。  然而，在众多的Java持久层框架中，选择最佳方案并不是一件容易的事情。每个框架都有各自的特点和...
Mvc Infraestructure:J2EE的可序列化数据传输对象/通用Dao-开源
04-17
Dto.java和其他类-用于在J2EE应用程序的业务和持久性层之间与视图（使用EL-Expression Language“层）进行数据传输。Dto从Java API的HashMap类扩展，用于通过键封装任何类型的信息类型：key_i.key_ij.key_ijk ....：...
pmfs:永久性内存文件系统
03-11
它直接管理持久性内存，避免了块驱动程序层和页面高速缓存层，因此提供了对持久性区域的同步读取和写入。 它支持所有现有的POSIX样式文件系统API，因此无需修改应用程序即可使用此文件系统。 另外，PMFS提供了对大...
SSS:Spring + Spring MVC + Spring数据JPA快速开发环境框架的集成。 Spring Data Jpa是Spring Data对JPA提供的一套解决方案。SpringData是SpringSource的其中一个父项目，旨在统一和简化对各类型持久化存储，而不拘泥于是关系型数据库还是NoSQL数据存储，Spring Data Jpa实现了大部分的持久层的逻辑代码，你需要做的只是声明持久层的接口，其他的都提交Spring Data Jpa完成
03-23
＃Spring + SpringMVC + Spring数据JPA构建快速开发环境### Spring数据JPA压缩数据JPA提供了一个完整的数据访问层（DAO）的解决方案，致力于减少数据访问层的开发量，并支持云服务的开源框架。 Spring Data作为...
java前后端分离源码-dao:用于rails的sa-weet数据访问对象库。绝密
06-05
是为某种类型的数据库或其他持久性机制提供抽象接口的对象。 通过将应用程序调用映射到持久层，DAO 提供了一些特定的数据操作而不暴露数据库的细节。 这种隔离支持单一职责原则。 它根据域特定对象和数据类型（DAO ...
C# Nullable Class 和Nullable<T> Struct
绝圣弃智-零的博客
11-07 1137
Nullable Class 微软介绍： Nullable Class 定义 命名空间: System Assemblies: System.Runtime.dll, mscorlib.dll, netstandard.dll 支持可分配有 null 的值类型。 此类不能被继承。 [System.Runtime.InteropServices.ComVisible(true)] ...
分布式数据访问层(DAL)
热门推荐
xcbeyond|疯狂源自梦想，技术成就辉煌
02-11 1万+
概述分布式(Distributed)数据访问层(Data Access Layer)，简称DAL，是利用MySQL Proxy、Memcached、集群等技术优点而构建的一个架构系统。主要目的是为了解决在高并发、大数据流操作遇到的和数据访问有关的诸多问题，例如怎么进行切库分表，怎样能更好地防止服务单点故障等等。分布式数据访问层是如何诞生的？ 是由手机之家一位资深的开发者和架构师许超前最先提出的。（和
常用的文件系统、存储类型小整理
Hehuyi_In的博客
02-07 3213
最近接触到了五花八门的文件系统、存储类型，名词听得头大，趁假期整理学习一番~
满意度调查行·知dr.pptx
04-25
满意度调查行·知dr.pptx
基于B2C的网上拍卖系统_秒杀与竞价.zip
04-25
基于B2C的网上拍卖系统主要用于帮助人们应用互联网方便快捷买到自己所中意的商品，并参与到秒杀与竞拍当中。 主要功能包括： 1.前台模块 （1）普通用户登录/注册。 （2）分类查看商品(普通商品与促销商品) （3）查看商品详细信息 （4）查看秒杀商品 （5）查看竞拍商品 （6）将商品加入购物车 （7)购买，结算功能 （8）留言 2.后台模块 （1）修改密码 (2)商品管理: -- 编辑/删除 -- 设置/取消促销 （3)秒杀商品：设置/取消秒杀 （4)竞拍商品：设置/取消竞拍 （5)订单管理：查看订单 （5)留言管理：查看/删除留言 项目访问路径: 前台：http://localhost:8080/sale 后台：http://localhost:8080/sale/user/adminlogin
分布式系统中Java后端开发技术及其应用实践.pdf
最新发布
04-25
分布式系统的核心思想是复杂计算任务的拆分与并行计算，可有效减少计算时间、节约算力成本。以分布式系统中Java后端开发技术的应用为主题，分析分布式系统开发的需求，探讨Java技术栈、分布式监控与日志管理、云服务模型在分布式系统Java后端开发中的应用路径，旨在为分布式系统的设计与实现提供全面的理论分析和实践指导，以支持构建高效、稳定、可扩展的企业级Java应用。 随着云计算、大数据和人工智能技术的飞速发展， 分布式系统已成为支撑现代企业信息系统的基础架构。 Java 后端开发技术在构建分布式系统中扮演着至关重要的 角色，其应用价值和研究重点主要集中在微服务架构、容 器化技术、自动化部署、服务网格、无服务器计算、应用 程序编程接口（Application Programming Interface， API）管理、数据一致性解决方案、分布式缓存、负载均衡、 复杂事件处理和分布式事务管理等方面[1]。Java平台以 其成熟的生态系统、跨平台的移植性、丰富的开源框架 和库以及稳定的性能，为分布式系统的开发提供了坚实 的基础[2]。深入探讨Java后端开发技术在分布式系统中 的应用实践，旨在为企
【微信小程序毕业设计】书店系统开发项目(源码+演示视频+说明).rar
04-25
【微信小程序毕业设计】书店系统开发项目(源码+演示视频+说明).rar 【项目技术】 微信小程序开发工具+java后端+mysql 【演示视频-编号：246】 https://pan.quark.cn/s/cb634e7c02b5 【实现功能】 用户信息管理，图书信息管理，图书类型管理，图书留言管理，论坛信息管理等
使用Spring in Guice和Guice in Spring的工具（高分项目）.zip
04-25
Java SSM项目是一种使用Java语言和SSM框架（Spring + Spring MVC + MyBatis）开发的Web应用程序。SSM是一种常用的Java开发框架组合，它结合了Spring框架、Spring MVC框架和MyBatis框架的优点，能够快速构建可靠、高效的企业级应用。 1. Spring框架：Spring是一个轻量级的Java开发框架，提供了丰富的功能和模块，用于开发企业级应用。它包括IoC（Inverse of Control，控制反转）容器、AOP（Aspect-Oriented Programming，面向切面编程）等特性，可以简化开发过程、提高代码的可维护性和可测试性。 2. Spring MVC框架：Spring MVC是基于Spring框架的Web框架，用于开发Web应用程序。它采用MVC（Model-View-Controller，模型-视图-控制器）的架构模式，将应用程序分为模型层、视图层和控制器层，提供了处理请求、渲染视图和管理流程的功能。 3. MyBatis框架：MyBatis是一个持久层框架，用于与数据库进行交互。它提供了一种将数据库操作与Java对象映射起来的方式，避免了手动编写繁琐的SQL语句，并提供了事务管理和缓存等功能，简化了数据库访问的过程
使用Mybatis作为数据库持久层框架是什么意思
05-20
Mybatis是一个开源的Java持久层框架，它简化了数据库操作的编写工作。使用Mybatis作为数据库持久层框架可以帮助我们将数据访问层与业务逻辑层分离，从而提高了代码的可维护性和可测试性。Mybatis通过提供SQL映射文件，将Java对象与数据库表进行映射，使开发人员可以直接使用Java对象进行数据库操作，而不必手动编写大量的JDBC代码。此外，Mybatis还提供了一些高级特性，例如缓存、插件机制等，可以帮助我们更好地管理数据层。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值