数据库是有很多个表组成，那么如何创建数据库呢，MySQL 提供三种方式创建数据库。

第一种，使用 create 命令创建数据库

[root@host]# mysql -u root -p   

Enter password:******  # 登录后进入终端

mysql> create DATABASE HUTHON;

第二种，使用 mysqladmin 创建数据库

[root@host]# mysqladmin -u root -p create HUTHON

Enter password:******

第三种，使用 PHP脚本 创建数据库

<?php

$dbhost = 'localhost:3306';  // mysql服务器主机地址

$dbuser = 'root';            // mysql用户名

$dbpass = '123456';          // mysql用户名密码

$conn = mysqli_connect($dbhost, $dbuser, $dbpass);

if(! $conn )

{

  die('连接错误: ' . mysqli_error($conn));

}

echo '连接成功<br />';

$sql = 'CREATE DATABASE HUTHON';

$retval = mysqli_query($conn,$sql );

if(! $retval )

{

    die('创建数据库失败: ' . mysqli_error($conn));

}

echo "数据库 HUTHON 创建成功\n www.oceanoemchina.com";

mysqli_close($conn);

?>

首先，做一点说明。Flex是不能直接连接数据库的，这一点大家需要知道，它只能间接地连接数据库。Flex中提供了三种方式：HttpService，WebService 和RemoteObject。其中HttpService可以直接获取XML中的数据，还可以通过JSP,ASP以及PHP读取数据库中的数据，这个比较简单，而且网上也有很多例子，我就不多说了。WebService我不懂，请自己查资料。我一直用的是JAVA对象连接数据库，感觉这个挺方便，而且J2EE的技术已经很成熟。今天的教程就是以 Flex + JAVA + SQLServer获取数据库公告信息为例简单说一下RemoteObject的用法。
前提
1.确保你安装了Flex Data Service。这个对于单个CUP无限APP是免费的，可以去Adobe下载。如果只是读取XML文件是不需要这个的，连接数据库就需要它了。
2.安装了Flex Builder或者有Flex SDK。我这里使用的是Flex Builder（IDE就是方便啊 ^_^）。
3.安装了SQLServer数据库。
4.安装了JRUN或者tomcat或其它的J2EE容器，因为发布的时候我们的程序要运行在J2EE平台上。
5.安装了JDK。
第一步：创建数据库
这里我们有一个公告表，表名为Bulletin。结构如下：
字段名称           字段类型            说明
ID              自动编号          自动编号
title           Nvarchar(100)    题目
date            datatime         日期
author         Nvarchar(20)      作者
content        ntext                内容
在数据库中创建这个表。保存之后进入下一步。
第二步：在JAVA中编写获取公告的代码
首先，我们要创建一个公告类来专门保存获取的公告信息，代码如下。
NoticeInfo.java
package net.zhuoqun.connectDB;
import java.util.Date;
public class NoticeInfo {
    private String title;        // 标题
    private String author;  // 作者
    private String content;// 内容
    private Date dates;       // 时间    
    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
    ……………… // 其它get 和 set 方法。
}
创建好这个之后我们要创建一个数据查询类：DataServiceImpl.java来查询数据库，并将查询结果传给将要创建的Flex程序。由于我们不清楚有多少条记录，所以就借助一下JAVA中的ArrayList这个类，它位于java.util 包中。先创建一个ArrayList：
ArrayList noticeList = new ArrayList();
查询数据库之后，每读取一条记录就添加到 noticeList。
while(rs.next()){
    NoticeInfo temp = new NoticeInfo();
    temp.setAuthor(rs.getString("author"));
    temp.setContent(rs.getString("content"));
    temp.setDates(rs.getDate("date"));
    temp.setTitle(rs.getString("title"));
    noticeList.add(temp);
}
查询完毕之后你就可以把这个noticeList传回去，你也可以传回去一个 NoticeInfo 数组：
NoticeInfo[] notices = new NoticeInfo[noticeList.size()];
for(int i=0;i<noticeList.size();i++){
    notices = (NoticeInfo)noticeList.get(i);
}
return notices;
我这里用的是后一种方法。如果你直接把noticeList传回去的话，记住一点，JAVA的ArrayList类型的对象到了Flex中会变成ArrayCollection类型的。
现在JAVA部分的代码就写好了。
DataServiceImpl.java 的全部代码如下：
package net.zhuoqun.connectDB;
import java.sql.*;
import java.util.ArrayList;
import java.util.Date;
public class DataServiceImpl {    
    private Connection conn = null;
    private Statement stmt = null;
    // 以下是数据库以及驱动信息
    public final static String DRIVER = "com.microsoft.jdbc.sqlserver.SQLServerDriver";
    public final static String CONN_STR_PRE = "jdbc:microsoft:sqlserver://";
    public final static String HOST_NAME = "localhost:1433;";
    public final static String DATABASE_NAME = "DatabaseName=mydata";
    public final static String USERNAME = "aaa";
    public final static String PASSWORD = "aaa";
        public DataServiceImpl(){
       
    }
    // 查询数据库
    private ResultSet executeQuery(String sqlText){
        try{
            Class.forName(DRIVER);
        }catch(ClassNotFoundException e){
            e.printStackTrace();
        }
        try{
            conn = DriverManager.getConnection(CONN_STR_PRE + HOST_NAME + DATABASE_NAME, USERNAME, PASSWORD);
            stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery(sqlText);
            return rs;
        }catch(SQLException e){
            e.printStackTrace();
        }
        return null;
    }
    // 查询公告. 这个是本程序的关键代码
    public NoticeInfo[] getNotices(){
        ArrayList noticeList = new ArrayList();       
        String sqlText = "select author,content,date,title from Bulletin";       
        ResultSet rs = executeQuery(sqlText);        
        try{
            while(rs.next()){
                NoticeInfo temp = new NoticeInfo();
                temp.setAuthor(rs.getString("author"));
                temp.setContent(rs.getString("content"));
                temp.setDates(rs.getDate("date"));
                temp.setTitle(rs.getString("title"));
                noticeList.add(temp);
            }          
            NoticeInfo[] notices = new NoticeInfo[noticeList.size()];
            for(int i=0;i<noticeList.size();i++){
                notices = (NoticeInfo)noticeList.get(i);
            }
            return notices;
        }catch(SQLException e){
            e.printStackTrace();
            return null;
        }
    }
}
第三步： 配置Flex Data Service
1，把刚才写的JAVA文件编译。打开FDS的安装文件夹，将编译的文件拷贝到/jrun4/servers/default/flex/WEB-INF/classes 文件夹中，进行下面的配置。
2.打开FDS的安装文件夹。进入jrun4/servers/default/flex/WEB-INF/flex 目录。里面是关于FlexData Service的配置文件，我们这里只看RemoteObject如何配置，其它配置信息请自己看帮助。现在我们打开里面的remoting-config.xml文件。向里面添加如下信息，作为<service>的子标签：
程序代码
<destination id="dataService">
     <properties>
          <source>net.zhuoqun.connectDB.DataServiceImpl</source>
     </properties>
</destination>
当你设定了 destination的时候，你就引用了了可以用来连接相应类的信息通道（messaging channel）。它的id必须在文件中是独一无二的。source属性是指你编译的JAVA类在classes文件夹中的路径。由于我的DataServiceImpl类在classes/net/zhuoqun/connectDB中，所以source的值为net.zhuoqun.connectDB.DataServiceImpl。记住，不要写.class后缀。<properties>标签还可以有一个<scope>子标签，其作用我在这里就不说了，大家自己看相关文档（关于FDS的配置其实有很多东西，这些在帮助文档里都有，我这里不多说了，也说不过来，自己看吧）。
现在我们已经配置好了后台的 FDS，做完了整个程序的大部分工作，接下来就是前台Flex程序调用的事情了。
第四步：创建Flex程序
打开Flex Builder，新建一个工程 ConnectDB。菜单栏中 File -> New -> Flex Project，这时会弹出一个对话框，选择 Flex Data Service，创建了一个Flex工程。
第五步：通过 RemoteObject 访问数据库
打开工程中生成的主文件 ConnectDB.mxml，声明一个 RemoteObject ：
程序代码
<mx:RemoteObjectid="getData" destination="dataService"result="proccessResult(event.result)"fault="Alert.show(event.fault.faultString,'Error')"/>
其中destination 的值是刚才我们在配置 FDS 的时候设定的 destination。 result 表示在这个RemoteObject成功返回之后所要做的动作，这里我们调用一个方法 proccessResult()来处理返回的数据，它的参数 event.result就是从服务器段获得的数据，数据是作为一个对象传过来的。 fault表示在这个RemoteObject请求失败时要做的处理，这里我们会弹出一个显示错误信息的对话框。接下来我们要声明一个DataGrid控件来显示公告的标题和发布日期：
程序代码
<mxataGrid id="myDG">
    <mx:columns>
        <mxataGridColumn headerText="标题" dataField="title"/>
        <mxataGridColumn headerText="发布日期" dataField="dates" labelFunction="formatDate"/>
    </mx:columns>
</mx:DataGrid>
其中headerText是显示在上方的表头，dataField表示要显示的数据域，为什么数据域是title和dates呢？因为我们传回的是一个NoticeInfo 对象数组，虽然它是作为一个对象传回来的，但是其中的数据结构并没有变，那些数据域的名字也没有变，所以我们可以根据NoticeInfo 中的变量设定dataField。labelFunction属性是用来格式化显示的，因为传回来的是格林威治时间，所以我们需要将其格式化然后显示出来。注意，这里只是显示两个数据域，并不代表其它的数据都没有了，它们仍然存在，只是没有显示出来。
接下来，在 <mx:Script> 标签中编写proccessResult()方法和格式化日期的 formatDate方法：
程序代码
private function proccessResult(result:Object):void
{
    myDG.dataProvider = ArrayUtil.toArray(result);
}
private function formatDate(item:Object,column:DataGridColumn):String
{
    return df.format(item.dates);
}    // df 是一个 DateFormatter，在下面会给出。关于如何格式化DataGrid的显示
    // 以及DateFormatter这里就不讨论了，帮助里写得很清楚
这个函数只是简单地将获得的数据传给 myDG 的 dataProvider。result的类型是Object，因为数据是作为一个对象传过来的。之所以调用 ArrayUtil.toArray()这个方法，是因为返回的记录可能只有一条，而myDG 的 dataProvider显示单个对象的时候可能会出错，所以安全起见先将其转换成数组。
最后，我们编写调用 RemoteObject 的方法，使其在程序启动时就调用。
程序代码
private function initApp():void
{
      getData.getNotices();
}
其中 getData 是RemoteObject的id，getNotices()是DataServiceImpl.java中的方法。在这里可以直接调用它。当然，如果DataServiceImpl.java有其它方法，也可以通过这种方式直接调用。接下来设定组件创建完毕时调用 initApp()方法，在<mx:Application>中添加一个creationComplete属性:
程序代码
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" fontSize="12" creationComplete="initApp()">
ConnectDB.mxml的全部代码：
程序代码
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" fontSize="12" creationComplete="initApp()">
    <mx:Script>
        <![CDATA[
            import mx.controls.Alert;           
            import mx.utils.ArrayUtil;        
            private function initApp():void
            {
                getData.getNotices();
            }
            private function proccessResult(result:Object):void
            {
                myDG.dataProvider = ArrayUtil.toArray(result);
            }
            private function formatDate(item:Object,column:DataGridColumn):String
            {
                return df.format(item.dates);
            }// df 是一个 DateFormatter，在下面会给出。关于如何格式化DataGrid的显示
            // 以及DateFormatter这里就不讨论了，帮助里写得很清楚
        ]]>
    </mx:Script>
    <mx:DateFormatter id="df" formatString="YYYY-MM-DD"/>
   <mx:RemoteObject id="getData" destination="dataService"result="proccessResult(event.result)"fault="Alert.show(event.fault.faultString,'Error')"/>   
    <mx:DataGrid id="myDG">
        <mx:columns>
            <mx:DataGridColumn headerText="标题" dataField="title"/>
            <mx:DataGridColumn headerText="发布日期" dataField="dates" labelFunction="formatDate"/>
        </mx:columns>
    </mx:DataGrid>
</mx:Application>
整个工程终于完成，启动JRUN，然后运行程序，查看程序结果
如果是其他数据库，只需要改一下数据库驱动信息就可以了 

#PG数据库几种删除重复数据的方法#

在使用PG数据库的这段时间，总结了三种删除重复数据的方法，其中最容易想到的就是最常规的删除方法，但此方法性能较差，删数据耗时较久，虽容易实现，但性能太差，影响写数据的速率。
另外就是被使用的group by删除方法，效率较高。
还有一种是刚发现的，还没有验证，现在就总结下这三种删除方法，并验证各自的执行效率。
首先创建一张基础表，并插入一定量的重复数据。
	test=# create table deltest(id int, name varchar(255));
	CREATE TABLE
	test=# create table deltest_bk (like deltest);
	CREATE TABLE
	test=# insert into deltest select generate_series(1, 10000), 'ZhangSan';
	INSERT 0 10000
	test=# insert into deltest select generate_series(1, 10000), 'ZhangSan';
	INSERT 0 10000
	test=# insert into deltest_bk select * from deltest;

##常规删除方法##
最容易想到的方法就是判断数据是否重复，对于重复的数据只保留ctid最小（或最大）的那条数据，删除其他的数据。

	test=# explain analyse delete from deltest a where a.ctid <> (select min(t.ctid) from deltest t where a.id=t.id);
    	                                                     QUERY PLAN
	-----------------------------------------------------------------------------------------------------------------------------
 	Delete on deltest a  (cost=0.00..195616.30 rows=1518 width=6) (actual time=67758.866..67758.866 rows=0 loops=1)
	   ->  Seq Scan on deltest a  (cost=0.00..195616.30 rows=1518 width=6) (actual time=32896.517..67663.228 rows=10000 loops=1)
         Filter: (ctid <> (SubPlan 1))
         Rows Removed by Filter: 10000
         SubPlan 1
           ->  Aggregate  (cost=128.10..128.10 rows=1 width=6) (actual time=3.374..3.374 rows=1 loops=20000)
                 ->  Seq Scan on deltest t  (cost=0.00..128.07 rows=8 width=6) (actual time=0.831..3.344 rows=2 loops=20000)
                       Filter: (a.id = id)
                       Rows Removed by Filter: 19998
 	Total runtime: 67758.931 ms
	test=# select count(*) from deltest;
 	count
	-------
 	10000
	(1 行记录)

可以看到，id相同的数据，保留ctid最小的那条，其他的删除。相当于把deltest表中的数据删掉一半，耗时达到67s多。相当慢。
##group by删除方法##
第二种方法为group by方法，通过分组找到ctid最小的数据，然后删除其他数据。
	test=# truncate table deltest;
	TRUNCATE TABLE
	test=# insert into deltest select * from deltest_bk;
	INSERT 0 20000
	test=# explain analyse delete from deltest a where a.ctid not in (select min(ctid) from deltest group by id);
                                                             QUERY PLAN
	----------------------------------------------------------------------------------------------------------------------------------
 	Delete on deltest a  (cost=131.89..2930.46 rows=763 width=6) (actual time=30942.496..30942.496 rows=0 loops=1)
	   ->  Seq Scan on deltest a  (cost=131.89..2930.46 rows=763 width=6) (actual time=10186.296..30814.366 rows=10000 loops=1)
         Filter: (NOT (SubPlan 1))
         Rows Removed by Filter: 10000
         SubPlan 1
           ->  Materialize  (cost=131.89..134.89 rows=200 width=10) (actual time=0.001..0.471 rows=7500 loops=20000)
                 ->  HashAggregate  (cost=131.89..133.89 rows=200 width=10) (actual time=10.568..13.584 rows=10000 loops=1)
                       ->  Seq Scan on deltest  (cost=0.00..124.26 rows=1526 width=10) (actual time=0.006..3.829 rows=20000 loops=1)
	 Total runtime: 30942.819 ms
	(9 行记录)
	test=# select count(*) from deltest;
	 count
	-------
 	10000
	(1 行记录)

可以看到同样是删除一半的数据，使用group by的方式，时间节省了一半。但仍含需要30s，下面试一下第三种删除操作。
##新的删除方法##
在postgres修炼之道这本书中，作者提到一种效率较高的删除方法， 在这里验证一下，具体如下：
	test=# truncate table deltest;
	TRUNCATE TABLE
	test=# insert into deltest select * from deltest_bk;
	INSERT 0 20000                                                         
	test=# explain analyze delete from deltest a where a.ctid = any(array (select ctid from (select row_number() over (partition by id), ctid from deltest) t where t.row_number > 1));
                                                             QUERY PLAN
	----------------------------------------------------------------------------------------------------------------------------------
 	Delete on deltest a  (cost=250.74..270.84 rows=10 width=6) (actual time=98.363..98.363 rows=0 loops=1)
   	InitPlan 1 (returns $0)
     ->  Subquery Scan on t  (cost=204.95..250.73 rows=509 width=6) (actual time=29.446..47.867 rows=10000 loops=1)
           Filter: (t.row_number > 1)
           Rows Removed by Filter: 10000
           ->  WindowAgg  (cost=204.95..231.66 rows=1526 width=10) (actual time=29.436..44.790 rows=20000 loops=1)
                 ->  Sort  (cost=204.95..208.77 rows=1526 width=10) (actual time=12.466..13.754 rows=20000 loops=1)
                       Sort Key: deltest.id
                       Sort Method: quicksort  Memory: 1294kB
                       ->  Seq Scan on deltest  (cost=0.00..124.26 rows=1526 width=10) (actual time=0.021..5.110 rows=20000 loops=1)
   	->  Tid Scan on deltest a  (cost=0.01..20.11 rows=10 width=6) (actual time=82.983..88.751 rows=10000 loops=1)
         TID Cond: (ctid = ANY ($0))
 	Total runtime: 98.912 ms
	(13 行记录)

	test=# select count(*) from deltest;
 	count
	-------
 	10000
	(1 行记录)

看到上述结果，啊，努力向大神学习！！

  
转载请注明出处：http://blog.csdn.net/linglongxin24/article/details/53234396    

  本文出自【DylanAndroid的博客】  


【玩转SQLite系列】文章目录 
【玩转SQLite系列】(一)初识SQLite,重拾sql语句 
【玩转SQLite系列】(二)SQLite创建和打开数据库的三种方式 
【玩转SQLite系列】(三)通过sql语句操作SQLite数据库 
【玩转SQLite系列】(四)通过Android提供的API操作SQLite数据库 
【玩转SQLite系列】(五)SQLite数据库优化  
【玩转SQLite系列】(六)SQLite数据库应用案例实现历史搜索记录
【玩转SQLite系列】(七)SQLite数据库轻量级ORM操作数据库工具类   
【玩转SQLite系列】(二)SQLite创建和打开数据库的三种方式


  
在上一篇 【玩转SQLite系列】(一)初识SQLite,重拾sql语句 中已经简单了解了下SQLite,不了解的可以去看一下。 

  我们发现，在Android中使用SQLite数据库的时候，创建和打开数据库的时候不止继承SQLiteOpenHelper 

  这一种方式。目前我至少发现了三种方式:
  
  
1.自定义一个类继承SQLiteOpenHelper；
  
  
2.使用Context.openOrCreateDatabase();
  
  
3.SQLiteDatabase.openOrCreateDatabase();
  
  
那么这三种方式到底有什么不同？






第一种方式：继承SQLiteOpenHelper打开或创建数据库


  
特点：可以在升级数据库版本的时候在回调函数里面做相应的操作


1.创建MySQLiteOpenHelper类
package cn.bluemobi.dylan.sqlite;

import android.content.Context;
import android.database.DatabaseErrorHandler;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;

import java.util.logging.Logger;

/**
 * Android操作使用SQLite的帮助类
 * Created by dylan on 2016-11-19.
 */

public class MySQLiteOpenHelper extends SQLiteOpenHelper {
    private final String TAG = "MySQLiteOpenHelper";

    /**
     * 构造函数
     * 一般用于在这里创建数据库，指定表名和版本号等
     *
     * @param context 上下文对象
     * @param name    数据库名称
     * @param factory 游标工程
     * @param version 数据版本号 >=1
     */
    public MySQLiteOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version) {
        super(context, name, factory, version);
        Log.d(TAG, "MySQLiteOpenHelper");
    }

    /**
     * 创建数据库时调用
     * <p>
     * 一般用于在创建数据表
     *
     * @param db
     */
    @Override
    public void onCreate(SQLiteDatabase db) {
        Log.d(TAG, "onCreate");
    }

    /**
     * 数据库升级更新时调用
     *
     * @param db
     * @param oldVersion
     * @param newVersion
     */
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        Log.d(TAG, "onUpgrade");
    }
}


2.创建数据库
   /**
     * 第一种方式：继承SQLiteOpenHelper打开或创建数据库
     * 特点：可以在升级数据库版本的时候在回调函数里面做相应的操作
     *
     * @param v
     */
    public void sQLiteOpenHelper(View v) {
        /**指定数据库的表名为info.db，版本号为1**/
        MySQLiteOpenHelper mySQLiteOpenHelper = new MySQLiteOpenHelper(this, Contacts.DATABASE_NAME, null, Contacts.DATABASE_VERSION);
        /**得到一个可写的数据库SQLiteDatabase对象**/
        SQLiteDatabase sqLiteDatabase = mySQLiteOpenHelper.getWritableDatabase();
        /**查看改对象做添加的数据库**/
        showDataBase(sqLiteDatabase);
    }

3.查看数据库文件是否创建成功

  
由于我用的是真机测试，而且没有Root，所以暂时采用这种方式去查看数据库文件是否创建成功




       /**
        * 查看手机中由SQLiteDatabase创建的的数据库文件
        */
       public void showDataBase(SQLiteDatabase sqLiteDatabase) {
           List<Pair<String, String>> ll = sqLiteDatabase.getAttachedDbs();
           for (int i = 0; i < ll.size(); i++) {
               Pair<String, String> p = ll.get(i);
               Log.d(Contacts.TAG, p.first + "=" + p.second);
           }
       }


4.打印结果


  
11-19 20:58:51.845 3422-3422/cn.bluemobi.dylan.sqlite D/SQLite: main=/data/data/cn.bluemobi.dylan.sqlite/databases/info.db

可以看出info.db数据库文件已经成功创建。



第二种方式：Context.openOrCreateDatabase打开或创建数据库


  
特点：可以指定数据库文件的操作模式


实现代码
    /**
     * 第二种方式：Context.openOrCreateDatabase打开或创建数据库
     * 特点：可以指定数据库文件的操作模式
     *
     * @param v
     */
    public void context(View v) {
        /**指定数据库的名称为info2.db,并指定数据文件的操作模式为MODE_PRIVATE**/
        SQLiteDatabase sqLiteDatabase = this.openOrCreateDatabase(Contacts.DATABASE_NAME2, MODE_PRIVATE, null);
        /**查看改对象所创建的数据库**/
        showDataBase(sqLiteDatabase);
    }

查看数据库文件是否创建成功


  
11-19 21:08:30.732 3422-3422/cn.bluemobi.dylan.sqlite D/SQLite: main=/data/data/cn.bluemobi.dylan.sqlite/databases/info2.db

第三种方式：SQLiteDatabase.openOrCreateDatabase打开或创建数据库


  
特点：可以指定数据库文件的路径


实现代码
    /**
     * 第三种方式：SQLiteDatabase.openOrCreateDatabase打开或创建数据库
     * 特点：可以指定数据库文件的路径
     *
     * @param v
     */
    public void sQLiteDatabase(View v) {
        File dataBaseFile = new File(Environment.getExternalStorageDirectory() + "/sqlite", Contacts.DATABASE_NAME3);
        if (!dataBaseFile.getParentFile().exists()) {
            dataBaseFile.mkdirs();
        }
        SQLiteDatabase sqLiteDatabase = SQLiteDatabase.openOrCreateDatabase(dataBaseFile, null);
        showDataBase(sqLiteDatabase);
    }

查看数据库文件是否创建成功


  
11-19 21:09:32.767 3422-3422/cn.bluemobi.dylan.sqlite D/SQLite: main=/storage/emulated/0/sqlite/info3.db

最后我们通过查阅源码发现，其实继承SQLiteOpenHelper和Context.openOrCreateDatabase最后都是会调用SQLiteDatabase.openOrCreateDatabase去实现对数据库的操作。