1、链接数据库



conn = sqlite3.connect('MyDB.db')   # MyDB.db为数据库名(sqllite)

coon = pymysql.connect(             # 地址、端口、用户名、密码、数据库名
    host = 'XXXX',
    port = 3306,
    user = 'user',
    passwd = 'password',
    db = 'MyDB',
)



2、使用 cursor() 方法创建一个游标对象 cursor



cursor = db.cursor()



3、SQL语句



3.1 创建Data表（PID和Mas两个字段）



sql = """
    create table Data(
    PID int NOT NULL PRIMARY KEY,
    Mas CHAR(100)
"""



3.2 数据插入



sql = """
    INSERT INTO Data(
    PID,
    Mas)
    VALUES ('%s', '%s')
    """ % (PID, Mas)



3.3 数据查找



sql = """
    select * 
    from Data
    where PID = '%d'
    """ % PID



3.4 数据更新



sql = """
    UPDATE Data 
    set Mas = '%s' 
    where PID = 1
    """ % Mas



3.5 数据删除



sql = """
    DELETE 
    from Data 
    where PID=2
    """



4、执行操作（可以对上方SQL进行封装，然后调用）



cursor.execute(sql)
coon.commit()
coon.close()

前言
在Android开发中，主要的数据存储有5种，具体如下

其中，SQLite数据库的存储方式 非常常用
今天我将带大家全面了解关于Android SQLite数据库的操作（增、删、查、改）
目录

1. SQLlite数据库 简介

2. SQLiteOpenHelper类
2.1 简介

2.2 SQLiteOpenHelper类 常用方法
/** 
  *  创建数据库
  */ 
 // 1. 创建 or 打开 可读/写的数据库（通过 返回的SQLiteDatabase对象 进行操作）
 getWritableDatabase（）

 // 2. 创建 or 打开 可读的数据库（通过 返回的SQLiteDatabase对象 进行操作）
 getReadableDatabase（）

 // 3. 数据库第1次创建时 则会调用，即 第1次调用 getWritableDatabase（） / getReadableDatabase（）时调用
 // 在继承SQLiteOpenHelper类的子类中复写
 onCreate(SQLiteDatabase db) 

 // 4. 数据库升级时自动调用
 // 在继承SQLiteOpenHelper类的子类中复写
 onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)

 // 5. 关闭数据库
 close（）

 /** 
  *  数据库操作（增、删、减、查）
  */ 
 // 1. 查询数据
 (Cursor) query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit)  
 // 查询指定的数据表返回一个带游标的数据集。
 // 各参数说明： 
 // table：表名称 
 // colums：列名称数组 
 // selection：条件子句，相当于where 
 // selectionArgs：条件语句的参数数组 
 // groupBy：分组 
 // having：分组条件 
 // orderBy：排序类 
 // limit：分页查询的限制 
 // Cursor：返回值，相当于结果集ResultSet 

 (Cursor) rawQuery(String sql, String[] selectionArgs) 
 //运行一个预置的SQL语句，返回带游标的数据集（与上面的语句最大的区别 = 防止SQL注入）

 // 2. 删除数据行  
 (int) delete(String table,String whereClause,String[] whereArgs) 
 
 // 3. 添加数据行 
 (long) insert(String table,String nullColumnHack,ContentValues values) 
 
 // 4. 更新数据行 
(int) update(String table, ContentValues values, String whereClause, String[] whereArgs) 
 
 // 5. 执行一个SQL语句，可以是一个select or 其他sql语句 
 // 即 直接使用String类型传入sql语句 & 执行
 (void) execSQL(String sql) 

3. 具体使用
使用步骤 = 自定义数据库子类（继承SQLiteOpenHelper类）、创建数据库 & 操作数据库（增、删、查、改）
下面，我将逐一介绍每个步骤
3.1 自定义数据库子类（继承 SQLiteOpenHelper 类）
/** 
  * 创建数据库子类，继承自SQLiteOpenHelper类
  * 需 复写 onCreat（）、onUpgrade（）
  */ 
public class DatabaseHelper extends SQLiteOpenHelper {

    // 数据库版本号
    private static Integer Version = 1;

    /** 
     * 构造函数
     * 在SQLiteOpenHelper的子类中，必须有该构造函数
     */ 
    public DatabaseHelper(Context context, String name, SQLiteDatabase.CursorFactory factory,
                          int version) {
        // 参数说明
        // context：上下文对象
        // name：数据库名称
        // param：一个可选的游标工厂（通常是 Null） 
        // version：当前数据库的版本，值必须是整数并且是递增的状态

        // 必须通过super调用父类的构造函数
        super(context, name, factory, version);
    }
    
    /** 
     * 复写onCreate（）
     * 调用时刻：当数据库第1次创建时调用
     * 作用：创建数据库 表 & 初始化数据
     * SQLite数据库创建支持的数据类型： 整型数据、字符串类型、日期类型、二进制
     */ 
    @Override
    public void onCreate(SQLiteDatabase db) {
              // 创建数据库1张表
              // 通过execSQL（）执行SQL语句（此处创建了1个名为person的表）
              String sql = "create table person(id integer primary key autoincrement,name varchar(64),address varchar(64))"; 
              db.execSQL(sql); 

              // 注：数据库实际上是没被创建 / 打开的（因该方法还没调用）
              // 直到getWritableDatabase() / getReadableDatabase() 第一次被调用时才会进行创建 / 打开 
    }

    /** 
     * 复写onUpgrade（）
     * 调用时刻：当数据库升级时则自动调用（即 数据库版本 发生变化时）
     * 作用：更新数据库表结构
     * 注：创建SQLiteOpenHelper子类对象时,必须传入一个version参数，该参数 = 当前数据库版本, 若该版本高于之前版本, 就调用onUpgrade()
     */ 

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // 参数说明： 
        // db ： 数据库 
        // oldVersion ： 旧版本数据库 
        // newVersion ： 新版本数据库 

        // 使用 SQL的ALTER语句
        String sql = "alter table person add sex varchar(8)";  
        db.execSQL(sql);  
    }

}

3.2 创建数据库：getWritableDatabase（）、getReadableDatabase（）
// 步骤1：创建DatabaseHelper对象
 // 注：此时还未创建数据库
 SQLiteOpenHelper dbHelper = new DatabaseHelper(SQLiteActivity.this,"test_carson");

// 步骤2：真正创建 / 打开数据库
 SQLiteDatabase sqliteDatabase = dbHelper.getWritableDatabase(); // 创建 or 打开 可读/写的数据库
 SQLiteDatabase sqliteDatabase = dbHelper.getReadableDatabase(); // 创建 or 打开 可读的数据库


注：当需操作数据库时，都必须先创建数据库对象 & 创建 / 打开数据库。

对于操作 = “增、删、改（更新）”，需获得 可"读 / 写"的权限：getWritableDatabase()
对于操作 = “查询”，需获得 可"读 "的权限getReadableDatabase()

3.3 操作数据库（增、删、查、改）
/** 
  * 1. 创建 & 打开数据库
  */ 

      // a. 创建DatabaseHelper对象
      // 注：一定要传入最新的数据库版本号
      SQLiteOpenHelper dbHelper = new DatabaseHelper(SQLiteActivity.this,"test_carson"，2);
      // b.创建 or 打开 可读/写的数据库
      SQLiteDatabase sqliteDatabase = dbHelper.getWritableDatabase();

  /** 
    *  操作1：插入数据 = insert()
    */ 
        // a. 创建ContentValues对象
        ContentValues values = new ContentValues();

        // b. 向该对象中插入键值对
        values.put("id", 1);
        values.put("name", "carson");
            //其中，key = 列名，value = 插入的值
            //注：ContentValues内部实现 = HashMap，区别在于：ContenValues Key只能是String类型，Value可存储基本类型数据 & String类型

        // c. 插入数据到数据库当中：insert()
        sqliteDatabase.insert("user", null, values);
                // 参数1：要操作的表名称
                // 参数2：SQl不允许一个空列，若ContentValues是空，那么这一列被明确的指明为NULL值
                // 参数3：ContentValues对象
        // 注：也可采用SQL语句插入
        String sql = "insert into user (id,name) values (1,'carson')";
        db.execSQL(sql) ；
            
  /** 
    *  操作2：修改数据 = update（）
    */ 
        // a. 创建一个ContentValues对象
        ContentValues values = new ContentValues();
        values.put("name", "zhangsan");

        // b. 调用update方法修改数据库：将id=1 修改成 name = zhangsan
        sqliteDatabase.update("user", values, "id=?", new String[] { "1" });
            // 参数1：表名(String)
            // 参数2：需修改的ContentValues对象
            // 参数3：WHERE表达式（String），需数据更新的行； 若该参数为 null, 就会修改所有行；？号是占位符
            // 参数4：WHERE选择语句的参数(String[]), 逐个替换 WHERE表达式中 的“？”占位符;

            // 注：调用完upgrate（）后，则会回调 数据库子类的onUpgrade()

        // 注：也可采用SQL语句修改
        String sql = "update [user] set name = 'zhangsan' where id="1";
        db.execSQL(sql);

  /** 
    *  操作3：删除数据 = delete()
    */
        // 删除 id = 1的数据
        sqliteDatabase.delete("user", "id=?", new String[]{"1"});
            // 参数1：表名(String)
            // 参数2：WHERE表达式（String），需删除数据的行； 若该参数为 null, 就会删除所有行；？号是占位符
            // 参数3：WHERE选择语句的参数(String[]), 逐个替换 WHERE表达式中 的“？”占位符;

        // 注：也可采用SQL语句修改
        String sql = "delete from user where id="1"；
        db.execSQL(sql);

  /** 
    *  操作4：查询数据1 = rawQuery() 
    *  直接调用 SELECT 语句
    */
        Cursor c = db.rawQuery("select * from user where id=?",new Stirng[]{"1"}); 
        // 返回值一个 cursor 对象

        // 通过游标的方法可迭代查询结果
        if(cursor.moveToFirst()) { 
           String password = c.getString(c.getColumnIndex("password")); 
         }
        
        //Cursor对象常用方法如下：
        c.move(int offset); //以当前位置为参考,移动到指定行  
        c.moveToFirst();    //移动到第一行  
        c.moveToLast();     //移动到最后一行  
        c.moveToPosition(int position); //移动到指定行  
        c.moveToPrevious(); //移动到前一行  
        c.moveToNext();     //移动到下一行  
        c.isFirst();        //是否指向第一条  
        c.isLast();     //是否指向最后一条  
        c.isBeforeFirst();  //是否指向第一条之前  
        c.isAfterLast();    //是否指向最后一条之后  
        c.isNull(int columnIndex);  //指定列是否为空(列基数为0)  
        c.isClosed();       //游标是否已关闭  
        c.getCount();       //总数据项数  
        c.getPosition();    //返回当前游标所指向的行数  
        c.getColumnIndex(String columnName);//返回某列名对应的列索引值  
        c.getString(int columnIndex);   //返回当前行指定列的值 
        
        // 通过游标遍历1个名为user的表
        Cursor result=db.rawQuery("SELECT _id, username, password FROM user");  
         result.moveToFirst();  
         while (!result.isAfterLast()) {  
            int id=result.getInt(0);  
            String name=result.getString(1);  
            String password =result.getString(2);  
            // do something useful with these  
            result.moveToNext();  
          }  
         result.close();


     // 若查询是动态的，使用该方法会复杂。此时使用 query() 会方便很多
     // 注：无法使用SQL语句，即db.execSQL(sql);

  /** 
    *  操作4：查询数据2 = query() 
    *  直接调用 SELECT 语句
    */
        // 方法说明
        db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy);  
        db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit);  
        db.query(String distinct, String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit); 

        // 参数说明
        // table：要操作的表
        // columns：查询的列所有名称集
        // selection：WHERE之后的条件语句，可以使用占位符
        // groupBy：指定分组的列名
        // having指定分组条件，配合groupBy使用
        // orderBy指定排序的列名
        // limit指定分页参数
        // distinct可以指定“true”或“false”表示要不要过滤重复值

        // 所有方法将返回一个Cursor对象，代表数据集的游标 

        // 具体使用
         Cursor cursor = sqliteDatabase.query("user", new String[] { "id","name" }, "id=?", new String[] { "1" }, null, null, null);
            // 参数1：（String）表名
            // 参数2：（String[]）要查询的列名
            // 参数3：（String）查询条件
            // 参数4：（String[]）查询条件的参数
            // 参数5：（String）对查询的结果进行分组
            // 参数6：（String）对分组的结果进行限制
            // 参数7：（String）对查询的结果进行排序
            
        // 注：无法使用SQL语句，即db.execSQL(sql);
  /** 
    *  操作5：关闭数据库 = close()
    *  注：完成数据库操作后，记得调用close（）关闭数据库，从而释放数据库的连接
    */
        sqliteDatabase.close();  

  /** 
    *  操作6：删除数据库 = deleteDatabase（）
    */
        // 删除 名为person的数据库  
        deleteDatabase("test.db");



3.4 特别注意
除了“查询”，所有的数据库操作都可使用 SQL 语句，即使用下列方法代替：
db.executeSQL(String sql);  
db.executeSQL(String sql, Object[] bindArgs);
// sql语句中使用占位符，参数2 = 实际的参数集  

使用建议：都使用SQL语句，因为：SQL语句 通用 & 简单

原生的方法insert()、delete()等方法具备多个参数，使用复杂

4. 实例Demo
Demo描述：创建数据库 & 对数据库进行操作（增、删、查、改）
实现步骤：
实现子类继承SQLiteOpenHelper类（复写onCreat()、onUpgrade()）
对数据库进行各种操作（增、删、查、改）

###4.1 具体代码如下：

建议先下载Demo再进行阅读：Carson的Github:DataBase_Demo
步骤1：实现子类继承SQLiteOpenHelper类（复写onCreat()、onUpgrade()）
MySQLiteOpenHelper.java
package scut.carson_ho.database_demo;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

/**
 * Created by Carson_Ho on 16/11/18.
 */
public class MySQLiteOpenHelper extends SQLiteOpenHelper {


    //数据库版本号
    private static Integer Version = 1;


    //在SQLiteOpenHelper的子类当中，必须有该构造函数
    public MySQLiteOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory,
                          int version) {
        //必须通过super调用父类当中的构造函数
        super(context, name, factory, version);
    }
    //参数说明
    //context:上下文对象
    //name:数据库名称
    //param:factory
    //version:当前数据库的版本，值必须是整数并且是递增的状态

    public MySQLiteOpenHelper(Context context,String name,int version)
    {
        this(context,name,null,version);
    }


    public MySQLiteOpenHelper(Context context,String name)
    {
        this(context, name, Version);
    }

    //当数据库创建的时候被调用
    @Override
    public void onCreate(SQLiteDatabase db) {

        System.out.println("创建数据库和表");
        //创建了数据库并创建一个叫records的表
        //SQLite数据创建支持的数据类型： 整型数据，字符串类型，日期类型，二进制的数据类型
        String sql = "create table user(id int primary key,name varchar(200))";
        //execSQL用于执行SQL语句
        //完成数据库的创建
        db.execSQL(sql);
        //数据库实际上是没有被创建或者打开的，直到getWritableDatabase() 或者 getReadableDatabase() 方法中的一个被调用时才会进行创建或者打开


    }

    //数据库升级时调用
    //如果DATABASE_VERSION值被改为2,系统发现现有数据库版本不同,即会调用onUpgrade（）方法
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        System.out.println("更新数据库版本为:"+newVersion);
    }


}




步骤2：在MainActivity里实现需要进行的数据库操作（增、删、查、改）
MainActivity.java
package scut.carson_ho.database_demo;

import android.content.ContentValues;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private Button instablish;
    private Button insert;
    private Button upgrade;
    private Button modify;
    private Button delete;
    private Button query;
    private Button delete_database;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //绑定按钮
        instablish = (Button) findViewById(R.id.instablish);
        insert = (Button) findViewById(R.id.insert);
        upgrade = (Button) findViewById(R.id.upgrade);
        modify = (Button) findViewById(R.id.modify);
        delete = (Button) findViewById(R.id.delete);
        query = (Button) findViewById(R.id.query);
        delete_database = (Button) findViewById(R.id.delete_database);

        //设置监听器
        instablish.setOnClickListener(this);
        insert.setOnClickListener(this);
        upgrade.setOnClickListener(this);
        modify.setOnClickListener(this);
        delete.setOnClickListener(this);
        query.setOnClickListener(this);
        delete_database.setOnClickListener(this);

    }

//设置每个按钮对数据库的操作进行控制
    @Override
    public void onClick(View v) {
        switch (v.getId()) {


            //点击创建数据库库
            case R.id.instablish:

                // 创建SQLiteOpenHelper子类对象
                MySQLiteOpenHelper dbHelper = new MySQLiteOpenHelper(this,"test_carson");
                //数据库实际上是没有被创建或者打开的，直到getWritableDatabase() 或者 getReadableDatabase() 方法中的一个被调用时才会进行创建或者打开
                SQLiteDatabase  sqliteDatabase = dbHelper.getWritableDatabase();
                // SQLiteDatabase  sqliteDatabase = dbHelper.getReadbleDatabase();

                break;

            //点击更新数据
            case R.id.upgrade:

                // 创建SQLiteOpenHelper子类对象
                MySQLiteOpenHelper dbHelper_upgrade = new MySQLiteOpenHelper(this,"test_carson",2);
                // 调用getWritableDatabase()方法创建或打开一个可以读的数据库
                SQLiteDatabase  sqliteDatabase_upgrade = dbHelper_upgrade.getWritableDatabase();
                // SQLiteDatabase  sqliteDatabase = dbHelper.getReadbleDatabase();

                break;

            //点击插入数据到数据库
            case R.id.insert:

                System.out.println("插入数据");

                // 创建SQLiteOpenHelper子类对象
                注意，一定要传入最新的数据库版本号
                MySQLiteOpenHelper dbHelper1 = new MySQLiteOpenHelper(this,"test_carson",2);
                // 调用getWritableDatabase()方法创建或打开一个可以读的数据库
                SQLiteDatabase  sqliteDatabase1 = dbHelper1.getWritableDatabase();

                // 创建ContentValues对象
                ContentValues values1 = new ContentValues();

                // 向该对象中插入键值对
                values1.put("id", 1);
                values1.put("name", "carson");

                // 调用insert()方法将数据插入到数据库当中
                sqliteDatabase1.insert("user", null, values1);

                // sqliteDatabase.execSQL("insert into user (id,name) values (1,'carson')");

                //关闭数据库
                sqliteDatabase1.close();

                break;

            //点击查询数据库
            case R.id.query:

                System.out.println("查询数据");

                // 创建DatabaseHelper对象
                MySQLiteOpenHelper dbHelper4 = new MySQLiteOpenHelper(MainActivity.this,"test_carson",2);

                // 调用getWritableDatabase()方法创建或打开一个可以读的数据库
                SQLiteDatabase sqliteDatabase4 = dbHelper4.getReadableDatabase();

                // 调用SQLiteDatabase对象的query方法进行查询
                // 返回一个Cursor对象：由数据库查询返回的结果集对象
                Cursor cursor = sqliteDatabase4.query("user", new String[] { "id",
                        "name" }, "id=?", new String[] { "1" }, null, null, null);


                String id = null;
                String name = null;

                //将光标移动到下一行，从而判断该结果集是否还有下一条数据
                //如果有则返回true，没有则返回false
                while (cursor.moveToNext()) {
                    id = cursor.getString(cursor.getColumnIndex("id"));
                    name = cursor.getString(cursor.getColumnIndex("name"));
                    //输出查询结果
                    System.out.println("查询到的数据是:"+"id: "+id+"  "+"name: "+name);

                }
                //关闭数据库
                sqliteDatabase4.close();

                break;


            //点击修改数据
            case R.id.modify:
                System.out.println("修改数据");

                // 创建一个DatabaseHelper对象
                // 将数据库的版本升级为2
                // 传入版本号为2，大于旧版本（1），所以会调用onUpgrade()升级数据库
                MySQLiteOpenHelper dbHelper2 = new MySQLiteOpenHelper(MainActivity.this,"test_carson", 2);


                // 调用getWritableDatabase()得到一个可写的SQLiteDatabase对象
                SQLiteDatabase sqliteDatabase2 = dbHelper2.getWritableDatabase();

                // 创建一个ContentValues对象
                ContentValues values2 = new ContentValues();
                values2.put("name", "zhangsan");

                // 调用update方法修改数据库
                sqliteDatabase2.update("user", values2, "id=?", new String[]{"1"});

                //关闭数据库
                sqliteDatabase2.close();
                break;

            //点击删除数据
            case R.id.delete:

                System.out.println("删除数据");

                // 创建DatabaseHelper对象
                MySQLiteOpenHelper dbHelper3 = new MySQLiteOpenHelper(MainActivity.this,"test_carson",2);

                // 调用getWritableDatabase()方法创建或打开一个可以读的数据库
                SQLiteDatabase sqliteDatabase3 = dbHelper3.getWritableDatabase();

                //删除数据
                sqliteDatabase3.delete("user", "id=?", new String[]{"1"});

                //关闭数据库
                sqliteDatabase3.close();
                break;




            //点击删除数据库
            case R.id.delete_database:

                System.out.println("删除数据库");

                MySQLiteOpenHelper dbHelper5 = new MySQLiteOpenHelper(MainActivity.this,
                        "test_carson",2);

                // 调用getReadableDatabase()方法创建或打开一个可以读的数据库
                SQLiteDatabase sqliteDatabase5 = dbHelper5.getReadableDatabase();

                //删除名为test.db数据库
                deleteDatabase("test_carson");
                break;

            default:
                break;

        }
    }
}

步骤3：在主布局文件设置按钮控制数据库的操作
activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="scut.carson_ho.database_demo.MainActivity">



    <Button
        android:id="@+id/instablish"
        android:layout_centerHorizontal="true"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="创建数据库"/>



    <Button
        android:id="@+id/upgrade"
        android:layout_below="@+id/instablish"
        android:layout_centerHorizontal="true"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="更新数据库"/>

    <Button
        android:id="@+id/insert"
        android:layout_below="@+id/upgrade"
        android:layout_centerHorizontal="true"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="插入数据"/>

    <Button
        android:id="@+id/modify"
        android:layout_centerHorizontal="true"
        android:layout_below="@+id/insert"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="修改数据"/>



    <Button
        android:id="@+id/query"
        android:layout_centerHorizontal="true"
        android:layout_below="@+id/modify"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="查询数据"/>

    <Button
        android:id="@+id/delete"
        android:layout_centerHorizontal="true"
        android:layout_below="@+id/query"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="删除数据"/>


    <Button
        android:id="@+id/delete_database"
        android:layout_centerHorizontal="true"
        android:layout_below="@+id/delete"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="删除数据库"/>



</RelativeLayout>




4.2 测试结果

界面显示



按顺序点击：创建 - 更新 - 插入 - 查询 - 修改 - 查询 - 删除数据


4.3 Demo地址
Carson的Github地址：DataBase_Demo
5. 总结
本文全面介绍了 Android SQLite数据库中所有知识
接下来，我会继续介绍Android中的常用数据库 的库，如Realm、GreenDao3.0 和 腾讯刚开源的WCDB，感兴趣的同学可以继续关注carson_ho的微信公众号


请帮顶 / 评论点赞！因为你们的赞同/鼓励是我写作的最大动力！

本文是原创文章，转载请注明出处：
http://blog.csdn.net/msdnchina/article/details/42780787

1.涉及到写入数据库的操作，请务必使用 nohup  &的方式 或者使用： “操作终端PC机-->客户机房windows主机-->数据库服务器主机”的连接模式 或者在数据库服务器上开一个vnc。

  这里的写入数据库的操作，包括如下行为：  
  1.1 imp (非impdp)导入数据，建议 使用 nohup  &的方式，放在os的后台运行。请将dmp文件事先放在 db server上，不要在客户端用imp @ 方式导入数据。
  1.2 db升级：建议使用 “操作终端PC机-->客户机房windows主机-->数据库服务器主机”的连接模式 或者 在数据库服务器上开一个vnc(以下简称vnc模式)。
           严禁 使用“操作终端PC机-->数据库服务器主机”的连接模式（非vnc模式）。因为，若是pc机被踢掉网线（等等此类的意外故障），那你就等着哭吧。 


2.涉及到写入数据库的操作，严禁使用无线网络，必须使用有线网络。
  若是客户执意要求使用无线网络，请客户务必签署免责声明书。当客户签署免责声明书之后，工程师才能干活。


3.工程师严禁将自己的USB设备（手机，移动硬盘，U盘等）直接插入客户服务器USB接口。
   以前遇到过维护工程师入场维护手机没电，自己将USB数据线直接插入客户服务器USB接口而造成服务器主板被烧坏，造成意外宕机的情况。

        没有连接过mysql数据库的vs，在创建实体模型的时候，数据源选项没有MySql database ，这是因为没有安装vs使用的MySQL驱动，需要在MySQL官网下载相关驱动，需要下载的文件总共有三个，（这三个是我亲测可用的，没有可以找我）

【mysql-for-visualstudio-1.2.7.msi】，vs驱动

【mysql-connector-net-6.9.9.msi】，连接文件

【mysql-connector-odbc-5.3.9-winx64.msi】 数据驱动

三个文件的安装顺序：


 

一，如果安装过mysql-connector-net、mysql-for-visualstudio-1.2.7、mysql-installer-community、mysql-installer-web-community等为了实现连接的应用或者驱动，卸载你所安装过的mysql-connector-net、mysql-for-visualstudio-1.2.7、mysql-installer-community、mysql-installer-web-community等为了实现连接的应用或者驱动，在控制面板，卸载程序里搜，搜到这个右键卸载。清理，重启，关掉VS。

二，安装【mysql-connector-odbc-5.3.9-winx64.msi】 程序，如果有可以跳过，（在控制面板\所有控制面板项\管理工具中查看ODBC数据源64位。）

 

三、安装【mysql-for-visualstudio-1.2.7.msi】。

四、安装【mysql-connector-net-6.9.9.msi】，安装成功后，最好重启，然后打开VS，就可以看到效果。



 

搞定了吧，搞定之后选择继续，然后你会发现第二个坑：

您的项目引用了最新实体框架；但是，找不到数据链接所需的与版本兼容的实体框架数据库

 

这是因为找不到数据连接所需的与版本兼容的实体框架数据提供程序。

这里提供两种解决办法：

1. 在 - 工具 - 库程序包管理器 - 程序包管理器控制台 这里 实体项目， 在PM>后 输入 

Install-Package EntityFramework -Version 6.0.0

Install-Package EntityFramework.zh-Hans -Version 6.0.0

Install-Package MySql.Data.Entity.EF6

（【这段是我抄的。。。】

 

1和2只要网络是正常的，基本都会成功，但是第三个在执行的时候，通常会报错，如下：

Install-Package : 无法找到程序包“MySql.Data.Entity.EF6”。

所在位置 行:1 字符: 16

+ Install-Package <<<< MySql.Data.Entity.EF6

+ CategoryInfo : NotSpecified: (:) [Install-Package], InvalidOperationException

+ FullyQualifiedErrorId : NuGetCmdletUnhandledException,NuGet.PowerShell.Commands.InstallPackageCommand

解决办法：

通过右键项目->添加引用->浏览，把MySQL Connector Net x.x.x\Assemblies\v4.5(这个是你项目中安装好的mysql文件下的)下的dll文件引用进来，

）每一句输完 回车执行

 

执行完成之后再APP.config的providers 里 添加一个mysql.data.MysqlClint节点， 这个步骤很重要。

<provider invariantName="MySql.Data.MySqlClient" type="MySql.Data.MySqlClient.MySqlProviderServices, MySql.Data.Entity.EF6"></provider>

效果如下

<providers>

<provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />

<provider invariantName="MySql.Data.MySqlClient" type="MySql.Data.MySqlClient.MySqlProviderServices, MySql.Data.Entity.EF6"></provider>

</providers>

到了这一步 ，重新生成一下方案  妥了！

 

然而：

你出来的不一定是上面的效果，而是闪退，好吧。。。。

让我们再回来看下这个问题的原因：找不到数据连接所需的与版本兼容的实体框架数据提供程序。

那我找见不就行了，保持mysql的驱动版本和.NET引用的mysql.Data和mysql.Data.EF的版本号一致。

，所以在安装完的MySQL Connector Net 找到路径下Assemblies找到MySql.Data.Entity.EF6，MySql.Data ，然后引用到项目中，这个才是终极解决办法。看图：

 

直接引用进来。

 

这样就可以了。

 

资源链接： https://download.csdn.net/download/u012658972/10723982