SQLite介绍和使用

SQLite特点：

（1）轻量级，跨平台的关系型数据库，所以支持视图，事务，触发器等。

（2）零配置-无需安装和管理配置，存储在单一磁盘文件中的完整的数据库

（3）数据库文件可共享，支持多种开发语言。

 

SQLite应用场景：

适用于并发量低，访问需求高于写入操作的一些引用

例如，最近的项目里，在客户的文件服务器下，需要要建立文件路径的索引，并能够文件打包下载，考虑到不想装单独的数据库，于是乎便用了SQLite

 

SQLite使用：

封装SQliteHelper类。

  public static class SqliteHelper
     {
         private static string connectionString =  ConfigurationManager.ConnectionStrings["SqliteConnectionstring"].ConnectionString;
 
         /// <summary>
         /// 创建一个数据库文件。如果存在同名数据库文件，则会覆盖。
         /// </summary>
         /// <param name="dbName">数据库文件名。为null或空串时不创建。</param>
         /// <param name="password">（可选）数据库密码，默认为空。</param>
         /// <exception cref="Exception"></exception>
         public static void CreateDB(string dbName)
         {
             SQLiteConnection conn = null;
             string dbPath = "Data Source ="+ connectionString+"/"+dbName + ".db";
             conn = new SQLiteConnection(dbPath);//创建数据库实例，指定文件位置
             conn.Open();//打开数据库，若文件不存在会自动创建
             string sql = "CREATE TABLE IF NOT EXISTS T_BuildChildPath(Id integer  IDENTITY(1,1), ProductsCode nvarchar(100), CodePath nvarchar(100), CreateTime  datetime);";//建表语句
             SQLiteCommand cmdCreateTable = new SQLiteCommand(sql, conn);
             cmdCreateTable.ExecuteNonQuery();//如果表不存在，创建数据表
             conn.Close();
         }
         /// <summary>
         /// 对SQLite数据库执行增删改操作，返回受影响的行数。
         /// </summary>
         /// <param name="sql">要执行的增删改的SQL语句。</param>
         /// <param name="parameters">执行增删改语句所需要的参数，参数必须以它们在SQL语句中的顺序为准。</param>
         /// <returns></returns>
         /// <exception cref="Exception"></exception>
         public static int ExecuteNonQuery(string sql, params SQLiteParameter[] parameters)
         {
             int affectedRows = ;
             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
             {
                 using (SQLiteCommand command = new SQLiteCommand(connection))
                 {
                     try
                     {
                         connection.Open();
                         command.CommandText = sql;
 
                         if (parameters.Length != )
                         {
                             command.Parameters.AddRange(parameters);
                         }
                         affectedRows = command.ExecuteNonQuery();
                     }
                     catch (Exception ex) { throw; }
                 }
             }
             return affectedRows;
         }
         public static int ExecuteNonQuery(string sql )
         {
             int affectedRows = ;
             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
             {
                 using (SQLiteCommand command = new SQLiteCommand(connection))
                 {
                     try
                     {
                         connection.Open();
                         command.CommandText = sql;
 
                         affectedRows = command.ExecuteNonQuery();
                     }
                     catch (Exception ex) { throw; }
                 }
             }
             return affectedRows;
         }
         /// <summary>
         /// 批量处理数据操作语句。
         /// </summary>
         /// <param name="list">SQL语句集合。</param>
         /// <exception cref="Exception"></exception>
         public static  void ExecuteNonQueryBatch(List<KeyValuePair<string,  SQLiteParameter[]>> list)
         {
             using (SQLiteConnection conn = new SQLiteConnection(connectionString))
             {
                 try { conn.Open(); }
                 catch { throw; }
                 using (SQLiteTransaction tran = conn.BeginTransaction())
                 {
                     using (SQLiteCommand cmd = new SQLiteCommand(conn))
                     {
                         try
                         {
                             foreach (var item in list)
                             {
                                 cmd.CommandText = item.Key;
                                 if (item.Value != null)
                                 {
                                     cmd.Parameters.AddRange(item.Value);
                                 }
                                 cmd.ExecuteNonQuery();
                             }
                             tran.Commit();
                         }
                         catch (Exception) { tran.Rollback(); throw; }
                     }
                 }
             }
         }
         /// <summary>
         /// 执行查询语句，并返回第一个结果。
         /// </summary>
         /// <param name="sql">查询语句。</param>
         /// <returns>查询结果。</returns>
         /// <exception cref="Exception"></exception>
         public static object ExecuteScalar(string sql, params SQLiteParameter[]  parameters)
         {
             using (SQLiteConnection conn = new SQLiteConnection(connectionString))
             {
                 using (SQLiteCommand cmd = new SQLiteCommand(conn))
                 {
                     try
                     {
                         conn.Open();
                         cmd.CommandText = sql;
                         if (parameters.Length != )
                         {
                             cmd.Parameters.AddRange(parameters);
                         }
                         return cmd.ExecuteScalar();
                     }
                     catch (Exception) { throw; }
                 }
             }
         }
         public static bool ExecuteScalar(string sql )
         {
             using (SQLiteConnection conn = new SQLiteConnection(connectionString))
             {
                 using (SQLiteCommand cmd = new SQLiteCommand(conn))
                 {
                     try
                     {
                         conn.Open();
                         cmd.CommandText = sql;
 
                         return  (Convert.ToInt32(cmd.ExecuteScalar()?.ToString()??"")>)?true:false;
                     }
                     catch (Exception) { throw; }
                 }
             }
         }
         public static string ExecuteScalarStr(string sql)
         {
             using (SQLiteConnection conn = new SQLiteConnection(connectionString))
             {
                 using (SQLiteCommand cmd = new SQLiteCommand(conn))
                 {
                     try
                     {
                         conn.Open();
                         cmd.CommandText = sql;
                         return cmd.ExecuteScalar()?.ToString();
                     }
                     catch (Exception) { throw; }
                 }
             }
         }
         /// <summary>
         /// 执行一个查询语句，返回一个包含查询结果的DataTable。
         /// </summary>
         /// <param name="sql">要执行的查询语句。</param>
         /// <param name="parameters">执行SQL查询语句所需要的参数，参数必须以它们在SQL语句中的顺序为准。</param>
         /// <returns></returns>
         /// <exception cref="Exception"></exception>
         public static DataTable ExecuteQuery(string sql, params SQLiteParameter[]  parameters)
         {
             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
             {
                 using (SQLiteCommand command = new SQLiteCommand(sql, connection))
                 {
                     if (parameters.Length != )
                     {
                         command.Parameters.AddRange(parameters);
                     }
                     SQLiteDataAdapter adapter = new SQLiteDataAdapter(command);
                     DataTable data = new DataTable();
                     try { adapter.Fill(data); }
                     catch (Exception) { throw; }
                     return data;
                 }
             }
         }
         /// <summary>
         /// 执行一个查询语句，返回一个关联的SQLiteDataReader实例。
         /// </summary>
         /// <param name="sql">要执行的查询语句。</param>
         /// <param name="parameters">执行SQL查询语句所需要的参数，参数必须以它们在SQL语句中的顺序为准。</param>
         /// <returns></returns>
         /// <exception cref="Exception"></exception>
         public static SQLiteDataReader ExecuteReader(string sql, params SQLiteParameter[]  parameters)
         {
             SQLiteConnection connection = new SQLiteConnection(connectionString);
             SQLiteCommand command = new SQLiteCommand(sql, connection);
             try
             {
                 if (parameters.Length != )
                 {
                     command.Parameters.AddRange(parameters);
                 }
                 connection.Open();
                 return command.ExecuteReader(CommandBehavior.CloseConnection);
             }
             catch (Exception) { throw; }
         }
         /// <summary>
         /// 查询数据库中的所有数据类型信息。
         /// </summary>
         /// <returns></returns>
         /// <exception cref="Exception"></exception>
         public static DataTable GetSchema()
         {
             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
             {
                 try
                 {
                     connection.Open();
                     return connection.GetSchema("TABLES");
                 }
                 catch (Exception) { throw; }
             }
         }
     }

这里的SqliteConnectionstring连接字符串和SQL类似，Data Source改成对应的物理路径即可。

  <add name="SqliteConnectionstring" connectionString="Data  Source=D:/ProductsIndex.db"  providerName="System.Data.SqlClient" />

页面的调用：

string sql = string.Format(@" select * from T_BuildChildPath where ProductsCode like '%"  + PartCode + "%'");
DataView dv = SqliteHelper.ExecuteQuery(sql).DefaultView;