SQLite介绍和使用

SQLite特点：

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

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

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

 

SQLite应用场景：

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

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

 

SQLite使用：

封装SQliteHelper类。

  1  public static class SqliteHelper
  2     {
  3         private static string connectionString =  ConfigurationManager.ConnectionStrings["SqliteConnectionstring"].ConnectionString;
  4          
  5         /// 

  6         /// 创建一个数据库文件。如果存在同名数据库文件，则会覆盖。
  7         /// 
  8         /// 数据库文件名。为null或空串时不创建。
  9         /// （可选）数据库密码，默认为空。
 10         /// 
 11         public static void CreateDB(string dbName)
 12         {
 13             SQLiteConnection conn = null;
 14             string dbPath = "Data Source ="+ connectionString+"/"+dbName + ".db";
 15             conn = new SQLiteConnection(dbPath);//创建数据库实例，指定文件位置  
 16             conn.Open();//打开数据库，若文件不存在会自动创建  
 17             string sql = "CREATE TABLE IF NOT EXISTS T_BuildChildPath(Id integer  IDENTITY(1,1), ProductsCode nvarchar(100), CodePath nvarchar(100), CreateTime  datetime);";//建表语句  
 18             SQLiteCommand cmdCreateTable = new SQLiteCommand(sql, conn);
 19             cmdCreateTable.ExecuteNonQuery();//如果表不存在，创建数据表  
 20             conn.Close();
 21         }
 22         /// 

 23         /// 对SQLite数据库执行增删改操作，返回受影响的行数。
 24         /// 
 25         /// 要执行的增删改的SQL语句。
 26         /// 执行增删改语句所需要的参数，参数必须以它们在SQL语句中的顺序为准。
 27         /// 
 28         /// 
 29         public static int ExecuteNonQuery(string sql, params SQLiteParameter[] parameters)
 30         {
 31             int affectedRows = 0;
 32             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
 33             {
 34                 using (SQLiteCommand command = new SQLiteCommand(connection))
 35                 {
 36                     try
 37                     {
 38                         connection.Open();
 39                         command.CommandText = sql;
 40                         
 41                         if (parameters.Length != 0)
 42                         {
 43                             command.Parameters.AddRange(parameters);
 44                         }
 45                         affectedRows = command.ExecuteNonQuery();
 46                     }
 47                     catch (Exception ex) { throw; }
 48                 }
 49             }
 50             return affectedRows;
 51         }
 52         public static int ExecuteNonQuery(string sql )
 53         {
 54             int affectedRows = 0;
 55             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
 56             {
 57                 using (SQLiteCommand command = new SQLiteCommand(connection))
 58                 {
 59                     try
 60                     {
 61                         connection.Open();
 62                         command.CommandText = sql;
 63                        
 64                         affectedRows = command.ExecuteNonQuery();
 65                     }
 66                     catch (Exception ex) { throw; }
 67                 }
 68             }
 69             return affectedRows;
 70         }
 71         /// 

 72         /// 批量处理数据操作语句。
 73         /// 
 74         /// SQL语句集合。
 75         /// 
 76         public static  void ExecuteNonQueryBatch(Liststring,  SQLiteParameter[]>> list)
 77         {
 78             using (SQLiteConnection conn = new SQLiteConnection(connectionString))
 79             {
 80                 try { conn.Open(); }
 81                 catch { throw; }
 82                 using (SQLiteTransaction tran = conn.BeginTransaction())
 83                 {
 84                     using (SQLiteCommand cmd = new SQLiteCommand(conn))
 85                     {
 86                         try
 87                         {
 88                             foreach (var item in list)
 89                             {
 90                                 cmd.CommandText = item.Key;
 91                                 if (item.Value != null)
 92                                 {
 93                                     cmd.Parameters.AddRange(item.Value);
 94                                 }
 95                                 cmd.ExecuteNonQuery();
 96                             }
 97                             tran.Commit();
 98                         }
 99                         catch (Exception) { tran.Rollback(); throw; }
100                     }
101                 }
102             }
103         }
104         /// 

105         /// 执行查询语句，并返回第一个结果。
106         /// 
107         /// 查询语句。
108         /// 查询结果。
109         /// 
110         public static object ExecuteScalar(string sql, params SQLiteParameter[]  parameters)
111         {
112             using (SQLiteConnection conn = new SQLiteConnection(connectionString))
113             {
114                 using (SQLiteCommand cmd = new SQLiteCommand(conn))
115                 {
116                     try
117                     {
118                         conn.Open();
119                         cmd.CommandText = sql;
120                         if (parameters.Length != 0)
121                         {
122                             cmd.Parameters.AddRange(parameters);
123                         }
124                         return cmd.ExecuteScalar();
125                     }
126                     catch (Exception) { throw; }
127                 }
128             }
129         }
130         public static bool ExecuteScalar(string sql )
131         {
132             using (SQLiteConnection conn = new SQLiteConnection(connectionString))
133             {
134                 using (SQLiteCommand cmd = new SQLiteCommand(conn))
135                 {
136                     try
137                     {
138                         conn.Open();
139                         cmd.CommandText = sql;
140                      
141                         return  (Convert.ToInt32(cmd.ExecuteScalar()?.ToString()??"0")>0)?true:false;
142                     }
143                     catch (Exception) { throw; }
144                 }
145             }
146         }
147         public static string ExecuteScalarStr(string sql)
148         {
149             using (SQLiteConnection conn = new SQLiteConnection(connectionString))
150             {
151                 using (SQLiteCommand cmd = new SQLiteCommand(conn))
152                 {
153                     try
154                     {
155                         conn.Open();
156                         cmd.CommandText = sql;
157                         return cmd.ExecuteScalar()?.ToString();
158                     }
159                     catch (Exception) { throw; }
160                 }
161             }
162         }
163         /// 

164         /// 执行一个查询语句，返回一个包含查询结果的DataTable。
165         /// 
166         /// 要执行的查询语句。
167         /// 执行SQL查询语句所需要的参数，参数必须以它们在SQL语句中的顺序为准。
168         /// 
169         /// 
170         public static DataTable ExecuteQuery(string sql, params SQLiteParameter[]  parameters)
171         {
172             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
173             {
174                 using (SQLiteCommand command = new SQLiteCommand(sql, connection))
175                 {
176                     if (parameters.Length != 0)
177                     {
178                         command.Parameters.AddRange(parameters);
179                     }
180                     SQLiteDataAdapter adapter = new SQLiteDataAdapter(command);
181                     DataTable data = new DataTable();
182                     try { adapter.Fill(data); }
183                     catch (Exception) { throw; }
184                     return data;
185                 }
186             }
187         }
188         /// 

189         /// 执行一个查询语句，返回一个关联的SQLiteDataReader实例。
190         /// 
191         /// 要执行的查询语句。
192         /// 执行SQL查询语句所需要的参数，参数必须以它们在SQL语句中的顺序为准。
193         /// 
194         /// 
195         public static SQLiteDataReader ExecuteReader(string sql, params SQLiteParameter[]  parameters)
196         {
197             SQLiteConnection connection = new SQLiteConnection(connectionString);
198             SQLiteCommand command = new SQLiteCommand(sql, connection);
199             try
200             {
201                 if (parameters.Length != 0)
202                 {
203                     command.Parameters.AddRange(parameters);
204                 }
205                 connection.Open();
206                 return command.ExecuteReader(CommandBehavior.CloseConnection);
207             }
208             catch (Exception) { throw; }
209         }
210         /// 

211         /// 查询数据库中的所有数据类型信息。
212         /// 
213         /// 
214         /// 
215         public static DataTable GetSchema()
216         {
217             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
218             {
219                 try
220                 {
221                     connection.Open();
222                     return connection.GetSchema("TABLES");
223                 }
224                 catch (Exception) { throw; }
225             }
226         }
227     }

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

  "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;