数据库操作类base
㈠ 请问数据库有哪些种类呢
数据库共有3种类型，为关系数据库、非关系型数据库和键值数据库。
1、关系数据库
Mysql、MariaDB（MySQL的代替品，英文维基网络从MySQL转向MariaDB）、Percona Server（MySQL的代替品·）、PostgreSQL、Microsoft Access、Microsoft SQL Server、Google Fusion Tables、FileMaker、Oracle数据库、Sybase、dBASE、Clipper、FoxPro、foshub。
几乎所有的数据库管理系统都配备了一个开放式数据库连接（ODBC）驱动程序，令各个数据库之间得以互相集成。
2、非关系型数据库（NoSQL）
BigTable（Google）、Cassandra、MongoDB、CouchDB。
3、键值（key-value）数据库
Apache Cassandra（为Facebook所使用）：高度可扩展、Dynamo、LevelDB（Google）。
(1)数据库操作类base扩展阅读：
数据库模型：对象模型、层次模型（轻量级数据访问协议）、网状模型（大型数据储存）、关系模型、面向对象模型、半结构化模型、平面模型（表格模型，一般在形式上是一个二维数组。如表格模型数据Excel)。
数据库的架构可以大致区分为三个概括层次：内层、概念层和外层。
㈡ 数据库有哪些种类分别是干什么用的
数据库共有3种类型，为关系数据库、非关系型数据库和键值数据库。
1、关系数据库
MySQL、MariaDB（MySQL的代替品，英文维基网络从MySQL转向MariaDB）、Percona Server（MySQL的代替品·）、PostgreSQL、Microsoft Access、Microsoft SQL Server、Google Fusion Tables、FileMaker、Oracle数据库、Sybase、dBASE、Clipper、FoxPro、foshub。
几乎所有的数据库管理系统都配备了一个开放式数据库连接（ODBC）驱动程序，令各个数据库之间得以互相集成。
2、非关系型数据库（NoSQL）
BigTable（Google）、Cassandra、MongoDB、CouchDB。
3、键值（key-value）数据库
Apache Cassandra（为Facebook所使用）：高度可扩展、Dynamo、LevelDB（Google）。
(2)数据库操作类base扩展阅读：
数据库模型：对象模型、层次模型（轻量级数据访问协议）、网状模型（大型数据储存）、关系模型、面向对象模型、半结构化模型、平面模型（表格模型，一般在形式上是一个二维数组。如表格模型数据Excel)。
数据库的架构可以大致区分为三个概括层次：内层、概念层和外层。
㈢ 数据库有哪些类型
数据库有两种类型，分别是关系型数据库与非关系型数据库。
数据库，简而言之可视为电子化的文件柜——存储电子文件的处所，用户可以对文件中的数据进行新增、截取、更新、删除等操作。
关系型数据库主要有：
Oracle、DB2、Microsoft
SQL
Server、Microsoft
Access、MySQL等等。
非关系型数据库主要有：
NoSql、Cloudant、MongoDb、redis、HBase等等。
(3)数据库操作类base扩展阅读：
非关系型数据库的优势：
1、性能高：NOSQL是基于键值对的，可以想象成表中的主键和值的对应关系，而且不需要经过SQL层的解析，所以性能非常高。
2、可扩展性好：同样也是因为基于键值对，数据之间没有耦合性，所以非常容易水平扩展。
关系型数据库的优势：
1、可以复杂查询：可以用SQL语句方便的在一个表以及多个表之间做非常复杂的数据查询。
2、事务支持良好：使得对于安全性能很高的数据访问要求得以实现。
参考资料来源：网络-数据库
㈣ 数据库有哪些基本操作
分5类： 查询语句：select DML(数据操作语言)：insert,update,delete,merge DDl(数据定义语言)：create.alter,drop,truncateDCL(数据控制语言)：revoke,grant事务控制语句:commit,roolback,savepoint
㈤ MFC操作数据库有关的类
1、 MFC的ODBC类简介
MFC的ODBC类对较复杂的ODBC API进行了封装，提供了简化的调用接口，从而大大方便了数据库应用程序的开发。程序员不必了解ODBC API和SQL的具体细节，利用ODBC类即可完成对数据库的大部分操作。
MFC的ODBC类主要包括：
CDatabase类：主要功能是建立与数据源的连接。
CRecordset类：该类代表从数据源选择的一组记录（记录集），程序可以选择数据源中的某个表作为一个记录集，也可以通过对表的查询得到记录集，还可以合并同一数据源中多个表的列到一个记录集中．通过该类可对记录集中的记录进行滚动、修改、增加和删除等操作。
CRecordView类：提供了一个表单视图与某个记录集直接相连，利用对话框数据交换机制(DDX)在记录集与表单视图的控件之间传输数据。该类支持对记录的浏览和更新，在撤销时会自动关闭与之相联系的记录集。
CFieldExchange类：支持记录字段数据交换（DFX），即记录集字段数据成员与相应的数据库的表的字段之间的数据交换。该类的功能与CDataExchange类的对话框数据交换功能类似。
CDBException类：代表ODBC类产生的异常。
概括地讲，CDatabase针对某个数据库，它负责连接数据源；CRecordset针对数据源中的记录集，它负责对记录的操作；CRecordView负责界面，而CFieldExchange负责CRecordset与数据源的数据交换。
利用AppWizard和ClassWizard，用户可以方便地建立数据库应用程序，但这并不意味着可以对MFC的ODBC类一无所知．读者应注意阅读后面几小节中的内容，为学习后面的例子打好基础．
2、 CDatabase类
要建立与数据源的连接，首先应构造一个CDatabase对象，然后再调用CDatabase的Open成员函数．Open函数负责建立连接，其声明为
virtual BOOL Open( LPCTSTR lpszDSN, BOOL bExclusive = FALSE, BOOL bReadOnly = FALSE, LPCTSTR lpszConnect = “ODBC;”, BOOL bUseCursorLib = TRUE ); throw( CDBException, CMemoryException );
参数lpszDSN指定了数据源名（构造数据源的方法将在后面介绍），在lpszConnect参数中也可包括数据源名，此时lpszDSN必需为 NULL，若在函数中未提供数据源名且使lpszDSN为NULL，则会显示一个数据源对话框，用户可以在该对话框中选择一个数据源．参数 bExclusive说明是否独占数据源，由于目前版本的类库还不支持独占方式，故该参数的值应该是FALSE，这说明数据源是被共享的．参数 bReadOnly若为TRUE则对数据源的连接是只读的．参数lpszConnect指定了一个连接字符串，连接字符串中可以包括数据源名、用户帐号 (ID)和口令等信息，字符串中的＂ODBC＂表示要连接到一个ODBC数据源上．参数bUseCursorLib若为TRUE，则会装载光标库，否则不 装载，快照需要光标库，动态集不需要光标库． 若连接成功，函数返回TRUE，若返回FALSE，则说明用户在数据源对话框中按了Cancel按钮。若函数内部出现错误，则框架会产生一个异常。
下面是一些调用Open函数的例子。
CDatabase m_db; //在文档类中嵌入一个CDatabase对象
//连接到一个名为＂Student Registration＂的数据源
m_db.Open("Student Registration");
//在连接数据源的同时指定了用户帐号和口令
m_db.Open(NULL,FALSE,FALSE,"ODBC;DSN=Student Registration;UID=ZYF;PWD=1234");
m_db.Open(NULL); //将弹出一个数据源对话框
要从一个数据源中脱离，可调用函数Close。在脱离后，可以再次调用Open函数来建立一个新的连接．调用IsOpen可判断当前是否有一个连接，调用GetConnect可返回当前的连接字符串。函数的声明为
virtual void Close( );
BOOL IsOpen( ) const; //返回TRUE则表明当前有一个连接
const CString& GetConnect( ) const;
CDatabase的析构函数会调用Close，所以只要删除了CDatabase对象就可以与数据源脱离。
3、CRecordset类
CRecordset类代表一个记录集．该类是MFC的ODBC类中最重要、功能最强大的类。
10.5.1 动态集、快照、光标和光标库
在多任务操作系统或网络环境中，多个用户可以共享同一个数据源。共享数据的一个主要问题是如何协调各个用户对数据源的修改。例如，当某一个应用改变了数 据源中的记录时，别的连接至该数据源的应用应该如何处理。对于这个问题，基于MFC的ODBC应用程序可以采取几种不同的处理办法，这将由程序采用哪种记 录集决定。
记录集主要分为快照(Snapshot) 和动态集(Dynaset)两种，CRecordset类对这两者都支持。这两种记录集的不同表现在它们对别的应用改变数据源记录采取了不同的处理方法。
快照型记录集提供了对数据的静态视．快照是个很形象的术语，就好象对数据源的某些记录照了一张照片一样．当别的用户改变了记录时（包括修改、添加和删 除），快照中的记录不受影响，也就是说，快照不反映别的用户对数据源记录的改变．直到调用了CRecordset::Requery重新查询后，快照才会 反映变化．对于象产生报告或执行计算这样的不希望中途变动的工作，快照是很有用的。需要指出的是，快照的这种静态特性是相对于别的用户而言的，它会正确反 映由本身用户对记录的修改和删除，但对于新添加的记录直到调用Requery后才能反映到快照中．
动态集提供了数据的动态视．当别的用户修改或删除了记录集中的记录时，会在动态集中反映出来：当滚动到修改过的记录时对其所作的修改会立即反映到动态集 中，当记录被删除时，MFC代码会跳过记录集中的删除部分．对于其它用户添加的记录，直到调用Requery时，才会在动态集中反映出来。本身应用程序对 记录的修改、添加和删除会反映在动态集中。当数据必须是动态的时侯，使用动态集是最适合的。例如，在一个火车票联网售票系统中，显然应该用动态集随时反映 出共享数据的变化。
在记录集中滚动，需要有一个标志来指明滚动后的位置（当前位置）。ODBC驱动程序会维护一个光标，用来跟踪记录集的当前记录，可以把光标理解成跟踪记录集位置的一种机制。
光标库(Cursor Library)是处于ODBC驱动程序管理器和驱动程序之间的动态链接库(ODBCCR32.DLL)．光标库的主要功能是支持快照以及为底层驱动程序 提供双向滚动能力，高层次的驱动程序不需要光标库，因为它们是可滚动的．光标库管理快照记录的缓冲区，该缓冲区反映本程序对记录的修改和删除，但不反映其 它用户对记录的改变，由此可见，快照实际上相当于当前的光标库缓冲区．
应注 意的是，快照是一种静态光标(Static Cursor)．静态光标直到滚动到某个记录才能取得该记录的数据．因此，要保证所有的记录都被快照，可以先滚动到记录集的末尾，然后再滚动到感兴趣的第 一个记录上．这样做的缺点是滚动到末尾需要额外的开销，会降低性能．
与快照不同，动态集不用光标库维持的缓冲区来存放记录．实际上，动态集是不使用光标库的，因为光标库会屏蔽掉一些支持动态集的底层驱动程序功能．动态集是一种键集驱动光标(Keyset-Driven Cursor)，当打开一个动态集时，驱动程序保存记录集中每个记录的键．只要光标在动态集中滚动，驱动程序就会通过键来从数据源中检取当前记录，从而保证选取的记录与数据源同步．
从上面的分析中可以看出，快照和动态集有一个共同的特点，那就是在建立记录集后，记录集中的成员就已经确定了．这就是为什么两种记录集都不能反映别的用户添加记录的原因．
10.5.2 域数据成员与数据交换
CRecordset类代表一个记录集．用户一般需要用ClassWizard创建一个CRecordset的派生类．ClassWizard可以为派 生的记录集类创建一批数据成员，这些数据成员与记录的各字段相对应，被称为字段数据成员或域数据成员．例如，对于表10.2所示的将在后面例子中使用的数 据库表，ClassWizard会在派生类中加入6个域数据成员
10.5.3 SQL查询
记录集的建立实际上主要是一个查询过程，SQL的SELECT语句用来查询数据源．在建立记录集时，CRecordset会根据一些参数构造一个 SELECT语句来查询数据源，并用查询的结果创建记录集．明白这一点对理解CRecordset至关重要．SELECT语句的句法如下：
SELECT rfx-field-list FROM table-name [WHERE m_strFilter]
[ORDER BY m_strSort]
其中table-name是表名，rfx-field-list是选择的列（字段）．WHERE和ORDER BY是两个子句，分别用来过滤和排序。下面是SELECT语句的一些例子：
SELECT CourseID, InstructorID FROM Section
SELECT * FROM Section WHERE CourseID=‘MATH202’ AND Capacity=15
SELECT InstructorID FROM Section ORDER BY CourseID ASC
其中第一个语句从Section表中选择CourseID和InstructorID字段．第二个语句从Section表中选择CourseID为 MATH202且Capacity等于15的记录，在该语句中使用了象＂AND＂或＂OR＂这样的逻辑连接符．要注意在SQL语句中引用字符串、日期或时 间等类型的数据时要用单引号括起来，而数值型数据则不用．第三个语句从Section表中选择InstructorID列并且按CourseID的升序排 列，若要降序排列，可使用关键字DESC．
提示：如果列名或表名中包含有空格，则必需用方括号把该名称包起来。例如，如果有一列名为“Client Name”，则应该写成“[Client Name]”。
10.5.4 记录集的建立和关闭
要建立记录集，首先要构造一个CRecordset派生类对象，然后调用Open成员函数查询数据源中的记录并建立记录集．在Open函数中，可能会调用GetDefaultConnect和GetDefaultSQL函数．函数的声明为
CRecordset( CDatabase* pDatabase = NULL);
参数pDatabase指向一个CDatabase对象，用来获取数据源．如果pDatabase为NULL，则会在Open函数中自动构建一个 CDatabase对象．如果CDatabase对象还未与数据源连接，那么在Open函数中会建立连接，连接字符串（参见10.3.1）由成员函数 GetDefaultConnect提供．
virtual CString GetDefaultConnect( );
该函数返回缺省的连接字符串．Open函数在必要的时侯会调用该函数获取连接字符串以建立与数据源的连接．一般需要在CRecordset派生类中覆盖该函数并在新版的函数中提供连接字符串．
virtual BOOL Open( UINT nOpenType = AFX_DB_USE_DEFAULT_TYPE, LPCTSTR lpszSQL = NULL, DWORD dwOptions = none );
throw( CDBException, CMemoryException );
该函数使用指定的SQL语句查询数据源中的记录并按指定的类型和选项建立记录集．参数nOpenType说明了记录集的类型，如表10.3所示，如果要求 的类型驱动程序不支持，则函数将产生一个异常．参数lpszSQL是一个SQL的SELECT语句，或是一个表名．函数用lpszSQL来进行查询，如果 该参数为NULL，则函数会调用GetDefaultSQL获取缺省的SQL语句．参数dwOptions可以是一些选项的组合，常用的选项在表10.4 中列出．若创建成功则函数返回TRUE，若函数调用了CDatabase::Open且返回FALSE，则函数返回FALSE．
表10.3 记录集的类型
类型
含义
AFX_DB_USE_DEFAULT_TYPE
使用缺省值．
CRecordset::dynaset
可双向滚动的动态集．
CRecordset::snapshot
可双向滚动的快照．
CRecordset::dynamic
提供比动态集更好的动态特性，大部分ODBC驱动程序不支持这种记录集．
CRecordset::forwardOnly
只能前向滚动的只读记录集．表10.4 创建记录集时的常用选项
选项
含义
CRecordset::none
无选项（缺省）．
CRecordset::appendOnly
不允许修改和删除记录，但可以添加记录．
CRecordset::readOnly
记录集是只读的．
CRecordset::skipDeletedRecords
有些数据库（如FoxPro）在删除记录时并不真删除，而是做个删除标记，在滚动时将跳过这些被删除的记录．virtual CString GetDefaultSQL( );
Open函数在必要时会调用该函数返回缺省的SQL语句或表名以查询数据源中的记录．一般需要在CRecordset派生类中覆盖该函数并在新版的函数中提供SQL语句或表名．下面是一些返回字符串的例子．
“Section” //选择Section表中的所有记录到记录集中
“Section, Course” //合并Section表和Course表的各列到记录集中
//对Section表中的所有记录按CourseID的升序进行排序，然后建立记录集
“SELECT * FROM Section ORDER BY CourseID ASC”
上面的例子说明，通过合理地安排SQL语句和表名，Open函数可以十分灵活地查询数据源中的记录．用户可以合并多个表的字段，也可以只选择记录中的某些字段，还可以对记录进行过滤和排序．
上一小节说过，在建立记录集时，CRecordset会构造一个SELECT语句来查询数据源．如果在调用Open时只提供了表名，那么SELECT语 句还缺少选择列参数rfx-field-list（参见10.5.3）．框架规定，如果只提供了表名，则选择列的信息从DoFieldExchange中 的RFX语句里提取．例如，如果在调用Open时只提供了＂Section＂表名，那么将会构造如下一个SELECT语句：
SELECT CourseID,SectionNo,InstructorID,RoomNo, Schele,Capacity FROM Section
建立记录集后，用户可以随时调用Requery成员函数来重新查询和建立记录集．Requery有两个重要用途：
使记录集能反映用户对数据源的改变（参见10.5.1）．
按照新的过滤或排序方法查询记录并重新建立记录集．
在调用Requery之前，可调用CanRestart来判断记录集是否支持Requery操作．要记住Requery只能在成功调用Open后调用，所以程序应调用IsOpen来判断记录集是否已建立．函数的声明为
virtual BOOL Requery( );throw( CDBException, CMemoryException );
返回TRUE表明记录集建立成功，否则返回FALSE．若函数内部出错则产生异常．
BOOL CanRestart( ) const; //若支持Requery则返回TRUE
BOOL IsOpen( ) const; //若记录集已建立则返回TRUE
CRecordset类有两个公共数据成员m_strFilter和m_strSort用来设置对记录的过滤和排序．在调用Open或Requery 前，如果在这两个数据成员中指定了过滤或排序，那么Open和Requery将按这两个数据成员指定的过滤和排序来查询数据源．
成员m_strFilter用于指定过滤器．m_strFilter实际上包含了SQL的WHERE子句的内容，但它不含WHERE关键字．使用m_strFilter的一个例子为：
m_pSet->m_strFilter=“CourseID=‘MATH101’”; //只选择CourseID为MATH101的记录
if(m_pSet->Open(CRecordset::snapshot, “Section”))
. . . . . .
成员m_strSort用于指定排序．m_strSort实际上包含了ORDER BY子句的内容，但它不含ORDER BY关键字．m_strSort的一个例子为
m_pSet->m_strSort=“CourseID DESC”; //按CourseID的降序排列记录
m_pSet->Open();
. . . . . .
事实上，Open函数在构造SELECT语句时，会把m_strFilter和m_strSort的内容放入SELECT语句的WHERE和ORDER BY子句中．如果在Open的lpszSQL参数中已包括了WHERE和ORDER BY子句，那么m_strFilter和m_strSort必需为空．
调用无参数成员函数Close可以关闭记录集．在调用了Close函数后，程序可以再次调用Open建立新的记录集．CRecordset的析构函数会调用Close函数，所以当删除CRecordset对象时记录集也随之关闭。
10.5.5 滚动记录
CRecordset提供了几个成员函数用来在记录集中滚动，如下所示．当用这些函数滚动到一个新记录时，框架会自动地把新记录的内容拷贝到域数据成员中．
void MoveNext( ); //前进一个记录
void MovePrev( ); //后退一个记录
void MoveFirst( ); //滚动到记录集中的第一个记录
void MoveLast( ); //滚动到记录集中的最后一个记录
void SetAbsolutePosition( long nRows );
该函数用于滚动到由参数nRows指定的绝对位置处．若nRows为负数，则从后往前滚动．例如，当nRows为-1时，函数就滚动到记录集的末尾．注意，该函数不会跳过被删除的记录．
virtual void Move( long nRows, WORD wFetchType = SQL_FETCH_RELATIVE );
该函数功能强大．通过将wFetchType参数指定为SQL_FETCH_NEXT、SQL_FETCH_PRIOR、 SQL_FETCH_FIRST、SQL_FETCH_LAST和SQL_FETCH_ABSOLUTE，可以完成上面五个函数的功能．若 wFetchType为SQL_FETCH_RELATIVE，那么将相对当前记录移动，若nRows为正数，则向前移动，若nRows为负数，则向后移 动．
如果在建立记录集时选择了CRecordset::skipDeletedRecords选项，那么除了SetAbsolutePosition外，在滚动记录时将跳过被删除的记录，这一点对象FoxPro这样的数据库十分重要．
如果记录集是空的，那么调用上述函数将产生异常．另外，必须保证滚动没有超出记录集的边界．调用IsEOF和IsBOF可以进行这方面的检测．
BOOL IsEOF( ) const;
如果记录集为空或滚动过了最后一个记录，那么函数返回TRUE，否则返回FALSE．
BOOL IsBOF( ) const;
如果记录集为空或滚动过了第一个记录，那么函数返回TRUE，否则返回FALSE．
㈥ 在android中对数据库做增删改查有两种方式分别是sqlitedatabase这个类中的哪几个
一、使用嵌入式关系型SQLite数据库存储数据
在Android平台上，集成了一个嵌入式关系型数据库——SQLite，SQLite3支持NULL、INTEGER、REAL（浮点数字）、 TEXT(字符串文本)和BLOB(二进制对象)数据类型，虽然它支持的类型只有五种，但实际上sqlite3也接受varchar(n)、 char(n)、decimal(p,s) 等数据类型，只不过在运算或保存时会转成对应的五种数据类型。 SQLite最大的特点是你可以把各种类型的数据保存到任何字段中，而不用关心字段声明的数据类型是什么。例如：可以在Integer类型的字段中存放字符串，或者在布尔型字段中存放浮点数，或者在字符型字段中存放日期型值。 但有一种情况例外：定义为INTEGER PRIMARY KEY的字段只能存储64位整数， 当向这种字段保存除整数以外的数据时，将会产生错误。 另外，在编写CREATE TABLE 语句时，你可以省略跟在字段名称后面的数据类型信息，如下面语句你可以省略name字段的类型信息：
CREATE TABLE person (personid integer primary key autoincrement, name varchar(20))
SQLite可以解析大部分标准SQL语句，如：
复制代码 代码如下:
查询语句：select * from 表名 where 条件子句 group by 分组字句 having ... order by 排序子句
如： select * from person
select * from person order by id desc
select name from person group by name having count(*)>1
分页SQL与mysql类似，下面SQL语句获取5条记录，跳过前面3条记录
select * from Account limit 5 offset 3 或者 select * from Account limit 3,5
插入语句：insert into 表名(字段列表) values(值列表)。如： insert into person(name, age) values(‘传智',3)
更新语句：update 表名 set 字段名=值 where 条件子句。如：update person set name=‘传智‘ where id=10
删除语句：delete from 表名 where 条件子句。如：delete from person where id=10
二、使用SQLiteOpenHelper对数据库进行版本管理
我们在编写数据库应用软件时，需要考虑这样的问题：因为我们开发的软件可能会安装在很多用户的手机上，如果应用使用到了SQLite数据库，我们必须在用户初次使用软件时创建出应用使用到的数据库表结构及添加一些初始化记录，另外在软件升级的时候，也需要对数据表结构进行更新。那么，我们如何才能实现在用户初次使用或升级软件时自动在用户的手机上创建出应用需要的数据库表呢？总不能让我们在每个需要安装此软件的手机上通过手工方式创建数据库表吧？因为这种需求是每个数据库应用都要面临的，所以在Android系统，为我们提供了一个名为SQLiteOpenHelper的抽象类，必须继承它才能使用，它是通过对数据库版本进行管理来实现前面提出的需求。
为了实现对数据库版本进行管理，SQLiteOpenHelper类提供了两个重要的方法，分别是onCreate(SQLiteDatabase db)和onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)，前者用于初次使用软件时生成数据库表，后者用于升级软件时更新数据库表结构。当调用SQLiteOpenHelper的getWritableDatabase()或者getReadableDatabase()方法获取用于操作数据库的SQLiteDatabase实例的时候，如果数据库不存在，Android系统会自动生成一个数据库，接着调用onCreate()方法，onCreate()方法在初次生成数据库时才会被调用，在onCreate()方法里可以生成数据库表结构及添加一些应用使用到的初始化数据。onUpgrade()方法在数据库的版本发生变化时会被调用，一般在软件升级时才需改变版本号，而数据库的版本是由程序员控制的，假设数据库现在的版本是1，由于业务的变更，修改了数据库表结构，这时候就需要升级软件，升级软件时希望更新用户手机里的数据库表结构，为了实现这一目的，可以把原来的数据库版本设置为2(有同学问设置为3行不行？当然可以，如果你愿意，设置为100也行)，并且在 onUpgrade()方法里面实现表结构的更新。当软件的版本升级次数比较多，这时在onUpgrade()方法里面可以根据原版号和目标版本号进行判断，然后作出相应的表结构及数据更新。
getWritableDatabase()和 getReadableDatabase()方法都可以获取一个用于操作数据库的SQLiteDatabase实例。但 getWritableDatabase() 方法以读写方式打开数据库，一旦数据库的磁盘空间满了，数据库就只能读而不能写，倘若使用getWritableDatabase()打开数据库就会出错。getReadableDatabase()方法先以读写方式打开数据库，如果数据库的磁盘空间满了，就会打开失败，当打开失败后会继续尝试以只读方式打开数据库。
注意：getWritableDatabase()，getReadableDatabase的区别是当数据库写满时，调用前者会报错，调用后者不会，所以如果不是更新数据库的话，最好调用后者来获得数据库连接。
代码：
复制代码 代码如下:
public class DatabaseHelper extends SQLiteOpenHelper {
//类没有实例化,是不能用作父类构造器的参数,必须声明为静态
private static final String name = "ljqdb"; //数据库名称
private static final int version = 1; //数据库版本
public DatabaseHelper(Context context) {
//第三个参数CursorFactory指定在执行查询时获得一个游标实例的工厂类,设置为null,代表使用系统默认的工厂类
super(context, name, null, version);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE IF NOT EXISTS person (
personid integer primary key autoincrement, name varchar(20), age INTEGER)");
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL(" ALTER TABLE person ADD phone VARCHAR(12) NULL "); //往表中增加一列
// DROP TABLE IF EXISTS person 删除表
}
}
在实际项目开发中，当数据库表结构发生更新时，应该避免用户存放于数据库中的数据丢失。
三、使用SQLiteDatabase操作SQLite数据库
Android提供了一个名为SQLiteDatabase的类，该类封装了一些操作数据库的API，使用该类可以完成对数据进行添加(Create)、查询(Retrieve)、更新(Update)和删除(Delete)操作（这些操作简称为CRUD）。对SQLiteDatabase的学习，我们应该重点掌握execSQL()和rawQuery()方法。execSQL()方法可以执行insert、delete、update和CREATE TABLE之类有更改行为的SQL语句； rawQuery()方法用于执行select语句。
execSQL()方法的使用例子：
复制代码 代码如下:
SQLiteDatabase db = ....;
db.execSQL("insert into person(name, age) values('林计钦', 24)");
db.close();
执行上面SQL语句会往person表中添加进一条记录，在实际应用中， 语句中的“林计钦”这些参数值会由用户输入界面提供，如果把用户输入的内容原样组拼到上面的insert语句， 当用户输入的内容含有单引号时，组拼出来的SQL语句就会存在语法错误。要解决这个问题需要对单引号进行转义，也就是把单引号转换成两个单引号。有些时候用户往往还会输入像“ & ”这些特殊SQL符号，为保证组拼好的SQL语句语法正确，必须对SQL语句中的这些特殊SQL符号都进行转义，显然，对每条SQL语句都做这样的处理工作是比较烦琐的。 SQLiteDatabase类提供了一个重载后的execSQL(String sql, Object[] bindArgs)方法，使用这个方法可以解决前面提到的问题，因为这个方法支持使用占位符参数(?)。使用例子如下：
复制代码 代码如下:
SQLiteDatabase db = ....;
db.execSQL("insert into person(name, age) values(?,?)", new Object[]{"传智播客", 4});
db.close();
execSQL(String sql, Object[] bindArgs)方法的第一个参数为SQL语句，第二个参数为SQL语句中占位符参数的值，参数值在数组中的顺序要和占位符的位置对应。
SQLiteDatabase的rawQuery()用于执行select语句，使用例子如下：
复制代码 代码如下:
SQLiteDatabase db = ....;
Cursor cursor = db.rawQuery("select * from person", null);
while (cursor.moveToNext()) {
int personid = cursor.getInt(0); //获取第一列的值,第一列的索引从0开始
String name = cursor.getString(1);//获取第二列的值
int age = cursor.getInt(2);//获取第三列的值
}
cursor.close();
db.close();
rawQuery()方法的第一个参数为select语句；第二个参数为select语句中占位符参数的值，如果select语句没有使用占位符，该参数可以设置为null。带占位符参数的select语句使用例子如下：
复制代码 代码如下:
Cursor cursor = db.rawQuery("select * from person where name like ? and age=?", new String[]{"%林计钦%", "4"});
Cursor是结果集游标，用于对结果集进行随机访问，如果大家熟悉jdbc， 其实Cursor与JDBC中的ResultSet作用很相似。使用moveToNext()方法可以将游标从当前行移动到下一行，如果已经移过了结果集的最后一行，返回结果为false，否则为true。另外Cursor 还有常用的moveToPrevious()方法（用于将游标从当前行移动到上一行，如果已经移过了结果集的第一行，返回值为false，否则为true ）、moveToFirst()方法（用于将游标移动到结果集的第一行，如果结果集为空，返回值为false，否则为true ）和moveToLast()方法（用于将游标移动到结果集的最后一行，如果结果集为空，返回值为false，否则为true ） 。
除了前面给大家介绍的execSQL()和rawQuery()方法， SQLiteDatabase还专门提供了对应于添加、删除、更新、查询的操作方法： insert()、delete()、update()和query() 。这些方法实际上是给那些不太了解SQL语法的菜鸟使用的，对于熟悉SQL语法的程序员而言，直接使用execSQL()和rawQuery()方法执行SQL语句就能完成数据的添加、删除、更新、查询操作。
㈦ C#中如何定义数据库操作类，并调用
以下是我编写的一个操作access数据库的类，其他数据库可以参考修改，原理差不多的。希望对你有帮助。
using System;
using System.Collections.Generic;
using System.Text;
using System.Data.OleDb;
using System.Configuration;
using System.Data;
namespace AutoEmailSender
{
/// <summary>
/// 数据库交互类
/// </summary>
public class DB
{
/// <summary>
/// 获得数据库连接
/// </summary>
/// <returns></returns>
public static OleDbConnection GetDBConnection()
{
return new OleDbConnection(ConfigurationManager.AppSettings["ConnectString"]);
}
/// <summary>
/// 查询结果集
/// </summary>
/// <param name="sql">执行语句</param>
/// <returns>返回一个DataTable对象</returns>
public static DataTable ExecuteDataTable(string sql)
{
using (OleDbConnection con = GetDBConnection())
{
OleDbCommand cmd = new OleDbCommand(sql, con);
return ExecuteDataTable(cmd);
}
}
/// <summary>
/// 查询结果集
/// </summary>
/// <param name="cmd">执行语句的OleDbCommand命令</param>
/// <returns>返回一个DataTable对象</returns>
public static DataTable ExecuteDataTable(OleDbCommand cmd)
{
DataSet ds = new DataSet();
using (OleDbDataAdapter da = new OleDbDataAdapter(cmd))
{
try
{
da.Fill(ds);
}
catch (Exception e)
{
throw e;
}
}
if (ds.Tables.Count > 0)
{
ds.Tables[0].DefaultView.RowStateFilter = DataViewRowState.Unchanged | DataViewRowState.Added | DataViewRowState.ModifiedCurrent | DataViewRowState.Deleted;
return ds.Tables[0];
}
else
return null;
}
/// <summary>
/// 执行查询，并返回查询所返回的结果集中第一行的第一列。忽略其他列或行。
/// </summary>
/// <param name="sql">查询语句</param>
/// <returns>返回结果集中第一行的第一列的object值</returns>
public static object ExecuteScalar(string sql)
{
using (OleDbConnection con = GetDBConnection())
{
OleDbCommand cmd = new OleDbCommand(sql, con);
return ExecuteScalar(cmd);
}
}
/// <summary>
/// 执行查询，并返回查询所返回的结果集中第一行的第一列。忽略其他列或行。
/// </summary>
/// <param name="cmd">查询命令</param>
/// <returns>返回结果集中第一行的第一列的object值</returns>
public static object ExecuteScalar(OleDbCommand cmd)
{
try
{
cmd.Connection.Open();
object obj = cmd.ExecuteScalar();
cmd.Connection.Close();
return obj;
}
catch (Exception error)
{
cmd.Connection.Close();
throw error;
}
}
/// <summary>
/// 更新数据集
/// </summary>
/// <param name="dt">要更新的数据集</param>
/// <param name="insertCmd">插入SQL语句</param>
/// <param name="updateCmd">更新SQL语句</param>
/// <param name="deleteCmd">删除SQL语句</param>
/// <returns></returns>
public static int UpdateDataSet(DataTable dt, OleDbCommand insertCmd, OleDbCommand updateCmd, OleDbCommand deleteCmd)
{
using (OleDbDataAdapter da = new OleDbDataAdapter())
{
da.InsertCommand = insertCmd;
da.UpdateCommand = updateCmd;
da.DeleteCommand = deleteCmd;
//da.UpdateBatchSize = 0; //UpdateBatchSize:指定可在一次批处理中执行的命令的数量,在Access不被支持。0:批大小没有限制。1:禁用批量更新。>1:更改是使用 UpdateBatchSize 操作的批处理一次性发送的。
da.InsertCommand.UpdatedRowSource = UpdateRowSource.None;
da.UpdateCommand.UpdatedRowSource = UpdateRowSource.None;
da.DeleteCommand.UpdatedRowSource = UpdateRowSource.None;
try
{
int row = da.Update(dt);
return row;
}
catch (Exception e)
{
throw e;
}
}
}
/// <summary>
/// 返回一个查询语句执行结果的表结构
/// </summary>
/// <param name="sql">查询语句,不支持复杂SQL</param>
/// <returns></returns>
public static DataTable GetTableSchema(string sql)
{
sql = sql.ToUpper();
DataTable dt = null;
using (OleDbConnection con = GetDBConnection())
{
OleDbCommand cmd = new OleDbCommand(sql, con);
con.Open();
using (OleDbDataReader dr = cmd.ExecuteReader(CommandBehavior.KeyInfo | CommandBehavior.SchemaOnly | CommandBehavior.CloseConnection))
{
dt = dr.GetSchemaTable();
}
}
return dt;
}
/// <summary>
/// 根据输入的查询语句自动生成插入,更新,删除命令
/// </summary>
/// <param name="sql">查询语句</param>
/// <param name="insertCmd">插入命令</param>
/// <param name="updateCmd">更新命令</param>
/// <param name="deleteCmd">删除命令</param>
public static void GenerateUpdateSQL(string sql, OleDbCommand insertCmd, OleDbCommand updateCmd, OleDbCommand deleteCmd)
{
sql = sql.ToUpper();
DataTable dt = GetTableSchema(sql);
string tableName = dt.Rows[0]["BaseTableName"].ToString();
List<OleDbParameter> updatePrimarykeys = new List<OleDbParameter>();//主键参数集合
List<OleDbParameter> deletePrimarykeys = new List<OleDbParameter>();//主键参数集合,因为不能同时被OleDbCommand个命令引用,所以多申明一个
List<OleDbParameter> insertFields = new List<OleDbParameter>();//字段参数集合
List<OleDbParameter> updateFields = new List<OleDbParameter>();//字段参数集合
string columns = string.Empty, values = "", set = "", where = "";
foreach (DataRow dr in dt.Rows)
{
if (dr["IsAutoIncrement"].ToString().Equals("False"))
{
insertFields.Add(new OleDbParameter("@" + dr["BaseColumnName"].ToString(),
(OleDbType)dr["ProviderType"],
Convert.ToInt32(dr["ColumnSize"]),
dr["BaseColumnName"].ToString()));
updateFields.Add(new OleDbParameter("@" + dr["BaseColumnName"].ToString(),
(OleDbType)dr["ProviderType"],
Convert.ToInt32(dr["ColumnSize"]),
dr["BaseColumnName"].ToString()));
if (!string.IsNullOrEmpty(columns))
columns += ",";
columns += dr["BaseColumnName"].ToString();
if (!string.IsNullOrEmpty(values))
values += ",";
values += "@" + dr["BaseColumnName"].ToString();
if (!string.IsNullOrEmpty(set))
set += ",";
set += dr["BaseColumnName"].ToString() + "=@" + dr["BaseColumnName"].ToString();
}
if (dr["IsKey"].ToString().Equals("True"))
{
updatePrimarykeys.Add(new OleDbParameter("@OLD_" + dr["BaseColumnName"].ToString(),
(OleDbType)dr["ProviderType"],
Convert.ToInt32(dr["ColumnSize"]),
ParameterDirection.Input,
Convert.ToBoolean(dr["AllowDBNull"]),
Convert.ToByte(dr["NumericScale"]),
Convert.ToByte(dr["NumericPrecision"]),
dr["BaseColumnName"].ToString(), DataRowVersion.Original, null));
deletePrimarykeys.Add(new OleDbParameter("@OLD_" + dr["BaseColumnName"].ToString(),
(OleDbType)dr["ProviderType"],
Convert.ToInt32(dr["ColumnSize"]),
ParameterDirection.Input,
Convert.ToBoolean(dr["AllowDBNull"]),
Convert.ToByte(dr["NumericScale"]),
Convert.ToByte(dr["NumericPrecision"]),
dr["BaseColumnName"].ToString(), DataRowVersion.Original, null));
if (!string.IsNullOrEmpty(where))
where += " and ";
where += dr["BaseColumnName"].ToString() + "=@OLD_" + dr["BaseColumnName"].ToString();
}
}
insertCmd.CommandText = string.Format("insert into {0} ({1}) values ({2})", tableName, columns, values);
updateCmd.CommandText = string.Format("update {0} set {1} where {2}", tableName, set, where);
deleteCmd.CommandText = string.Format("delete from {0} where {1}", tableName, where);
insertCmd.Connection = GetDBConnection();
updateCmd.Connection = GetDBConnection();
deleteCmd.Connection = GetDBConnection();
foreach (OleDbParameter pa in insertFields)
{
insertCmd.Parameters.Add(pa);
}
foreach (OleDbParameter pa in updateFields)
{
updateCmd.Parameters.Add(pa);
}
foreach (OleDbParameter pa in updatePrimarykeys)
{
updateCmd.Parameters.Add(pa);
}
foreach (OleDbParameter pa in deletePrimarykeys)
{
deleteCmd.Parameters.Add(pa);
}
}
}
}
㈧ c#.net关于数据库操作的类
1.这仅仅是一个声明了一个数据库的连接字符串。它只是告诉你要使用的数据库在什么位置以及我们使用何种身份去连接数据库。要实际的连接数据库的操作还需要你去创建SqlConnection对象，之后调用Open方法，这样才真正的连接到了数据库。
2.以后你使用DBBase这个类去操作数据库时都会采用connectionString 这个连接字符串。
㈨ 如何进行Android数据库操作
Android数据库操作类实例
实体类：UserInfo.java
package my.db;
import java.io.Serializable;
import android.graphics.drawable.Drawable;
public class UserInfo implements Serializable {
public static final String ID = "_id";
public static final String USERID = "userId";
public static final String TOKEN = "token";
public static final String TOKENSECRET = "tokenSecret";
public static final String USERNAME = "userName";
public static final String USERICON = "userIcon";
private String id;
private String userId; // 用户id
private String token;
private String tokenSecret;
private String userName;
private Drawable userIcon;
//getter and setter省略
}
SqliteHelper类：
package my.db;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;
public class SqliteHelper extends SQLiteOpenHelper{
//用来保存UserID、Access Token、Access Secret的表名
public static final String TB_NAME= "users";
public SqliteHelper(Context context, String name, CursorFactory factory, int version) {
super(context, name, factory, version);
}
//创建表
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL( "CREATE TABLE IF NOT EXISTS "+
TB_NAME+ "("+
UserInfo. ID+ " integer primary key,"+
UserInfo. USERID+ " varchar,"+
UserInfo. TOKEN+ " varchar,"+
UserInfo. TOKENSECRET+ " varchar,"+
UserInfo. USERNAME+ " varchar,"+
UserInfo. USERICON+ " blob"+
")"
);
Log. e("Database" ,"onCreate" );
}
//更新表
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL( "DROP TABLE IF EXISTS " + TB_NAME );
onCreate(db);
Log. e("Database" ,"onUpgrade" );
}
//更新列
public void updateColumn(SQLiteDatabase db, String oldColumn, String newColumn, String typeColumn){
try{
db.execSQL( "ALTER TABLE " +
TB_NAME + " CHANGE " +
oldColumn + " "+ newColumn +
" " + typeColumn
);
} catch(Exception e){
e.printStackTrace();
}
}
}
CRUD类DataHelper:
package my.db;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.ArrayList;
import java.util.List;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.graphics.Bitmap;
import android.graphics.drawable.Drawable;
import android.util.Log;
public class DataHelper {
// 数据库名称
private static String DB_NAME = "weibo.db";
// 数据库版本
private static int DB_VERSION = 2;
private SQLiteDatabase db;
private SqliteHelper dbHelper;
public DataHelper(Context context) {
dbHelper = new SqliteHelper(context, DB_NAME, null, DB_VERSION );
db = dbHelper.getWritableDatabase();
}
public void Close() {
db.close();
dbHelper.close();
}
// 获取users表中的UserID、Access Token、Access Secret的记录
public List<UserInfo> GetUserList(Boolean isSimple) {
List<UserInfo> userList = new ArrayList<UserInfo>();
Cursor cursor = db.query(SqliteHelper. TB_NAME, null, null , null, null,
null, UserInfo. ID + " DESC");
cursor.moveToFirst();
while (!cursor.isAfterLast() && (cursor.getString(1) != null )) {
UserInfo user = new UserInfo();
user.setId(cursor.getString(0));
user.setUserId(cursor.getString(1));
user.setToken(cursor.getString(2));
user.setTokenSecret(cursor.getString(3));
if (!isSimple) {
user.setUserName(cursor.getString(4));
ByteArrayInputStream stream = new ByteArrayInputStream(cursor.getBlob(5));
Drawable icon = Drawable.createFromStream(stream, "image");
user.setUserIcon(icon);
}
userList.add(user);
cursor.moveToNext();
}
cursor.close();
return userList;
}
// 判断users表中的是否包含某个UserID的记录
public Boolean HaveUserInfo(String UserId) {
Boolean b = false;
Cursor cursor = db.query(SqliteHelper. TB_NAME, null, UserInfo.USERID
+ "=?", new String[]{UserId}, null, null, null );
b = cursor.moveToFirst();
Log. e("HaveUserInfo", b.toString());
cursor.close();
return b;
}
// 更新users表的记录，根据UserId更新用户昵称和用户图标
public int UpdateUserInfo(String userName, Bitmap userIcon, String UserId) {
ContentValues values = new ContentValues();
values.put(UserInfo. USERNAME, userName);
// BLOB类型
final ByteArrayOutputStream os = new ByteArrayOutputStream();
// 将Bitmap压缩成PNG编码，质量为100%存储
userIcon.compress(Bitmap.CompressFormat. PNG, 100, os);
// 构造SQLite的Content对象，这里也可以使用raw
values.put(UserInfo. USERICON, os.toByteArray());
int id = db.update(SqliteHelper. TB_NAME, values, UserInfo.USERID + "=?" , new String[]{UserId});
Log. e("UpdateUserInfo2", id + "");
return id;
}
// 更新users表的记录
public int UpdateUserInfo(UserInfo user) {
ContentValues values = new ContentValues();
values.put(UserInfo. USERID, user.getUserId());
values.put(UserInfo. TOKEN, user.getToken());
values.put(UserInfo. TOKENSECRET, user.getTokenSecret());
int id = db.update(SqliteHelper. TB_NAME, values, UserInfo.USERID + "="
+ user.getUserId(), null);
Log. e("UpdateUserInfo", id + "");
return id;
}
// 添加users表的记录
public Long SaveUserInfo(UserInfo user) {
ContentValues values = new ContentValues();
values.put(UserInfo. USERID, user.getUserId());
values.put(UserInfo. TOKEN, user.getToken());
values.put(UserInfo. TOKENSECRET, user.getTokenSecret());
Long uid = db.insert(SqliteHelper. TB_NAME, UserInfo.ID, values);
Log. e("SaveUserInfo", uid + "");
return uid;
}
// 添加users表的记录
public Long SaveUserInfo(UserInfo user, byte[] icon) {
ContentValues values = new ContentValues();
values.put(UserInfo. USERID, user.getUserId());
values.put(UserInfo. USERNAME, user.getUserName());
values.put(UserInfo. TOKEN, user.getToken());
values.put(UserInfo. TOKENSECRET, user.getTokenSecret());
if(icon!= null){
values.put(UserInfo. USERICON, icon);
}
Long uid = db.insert(SqliteHelper. TB_NAME, UserInfo.ID, values);
Log. e("SaveUserInfo", uid + "");
return uid;
}
// 删除users表的记录
public int DelUserInfo(String UserId) {
int id = db.delete(SqliteHelper. TB_NAME,
UserInfo. USERID + "=?", new String[]{UserId});
Log. e("DelUserInfo", id + "");
return id;
}
public static UserInfo getUserByName(String userName,List<UserInfo> userList){
UserInfo userInfo = null;
int size = userList.size();
for( int i=0;i<size;i++){
if(userName.equals(userList.get(i).getUserName())){
userInfo = userList.get(i);
break;
}
}
return userInfo;
}
}
㈩ 数据库分为哪几类
常用数据库
1. IBM 的DB2
作为关系数据库领域的开拓者和领航人，IBM在1997年完成了System R系统的原型，1980年开始提供集成的数据库服务器—— System/38，随后是SQL/DSforVSE和VM，其初始版本与SystemR研究原型密切相关。DB2 forMVSV1 在1983年推出。该版本的目标是提供这一新方案所承诺的简单性，数据不相关性和用户生产率。1988年DB2 for MVS 提供了强大的在线事务处理（OLTP）支持，1989 年和1993 年分别以远程工作单元和分布式工作单元实现了分布式数据库支持。最近推出的DB2 Universal Database 6.1则是通用数据库的典范，是第一个具备网上功能的多媒体关系数据库管理系统，支持包括Linux在内的一系列平台。
2. Oracle
Oracle 前身叫SDL，由Larry Ellison 和另两个编程人员在1977创办，他们开发了自己的拳头产品，在市场上大量销售，1979 年，Oracle公司引入了第一个商用SQL 关系数据库管理系统。Oracle公司是最早开发关系数据库的厂商之一，其产品支持最广泛的操作系统平台。目前Oracle关系数据库产品的市场占有率名列前茅。
3. Informix
Informix在1980年成立，目的是为Unix等开放操作系统提供专业的关系型数据库产品。公司的名称Informix便是取自Information 和Unix的结合。Informix第一个真正支持SQL语言的关系数据库产品是Informix SE（StandardEngine）。InformixSE是在当时的微机Unix环境下主要的数据库产品。它也是第一个被移植到Linux上的商业数据库产品。
4. Sybase
Sybase公司成立于1984年，公司名称“Sybase”取自“system”和 “database” 相结合的含义。Sybase公司的创始人之一Bob Epstein 是Ingres 大学版（与System/R同时期的关系数据库模型产品）的主要设计人员。公司的第一个关系数据库产品是1987年5月推出的Sybase SQLServer1.0。Sybase首先提出Client/Server 数据库体系结构的思想，并率先在Sybase SQLServer 中实现。
5. SQL Server
1987 年，微软和 IBM合作开发完成OS/2，IBM 在其销售的OS/2 ExtendedEdition 系统中绑定了OS/2Database Manager，而微软产品线中尚缺少数据库产品。为此，微软将目光投向Sybase，同Sybase 签订了合作协议，使用Sybase的技术开发基于OS/2平台的关系型数据库。1989年，微软发布了SQL Server 1.0 版。
6. PostgreSQL
PostgreSQL 是一种特性非常齐全的自由软件的对象——关系性数据库管理系统（ORDBMS），它的很多特性是当今许多商业数据库的前身。PostgreSQL最早开始于BSD的Ingres项目。PostgreSQL 的特性覆盖了SQL-2/SQL-92和SQL-3。首先，它包括了可以说是目前世界上最丰富的数据类型的支持；其次，目前PostgreSQL 是唯一支持事务、子查询、多版本并行控制系统、数据完整性检查等特性的唯一的一种自由软件的数据库管理系统.
7.mySQL
mySQL是一个小型关系型数据库管理系统，开发者为瑞典MySQL AB公司。在2008年1月16号被Sun公司收购。目前MySQL被广泛地应用在Internet上的中小型网站中。由于其体积小、速度快、总体拥有成本低，尤其是开放源码这一特点，许多中小型网站为了降低网站总体拥有成本而选择了MySQL作为网站数据库。MySQL的官方网站的网址是： www.mysql.com