C#保存简单数据库SQLite

最新推荐文章于 2026-04-26 00:08:24 发布
原创 最新推荐文章于 2026-04-26 00:08:24 发布 · 1.3k 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#sqlite
本文详细介绍如何使用C#操作SQLite数据库，包括数据库的创建、查询、更新等操作，并提供了丰富的代码示例。

SQLite介绍

SQLite is a software library that implements a self-contained, serverless, zero-configuration, transactional SQL database engine.

SQLite是一个开源、免费的小型RDBMS(关系型数据库)，能独立运行、无服务器、零配置、支持事物，用C实现，内存占用较小，支持绝大数的SQL92标准。

SQLite数据库官方主页：http://www.sqlite.org/index.html

C#操作SQLite Database

C#下SQLite操作驱动dll下载：System.Data.SQLite

C#使用SQLite步骤：

（1）新建一个project

（2）添加SQLite操作驱动dll引用

（3）使用API操作SQLite DataBase

以下写了几个类

Helper类

// Version 1.2
// Date: 2014-03-27
// http://sh.codeplex.com
// Dedicated to Public Domain

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SQLite;
using System.Text;

namespace SQLiteHelper
{
    public enum ColType
    {
        Text,
        DateTime,
        Integer,
        Decimal,
        Blob
    }

    public class SqLiteHelper
    {
        private readonly SQLiteCommand _cmd;

        public SqLiteHelper(SQLiteCommand command)
        {
            _cmd = command;
        }

        #region DB Info

        public DataTable GetTableStatus()
        {
            return Select("SELECT * FROM sqlite_master;");
        }

        public DataTable GetTableList()
        {
            DataTable dt = GetTableStatus();
            DataTable dt2 = new DataTable();
            dt2.Columns.Add("Tables");
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                string t = dt.Rows[i]["name"] + "";
                if (t != "sqlite_sequence")
                    dt2.Rows.Add(t);
            }
            return dt2;
        }

        public DataTable GetColumnStatus(string tableName)
        {
            return Select(string.Format("PRAGMA table_info(`{0}`);", tableName));
        }

        public DataTable ShowDatabase()
        {
            return Select("PRAGMA database_list;");
        }

        #endregion

        #region Query

        public void BeginTransaction()
        {
            _cmd.CommandText = "begin transaction;";
            _cmd.ExecuteNonQuery();
        }

        public void Commit()
        {
            _cmd.CommandText = "commit;";
            _cmd.ExecuteNonQuery();
        }

        public void Rollback()
        {
            _cmd.CommandText = "rollback";
            _cmd.ExecuteNonQuery();
        }

        public DataTable Select(string sql)
        {
            return Select(sql, new List<SQLiteParameter>());
        }

        public DataTable Select(string sql, Dictionary<string, object> dicParameters = null)
        {
            List<SQLiteParameter> lst = GetParametersList(dicParameters);
            return Select(sql, lst);
        }

        public DataTable Select(string sql, IEnumerable<SQLiteParameter> parameters = null)
        {
            _cmd.CommandText = sql;
            if (parameters != null)
            {
                foreach (var param in parameters)
                {
                    _cmd.Parameters.Add(param);
                }
            }
            SQLiteDataAdapter da = new SQLiteDataAdapter(_cmd);
            DataTable dt = new DataTable();
            da.Fill(dt);
            return dt;
        }

        public void Execute(string sql)
        {
            Execute(sql, new List<SQLiteParameter>());
        }

        public void Execute(string sql, Dictionary<string, object> dicParameters = null)
        {
            List<SQLiteParameter> lst = GetParametersList(dicParameters);
            Execute(sql, lst);
        }

        public void Execute(string sql, IEnumerable<SQLiteParameter> parameters = null)
        {
            _cmd.CommandText = sql;
            if (parameters != null)
            {
                foreach (var param in parameters)
                {
                    _cmd.Parameters.Add(param);
                }
            }
            _cmd.ExecuteNonQuery();
        }

        public object ExecuteScalar(string sql)
        {
            _cmd.CommandText = sql;
            return _cmd.ExecuteScalar();
        }

        public object ExecuteScalar(string sql, Dictionary<string, object> dicParameters = null)
        {
            List<SQLiteParameter> lst = GetParametersList(dicParameters);
            return ExecuteScalar(sql, lst);
        }

        public object ExecuteScalar(string sql, IEnumerable<SQLiteParameter> parameters = null)
        {
            _cmd.CommandText = sql;
            if (parameters != null)
            {
                foreach (var parameter in parameters)
                {
                    _cmd.Parameters.Add(parameter);
                }
            }
            return _cmd.ExecuteScalar();
        }

        public dataType ExecuteScalar<dataType>(string sql, Dictionary<string, object> dicParameters = null)
        {
            List<SQLiteParameter> lst = null;
            if (dicParameters != null)
            {
                lst = new List<SQLiteParameter>();
                foreach (KeyValuePair<string, object> kv in dicParameters)
                {
                    lst.Add(new SQLiteParameter(kv.Key, kv.Value));
                }
            }
            return ExecuteScalar<dataType>(sql, lst);
        }

        public dataType ExecuteScalar<dataType>(string sql, IEnumerable<SQLiteParameter> parameters = null)
        {
            _cmd.CommandText = sql;
            if (parameters != null)
            {
                foreach (var parameter in parameters)
                {
                    _cmd.Parameters.Add(parameter);
                }
            }
            return (dataType)Convert.ChangeType(_cmd.ExecuteScalar(), typeof(dataType));
        }

        public dataType ExecuteScalar<dataType>(string sql)
        {
            _cmd.CommandText = sql;
            return (dataType)Convert.ChangeType(_cmd.ExecuteScalar(), typeof(dataType));
        }

        private List<SQLiteParameter> GetParametersList(Dictionary<string, object> dicParameters)
        {
            List<SQLiteParameter> lst = new List<SQLiteParameter>();
            if (dicParameters != null)
            {
                foreach (KeyValuePair<string, object> kv in dicParameters)
                {
                    lst.Add(new SQLiteParameter(kv.Key, kv.Value));
                }
            }
            return lst;
        }

        public string Escape(string data)
        {
            data = data.Replace("'", "''");
            data = data.Replace("\\", "\\\\");
            return data;
        }

        public void Insert(string tableName, Dictionary<string, object> dic)
        {
            StringBuilder sbCol = new System.Text.StringBuilder();
            StringBuilder sbVal = new System.Text.StringBuilder();

            foreach (KeyValuePair<string, object> kv in dic)
            {
                if (sbCol.Length == 0)
                {
                    sbCol.Append("insert into ");
                    sbCol.Append(tableName);
                    sbCol.Append("(");
                }
                else
                {
                    sbCol.Append(",");
                }

                sbCol.Append("`");
                sbCol.Append(kv.Key);
                sbCol.Append("`");

                if (sbVal.Length == 0)
                {
                    sbVal.Append(" values(");
                }
                else
                {
                    sbVal.Append(", ");
                }

                sbVal.Append("@v");
                sbVal.Append(kv.Key);
            }

            sbCol.Append(") ");
            sbVal.Append(");");

            _cmd.CommandText = sbCol.ToString() + sbVal.ToString();

            foreach (KeyValuePair<string, object> kv in dic)
            {
                _cmd.Parameters.AddWithValue("@v" + kv.Key, kv.Value);
            }

            _cmd.ExecuteNonQuery();
        }

        public void Update(string tableName, Dictionary<string, object> dicData, string colCond, object varCond)
        {
            Dictionary<string, object> dic = new Dictionary<string, object>();
            dic[colCond] = varCond;
            Update(tableName, dicData, dic);
        }

        public void Update(string tableName, Dictionary<string, object> dicData, Dictionary<string, object> dicCond)
        {
            if (dicData.Count == 0)
                throw new Exception("dicData is empty.");

            StringBuilder sbData = new System.Text.StringBuilder();

            Dictionary<string, object> _dicTypeSource = new Dictionary<string, object>();

            foreach (KeyValuePair<string, object> kv1 in dicData)
            {
                _dicTypeSource[kv1.Key] = null;
            }

            foreach (KeyValuePair<string, object> kv2 in dicCond)
            {
                if (!_dicTypeSource.ContainsKey(kv2.Key))
                    _dicTypeSource[kv2.Key] = null;
            }

            sbData.Append("update `");
            sbData.Append(tableName);
            sbData.Append("` set ");

            bool firstRecord = true;

            foreach (KeyValuePair<string, object> kv in dicData)
            {
                if (firstRecord)
                    firstRecord = false;
                else
                    sbData.Append(",");

                sbData.Append("`");
                sbData.Append(kv.Key);
                sbData.Append("` = ");

                sbData.Append("@v");
                sbData.Append(kv.Key);
            }

            sbData.Append(" where ");

            firstRecord = true;

            foreach (KeyValuePair<string, object> kv in dicCond)
            {
                if (firstRecord)
                    firstRecord = false;
                else
                {
                    sbData.Append(" and ");
                }

                sbData.Append("`");
                sbData.Append(kv.Key);
                sbData.Append("` = ");

                sbData.Append("@c");
                sbData.Append(kv.Key);
            }

            sbData.Append(";");

            _cmd.CommandText = sbData.ToString();

            foreach (KeyValuePair<string, object> kv in dicData)
            {
                _cmd.Parameters.AddWithValue("@v" + kv.Key, kv.Value);
            }

            foreach (KeyValuePair<string, object> kv in dicCond)
            {
                _cmd.Parameters.AddWithValue("@c" + kv.Key, kv.Value);
            }

            _cmd.ExecuteNonQuery();
        }

        public long LastInsertRowId()
        {
            return ExecuteScalar<long>("select last_insert_rowid();");
        }

        #endregion

        #region Utilities

        public void CreateTable(SqLiteTable table)
        {
            StringBuilder sb = new System.Text.StringBuilder();
            sb.Append("create table if not exists `");
            sb.Append(table.TableName);
            sb.AppendLine("`(");

            bool firstRecord = true;

            foreach (SqLiteColumn col in table.Columns)
            {
                if (col.ColumnName.Trim().Length == 0)
                {
                    throw new Exception("Column name cannot be blank.");
                }

                if (firstRecord)
                    firstRecord = false;
                else
                    sb.AppendLine(",");

                sb.Append(col.ColumnName);
                sb.Append(" ");

                if (col.AutoIncrement)
                {

                    sb.Append("integer primary key autoincrement");
                    continue;
                }

                switch (col.ColDataType)
                {
                    case ColType.Text:
                        sb.Append("text"); break;
                    case ColType.Integer:
                        sb.Append("integer"); break;
                    case ColType.Decimal:
                        sb.Append("decimal"); break;
                    case ColType.DateTime:
                        sb.Append("datetime"); break;
                    case ColType.Blob:
                        sb.Append("blob"); break;
                }

                if (col.PrimaryKey)
                    sb.Append(" primary key");
                else if (col.NotNull)
                    sb.Append(" not null");
                else if (col.DefaultValue.Length > 0)
                {
                    sb.Append(" default ");

                    if (col.DefaultValue.Contains(" ") || col.ColDataType == ColType.Text || col.ColDataType == ColType.DateTime)
                    {
                        sb.Append("'");
                        sb.Append(col.DefaultValue);
                        sb.Append("'");
                    }
                    else
                    {
                        sb.Append(col.DefaultValue);
                    }
                }
            }

            sb.AppendLine(");");

            _cmd.CommandText = sb.ToString();
            _cmd.ExecuteNonQuery();
        }

        public void RenameTable(string tableFrom, string tableTo)
        {
            _cmd.CommandText = string.Format("alter table `{0}` rename to `{1}`;", tableFrom, tableTo);
            _cmd.ExecuteNonQuery();
        }

        public void CopyAllData(string tableFrom, string tableTo)
        {
            DataTable dt1 = Select(string.Format("select * from `{0}` where 1 = 2;", tableFrom));
            DataTable dt2 = Select(string.Format("select * from `{0}` where 1 = 2;", tableTo));

            Dictionary<string, bool> dic = new Dictionary<string, bool>();

            foreach (DataColumn dc in dt1.Columns)
            {
                if (dt2.Columns.Contains(dc.ColumnName))
                {
                    if (!dic.ContainsKey(dc.ColumnName))
                    {
                        dic[dc.ColumnName] = true;
                    }
                }
            }

            foreach (DataColumn dc in dt2.Columns)
            {
                if (dt1.Columns.Contains(dc.ColumnName))
                {
                    if (!dic.ContainsKey(dc.ColumnName))
                    {
                        dic[dc.ColumnName] = true;
                    }
                }
            }

            StringBuilder sb = new System.Text.StringBuilder();

            foreach (KeyValuePair<string, bool> kv in dic)
            {
                if (sb.Length > 0)
                    sb.Append(",");

                sb.Append("`");
                sb.Append(kv.Key);
                sb.Append("`");
            }

            StringBuilder sb2 = new System.Text.StringBuilder();
            sb2.Append("insert into `");
            sb2.Append(tableTo);
            sb2.Append("`(");
            sb2.Append(sb.ToString());
            sb2.Append(") select ");
            sb2.Append(sb.ToString());
            sb2.Append(" from `");
            sb2.Append(tableFrom);
            sb2.Append("`;");

            _cmd.CommandText = sb2.ToString();
            _cmd.ExecuteNonQuery();
        }

        public void DropTable(string table)
        {
            _cmd.CommandText = string.Format("drop table if exists `{0}`", table);
            _cmd.ExecuteNonQuery();
        }

        public void UpdateTableStructure(string targetTable, SqLiteTable newStructure)
        {
            newStructure.TableName = targetTable + "_temp";

            CreateTable(newStructure);

            CopyAllData(targetTable, newStructure.TableName);

            DropTable(targetTable);

            RenameTable(newStructure.TableName, targetTable);
        }

        public void AttachDatabase(string database, string alias)
        {
            Execute(string.Format("attach '{0}' as '{1}';", database, alias));
        }

        public void DetachDatabase(string alias)
        {
            Execute(string.Format("detach {0};", alias));
        }

        #endregion

    }
}

SqLiteColumnList类

using System;
using System.Collections.Generic;
using System.Data.SQLite;

namespace SQLiteHelper
{

    public class SqLiteColumnList : IList<SqLiteColumn>
    {
        List<SqLiteColumn> _lst = new List<SqLiteColumn>();

        private void CheckColumnName(string colName)
        {
            for (int i = 0; i < _lst.Count; i++)
            {
                if (_lst[i].ColumnName == colName)
                    throw new Exception("Column name of \"" + colName + "\" is already existed.");
            }
        }

        public int IndexOf(SqLiteColumn item)
        {
            return _lst.IndexOf(item);
        }

        public void Insert(int index, SqLiteColumn item)
        {
            CheckColumnName(item.ColumnName);

            _lst.Insert(index, item);
        }

        public void RemoveAt(int index)
        {
            _lst.RemoveAt(index);
        }

        public SqLiteColumn this[int index]
        {
            get
            {
                return _lst[index];
            }
            set
            {
                if (_lst[index].ColumnName != value.ColumnName)
                {
                    CheckColumnName(value.ColumnName);
                }

                _lst[index] = value;
            }
        }

        public void Add(SqLiteColumn item)
        {
            CheckColumnName(item.ColumnName);

            _lst.Add(item);
        }

        public void Clear()
        {
            _lst.Clear();
        }

        public bool Contains(SqLiteColumn item)
        {
            return _lst.Contains(item);
        }

        public void CopyTo(SqLiteColumn[] array, int arrayIndex)
        {
            _lst.CopyTo(array, arrayIndex);
        }

        public int Count
        {
            get { return _lst.Count; }
        }

        public bool IsReadOnly
        {
            get { return false; }
        }

        public bool Remove(SqLiteColumn item)
        {
            return _lst.Remove(item);
        }

        public IEnumerator<SqLiteColumn> GetEnumerator()
        {
            return _lst.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return _lst.GetEnumerator();
        }
    }

}

SqLiteColumn类

namespace SQLiteHelper
{
    public class SqLiteColumn
    {
        public string ColumnName = "";
        public bool PrimaryKey = false;
        public ColType ColDataType = ColType.Text;
        public bool AutoIncrement = false;
        public bool NotNull = false;
        public string DefaultValue = "";

        public SqLiteColumn()
        { }

        public SqLiteColumn(string colName)
        {
            ColumnName = colName;
            PrimaryKey = false;
            ColDataType = ColType.Text;
            AutoIncrement = false;
        }

        public SqLiteColumn(string colName, ColType colDataType)
        {
            ColumnName = colName;
            PrimaryKey = false;
            ColDataType = colDataType;
            AutoIncrement = false;
        }

        public SqLiteColumn(string colName, bool autoIncrement)
        {
            ColumnName = colName;

            if (autoIncrement)
            {
                PrimaryKey = true;
                ColDataType = ColType.Integer;
                AutoIncrement = true;
            }
            else
            {
                PrimaryKey = false;
                ColDataType = ColType.Text;
                AutoIncrement = false;
            }
        }

        public SqLiteColumn(string colName, ColType colDataType, bool primaryKey, bool autoIncrement, bool notNull, string defaultValue)
        {
            ColumnName = colName;

            if (autoIncrement)
            {
                PrimaryKey = true;
                ColDataType = ColType.Integer;
                AutoIncrement = true;
            }
            else
            {
                PrimaryKey = primaryKey;
                ColDataType = colDataType;
                AutoIncrement = false;
                NotNull = notNull;
                DefaultValue = defaultValue;
            }
        }
    }
}

SqLiteTable类

namespace SQLiteHelper
{
    public class SqLiteTable
    {
        public string TableName = "";
        public SqLiteColumnList Columns = new SqLiteColumnList();

        public SqLiteTable()
        { }

        public SqLiteTable(string name)
        {
            TableName = name;
        }
    }
}
C# Sqlite 本地存储
我的英文站点：https://iorilan.medium.com/
07-13 2999
C# Sqlite
sqlite3内存数据库与文件数据库的应用总结
fengweibo112的博客
10-07 1922
概述 使用sqlite3进行数据库写操作，每插入一条数据都会回写到磁盘上，这样会导致写数据库的效率低，而且增加磁盘的擦写次数。为了解决该问题，我们可以将数据写入内存数据库中，定时把内存数据库的数据保存到文件数据库中，较少磁盘的操作次数。 C代码 1.创建文件数据库； 2.创建内存数据库； 3.创建文件数据库表格； 4.创建内存数据库表格（和文件数据表格一致）； 5.内存数据库中attach文件数据库，这样可以保证文件数据库中的内容在内存数据库中可见； 6.将数据写入内存数据表格中； 7.定时将内存数据中的内
C#【SQLite数据库实例】
最新发布
C/C#、Android driver、STM32、Linux等等。
04-26 642
SQLite是一种轻量级、嵌入式的关系型数据库，具有无服务器、零配置、单文件存储等特点，适合本地应用和嵌入式设备。本文介绍了SQLite的核心特性，并与MySQL进行了对比。重点阐述了C#程序如何集成SQLite，包括添加System.Data.SQLite引用、依赖库配置、编译选项设置等关键步骤。通过SQLiteHelper类实现了数据库连接、建表、增删改查等基本操作，并提供了代码示例。文章强调SQLite适用于本地数据存储场景，不适合高并发或多用户共享环境。
C#__使用流读取和写入数据的简单用法
qq_57233919的博客
09-21 801
使用流读取和写入数据
C# SQLite
allway2的博客
04-19 1万+
C# SQLite 教程展示了如何在 C# 中编写 SQLite 数据库。 SQLite SQLite 是一个嵌入式关系数据库引擎。它是一个自包含、无服务器、零配置和事务性 SQL 数据库引擎。SQLite 实现了 SQL 的大部分 SQL-92 标准。SQLite 引擎不是一个独立的进程。相反，它是静态或动态链接到应用程序中的。SQLite 数据库是单个普通磁盘文件，可以位于目录层次结构中的任何位置。 ADO.NET ADO.NET是.NET 框架的重要组成部分。它是一种统一对关系数据
SQLite学习——C#操作数据库（增删改查、保存、显示）
jiDxiaohuo的博客
09-20 1016
https://zhidao.baidu.com/question/1988946282128601667.html
C#学习-任务五：学习SQLite数据库,将图片exif信息保存到数据库中
m0_61689711的博客
01-24 716
SQLite 数据库保存图片 EXIF 信息（适配 VS2012/.NET4.0、对比 MySQL），以及dll引用文件的下载地址
C#实践: 基于.net linq技术 使用sqlite数据库
didigui1108的博客
07-25 818
(转载请注明来源:cnblogs coder-fang) 背景:使用VS2013 .net4.5 开发sqlite数据库访问应用。 创建并设计sqlite测试数据库dbsqlite.db，填上一些测试数据 ，数据库关系如下: 使用vs2013创建类库DBTest,打开Nuget管理器控制台：输入: PM> install-package linq2db.S...
图漾双目相机 C#拍照 并保存入sqlite数据库
MAILJMQ的博客
01-02 828
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using pcammls; u...
C#读写sqlite(含二进制方式读写)
festone000的专栏
08-17 5087
环境: windows 10 64bit SQLite版本 sqlite> select version(); no such function: version sqlite> SELECT sqlite_version(); +------------------+ | sqlite_version() | +------------------+ | 3.21.0 | +------------------+ 1 row in set (0.02 sec) 项目版本:
使用SQLite内存数据库进行操作
IqlFullstack的博客
10-14 1129
除了基本的插入和查询操作，SQLite还支持其他SQL操作，如更新数据、删除数据和创建索引等。SQLite是一种轻量级的嵌入式数据库，它提供了在内存中进行操作的功能。在本文中，我们将讨论如何使用SQLite内存数据库进行数据存储和查询操作。以上是使用SQLite内存数据库进行操作的基本流程。使用内存数据库可以在内存中快速存储和查询数据，适用于一些临时性的数据处理任务。首先，我们需要确保已经安装了SQLite数据库。上述代码创建了一个名为"employees"的表，该表包含id、name和salary三列。
SQLite 插入大量数据慢的解决方法
weixin_34168700的博客
06-15 456
sqlite 插入数据很慢的原因：sqlite在没有显式使用事务的时候会为每条insert都使用事务操作，而sqlite数据库是以文件的形式存在磁盘中，就相当于每次访问时都要打开一次文件，如果对数据进行大量的操作，时间都耗费在I/O操作上，所以很慢。解决方法是显式使用事务的形式提交：因为我们开始事务后，进行的大量操作的语句都保存在内存中，当提交时才全部写入数据库，此时，数据库文件也就只用打开一次。...
【解决方案】SQLite操作优化：从内存中读取，写入内存和本地
热门推荐
赵庆明老师
11-07 1万+
SQLite是我非常喜欢的一个小型数据库。如果你真把它当SQL Server、Oracle来使用的话，那简直是灾难，读写效率带来的死锁问题够你受的。 不过，如果把整个数据库加载到内存中呢？哈哈，那简直是爽翻了。不过，写入怎么解决呢？ 你的程序不知道什么时候会退出，一旦退出，数据还未保存的话，哭吧。。。。 其实，向数据库中写入数据的频率是非常低的，而读取数据的频率却很高。 且看我的更新方法： 1、把...
C# 读写快速读写大文件
alechy的专栏
08-13 8036
需要开发一个客户端来存储一些期货数据.
C# 文件压缩解压与sqlite存储文件数据
iml6yu的博客
12-01 933
创建 zip 存档，该存档包括文件和指定目录的目录，使用指定压缩级别和条目名称的字符编码，以及可以选择包含基目录。创建 zip 存档，该存档包括指定目录的文件和目录，使用指定压缩级别，以及可以选择包含基目录。将指定 zip 存档中的所有文件解压缩到文件系统的一目录下，并使用项名称的指定字符编码。在指定的模式中用指定的项名称汉字解码打开指定路径的 zip 存档。将指定 zip 存档中的所有文件都解压缩到文件系统的一个目录下。创建 zip 存档，该存档包含指定目录的文件和目录。
C# 操作SQLite3数据库（内附操作源码分享）
weixin_39525333的博客
07-16 4344
C#使用辅助类，操作SQLite3数据库，帮助大家在使用单机库时少走弯路
C# SQLite数据本地存储方案
李厂长的自留地
11-14 1355
即使是做网络应用，在断线情况下，也需要考虑数据的本地存储。在SQLite出现之前，数据量大的情况下，我们一直使用ACCESS，数据量小，则文件存储。ACCESS不支持事务原子性，在断电情况下（这种情况总是会发生）会导致数据很难恢复。powered by 25175.net 一：安装 SQLITE，是一款轻型的数据库，是遵守ACID的关联式数据库管理系统。我直接使用的是http://sqlite
SQLite做为本地缓存应注意的几大方面
codepython的专栏
02-26 1209
 SQLite做为本地缓存应注意的几大方面 2011-02-18 09:34 Tecky Li 博客园 字号：T | T 今天我们要介绍的就是如何利用SQLite作为本地缓存的方法。其拥有适应于本地数据缓存和应用程序等诸多优点。 AD：WOT2015 互联网运维与开发者大会 热销抢票 今天看到了园友陆敏计的一篇文章>,
SqlServer数据库数据表修改后无法保存
yx2513134520的博客
09-08 5665
数据表建立过程中，对已经保存了的数据表进行修改时，无法对其修改内容保存，弹出如下对话框： 这是为什么呢？小编有妙招，具体操作如下： （1）“工具”菜单中选择“选项”： （2）”选项“对话框中选择”Designers",然后选择“Designers"下的”表设计器和数据库设计器 （3）把“ 阻止保存要求重新创建表的更改”复选框前面的“✔”去掉，确定即可。 这样修改后数据表的属性内容就可以保存啦。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值