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  存储过程

}

时间： 2024-07-29 01:20:01

C#对sqlite操作类的相关文章

android Sqlite操作之-- 自定义ORM关系实体映射类

任何android应用程序都少不了数据库的操作,即使是客户端程序也会有一些特定的数据存入到数据库中,例如:用户浏览记录,收藏列表等等,所以数据库的操作就是一个会很频繁使用的操作,所以对这个部分的封装就很有必要了,Web端有Hibernate等一系列优秀的框架,虽然android应用程序在git上也有一些开源的OOM框架,但总觉得还是没必要引入第三方的东西,于是就自己封装了一个数据库操作类,只要调用此类相应的方法,传入要保存的实体对象或更新的实体对象即可,查询也是同样的,只要传入查询条件和Clas

Android打造属于自己的数据库操作类。

1.概述 开发Android的同学都知道sdk已经为我们提供了一个SQLiteOpenHelper类来创建和管理SQLite数据库,通过写一个子类去继承它,就可以方便的创建.管理数据库.但是当我们需要去做增删改查的操作的时候,就得通过getWritableDatabase获取一个SQLiteDataBase然后老老实实去写操作值的put以及查询返回的Cursor处理,其实我们可以搞一个对象来帮我们干这些事情,打造属于你自己的数据库操作类. 2.操作类的初显形 假设现在我们什么都没有,我们要去搞一

PHP 数据库操作类：ezSQL

EZSQL类介绍: 下载地址:http://www.jb51.net/codes/26393.html ezsql是一个小型的快速的数据库操作类,可以让你很容易地用PHP操作各种数据库( MySQL.oracle8/9 .interbase.FireBird.PostgreSQL.MS-SQL.sqlite.sqlite C++). 在你的脚本开头是要包含一个一个PHP文件.然后,你就可以使用更小.更容易的一套ezsql函数来代替标准的PHP数据库函数. 它会自动缓存的查询结果,提供了一系列简单

[Android新手区] SQLite 操作详解--SQL语法

该文章完全摘自转自:北大青鸟[Android新手区] SQLite 操作详解--SQL语法  :http://home.bdqn.cn/thread-49363-1-1.html SQLite库可以解析大部分标准SQL语言.但它也省去了一些特性并且加入了一些自己的新特性.这篇文档就是试图描述那些SQLite支持/不支持的SQL语法的.查看关键字列表. 如下语法表格中,纯文本用蓝色粗体显示.非终极符号为斜体红色.作为语法一部分的运算符用黑色Roman字体表示. 这篇文档只是对SQLite实现的SQ

C#通用数据库操作类

ADO.NET操作 使用ADO.NET的方式操作数据库时,对于经常需要操作不同数据库的同学,需要对不同的数据库翻来覆去地写操作类. 对ADO.NET,操作数据库需要有几个核心的东西(以MySql为例): MySqlConnection 负责mysql的连接,在操作mysql前,需要先获得连接. MySqlCommand 负责具体命令的类,具体需要执行的sql的语句需要放到它的CommandText下. MySqlDataAdapter 对于查询数据,可以选择使用DataAdapter将数据一次性

c# Sqlite帮助类

最近有WPF做客户端,需要离线操作存储数据,在项目中考虑使用Sqlite嵌入式数据库,在网上找了不少资料,最终整理出一个公共的帮助类. Sqlite是一个非常小巧的数据库,基本上具备关系型数据库操作的大多数功能,Sql语法也大同小异.下面是我整理的帮助类代码: 1.获取 SQLiteConnection 对象,传入数据库有地址即可. ? 1    /// <summary><br>        /// 获得连接对象<br>        /// </summar

SQLite操作数据库的步骤

package com.example.dbdemo; import android.content.Context; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteDatabase.CursorFactory; import android.database.sqlite.SQLiteOpenHelper; import android.widget.Toast; publ

ASP.net如何保证EF操作类线程内唯一

说到线程内唯一,肯定会想到单例模式,但是如果多用户访问网站就会出现问题.ASP.net中有两种方法可以保证EF操作类线程内唯一(目前只会这两种,以后有好的方法再添加): 1.httpcontext(实现原理也是通过数据槽callcontext) 将EF操作类通过键值对方法保存在HttpContext.Current.Items["key"],封装成方法直接调用 2.callcontext public static DbContext CreateDbContext() { DbCon

反射之操作类，方法，属性等

1.操作类 获取类,并通过反射获取一个实例对象 Class class1 = Student.class; Student student = (Student)class1.newInstance();   //默认调用无参数的构造方法 student.setName("heh"); System.out.println(student.getName()); 2.操作构造方法   获取指定参数类型的构造方法,通过此对象创建一个特定参数值的实例对象 Class class1 = St