C#對sqlite操作類

    /// <summary>
    /// SQLite 操作類
    /// Author Light
    /// </summary>
    public class SQLite
    {
        /// <summary>
        /// 數據庫
        /// </summary>
        public static string dataBasePath;

        public static string dataBasePasssord;

        /// <summary>
        /// 獲取連接
        /// </summary>
        /// <returns></returns>
        private static SQLiteConnection getSQLiteConnection()
        {
            SQLiteConnection conn = null;         
            try
            {
                conn = new SQLiteConnection();
                SQLiteConnectionStringBuilder connStr = new SQLiteConnectionStringBuilder();
                connStr.DataSource = dataBasePath;
                connStr.Password = dataBasePasssord;                        //設置密碼，SQLite ADO.NET實現了數據庫密碼保護
                conn.ConnectionString = connStr.ToString();
            }
            catch (ExceptionUtility ex)
            {
                throw new ExceptionUtility("連接數據庫異常:" + ex.Message);
            }                    
            return conn;
        }

        #region 執行查詢

        /// <summary>
        /// 執行SQL，返回影響的記錄數
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public static int ExecuteSql(string sql)
        {
            int iResult = -1;
            using (SQLiteConnection conn = getSQLiteConnection())
            {
                using (SQLiteCommand cmd = new SQLiteCommand(sql, conn))
                {
                    try
                    {
                        conn.Open();
                        iResult = cmd.ExecuteNonQuery();
                    }
                    catch (ExceptionUtility ex)
                    {
                        throw new ExceptionUtility("執行SQL，返回影響的記錄數異常:" + ex.Message);
                    }
                }
            }
            return iResult;
        }

        /// <summary>
        /// 執行帶一個存儲過程參數的SQL語句
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="content"></param>
        /// <returns></returns>
        public static int ExecuteSql(string sql, string content)
        {
            int iResult = -1;
            using (SQLiteConnection conn = getSQLiteConnection())
            {
                using (SQLiteCommand cmd = new SQLiteCommand(sql, conn))
                {
                    try
                    {
                        SqlParameter parameter = new SqlParameter("@content", SqlDbType.NText);
                        parameter.Value = content;
                        cmd.Parameters.Add(parameter);
                        conn.Open();
                        iResult = cmd.ExecuteNonQuery();
                    }
                    catch (ExceptionUtility ex)
                    {
                        throw new ExceptionUtility("執行帶一個存儲過程參數的SQL語句異常:" + ex.Message);
                    }
                }
            }
            return iResult;
        }

        /// <summary>
        /// 執行SQL語句，返回影響的記錄數
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="sqlParams"></param>
        /// <returns></returns>
        public static int ExecuteSql(string sql, params SqlParameter[] sqlParams)
        {
            int iResult = -1;
            using (SQLiteConnection conn = getSQLiteConnection())
            {
                using (SQLiteCommand cmd = new SQLiteCommand())
                {
                    try
                    {
                        PrepareCommand(conn, cmd, null, sql, sqlParams);
                        iResult = cmd.ExecuteNonQuery();
                        cmd.Parameters.Clear();
                    }
                    catch (ExceptionUtility ex)
                    {
                        throw new ExceptionUtility("執行SQL語句，返回影響的記錄數異常:" + ex.Message);
                    }
                }
            }
            return iResult;
        }

        /// <summary>
        /// 執行查詢
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public static DataSet Query(string sql)
        {
            DataSet dsResult = null;
            using (SQLiteConnection conn = getSQLiteConnection())
            {
                using (SQLiteDataAdapter da = new SQLiteDataAdapter(sql, conn))
                {
                    try
                    {
                        conn.Open();
                        dsResult = new DataSet();
                        da.Fill(dsResult, "ds");
                    }
                    catch (ExceptionUtility ex)
                    {
                        throw new ExceptionUtility("執行查詢異常:" + ex.Message);
                    }
                }
            }
            return dsResult;
        }

        /// <summary>
        /// 執行查詢語句，返回DataSet
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="sqlParams"></param>
        /// <returns></returns>
        public static DataSet Query(string sql, params SqlParameter[] sqlParams)
        {
            DataSet dsResult = null;
            using (SQLiteConnection conn = getSQLiteConnection())
            {
                using (SQLiteCommand cmd = new SQLiteCommand())
                {
                    using (SQLiteDataAdapter da = new SQLiteDataAdapter(cmd))
                    {
                        try
                        {
                            PrepareCommand(conn, cmd, null, sql, sqlParams);
                            dsResult = new DataSet();
                            da.Fill(dsResult, "ds");
                            cmd.Parameters.Clear();
                        }
                        catch (ExceptionUtility ex)
                        {
                            throw new ExceptionUtility("執行查詢返回DataSet異常:" + ex.Message);
                        }
                    }
                }
            }
            return dsResult;
        }

        /// <summary>
        /// 執行一條計算查詢結果語句，返回查詢結果（object）
        /// 第一行第一列
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public static object GetSingle(string sql)
        {
            object oResult = null;
            using (SQLiteConnection conn = getSQLiteConnection())
            {
                using (SQLiteCommand cmd = new SQLiteCommand(sql, conn))
                {
                    try
                    {
                        conn.Open();
                        oResult = cmd.ExecuteScalar();
                    }
                    catch (ExceptionUtility ex)
                    {
                        throw new ExceptionUtility("執行一條計算查詢結果語句，返回查詢結果（object）異常:" + ex.Message);
                    }
                }
            }
            return oResult;
        }

        /// <summary>
        /// 執行一條計算查詢結果語句，返回查詢結果（object）
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="sqlParams"></param>
        /// <returns></returns>
        public static object GetSingle(string sql, params SqlParameter[] sqlParams)
        {
            object oResult = null;
            using (SQLiteConnection conn = getSQLiteConnection())
            {
                using (SQLiteCommand cmd = new SQLiteCommand())
                {
                    try
                    {
                        PrepareCommand(conn, cmd, null, sql, sqlParams);
                        oResult = cmd.ExecuteScalar();
                        cmd.Parameters.Clear();
                    }
                    catch (ExceptionUtility ex)
                    {
                        throw new ExceptionUtility("執行查詢異常:" + ex.Message);
                    }
                }
            }
            return oResult;
        }

        /// <summary>
        /// 執行查詢，返回sqliteDataReader
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public static SQLiteDataReader ExecuteReader(string sql)
        {
            SQLiteDataReader rResult = null;
            using (SQLiteConnection conn = getSQLiteConnection())
            {
                using (SQLiteCommand cmd = new SQLiteCommand(sql, conn))
                {
                    try
                    {
                        conn.Open();
                        rResult = cmd.ExecuteReader();
                    }
                    catch (ExceptionUtility ex)
                    {
                        throw new ExceptionUtility("執行查詢返回sqliteDataReader異常:" + ex.Message);
                    }
                }
            }
            return rResult;
        }

        /// <summary>
        /// 執行查詢語句，返回SqliteDataReader
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="sqlParams"></param>
        /// <returns></returns>
        public static SQLiteDataReader ExecuteReader(string sql, params SqlParameter[] sqlParams)
        {
            SQLiteDataReader rResult = null;
            using (SQLiteConnection conn = getSQLiteConnection())
            {
                using (SQLiteCommand cmd = new SQLiteCommand())
                {
                    try
                    {
                        PrepareCommand(conn, cmd, null, sql, sqlParams);
                        rResult = cmd.ExecuteReader();
                        cmd.Parameters.Clear();
                    }
                    catch (ExceptionUtility ex)
                    {
                        throw new ExceptionUtility("執行查詢返回SqliteDataReader異常:" + ex.Message);
                    }
                }
            }
            return rResult;
        }

        #endregion  執行查詢

        #region  執行事務

        /// <summary>
        /// 執行SQL事務操作
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public static int ExecuteSqlTran(string sql)
        {
            int iResult = -1;
            using (SQLiteConnection conn = getSQLiteConnection())
            {
                using (SQLiteTransaction tran = conn.BeginTransaction())
                {
                    using (SQLiteCommand cmd = new SQLiteCommand(sql, conn, tran))
                    {
                        try
                        {
                            if (!string.IsNullOrEmpty(sql))
                            {
                                conn.Open();
                                iResult = cmd.ExecuteNonQuery();
                                tran.Commit();
                            }
                        }
                        catch (ExceptionUtility ex)
                        {
                            tran.Rollback();
                            throw new ExceptionUtility("執行SQL事務操作異常:" + ex.Message);
                        }
                    }
                }
            }
            return iResult;
        }

        /// <summary>
        /// 執行多條SQL事務操作
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public static int ExecuteSqlTran(List<string> sqlList)
        {
            int iResult = -1;
            using (SQLiteConnection conn = getSQLiteConnection())
            {
                using (SQLiteTransaction tran = conn.BeginTransaction())
                {
                    using (SQLiteCommand cmd = new SQLiteCommand())
                    {
                        try
                        {
                            conn.Open();
                            cmd.Connection = conn;
                            cmd.Transaction = tran;
                            foreach (string sql in sqlList)
                            {
                                if (!string.IsNullOrEmpty(sql))
                                {
                                    cmd.CommandText = sql;
                                    iResult += cmd.ExecuteNonQuery();
                                }
                            }
                            tran.Commit();
                        }
                        catch (ExceptionUtility ex)
                        {
                            tran.Rollback();
                            throw new ExceptionUtility("執行多條SQL事務操作異常:" + ex.Message);
                        }
                    }
                }
            }
            return iResult;
        }

        /// <summary>
        /// 執行多條SQL語句，實現數據庫事務
        /// </summary>
        /// <param name="sqlHashTable"></param>
        /// <returns></returns>
        public static int ExecuteSqlTran(Hashtable sqlHashTable)
        {
            int iResult = -1;
            using (SQLiteConnection conn = getSQLiteConnection())
            {
                using (SQLiteTransaction tran = conn.BeginTransaction())
                {
                    using (SQLiteCommand cmd = new SQLiteCommand())
                    {
                        try
                        {
                            conn.Open();
                            foreach (DictionaryEntry de in sqlHashTable)
                            {
                                string cmdSql = de.Key.ToString();
                                SqlParameter[] cmdParams = (SqlParameter[])de.Value;
                                PrepareCommand(conn, cmd, tran, cmdSql, cmdParams);
                                iResult = cmd.ExecuteNonQuery();
                                cmd.Parameters.Clear();
                                tran.Commit();
                            }
                        }
                        catch (ExceptionUtility ex)
                        {
                            tran.Rollback();
                            throw new ExceptionUtility("執行多條SQL事務異常:" + ex.Message);
                        }
                    }
                }
            }
            return iResult;
        }

 

        /// <summary>
        /// 向數據庫中插入圖像格式字段
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="fs"></param>
        /// <returns></returns>
        public static int ExecuteSqlInsertImg(string sql, byte[] fs)
        {
            int iResult = -1;
            using (SQLiteConnection conn = getSQLiteConnection())
            {
                using (SQLiteCommand cmd = new SQLiteCommand(sql, conn))
                {
                    try
                    {
                        SqlParameter sqlParam = new SqlParameter("@fs", SqlDbType.Image);
                        sqlParam.Value = fs;
                        cmd.Parameters.Add(sqlParam);
                        conn.Open();
                        iResult = cmd.ExecuteNonQuery();
                    }
                    catch (ExceptionUtility ex)
                    {
                        throw new ExceptionUtility("插入圖像字段異常:" + ex.Message);
                    }
                }
            }
            return iResult;
        }

        #endregion 執行事務

        #region 私有公共方法

        private static void PrepareCommand(SQLiteConnection conn, SQLiteCommand cmd, SQLiteTransaction tran, string sql, SqlParameter[] sqlParams)
        {
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }
            cmd.Connection = conn;
            cmd.CommandText = sql;

            if (tran != null)
            {
                cmd.Transaction = tran;
            }
            cmd.CommandType = CommandType.Text;

            if (sqlParams != null)
            {
                foreach (SqlParameter param in sqlParams)
                {
                    cmd.Parameters.Add(param);
                }
            }
        }

        #endregion 私有公共方法

        #region 存儲過程

        /// <summary>
        /// 執行存儲過程
        /// </summary>
        /// <param name="storedProcName"></param>
        /// <param name="dataParams"></param>
        /// <returns></returns>
        public static SQLiteDataReader RunProcedure(string storedProcName, IDataParameter[] dataParams)
        {
            SQLiteDataReader rResult = null;
            using (SQLiteConnection conn = getSQLiteConnection())
            {
                using (SQLiteCommand cmd = BuildQueryCommand(conn, storedProcName, dataParams))
                {
                    try
                    {
                        rResult = cmd.ExecuteReader();
                    }
                    catch (ExceptionUtility ex)
                    {
                        throw new ExceptionUtility("執行存儲過程異常:" + ex.Message);
                    }
                }
            }
            return rResult;
        }

        /// <summary>
        /// 執行存儲過程
        /// </summary>
        /// <param name="storedProcName"></param>
        /// <param name="dataParams"></param>
        /// <param name="tableName"></param>
        /// <returns></returns>
        public static DataSet RunProcedure(string storedProcName, IDataParameter[] dataParams, string tableName)
        {
            DataSet dsResult = null;
            using (SQLiteConnection conn = getSQLiteConnection())
            {
                using (SQLiteDataAdapter da = new SQLiteDataAdapter())
                {
                    try
                    {
                        dsResult = new DataSet();
                        da.SelectCommand = BuildQueryCommand(conn, storedProcName, dataParams);
                        da.Fill(dsResult, tableName);
                    }
                    catch (ExceptionUtility ex)
                    {
                        throw new ExceptionUtility("執行存儲過程異常:" + ex.Message);
                    }
                }
            }
            return dsResult;
        }

        /// <summary>
        /// 執行存儲過程，返回影響的行數
        /// </summary>
        /// <param name="storedProcName"></param>
        /// <param name="dataParams"></param>
        /// <param name="rowsAffected"></param>
        /// <returns></returns>
        public static int RunProcedure(string storedProcName, IDataParameter[] dataParams, out int rowsAffected)
        {
            int iResult = -1;
            using (SQLiteConnection conn = getSQLiteConnection())
            {
                try
                {
                    SQLiteCommand cmd = BuildIntCommand(conn, storedProcName, dataParams);
                    rowsAffected = cmd.ExecuteNonQuery();
                    iResult = (int)cmd.Parameters["ReturnValue"].Value;
                }
                catch (ExceptionUtility ex)
                {
                    throw new ExceptionUtility("執行存儲過程異常:" + ex.Message);
                }               
            }
            return iResult;
        }

        /// <summary>
        /// 創建SQLiteCommand對象實例（用來返回一個整數值）
        /// </summary>
        /// <param name="conn"></param>
        /// <param name="storedProcName"></param>
        /// <param name="dataParams"></param>
        /// <returns></returns>
        private static SQLiteCommand BuildIntCommand(SQLiteConnection conn, string storedProcName, IDataParameter[] dataParams)
        {
            SQLiteCommand cmd = BuildQueryCommand(conn, storedProcName, dataParams);
            cmd.Parameters.Add(new SqlParameter("ReturnValue", SqlDbType.Int, 4, ParameterDirection.ReturnValue, false, 0, 0, string.Empty, DataRowVersion.Default, null));
            return cmd;
        }

        /// <summary>
        /// 構建SqliteCommand對象（用來返回一個結果集，而不是一個整數值）
        /// </summary>
        /// <param name="conn"></param>
        /// <param name="storedProcName"></param>
        /// <param name="dataParams"></param>
        /// <returns></returns>
        private static SQLiteCommand BuildQueryCommand(SQLiteConnection conn, string storedProcName, IDataParameter[] dataParams)
        {
            SQLiteCommand cmd = new SQLiteCommand(storedProcName, conn);
            try
            {
                if (conn.State != ConnectionState.Open)
                {
                    conn.Open();
                }
                cmd.CommandType = CommandType.StoredProcedure;
                foreach (SqlParameter param in dataParams)
                {
                    cmd.Parameters.Add(param);
                }
            }
            catch (ExceptionUtility ex)
            {
                throw new ExceptionUtility("構建SQLiteCommand異常:" + ex.Message);
            }
            return cmd;
        }

        #endregion  存儲過程

       
    }