微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

一个功能齐全的SQLite数据库的帮助类

分类：Sqlite作者：编程之家AI导航网 
using System;
using System.Text;
using System.Data.Common;
using System.Collections;
using System.Collections.Generic;
using System.Web;
using System.Configuration;
using System.Data;
using System.Data.sqlite;

namespace xhan2000.Common40.Data
{
    public static class sqliteHelper
    {
        public static readonly object WriteLock = new object();
        static readonly object writeLock = new object();
        public static char[] SplitChars = new char[] { ',',' ',')','(','+','-','*','/' };

        static string connectionString = System.Configuration.ConfigurationManager.ConnectionStrings[0].ToString();
        public static string ConnectionString
        {
            get
            {
                return connectionString;
            }
            set
            {
                connectionString = value;
            }
        }

        public static bool SureOpen(DbConnection conn)
        {
            return Open(conn);
        }
        public static bool Open(DbConnection conn)
        {
            if (conn != null && conn.State != ConnectionState.Open)
            {
                conn.open();
                return true;
            }
            return false;
        }
        public static bool SureClose(DbConnection conn)
        {
            return Close(conn);
        }
        public static bool Close(DbConnection conn)
        {
            if (conn != null && conn.State != ConnectionState.Closed)
            {
                conn.Close();
                return true;
            }
            return false;
        }

        public static object GetDbValue(object o)
        {
            if (o == null)
                return dbnull.Value;
            return o;
        }

        public static string GetSortString(Dictionary<string,bool> dic,bool isReverse)
        {
            StringBuilder sb = new StringBuilder();
            System.Collections.IEnumerator ienum = dic.GetEnumerator();
            while (ienum.MoveNext())
            {
                keyvaluePair<string,bool> kvp = (keyvaluePair<string,bool>)ienum.Current;
                sb.Append(kvp.Key + " " + (isReverse ? (kvp.Value ? "desc" : "asc") : (kvp.Value ? "asc" : "desc")) + ",");
            }
            string temp = sb.ToString();
            return temp.Substring(0,temp.Length - 1);
        }

        //static readonly sqliteTransaction singleton = GetsqliteTransaction();
        //public static sqliteTransaction Singleton
        //{
        //    get
        //    {
        //        return singleton;
        //    }
        //}

        /// <summary>
        /// 获得连接对象
        /// </summary>
        /// <returns></returns>
        public static sqliteConnection GetsqliteConnection(string connectionString)
        {
            return new sqliteConnection(connectionString);
        }
        public static sqliteConnection GetsqliteConnection()
        {
            return GetsqliteConnection(ConnectionString);
        }
        public static sqliteConnection CreateConnection(string connectionString)
        {
            return new sqliteConnection(connectionString);
        }
        public static sqliteConnection CreateConnection()
        {
            return CreateConnection(ConnectionString);
        }
        public static sqliteTransaction GetsqliteTransaction(string connectionString)
        {
            sqliteConnection conn = GetsqliteConnection(connectionString);
            conn.open();
            return conn.BeginTransaction();
        }
        public static sqliteTransaction GetsqliteTransaction()
        {
            return GetsqliteTransaction(ConnectionString);
        }
        public static sqliteTransaction CreateTransaction(string connectionString)
        {
            sqliteConnection conn = GetsqliteConnection(connectionString);
            conn.open();
            return conn.BeginTransaction(true);
        }
        public static sqliteTransaction CreateTransaction()
        {
            return CreateTransaction(ConnectionString);
        }

        public static sqliteCommand PrepareCommand(sqliteCommand cmd,sqliteConnection conn,string cmdText,params object[] p)
        {
            //if (conn.State != ConnectionState.Open)
            //    conn.open();
            cmd.Parameters.Clear();
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            //cmd.CommandType = CommandType.Text;
            //cmd.CommandTimeout = 30;

            if (cmd.CommandType == CommandType.Text && !cmdText.Contains(" "))
            {
                cmd.CommandType = CommandType.StoredProcedure;
            }

            if (p != null && p.Length > 0)
            {
                List<object> list = new List<object>();
                for (int i = 0; i < p.Length; i++)
                {
                    if (p[i] is IList)
                    {
                        IList l = p[i] as IList;
                        for (int j = 0; j < l.Count; j++)
                        {
                            list.Add(l[j]);
                        }
                    }
                    else
                    {
                        list.Add(p[i]);
                    }
                }

                if (cmd.CommandText.Contains("?"))
                {
                    string[] temp = cmd.CommandText.Split('?');
                    for (int i = 0; i < temp.Length - 1; i++)
                    {
                        temp[i] = temp[i] + "@p" + (i + 1).ToString();
                    }
                    StringBuilder sb = new StringBuilder();
                    for (int i = 0; i < temp.Length; i++)
                    {
                        sb.Append(temp[i]);
                    }
                    cmd.CommandText = sb.ToString();
                }

                string[] tempStr = cmd.CommandText.Split('@');
                for (int i = 0; i < list.Count; i++)
                {
                    DbParameter parameter = cmd.CreateParameter();
                    if (tempStr[i + 1].IndexOfAny(SplitChars) > -1)
                    {
                        if (cmd.Parameters.Contains("@" + tempStr[i + 1].Substring(0,tempStr[i + 1].IndexOfAny(SplitChars))))
                            continue;
                        parameter.ParameterName = "@" + tempStr[i + 1].Substring(0,tempStr[i + 1].IndexOfAny(SplitChars));
                    }
                    else
                    {
                        if (cmd.Parameters.Contains("@" + tempStr[i + 1]))
                            continue;
                        parameter.ParameterName = "@" + tempStr[i + 1];
                    }
                    parameter.Value = GetDbValue(list[i]);
                    cmd.Parameters.Add(parameter);
                }
            }
            return cmd;
        }
        public static sqliteCommand PrepareCommand(this sqliteTransaction trans,params object[] p)
        {
            return PrepareCommand(PrepareCommand(trans),cmdText,p);
        }
        public static sqliteCommand PrepareCommand(this sqliteCommand cmd,CommandType commandType,params object[] p)
        {
            cmd.CommandType = commandType;
            return PrepareCommand(cmd,cmd.Connection,params object[] p)
        {
            return PrepareCommand(cmd,p);
        }
        public static sqliteCommand PrepareCommand(this sqliteConnection conn,params object[] p)
        {
            return PrepareCommand(conn.CreateCommand(),cmd.CommandText,p);
        }
        public static sqliteCommand PrepareCommand(this sqliteTransaction trans)
        {
            if (trans == null)
            {
                return GetsqliteConnection().CreateCommand();
            }
            else
            {
                sqliteCommand cmd = trans.Connection.CreateCommand();
                cmd.Transaction = trans;
                return cmd;
            }
        }

        public static DataSet ExecuteDataSet(this sqliteTransaction trans,params object[] p)
        {
            return ExecuteDataSet(PrepareCommand(trans),p);
        }
        public static DataSet ExecuteDataSet(sqliteCommand cmd,params object[] p)
        {
            DataSet ds = new DataSet();
            PrepareCommand(cmd,commandType,p);
            sqliteDataAdapter da = new sqliteDataAdapter(cmd);
            da.Fill(ds);
            return ds;
        }
        public static DataSet ExecuteDataSet(sqliteCommand cmd,params object[] p)
        {
            return ExecuteDataSet(cmd,CommandType.Text,p);
        }
        public static DataSet ExecuteDataSet(CommandType commandType,params object[] p)
        {
            DataSet ds = new DataSet();
            sqliteCommand cmd = new sqliteCommand();
            cmd.CommandType = commandType;
            using (sqliteConnection connection = GetsqliteConnection())
            {
                PrepareCommand(cmd,connection,p);
                sqliteDataAdapter da = new sqliteDataAdapter(cmd);
                da.Fill(ds);
            }
            return ds;
        }
        public static DataSet ExecuteDataSet(string cmdText,params object[] p)
        {
            return ExecuteDataSet(CommandType.Text,p);
        }

        public static DataTable ExecuteDataTable(this sqliteTransaction trans,params object[] p)
        {
            return ExecuteDataTable(PrepareCommand(trans),p);
        }
        public static DataTable ExecuteDataTable(sqliteCommand cmd,p).Tables[0];
        }
        public static DataTable ExecuteDataTable(sqliteCommand cmd,params object[] p)
        {
            return ExecuteDataTable(cmd,p);
        }
        public static DataTable ExecuteDataTable(CommandType commandType,params object[] p)
        {
            return ExecuteDataSet(commandType,p).Tables[0];
        }
        public static DataTable ExecuteDataTable(string cmdText,params object[] p)
        {
            return ExecuteDataSet(cmdText,p).Tables[0];
        }

        public static DaTarow ExecuteDaTarow(this sqliteTransaction trans,params object[] p)
        {
            return ExecuteDaTarow(PrepareCommand(trans),p);
        }
        public static DaTarow ExecuteDaTarow(sqliteCommand cmd,params object[] p)
        {
            DataSet ds = ExecuteDataSet(cmd,p);
            if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                return ds.Tables[0].Rows[0];
            return null;
        }
        public static DaTarow ExecuteDaTarow(sqliteCommand cmd,params object[] p)
        {
            return ExecuteDaTarow(cmd,p);
        }
        public static DaTarow ExecuteDaTarow(CommandType commandType,params object[] p)
        {
            DataSet ds = ExecuteDataSet(commandType,p);
            if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                return ds.Tables[0].Rows[0];
            return null;
        }
        public static DaTarow ExecuteDaTarow(string cmdText,params object[] p)
        {
            return ExecuteDaTarow(CommandType.Text,p);
        }

        public static int ExecuteNonQuery(this sqliteTransaction trans,params object[] p)
        {
            return ExecuteNonQuery(PrepareCommand(trans),p);
        }
        public static int ExecuteNonQuery(sqliteCommand cmd,params object[] p)
        {
            PrepareCommand(cmd,p);
            if (cmd.Transaction == null)
            {
                int i = 0;
                if (cmd.Sureopen())
                {
                    lock (writeLock)
                        i = cmd.ExecuteNonQuery();
                    cmd.SureClose();
                }
                else
                {
                    lock (writeLock)
                        i = cmd.ExecuteNonQuery();
                }
                return i;
            }
            else
            {
                return cmd.ExecuteNonQuery();
            }
        }
        public static int ExecuteNonQuery(sqliteCommand cmd,params object[] p)
        {
            return ExecuteNonQuery(cmd,p);
        }
        public static int ExecuteNonQuery(CommandType commandType,params object[] p)
        {
            sqliteCommand cmd = new sqliteCommand();
            cmd.CommandType = commandType;
            using (sqliteConnection connection = GetsqliteConnection())
            {
                PrepareCommand(cmd,p);
                connection.Sureopen();
                lock (writeLock)
                    return cmd.ExecuteNonQuery();
            }
        }
        public static int ExecuteNonQuery(string cmdText,params object[] p)
        {
            return ExecuteNonQuery(CommandType.Text,p);
        }

        public static sqliteDataReader ExecuteReader(this sqliteTransaction trans,params object[] p)
        {
            return ExecuteReader(PrepareCommand(trans),p);
        }
        public static sqliteDataReader ExecuteReader(sqliteCommand cmd,p);
            if (cmd.Sureopen())
                return cmd.ExecuteReader(CommandBehavior.CloseConnection);
            else
                return cmd.ExecuteReader();
        }
        public static sqliteDataReader ExecuteReader(sqliteCommand cmd,params object[] p)
        {
            return ExecuteReader(cmd,p);
        }
        public static sqliteDataReader ExecuteReader(CommandType commandType,params object[] p)
        {
            sqliteCommand cmd = new sqliteCommand();
            cmd.CommandType = commandType;
            sqliteConnection connection = GetsqliteConnection();
            try
            {
                PrepareCommand(cmd,p);
                if (cmd.Sureopen())
                    return cmd.ExecuteReader(CommandBehavior.CloseConnection);
                else
                    return cmd.ExecuteReader();
            }
            catch
            {
                connection.Close();
                throw;
            }
        }
        public static sqliteDataReader ExecuteReader(string cmdText,params object[] p)
        {
            return ExecuteReader(CommandType.Text,p);
        }

        public static object ExecuteScalar(this sqliteTransaction trans,params object[] p)
        {
            return ExecuteScalar(PrepareCommand(trans),p);
        }
        public static object ExecuteScalar(sqliteCommand cmd,p);
            object o = null;
            if (cmd.Sureopen())
            {
                o = cmd.ExecuteScalar();
                cmd.SureClose();
            }
            else
            {
                o = cmd.ExecuteScalar();
            }
            return o;
        }
        public static object ExecuteScalar(sqliteCommand cmd,params object[] p)
        {
            return ExecuteScalar(cmd,p);
        }
        public static object ExecuteScalar(CommandType commandType,p);
                connection.Sureopen();
                return cmd.ExecuteScalar();
            }
        }
        public static object ExecuteScalar(string cmdText,params object[] p)
        {
            return ExecuteScalar(CommandType.Text,p);
        }


        public static int ExecuteInsert(this sqliteTransaction trans,string tableName,params Dictionary<string,object>[] dic)
        {
            return ExecuteInsert(PrepareCommand(trans),tableName,dic);
        }
        public static int ExecuteInsert(this sqliteCommand cmd,object>[] dic)
        {
            cmd.Parameters.Clear();
            cmd.CommandType = CommandType.Text;
            cmd.CommandText = "select * from " + tableName + " where 1=2";
            sqliteDataAdapter a = new sqliteDataAdapter(cmd);
            sqliteCommandBuilder b = new sqliteCommandBuilder(a);
            DataSet ds = new DataSet();
            a.Fill(ds);
            for (int i = 0; i < dic.Length; i++)
            {
                DaTarow dr = ds.Tables[0].NewRow();
                IDictionaryEnumerator Mycollection = dic[i].GetEnumerator();
                while (Mycollection.MoveNext())
                {
                    dr[Mycollection.Key.ToString()] = Mycollection.Value != null ? (Mycollection.Value.ToString() != "" ? Mycollection.Value : dbnull.Value) : dbnull.Value;
                }
                ds.Tables[0].Rows.Add(dr);
            }
            if (cmd.Transaction == null)
            {
                lock (writeLock)
                    a.Update(ds);
            }
            else
            {
                a.Update(ds);
            }
            return dic.Length;
        }

        public static int ExecuteInsert(string tableName,object>[] dic)
        {
            using (sqliteConnection connection = GetsqliteConnection())
            {
                sqliteDataAdapter a = new sqliteDataAdapter("select * from " + tableName + " where 1=2",connection);
                sqliteCommandBuilder b = new sqliteCommandBuilder(a);
                DataSet ds = new DataSet();
                a.Fill(ds);
                for (int i = 0; i < dic.Length; i++)
                {
                    DaTarow dr = ds.Tables[0].NewRow();
                    IDictionaryEnumerator Mycollection = dic[i].GetEnumerator();
                    while (Mycollection.MoveNext())
                    {
                        dr[Mycollection.Key.ToString()] = Mycollection.Value != null ? (Mycollection.Value.ToString() != "" ? Mycollection.Value : dbnull.Value) : dbnull.Value;
                    }
                    ds.Tables[0].Rows.Add(dr);
                }
                lock (writeLock)
                    a.Update(ds);
                return dic.Length;
            }
        }

        public static void ExecuteUpdate(this sqliteTransaction trans,Dictionary<string,object> dic,string pkName)
        {
            ExecuteUpdate(PrepareCommand(trans),dic,pkName);
        }
        public static void ExecuteUpdate(this sqliteCommand cmd,string pkName)
        {
            cmd.Parameters.Clear();
            cmd.CommandType = CommandType.Text;
            cmd.CommandText = "select * from " + tableName + " where " + pkName + "=@p";
            cmd.Parameters.AddWithValue("@p",dic[pkName]);
            sqliteDataAdapter a = new sqliteDataAdapter(cmd);
            sqliteCommandBuilder b = new sqliteCommandBuilder(a);
            DataSet ds = new DataSet();
            a.Fill(ds);
            DaTarow dr = ds.Tables[0].Rows[0];
            IDictionaryEnumerator Mycollection = dic.GetEnumerator();
            while (Mycollection.MoveNext())
            {
                dr[Mycollection.Key.ToString()] = Mycollection.Value != null ? (Mycollection.Value.ToString() != "" ? Mycollection.Value : dbnull.Value) : dbnull.Value;
            }
            if (cmd.Transaction == null)
            {
                lock (writeLock)
                    a.Update(ds);
            }
            else
            {
                a.Update(ds);
            }
        }

        public static void ExecuteUpdate(this Dictionary<string,string pkName)
        {
            using (sqliteConnection connection = GetsqliteConnection())
            {
                sqliteCommand command = new sqliteCommand();
                PrepareCommand(command,"select * from " + tableName + " where " + pkName + "=@p",dic[pkName]);
                sqliteDataAdapter a = new sqliteDataAdapter(command);
                sqliteCommandBuilder b = new sqliteCommandBuilder(a);
                DataSet ds = new DataSet();
                a.Fill(ds);
                DaTarow dr = ds.Tables[0].Rows[0];
                IDictionaryEnumerator Mycollection = dic.GetEnumerator();
                while (Mycollection.MoveNext())
                {
                    dr[Mycollection.Key.ToString()] = Mycollection.Value != null ? (Mycollection.Value.ToString() != "" ? Mycollection.Value : dbnull.Value) : dbnull.Value;
                }
                lock (writeLock)
                    a.Update(ds);
            }
        }




        /// <summary>  
        /// 查询数据库中的所有数据类型信息  
        /// </summary>  
        /// <returns></returns>  
        public static DataTable GetSchema()
        {
            using (sqliteConnection connection = GetsqliteConnection())
            {
                connection.open();
                DataTable data = connection.GetSchema("TABLES");
                connection.Close();
                //foreach (DataColumn column in data.Columns)  
                //{  
                //    Console.WriteLine(column.ColumnName);  
                //}  
                return data;
            }
        }

        public static string GetPagesql(string tableName,string columns,int pageSize,int currentPageIndex,string condition,bool> dic)
        {
            return "select " + columns + " from " + tableName + " where " + condition + " order by " + GetSortString(dic,false) + " LIMIT " + (currentPageIndex * pageSize).ToString() + "," + ((currentPageIndex + 1) * pageSize).ToString();
        }
        public static string GetPagesql(string tableName,string sort)
        {
            return "select " + columns + " from " + tableName + " where " + condition + " order by " + sort + " LIMIT " + (currentPageIndex * pageSize).ToString() + "," + ((currentPageIndex + 1) * pageSize).ToString();
        }

        public static string GetPagesql(string tableName,int currentSize," + ((currentPageIndex * pageSize) + currentSize).ToString();
        }
        public static string GetPagesql(string tableName," + ((currentPageIndex * pageSize) + currentSize).ToString();
        }


        public static bool CreateDB(string dbPath)
        {
            if (System.IO.File.Exists(dbPath))
            {
                return false;
            }
            else
            {
                System.Data.sqlite.sqliteConnection.CreateFile(dbPath);
                return true;
            }
            //using (sqliteConnection connection = new sqliteConnection("Data Source=" + dbPath + ";"))
            //{
            //    connection.open();
            //    using (sqliteCommand command = new sqliteCommand(connection))
            //    {
            //        try
            //        {
            //            command.CommandText = "CREATE TABLE Demo(id integer NOT NULL PRIMARY KEY AUTOINCREMENT UNIQUE)";
            //            command.ExecuteNonQuery();
            //            command.CommandText = "DROP TABLE Demo";
            //            command.ExecuteNonQuery();
            //            return true;
            //        }
            //        catch
            //        {
            //            return false;
            //        }
            //    }
            //}
        }


        public static bool CreateLogInfo(string dbPath)
        {
            sqliteHelper.CreateDB(dbPath);
            using (sqliteConnection conn = new sqliteConnection("Data Source=" + dbPath + ";"))
            {
                using (sqliteCommand cmd = new sqliteCommand(conn))
                {
                    cmd.CommandText = "select count(*) from sqlite_master where type='table' and tbl_name='LogInfo'";
                    lock (writeLock)
                    {
                        conn.open();
                        int i = int.Parse(cmd.ExecuteScalar().ToString());
                        if (i == 1) return false;
                        cmd.CommandText = "CREATE TABLE LogInfo (LogID integer NOT NULL PRIMARY KEY AUTOINCREMENT UNIQUE,UserName nvarchar(60),LogGroup tinyint,LogType nvarchar(100),LogLevel tinyint,LogTarget nvarchar(100),LogContent nvarchar(4000),Comment nvarchar(2000),TheTime datetime DEFAULT (datetime(CURRENT_TIMESTAMP,'localtime')),Status tinyint);";
                        cmd.ExecuteNonQuery();
                    }
                    return true;
                }
            }
        }

        public static sqliteDataReader GetLogInfo(int pageSize,string sort)
        {
            return ExecuteReader(GetPagesql("LogInfo","*",pageSize,currentPageIndex,condition,sort));
        }

    }
}

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

Java 嵌入数据处理引擎：SQLite 的挑战者 esProc SPL
SQLite架构简单，又有Json计算能力，有时会承担Json文件/RESTful的计算功能，但SQLite不能直接解析Json文件/RESTful，需要用Java代码硬写，或借助第三方类库，最后再拼成insert语句插入数据表，代码非常繁琐，这里就不展示了。参考前面的代码可知，入库的过程比较麻烦，不能只用SQL，还要借助Java或命令行。SPL是现代的数据计算语言，属于简化的面向对象的语言风格，有对象的概念，可以用点号访问属性并进行多步骤计算，但没有继承重载这些内容，不算彻底的面向对象语言。...
五、使用Python操作数据库
使用Python操作内置数据库SQLite以及MySQL数据库。
AndroidStudio-实现登录界面数据存储在SQLite
登陆界面
一文教会你导出微信聊天记录
破解微信数据库密码，用python导出微信聊天记录
UnitySqlite持久化数据
（Unity）SQLite 是一个软件库，实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。SQLite 是在世界上最广泛部署的 SQL 数据库引擎。SQLite 源代码不受版权限制。本教程将告诉您如何使用 SQLite 编程，并让你迅速上手。.................................
Android用户登陆与注册功能的简单实现SQLite
安卓开发，利用SQLite实现登陆注册功能
SQLite——Java使用SQLite初体验
相比大多数数据库而言，具有等优势，广泛应用于、等领域。
使用SqlSugar连接多个数据库sqlserver，sqlite，mysql
有时候，一个项目只有一个数据库，比如只有SQLite，或者MySQL数据库，那么我们只需要使用一个固定的数据库即可。但是一个项目如果写好了，有多个用户使用，但是多个用户使用不同的数据库，这个时候，我们就需要把软件设计成可以连接多个数据库的模式，用什么数据库，就配置什么数据库即可。4.Users实体类，这个实体类要和数据库一样的，形成一一对应的关系。11.Sqlite数据库，需要在代码里面创建数据库，建立表，再建立数据。8.我们开启MySQL数据库，然后进行调试，看程序的结果。2.安装SqlSugar。
基于Android的背单词软件【源码+文档+答辩PPT】
基于Android的背单词软件，功能强大完整。
python ——操作sqlite 数据库
SQLite，是一款轻型的数据库，是遵守ACID的关系型数据库管理系统。说白了就是使用起来轻便简单，
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native