精华内容
下载资源
问答
  • 数据库操作流程

    千次阅读 2018-07-05 11:29:13
    数据库操作流程(MySQL和sqllite)

    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()
    展开全文
  • SQLite数据库操作在Android开发中非常常用 今天我将带大家全面了解关于SQLite数据库的操作(增、删、查、改) 目录1. SQLite数据库介绍 SQLite是Android内置的一个小型、关系型、属于文本型的数据库。 Android提供...

    前言

    • 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 打开 可读的数据库
    
    

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

    1. 对于操作 = “增、删、改(更新)”,需获得 可"读 / 写"的权限:getWritableDatabase()
    2. 对于操作 = “查询”,需获得 可"读 "的权限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描述:创建数据库 & 对数据库进行操作(增、删、查、改)
    • 实现步骤:
      1. 实现子类继承SQLiteOpenHelper类(复写onCreat()onUpgrade()
      2. 对数据库进行各种操作(增、删、查、改)

    ###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中的常用数据库 的库,如RealmGreenDao3.0 和 腾讯刚开源的WCDB,感兴趣的同学可以继续关注carson_ho的微信公众号
      示意图
      示意图

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

    展开全文
  • Hive命令行常用操作(数据库操作,表操作)

    万次阅读 多人点赞 2015-07-14 22:48:01
    数据库操作查看所有的数据库 hive> show databases ; 使用数据库default hive> use default; 查看数据库信息 hive > describe database default; OK db_name comment location owner_name owner_type ...

    数据库操作

    查看所有的数据库

    hive> show databases ;

    使用数据库default

    hive> use default;

    查看数据库信息

    hive > describe database default;
    OK
    db_name comment location owner_name owner_type parameters
    default Default Hive database hdfs://hadoop1:8020/user/hive/warehouse public ROLE
    Time taken: 0.042 seconds, Fetched: 1 row(s)

    显示地展示当前使用的数据库

    hive> set hive.cli.print.current.db=true;
    hive(default)>

    Hive显示列头

    hive (default)> set hive.cli.print.header=true;
    hive (default)> desc addressall_2015_07_09;
    OK
    col_name data_type comment
    _c0 string
    addr1 bigint
    addr2 bigint
    addr3 bigint
    Time taken: 0.182 seconds, Fetched: 4 row(s)
    hive (default)> select * from addressall_2015_07_09;
    OK
    addressall_2015_07_09._c0 addressall_2015_07_09.addr1 addressall_2015_07_09.addr2 addressall_2015_07_09.addr3
    2015_07_09 536 488 493
    Time taken: 10.641 seconds, Fetched: 1 row(s)

    创建数据库命令

    hive (default)> create database liguodong;
    OK
    Time taken: 10.128 seconds

    切换当前的数据库

    hive (default)> use liguodong;
    OK
    Time taken: 0.031 seconds
    hive (liguodong)>

    删除数据库

    删除数据库的时候,不允许删除有数据的数据库,如果数据库里面有数据则会报错。如果要忽略这些内容,则在后面增加CASCADE关键字,则忽略报错,删除数据库。

    hive> DROP DATABASE DbName CASCADE(可选);
    hive> DROP DATABASE IF EXISTS DbName CASCADE;

    表操作

    查看当前DB有啥表

    hive> SHOW TABLES IN DbName;
    hive (liguodong)> SHOW TABLES IN liguodong;
    OK
    tab_name
    Time taken: 0.165 seconds

    也可以使用正则表达式 hive> SHOW TABLES LIKE 'h*';

    hive (default)> SHOW TABLES LIKE '*all*' ;
    OK
    tab_name
    addressall_2015_07_09
    Time taken: 0.039 seconds, Fetched: 1 row(s)

    获得表的建表语句

    hive (default)> show create table address1_2015_07_09;
    OK
    createtab_stmt
    CREATE  TABLE `address1_2015_07_09`(
      `addr1` bigint)
    ROW FORMAT SERDE
      'org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe'
    STORED AS INPUTFORMAT
      'org.apache.hadoop.mapred.TextInputFormat'
    OUTPUTFORMAT
      'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
    LOCATION
      'hdfs://nameservice1/user/hive/warehouse/address1_2015_07_09'
    TBLPROPERTIES (
      'COLUMN_STATS_ACCURATE'='true',
      'numFiles'='1',
      'numRows'='0',
      'rawDataSize'='0',
      'totalSize'='4',
      'transient_lastDdlTime'='1436408451')
    Time taken: 0.11 seconds, Fetched: 17 row(s)
    

    创建表

    CREATE [TEMPORARY] [EXTERNAL] TABLE [IF NOT EXISTS] [db_name.]table_name    -- (Note: TEMPORARY available in Hive 0.14.0 and later)
      [(col_name data_type [COMMENT col_comment], ...)]
      [COMMENT table_comment]
      [PARTITIONED BY (col_name data_type [COMMENT col_comment], ...)]
      [CLUSTERED BY (col_name, col_name, ...) [SORTED BY (col_name [ASC|DESC], ...)] INTO num_buckets BUCKETS]
      [SKEWED BY (col_name, col_name, ...)                  -- (Note: Available in Hive 0.10.0 and later)]
         ON ((col_value, col_value, ...), (col_value, col_value, ...), ...)
         [STORED AS DIRECTORIES]
      [
       [ROW FORMAT row_format] 
       [STORED AS file_format]
         | STORED BY 'storage.handler.class.name' [WITH SERDEPROPERTIES (...)]  -- (Note: Available in Hive 0.6.0 and later)
      ]
      [LOCATION hdfs_path]
      [TBLPROPERTIES (property_name=property_value, ...)]   -- (Note: Available in Hive 0.6.0 and later)
      [AS select_statement];   -- (Note: Available in Hive 0.5.0 and later; not supported for external tables)

    hive (default)> create table test(id int);
    OK
    Time taken: 10.143 seconds

    获得表的建表语句

    hive (default)> show create table test;
    OK
    createtab_stmt
    CREATE  TABLE `test`(
      `id` int)
    ROW FORMAT SERDE
      'org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe'
    STORED AS INPUTFORMAT
      'org.apache.hadoop.mapred.TextInputFormat'
    OUTPUTFORMAT
      'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
    LOCATION
      'hdfs://nameservice1/user/hive/warehouse/test'
    TBLPROPERTIES (
      'transient_lastDdlTime'='1436799093')
    Time taken: 0.135 seconds, Fetched: 12 row(s)

    创建内部表

    其他获得表的信息

    创建外部表

    hive (default)> create external table testexttable(
                  > name string comment 'name value',
                  > addr string comment 'addr value'
                  > );
    OK
    Time taken: 10.172 seconds

    create table if not exists testtable(
    name string comment 'name value',
    addr string comment 'addr value'
    )
    row format delimited fields terminated by '\t' lines terminated by '\n' stored as textfile
    ;

    加载数据

    hive (default)> load data local inpath ‘/liguodong/hivedata/datatest’ overwrite into table testtable;

    hive (default)> load data local inpath ‘/liguodong/hivedata/datatest’ into table testtable;
    如果没有使用overwrite,则会再拷贝一份数据,不会覆盖原来的数据。

    hive (default)> create external table if not exists employees(
                  > name string,
                  > salary string,
                  > subordinates array<string>,
                  > deductions map<string,float>,
                  > address struct<street:string,city:string,state:string,zip:int>
                  > )
                  > row format delimited fields terminated by '\t'
                  > collection items terminated by ','
                  > map keys terminated by ':'
                  > lines terminated by '\n'
                  > stored as textfile
                  > location '/liguodong/data/'
                  > ;

    查找表数据

    hive> select * from employees;
    OK
    tony    1338    ["a1","a2","a3"]        {"k1":1.0,"k2":2.0,"k3":3.0}    {"street":"s1","city":"s2","state":"s3","zip":4}
    mark    5453    ["a4","a5","a6"]        {"k4":4.0,"k5":5.0,"k6":6.0}    {"street":"s4","city":"s5","state":"s6","zip":6}
    ivy     323     ["a7","a8","a9"]        {"k7":7.0,"k8":8.0,"k9":9.0}    {"street":"s7","city":"s8","state":"s9","zip":9}
    Time taken: 10.204 seconds, Fetched: 3 row(s)
    
    查树组
    hive> select subordinates[1]  from employees;
    Total MapReduce CPU Time Spent: 2 seconds 740 msec
    OK
    a2
    a5
    a8
    查map
    hive> select deductions["k2"]  from employees;
    
    OK
    2.0
    NULL
    NULL
    Time taken: 75.812 seconds, Fetched: 3 row(s)
    
    查结构体
    hive> select address.city  from employees;
    Total MapReduce CPU Time Spent: 2 seconds 200 msec
    OK
    s2
    s5
    s8
    Time taken: 75.311 seconds, Fetched: 3 row(s)

    注意:select * 不执行mapreduce,只进行一个本地的查询。
    select 某个字段 生成一个job,执行mapreduce。

    select * from employees;
    select * from employees limit 10;

    删除表

    内部表删除,会连同hdfs存储的数据一同删除,而外部表删除,只会删除外部表的元数据信息。

    hive (default)> drop table testtable;
    OK
    Time taken: 10.283 seconds
    hive (default)> drop table testexttable;
    OK
    Time taken: 0.258 seconds

    Hive建表的其他方式

    有一个表,创建另一个表

    (只是复制了表结构,并不会复制内容。)
    create table test3 like test2;
    不需要执行mapreduce

    hive> desc testtable;
    OK
    name                    string                  name value
    addr                    string                  addr value
    Time taken: 0.267 seconds, Fetched: 2 row(s)
    hive> create table testtableNew like testtable;
    OK
    Time taken: 10.323 seconds
    hive> desc testtableNew;
    OK
    name                    string                  name value
    addr                    string                  addr value
    Time taken: 0.135 seconds, Fetched: 2 row(s)
    

    从其他表查询,再创建表

    (复制表结构的同时,把内容也复制过来了)
    create table test2 as select name,addr from test1;
    需要执行mapreduce

    hive> create table testNewtable as select name,addr from testtable;
    hive> desc testNewtable;
    OK
    name                    string
    addr                    string
    Time taken: 0.122 seconds, Fetched: 2 row(s)
    hive> select * from testNewtable;
    OK
    liguodong       cd
    aobama  lsj
    Time taken: 10.226 seconds, Fetched: 4 row(s)
    展开全文
  • python SQLite数据库操作

    万次阅读 2020-05-05 10:38:42
    SQLite SQLite是一个软件库,实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。SQLite是一个增长最快的数据库引擎,这是在...不需要一个单独的服务器进程或操作的系统(无服务器的) SQLite 不需...

    SQLite

    SQLite是一个软件库,实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。SQLite是一个增长最快的数据库引擎,这是在普及方面的增长,与它的尺寸大小无关。SQLite 源代码不受版权限制。
    它是一个零配置的数据库,这意味着与其他数据库一样,您不需要在系统中配置。

    SQLite数据库优点

    1. 不需要一个单独的服务器进程或操作的系统(无服务器的)
    2. SQLite 不需要配置,这意味着不需要安装或管理
    3. 一个完整的 SQLite 数据库是存储在一个单一的跨平台的磁盘文件
    4. SQLite 是非常小的,是轻量级的
    5. SQLite 是自给自足的,这意味着不需要任何外部的依赖
    6. SQLite 可在 UNIX(Linux, Mac OS-X, Android, iOS)和 Windows(Win32, WinCE, WinRT)中运行

    代码实现SQLite创建、插入、查询、删除操作

    import sqlite3
    class Mysqlite(object):
        def __init__(self,dbpath):
            # 如果不存在则创建
            self.con = sqlite3.connect(dbpath)
            self.cur = self.con.cursor()
    
        def __del__(self):
            self.close()
        
        def execute_sqlite3(self,sql):
            # 命令处理
            sql = sql.lower()
            if 'insert' in sql or 'delete' in sql or  'update' in sql or  'create' in sql:
                self.cur.execute(sql)
                self.con.commit()
                print('done..')
                return 
            elif 'select' in sql :
                self.cur.execute(sql)
                data = self.cur.fetchall()
                print(data)
                return data
    
        def create_table(self,table_name,title):
            # 自定义创建表
            sql = "CREATE TABLE {}({})".format(table_name,title)
            self.execute_sqlite3(sql)
    
        def insert_value(self,table_name,value):
            # 插入自定义数据
            sql = "INSERT INTO {} values({})".format(table_name,value)
            self.execute_sqlite3(sql)
    
        def select_data(self,table_name):
            # 查询数据
            sql = "SELECT * FROM {}".format(table_name)
            self.execute_sqlite3(sql)
    
        def update_data(self,table_name,field,value,id):
            # 修改数据
            sql = "UPDATE {} set {} = '{}' where id = {}".format(table_name,field,value,id)
            self.execute_sqlite3(sql)
        
        def delete_data(self,table_name,id):
            # 删除数据
            sql = "DELETE FROM {} where id = {}".format(table_name,id)
            self.execute_sqlite3(sql)
    
        def close(self):
            # 关闭资源
            self.cur.close()
            self.con.close()
    
    if __name__ == "__main__":
        sqlite = Mysqlite('test.db')
        table_name = 'foo'
        try:
            sqlite.create_table(table_name,'id integer primary key autoincrement, name varchar(128), info varchar(128)')
        except:
            print("{} created..")
        sqlite.insert_value(table_name,'NULL,\"apple\",\"broccoli\"')
        sqlite.select_data(table_name)
        sqlite.update_data(table_name,'name',"orange",1)
        sqlite.select_data(table_name)
        sqlite.delete_data(table_name,2)
        sqlite.select_data(table_name)
    

    运行结果

    在这里插入图片描述

    展开全文
  • Sqlite3数据库操作

    千次阅读 2018-02-23 13:56:31
    Sqlite3数据库操作基本命令 进入命令行环境:sqlite3 命令行帮助:.help 退出命令行环境 .quit 或者 .exit 都可以退出 数据库和表的相关命令 创建一个新的数据库:sqlite3 文件名 打开一个已经存在的数据库:sqlite3...
  • C#简单数据库操作

    万次阅读 多人点赞 2017-10-30 13:08:37
    C#语言提供了丰富的数据库操作类库,极大地方便了对数据库的操作。在C#中,常用的有三种 访问数据库的模式分别为:SqlClient模式、OleDb模式和Odbc模式。其中SqlClient模式是微软老大哥专门为其产品Sql Server数据库...
  • SpringBoot的数据库操作

    千次阅读 2019-05-14 22:18:08
    SpringBoot的数据库操作 1.添加依赖,一个是我们数据库也要用到的data-jpa(简化程序与数据库之间的交互),一个数据库驱动。(文件名:pom.xml),基本的配置在建好项目的时候就有了,只需把这个添加。我只是针对这...
  • 微信小程序 | 云函数上的数据库操作

    万次阅读 多人点赞 2019-06-17 16:42:16
    前阵子做了个微信小程序的项目,这次来主要讲讲云函数上的数据库操作。本文将按照以下顺序进行讲解: 目录 00 什么是云函数和数据库操作 云函数 数据库操作 数据类型 01 小程序端与云端数据库操作的比较 02...
  • pymysql数据库操作

    万次阅读 2018-06-14 22:02:30
    title: 22-Python操作数据库 date: 2018-05-17 22:07:37 tags: 数据库 &lt;h4 style="color: #228B22;"&gt;在Python中操作数据库 ORM 通过pymysql 操作数据库&lt;/h4&gt;ORM - Object ...
  • MySQL数据库操作生成UUID

    万次阅读 2018-05-24 14:54:43
    通过数据库操作,生成无横线的uuid,同时插入至数据库之中。 因为我要给项目做一些测试数据,项目的主键为32位无’-‘的uuid,然后在数据库中,通过数据库操作,然后插入一些测试数据。 生成32位无横线的uuid; ...
  • Qgis应用-数据库操作

    千次阅读 2016-10-18 22:25:36
    1数据库操作(QGIS 2.16) QGIS数据库,使用DBManager统一管理,可以进行数据导入、导出数据库,数据操作(增删改查、预览等操作)。 1.1 创建数据库连接:QGISBrowser 中选择Postgis-》new创建数据库连接。 ...
  • vs2017连接mysql数据库操作步骤

    万次阅读 多人点赞 2018-01-25 09:26:47
    没有连接过mysql数据库的vs,在创建实体模型的时候,数据源选项没有MySql database ,这是因为没有安装vs使用的MySQL驱动,需要在MySQL官网下载相关驱动,需要下载的文件总共有三个,(这三个是我亲测可用的,没有...
  • Django 数据库操作(MongoDB+Django)

    万次阅读 热门讨论 2018-10-16 13:41:31
    Django 数据库操作(MongoDB+Django)1、mongodb 可以使用 mongoengine2、配置 setting.py 文件3、新建一个app4、在新建的app的models.py中新建数据模型5、在视图文件中创建一个视图6、配置urls7、操作增删改查7.2、...
  • PLSQL查询数据库操作历史记录

    千次阅读 2019-04-16 17:58:09
    PLSQL查询数据库操作历史记录: 1、在PLSQL按键Ctrl+E 可以查询我们在PLSQL执行过的历史SQL,包括时间、用户、语句; 2、SELECT * FROM V$SQL 执行sql查询,查询内容包含所有用户和应用系统对数据库的操作,执行...
  • Django数据库操作之save与update

    万次阅读 2017-09-21 15:21:03
    Python框架Django有着诸多优点,它提供的models可以让开发者方便地操作数据库,但正是由于对上层的良好的封装,使得提升数据库操作性能必须要清楚地知道Django的数据库操作到底执行了哪些SQL语句。例如数据更新操作...
  • Hive数据库操作

    千次阅读 2019-05-15 15:08:59
    -- 创建数据库, 数据库名称不分大小写 CREATE DATABASE IF NOT EXISTS mydb; -- 创建数据库,添加描述信息 CREATE DATABASE IF NOT EXISTS mydb COMMENT "MY DATABASE"; -- 创建数据库,指定路径,修改默认位置 ...
  • hive数据库操作——hive命令行

    千次阅读 2018-01-06 17:49:16
    hive数据库操作——hive命令行 本文主要介绍通过hive命令行对hive数据库进行操作。 好,下面上货。 1、显示所有数据库 show databases; 模糊匹配数据库名称 show databases like 'd*'; 、 ...
  • MySQL数据库操作卡死问题

    千次阅读 2018-01-30 16:30:40
    在MySQL数据库操作的时候难免会遇到卡死的问题, 下面给出一个常用的小技巧: 1、show full processlist;  列出当前的操作process,一般会看到很多waiting的process,说明已经有卡住的proces了,我们要杀...
  • python 数据库操作以及一个GUI界面

    万次阅读 多人点赞 2015-12-23 16:27:58
    python 数据库操作以及一个GUI界面
  • jmeter第六章:数据库操作与断言

    千次阅读 2019-06-13 15:15:10
    jmeter第六章:数据库操作与断言本章概要一、jmeter数据库的搭建配置二、jmeter对数据库操作三、数据库断言 本章概要 本章将讲解数据库的配置、操作和进行接口库断言 一、jmeter数据库的搭建配置 数据库的分类:...
  • QT SQLite 多数据库操作大全

    千次阅读 2015-02-22 17:28:57
    QT SQLite 多数据库操作大全一.单数据库模型一般QT都是把打开一个缺省数据库连接,操作一个数据库连接,但是对Sqlite中频率修改容易加锁,因此有一种设计模式是把频率修改的表放在不同的数据库文件中,但这样要修改...
  • 数据库操作——附加数据库

    千次阅读 多人点赞 2014-07-27 11:37:05
    在附加数据库的时候,出现错误“附加数据库时出错,有关详细信息,请单击“消息”列中的超链接。...请将数据库或文件设为可写,然后重新运行恢复操作。” 错误原因:这是NTFS的权限问题(磁盘分区格式),NTFS格
  • 微信小程序云开发:数据库操作

    千次阅读 2019-06-24 23:34:44
    field数据库操作创建记录查询记录删除记录更新记录 数据库官方文档 微信云开发数据库 不同于一般的关系型数据库(例如:MySQL)以及对象数据库(例如:NoSQL),微信云开发为我们提供的是一个JSON数据库,通过集合...
  • 主要内容: 1、scala连接mysql(jdbc方式) ...在我的本地mysql 数据库中,有一张persons表,内容如下: 下面我们希望通过scala执行 mysql 查询数据和插入数据 和更新数据,删除数据、调用存储过程等
  • php数据库操作-创建库和表以及插入数据

    万次阅读 多人点赞 2016-12-27 14:59:01
    以上我们正确连接到了mysql数据库,本文将进一步创建... * 数据库操作*(创建数据库,表,插入数据,插入多条数据) * * To change the template for this generated file go to * Window - Preferences - PHPec
  • 微信小程序云开发 初学者入门教程二-前端操作数据库模块:https://www.jianshu.com/p/fb5be2e7f507中有写到对数据库的一些简单...数据库操作API:https://developers.weixin.qq.com/miniprogram/dev/wxcloud/referenc...
  • 从命令行执行django数据库操作

    千次阅读 2014-07-05 21:59:23
    从命令行执行django数据库操作,报错: django.core.exceptions.ImproperlyConfigured: Requested setting DEFAULT_INDEX_TABLESPACE, but settings are not configured. You must either define the environment ...
  • linux 下访问windows下的数据库操作

    千次阅读 2017-12-29 15:22:54
    linux 下访问windows下的数据库操作 将项目部署到虚拟机中tomcat文件夹webapps下,如果想访问windows下的oracle数据库,操作步骤如下 1、找到在windows下安装的oracle目录,我的路径为E:\app\lenovo\product\11.2.0\...
  • c语言连接数据库以及对数据库操作

    万次阅读 多人点赞 2017-07-13 15:03:19
    查询数据库接口代码 原数据库效果: 所有的表 表中原始数据为空,表属性为 #include #include int main() { MYSQL *conn; MYSQL_RES *res; MYSQL_ROW row; char* server="localhost"; char* user="root";...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,829,810
精华内容 1,131,924
关键字:

数据库操作