Android中SQLite使用方法
分享一下在Android中如何使用SQLite。
现在的主流移动设备像Android、iPhone等都使用SQLite作为复杂数据的存储引擎，在我们为移动设备开发应用程序时，也许就要使用到SQLite来存储我们大量的数据，所以我们就需要掌握移动设备上的SQLite开发技巧。对于Android平台来说，系统内置了丰富的API来供开发人员操作SQLite，我们可以轻松的完成对数据的存取。
下面就向大家介绍一下SQLite常用的操作方法，为了方便，我将代码写在了Activity的onCreate中：
[java]view plaincopyprint?
1.@Override
2.protected void onCreate(Bundle savedInstanceState) {
3.super.onCreate(savedInstanceState);
4.
5.//打开或创建test.db数据库
6.SQLiteDatabase db = openOrCreateDatabase("test.db", Context.MODE_PRIVATE,
null);
7.db.execSQL("DROP TABLE IF EXISTS person");
8.//创建person表
9.db.execSQL("CREATE TABLE person (_id INTEGER PRIMARY KEY AUTOINCREMENT,
name VARCHAR, age SMALLINT)");
10.Person person = new Person();
https://www.doczj.com/doc/6c2895623.html, = "john";
12.person.age = 30;
13.//插入数据
14.db.execSQL("INSERT INTO person VALUES (NULL, ?, ?)", new
Object[]{https://www.doczj.com/doc/6c2895623.html,, person.age});
15.
https://www.doczj.com/doc/6c2895623.html, = "david";
17.person.age = 33;
18.//ContentValues以键值对的形式存放数据
19.ContentValues cv = new ContentValues();
20.cv.put("name", https://www.doczj.com/doc/6c2895623.html,);
21.cv.put("age", person.age);
22.//插入ContentValues中的数据
23.db.insert("person", null, cv);
24.
25.cv = new ContentValues();
26.cv.put("age", 35);
27.//更新数据
28.db.update("person", cv, "name = ?", new String[]{"john"});
29.
30.Cursor c = db.rawQuery("SELECT * FROM person WHERE age >= ?", new
String[]{"33"});
31.while (c.moveToNext()) {
32.int _id = c.getInt(c.getColumnIndex("_id"));
33.String name = c.getString(c.getColumnIndex("name"));
34.int age = c.getInt(c.getColumnIndex("age"));
35.Log.i("db", "_id=>" + _id + ", name=>" + name + ", age=>" + age);
36.}
37. c.close();
38.
39.//删除数据
40.db.delete("person", "age < ?", new String[]{"35"});
41.
42.//关闭当前数据库
43.db.close();
44.
45.//删除test.db数据库
46.// deleteDatabase("test.db");
47.}
在执行完上面的代码后，系统就会在/data/data/[PACKAGE_NAME]/databases目录下生成一个“test.db”的数据库文件，如图：
上面的代码中基本上囊括了大部分的数据库操作；对于添加、更新和删除来说，我们都可以使用
[java]view plaincopyprint?
1.db.executeSQL(String sql);
2.db.executeSQL(String sql, Object[] bindArgs);//sql语句中使用占位符，然后
第二个参数是实际的参数集
除了统一的形式之外，他们还有各自的操作方法：
[java]view plaincopyprint?
1.db.insert(String table, String nullColumnHack, ContentValues values);
2.db.update(String table, Contentvalues values, String whereClause, String
whereArgs);
3.db.delete(String table, String whereClause, String whereArgs);
以上三个方法的第一个参数都是表示要操作的表名；insert中的第二个参数表示如果插入的数据每一列都为空的话，需要指定此行中某一列的名称，系统将此列设置为NULL，不至于出现错误；insert中的第三个参数是ContentValues类型的变量，是键值对组成的Map，key代表列名，value代表该列要插入的值；update的第二个参数也很类似，只不过它是更新该字段key为最新的value值，第三个参数whereClause表示WHERE 表达式，比如“age > ? and age < ?”等，最后的whereArgs参数是占位符的实际参数值；delete方法的参数也是一样。
下面来说说查询操作。查询操作相对于上面的几种操作要复杂些，因为我们经常要面对着各种各样的查询条件，所以系统也考虑到这种复杂性，为我们提供了较为丰富的查询形式：
[java]view plaincopyprint?
1.db.rawQuery(String sql, String[] selectionArgs);
2.db.query(String table, String[] columns, String selection, String[]
selectionArgs, String groupBy, String having, String orderBy);
3.db.query(String table, String[] columns, String selection, String[]
selectionArgs, String groupBy, String having, String orderBy, String
limit);
4.db.query(String distinct, String table, String[] columns, String
selection, String[] selectionArgs, String groupBy, String having, String
orderBy, String limit);
上面几种都是常用的查询方法，第一种最为简单，将所有的SQL语句都组织到一个字符串中，使用占位符代替实际参数，selectionArgs就是占位符实际参数集；下面的几种参数都很类似，columns表示要查询的列所有名称集，selection表示WHERE之后的条件语句，可以使用占位符，groupBy指定分组的列名，having指定分组条件，配合groupBy 使用，orderBy指定排序的列名，limit指定分页参数，distinct可以指定“true”或“false”表示要不要过滤重复值。需要注意的是，selection、groupBy、having、orderBy、limit这几个参数中不包括“WHERE”、“GROUP BY”、“HAVING”、“ORDER BY”、“LIMIT”等SQL 关键字。
最后，他们同时返回一个Cursor对象，代表数据集的游标，有点类似于JavaSE中的ResultSet。
下面是Cursor对象的常用方法：
[java]view plaincopyprint?
1.c.move(int offset); //以当前位置为参考,移动到指定行
2.c.moveToFirst(); //移动到第一行
3.c.moveToLast(); //移动到最后一行
4.c.moveToPosition(int position); //移动到指定行
5.c.moveToPrevious(); //移动到前一行
6.c.moveToNext(); //移动到下一行
7.c.isFirst(); //是否指向第一条
8.c.isLast(); //是否指向最后一条
9.c.isBeforeFirst(); //是否指向第一条之前
10. c.isAfterLast(); //是否指向最后一条之后
11. c.isNull(int columnIndex); //指定列是否为空(列基数为0)
12. c.isClosed(); //游标是否已关闭
13. c.getCount(); //总数据项数
14. c.getPosition(); //返回当前游标所指向的行数
15. c.getColumnIndex(String columnName);//返回某列名对应的列索引值
16. c.getString(int columnIndex); //返回当前行指定列的值
在上面的代码示例中，已经用到了这几个常用方法中的一些，关于更多的信息，大家可以参考官方文档中的说明。
最后当我们完成了对数据库的操作后，记得调用SQLiteDatabase的close()方法释放数据库连接，否则容易出现SQLiteException。
上面就是SQLite的基本应用，但在实际开发中，为了能够更好的管理和维护数据库，我们会封装一个继承自SQLiteOpenHelper类的数据库操作类，然后以这个类为基础，再封装我们的业务逻辑方法。
下面，我们就以一个实例来讲解具体的用法，我们新建一个名为db的项目，结构如下：
其中DBHelper继承了SQLiteOpenHelper，作为维护和管理数据库的基类，DBManager 是建立在DBHelper之上，封装了常用的业务方法，Person是我们的person表对应的JavaBean，MainActivity就是我们显示的界面。
下面我们先来看一下DBHelper：
[java]view plaincopyprint?
1.package com.scott.db;
2.
3.import android.content.Context;
4.import android.database.sqlite.SQLiteDatabase;
5.import android.database.sqlite.SQLiteOpenHelper;
6.
7.public class DBHelper extends SQLiteOpenHelper {
8.
9.private static final String DATABASE_NAME = "test.db";
10.private static final int DATABASE_VERSION = 1;
11.
12.public DBHelper(Context context) {
13.//CursorFactory设置为null,使用默认值
14.super(context, DATABASE_NAME, null, DATABASE_VERSION);
15.}
16.
17.//数据库第一次被创建时onCreate会被调用
18.@Override
19.public void onCreate(SQLiteDatabase db) {
20.db.execSQL("CREATE TABLE IF NOT EXISTS person" +
21."(_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, age INTEGER, info
TEXT)");
22.}
23.
24.//如果DATABASE_VERSION值被改为2,系统发现现有数据库版本不同,即会调用
onUpgrade
25.@Override
26.public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)
{
27.db.execSQL("ALTER TABLE person ADD COLUMN other STRING");
28.}
29.}
正如上面所述，数据库第一次创建时onCreate方法会被调用，我们可以执行创建表的语句，当系统发现版本变化之后，会调用onUpgrade方法，我们可以执行修改表结构等语句。
为了方便我们面向对象的使用数据，我们建一个Person类，对应person表中的字段，如下：
[java]view plaincopyprint?
1.package com.scott.db;
2.
3.public class Person {
4.public int _id;
5.public String name;
6.public int age;
7.public String info;
8.
9.public Person() {
10.}
11.
12.public Person(String name, int age, String info) {
https://www.doczj.com/doc/6c2895623.html, = name;
14.this.age = age;
https://www.doczj.com/doc/6c2895623.html, = info;
16.}
17.}
然后，我们需要一个DBManager，来封装我们所有的业务方法，代码如下：[java]view plaincopyprint?
1.package com.scott.db;
2.
3.import java.util.ArrayList;
4.import java.util.List;
5.
6.import android.content.ContentValues;
7.import android.content.Context;
8.import android.database.Cursor;
9.import android.database.sqlite.SQLiteDatabase;
10.
11.public class DBManager {
12.private DBHelper helper;
13.private SQLiteDatabase db;
14.
15.public DBManager(Context context) {
16.helper = new DBHelper(context);
17.//因为getWritableDatabase内部调用了
mContext.openOrCreateDatabase(mName, 0, mFactory);
18.//所以要确保context已初始化,我们可以把实例化DBManager的步骤放在
Activity的onCreate里
19.db = helper.getWritableDatabase();
20.}
21.
22./**
23.* add persons
24.* @param persons
25.*/
26.public void add(List
27.db.beginTransaction(); //开始事务
28.try {
29.for (Person person : persons) {
30.db.execSQL("INSERT INTO person VALUES(null, ?, ?, ?)", new
Object[]{https://www.doczj.com/doc/6c2895623.html,, person.age, https://www.doczj.com/doc/6c2895623.html,});
31.}
32.db.setTransactionSuccessful(); //设置事务成功完成
33.} finally {
34.db.endTransaction(); //结束事务
35.}
36.}
37.
38./**
39.* update person's age
40.* @param person
41.*/
42.public void updateAge(Person person) {
43.ContentValues cv = new ContentValues();
44.cv.put("age", person.age);
45.db.update("person", cv, "name = ?", new String[]{https://www.doczj.com/doc/6c2895623.html,});
46.}
47.
48./**
49.* delete old person
50.* @param person
51.*/
52.public void deleteOldPerson(Person person) {
53.db.delete("person", "age >= ?", new
String[]{String.valueOf(person.age)});
54.}
55.
56./**
57.* query all persons, return list
58.* @return List
59.*/
60.public List
61.ArrayList
62.Cursor c = queryTheCursor();
63.while (c.moveToNext()) {
64.Person person = new Person();
65.person._id = c.getInt(c.getColumnIndex("_id"));
https://www.doczj.com/doc/6c2895623.html, = c.getString(c.getColumnIndex("name"));
67.person.age = c.getInt(c.getColumnIndex("age"));
https://www.doczj.com/doc/6c2895623.html, = c.getString(c.getColumnIndex("info"));
69.persons.add(person);
70.}
71. c.close();
72.return persons;
73.}
74.
75./**
76.* query all persons, return cursor
77.* @return Cursor
78.*/
79.public Cursor queryTheCursor() {
80.Cursor c = db.rawQuery("SELECT * FROM person", null);
81.return c;
82.}
83.
84./**
85.* close database
86.*/
87.public void closeDB() {
88.db.close();
89.}
90.}
我们在DBManager构造方法中实例化DBHelper并获取一个SQLiteDatabase对象，作为整个应用的数据库实例；在添加多个Person信息时，我们采用了事务处理，确保数据完整性；最后我们提供了一个closeDB方法，释放数据库资源，这一个步骤在我们整个应用关闭时执行，这个环节容易被忘记，所以朋友们要注意。
我们获取数据库实例时使用了getWritableDatabase()方法，也许朋友们会有疑问，在getWritableDatabase()和getReadableDatabase()中，你为什么选择前者作为整个应用的数据库实例呢？在这里我想和大家着重分析一下这一点。
我们来看一下SQLiteOpenHelper中的getReadableDatabase()方法：
[java]view plaincopyprint?
1.public synchronized SQLiteDatabase getReadableDatabase() {
2.if (mDatabase != null && mDatabase.isOpen()) {
3.// 如果发现mDatabase不为空并且已经打开则直接返回
4.return mDatabase;
5.}
6.
7.if (mIsInitializing) {
8.// 如果正在初始化则抛出异常
9.throw new IllegalStateException("getReadableDatabase called
recursively");
10.}
11.
12.// 开始实例化数据库mDatabase
13.
14.try {
15.// 注意这里是调用了getWritableDatabase()方法
16.return getWritableDatabase();
17.} catch (SQLiteException e) {
18.if (mName == null)
19.throw e; // Can't open a temp database read-only!
20.Log.e(TAG, "Couldn't open " + mName + " for writing (will try read-only):",
e);
21.}
22.
23.// 如果无法以可读写模式打开数据库则以只读方式打开
24.
25.SQLiteDatabase db = null;
26.try {
27.mIsInitializing = true;
28.String path = mContext.getDatabasePath(mName).getPath();// 获取数据库
路径
29.// 以只读方式打开数据库
30.db = SQLiteDatabase.openDatabase(path, mFactory,
SQLiteDatabase.OPEN_READONLY);
31.if (db.getVersion() != mNewVersion) {
32.throw new SQLiteException("Can't upgrade read-only database from
version " + db.getVersion() + " to "
33.+ mNewVersion + ": " + path);
34.}
35.
36.onOpen(db);
37.Log.w(TAG, "Opened " + mName + " in read-only mode");
38.mDatabase = db;// 为mDatabase指定新打开的数据库
39.return mDatabase;// 返回打开的数据库
40.} finally {
41.mIsInitializing = false;
42.if (db != null && db != mDatabase)
43.db.close();
44.}
45.}
在getReadableDatabase()方法中，首先判断是否已存在数据库实例并且是打开状态，如果是，则直接返回该实例，否则试图获取一个可读写模式的数据库实例，如果遇到磁盘空间已满等情况获取失败的话，再以只读模式打开数据库，获取数据库实例并返回，然后为mDatabase赋值为最新打开的数据库实例。既然有可能调用到getWritableDatabase()方法，我们就要看一下了：
[java]view plaincopyprint?
1.public synchronized SQLiteDatabase getWritableDatabase() {
2.if (mDatabase != null && mDatabase.isOpen() && !mDatabase.isReadOnly())
{
3.// 如果mDatabase不为空已打开并且不是只读模式则返回该实例
4.return mDatabase;
5.}
6.
7.if (mIsInitializing) {
8.throw new IllegalStateException("getWritableDatabase called
recursively");
9.}
10.
11.// If we have a read-only database open, someone could be using it
12.// (though they shouldn't), which would cause a lock to be held on
13.// the file, and our attempts to open the database read-write would
14.// fail waiting for the file lock. To prevent that, we acquire the
15.// lock on the read-only database, which shuts out other users.
16.
17.boolean success = false;
18.SQLiteDatabase db = null;
19.// 如果mDatabase不为空则加锁阻止其他的操作
20.if (mDatabase != null)
21.mDatabase.lock();
22.try {
23.mIsInitializing = true;
24.if (mName == null) {
25.db = SQLiteDatabase.create(null);
26.} else {
27.// 打开或创建数据库
28.db = mContext.openOrCreateDatabase(mName, 0, mFactory);
29.}
30.// 获取数据库版本(如果刚创建的数据库,版本为0)
31.int version = db.getVersion();
32.// 比较版本(我们代码中的版本mNewVersion为1)
33.if (version != mNewVersion) {
34.db.beginTransaction();// 开始事务
35.try {
36.if (version == 0) {
37.// 执行我们的onCreate方法
38.onCreate(db);
39.} else {
40.// 如果我们应用升级了mNewVersion为2,而原版本为1则执行onUpgrade方法
41.onUpgrade(db, version, mNewVersion);
42.}
43.db.setVersion(mNewVersion);// 设置最新版本
44.db.setTransactionSuccessful();// 设置事务成功
45.} finally {
46.db.endTransaction();// 结束事务
47.}
48.}
49.
50.onOpen(db);
51.success = true;
52.return db;// 返回可读写模式的数据库实例
53.} finally {
54.mIsInitializing = false;
55.if (success) {
56.// 打开成功
57.if (mDatabase != null) {
58.// 如果mDatabase有值则先关闭
59.try {
60.mDatabase.close();
61.} catch (Exception e) {
62.}
63.mDatabase.unlock();// 解锁
64.}
65.mDatabase = db;// 赋值给mDatabase
66.} else {
67.// 打开失败的情况：解锁、关闭
68.if (mDatabase != null)
69.mDatabase.unlock();
70.if (db != null)
71.db.close();
72.}
73.}
74.}
大家可以看到，几个关键步骤是，首先判断mDatabase如果不为空已打开并不是只读模式则直接返回，否则如果mDatabase不为空则加锁，然后开始打开或创建数据库，比较版本，根据版本号来调用相应的方法，为数据库设置新版本号，最后释放旧的不为空的mDatabase并解锁，把新打开的数据库实例赋予mDatabase，并返回最新实例。
看完上面的过程之后，大家或许就清楚了许多，如果不是在遇到磁盘空间已满等情况，getReadableDatabase()一般都会返回和getWritableDatabase()一样的数据库实例，所以我们在DBManager构造方法中使用getWritableDatabase()获取整个应用所使用的数据库实例是可行的。当然如果你真的担心这种情况会发生，那么你可以先用
getWritableDatabase()获取数据实例，如果遇到异常，再试图用getReadableDatabase()获取实例，当然这个时候你获取的实例只能读不能写了。
最后，让我们看一下如何使用这些数据操作方法来显示数据，下面是MainActivity.java 的布局文件和代码：
[html]view plaincopyprint?
1.
2. xmlns:android="https://www.doczj.com/doc/6c2895623.html,/apk/res/android" 3.android:orientation="vertical" 4.android:layout_width="fill_parent" 5.android:layout_height="fill_parent"> 6. 7.android:layout_width="fill_parent" 8.android:layout_height="wrap_content" 9.android:text="add" 10.android:onClick="add"/> 11. 12.android:layout_width="fill_parent" 13.android:layout_height="wrap_content" 14.android:text="update" 15.android:onClick="update"/> 16. 17.android:layout_width="fill_parent" 18.android:layout_height="wrap_content" 19.android:text="delete" 20.android:onClick="delete"/> 21. 22.android:layout_width="fill_parent" 23.android:layout_height="wrap_content" 24.android:text="query" 25.android:onClick="query"/> 26. 27.android:layout_width="fill_parent" 28.android:layout_height="wrap_content" 29.android:text="queryTheCursor" 30.android:onClick="queryTheCursor"/> 31. 32.android:id="@+id/listView" 33.android:layout_width="fill_parent" 34.android:layout_height="wrap_content"/> 35. [java]view plaincopyprint? 1.package com.scott.db; 2. 3.import java.util.ArrayList; 4.import java.util.HashMap; 5.import java.util.List; 6.import java.util.Map; 7. 8.import android.app.Activity; 9.import android.database.Cursor; 10.import android.database.CursorWrapper; 11.import android.os.Bundle; 12.import android.view.View; 13.import android.widget.ListView; 14.import android.widget.SimpleAdapter; 15.import android.widget.SimpleCursorAdapter; 16. 17. 18.public class MainActivity extends Activity { 19. 20.private DBManager mgr; 21.private ListView listView; 22. 23.@Override 24.public void onCreate(Bundle savedInstanceState) { 25.super.onCreate(savedInstanceState); 26.setContentView(https://www.doczj.com/doc/6c2895623.html,yout.main); 27.listView = (ListView) findViewById(R.id.listView); 28.//初始化DBManager 29.mgr = new DBManager(this); 30.} 31. 32.@Override 33.protected void onDestroy() { 34.super.onDestroy(); 35.//应用的最后一个Activity关闭时应释放DB 36.mgr.closeDB(); 37.} 38. 39.public void add(View view) { 40.ArrayList 41. 42.Person person1 = new Person("Ella", 22, "lively girl"); 43.Person person2 = new Person("Jenny", 22, "beautiful girl"); 44.Person person3 = new Person("Jessica", 23, "sexy girl"); 45.Person person4 = new Person("Kelly", 23, "hot baby"); 46.Person person5 = new Person("Jane", 25, "a pretty woman"); 47. 48.persons.add(person1); 49.persons.add(person2); 50.persons.add(person3); 51.persons.add(person4); 52.persons.add(person5); 53. 54.mgr.add(persons); 55.} 56. 57.public void update(View view) { 58.Person person = new Person(); https://www.doczj.com/doc/6c2895623.html, = "Jane"; 60.person.age = 30; 61.mgr.updateAge(person); 62.} 63. 64.public void delete(View view) { 65.Person person = new Person(); 66.person.age = 30; 67.mgr.deleteOldPerson(person); 68.} 69. 70.public void query(View view) { 71.List 72.ArrayList String>>(); 73.for (Person person : persons) { 74.HashMap 75.map.put("name", https://www.doczj.com/doc/6c2895623.html,); 76.map.put("info", person.age + " years old, " + https://www.doczj.com/doc/6c2895623.html,); 77.list.add(map); 78.} 79.SimpleAdapter adapter = new SimpleAdapter(this, list, https://www.doczj.com/doc/6c2895623.html,yout.simple_list_item_2, 80.new String[]{"name", "info"}, new int[]{android.R.id.text1, android.R.id.text2}); 81.listView.setAdapter(adapter); 82.} 83. 84.public void queryTheCursor(View view) { 85.Cursor c = mgr.queryTheCursor(); 86.startManagingCursor(c); //托付给activity根据自己的生命周期去管理Cursor 的生命周期 87.CursorWrapper cursorWrapper = new CursorWrapper(c) { 88.@Override 89.public String getString(int columnIndex) { 90.//将简介前加上年龄 91.if (getColumnName(columnIndex).equals("info")) { 92.int age = getInt(getColumnIndex("age")); 93.return age + " years old, " + super.getString(columnIndex); 94.} 95.return super.getString(columnIndex); 96.} 97.}; 98.//确保查询结果中有"_id"列 99.SimpleCursorAdapter adapter = new SimpleCursorAdapter(this, https://www.doczj.com/doc/6c2895623.html,yout.simple_list_item_2, 100.cursorWrapper, new String[]{"name", "info"}, new int[]{android.R.id.text1, android.R.id.text2}); 101.ListView listView = (ListView) findViewById(R.id.listView); 102.listView.setAdapter(adapter); 103.} 104.} Android学习笔记---SQLite介绍,以及使用Sqlite,进行数据库的创建,完成数据添删改查的理解 17_创建数据库与完成数据添删改查--------------------------------------1.SQLite介绍:最大特点是,无数据类型; 除了可以使用文件或SharedPreferences存储数据，还可以选择使用SQLite数据库存储数据。在Android平台上，集成了一个嵌入式关系型数据库—SQLite，SQLite3支持 NULL、INTEGER n n 、REAL（浮点数字）、TEXT(字符串文本)和BLOB(二进制对象)数据类型，虽然它支持的类型 n n 只有五种，但实际上sqlite3也接受varchar(n)、char(n)、decimal(p,s) 等数据类型，只不 n n 过在运算或保存时会转成对应的五种数据类型。 SQLite最大的特点是你可以把各种类型的数n n 据保存到任何字段中，而不用关心字段声明的数据类型是什么。例如：可以在Integer类型的 n n 字段中存放字符串，或者在布尔型字段中存放浮点数，或者在字符型字段中存放日期型值。n n n 但有一种情况例外：定义为INTEGER PRIMARY KEY的字段只能存储64位整数， 当向这种字段 n n 保存除整数以外的数据时，将会产生错误。 另外， SQLite 在解析CREATE TABLE 语句时， n n 会忽略 CREATE TABLE 语句中跟在字段名后面的数据类型信息，如下面语句会忽略 name字段 n n 的类型信息： CREATE TABLE person (personid integer primary key autoincrement, name varchar n n (20)) SQLite可以解析大部分标准SQL语句，如：查询语句：select * from 表名 where 条件子句 group by 分组字句 having ... order byn n n 排序子句如：select * from person n n n n select * from person order by id desc n n n n select name from person group by name having count(*)>1 ---------------------------------------------------------------------------2.a.分页SQL与mysql类似，下面SQL语句获取5条记录，跳过前面3条记录n n select * from Account limit 5 offset 3 或者 select * from Account limit 3,5 n b.select * from Account limit 3,5,指的是跳过前面的3条记录,然后获取5条记录n c.select * from Account limit 3,5是select * from Account limit 5 offset 3语句 n n 的简写版 -------------------------------------------------------------------------------n 3.常用操作: a.插入语句：insert into 表名(字段列表) values(值列表)。如： insert into person nn n n (name, age) values(‘传智’,3) b.更新语句：update 表名 set 字段名=值where 条件子句。如：update person set name=n n n n'credream ‘where id=10 c.删除语句：delete from 表名 where 条件子句。如：delete from person nwhere id=10 -------------------------------------------------------------------------------2.虽然无数据类型,但是建议加上,这样可以增加可读性,支持标准sql,oracle中的不行 ---------------------------------------------------3.获取添加记录后的自增长的ID值:select last_insert_rowid(); -----------------------------------------------------------4.在android中开发数据库应用: n a.创建数据库:以前在javaee时候,需要手工数据,但是android应用,需要运行在用户的 n n 手机上,所以,android应用,要有自动创建数据库功能,当第一次使用软件的时候 n n 就创建数据库----------------------------------------5.关于数据库自动创建的详细介绍: 我们在编写数据库应用软件时，需要考虑这样的问题：因为我们开发的软件可能会安装在很 n n 多用户的手机上，如果应用使用到了SQLite数据库，我们必须在用户初次使用软件时创建出 n n 应用使用到的数据库表结构及添加一些初始化记录，另外在软件升级的时候，也需要对数据 n n 表结构进行更新。那么，我们如何才能实现在用户初次使用或升级软件时自动在用户的手机 n n 上创建出应用需要的数据库表呢？总不能让我们在每个需要安装此软件的手机上通过手工方 n n 式创建数据库表吧？因为这种需求是每个数据库应用都要面临的，所以在Android系统，为我 n n 们提供了一个名为SQLiteOpenHelper的抽象类，必须继承它才能使用，它是通过对数据库版 n n 本进行管理来实现前面提出的需求。n -----------------------------------------6.SQLite数据库添加,删除,改查操作 n A.创建数据库:SQLiteOpenHelper .getWritableDatabase ()或getReadableDatabase() n n 可以创建数据库7.创建完成以后可以使用SQLITE Expert软件打开生成的数据库n 可以看到除了生成的自己的需要的表之外,还生成了一张:android_metadata表: n 如果在sqlite中使用数据库一定会有一张android_metadata表,用来登记用户的 n 使用语言:zh_cn -----------------------------------------------------n b.数据库自动创建的过程及方法详细介绍: n n我们在编写数据库应用软件时，需要考虑这样的问题：因为我们开发的软件可能会安装在 n n 很多用户的手机上，如果应用使用到了SQLite数据库，我们必须在用户初次使用软件时创建 n n 出应用使用到的数据库表结构及添加一些初始化记录，另外在软件升级的时候，也需要对数n n 据表结构进行更新。那么，我们如何才能实现在用户初次使用或升级软件时自动在用户的手 n n 机上创建出应用需要的数据库表呢？总不能让我们在每个需要安装此软件的手机上通过手工 n n 方式创建数据库表吧？因为这种需求是每个数据库应用都要面临的，所以在Android系统，为n n 我们提供了一个名为SQLiteOpenHelper的抽象类，必须继承它才能使用，它是通过对数据库n n 版本进行管理来实现前面提出的需求。n -------------------------------------------8.详细介绍: 为了实现对数据库版本进行管理，SQLiteOpenHelper类提供了两个重要的方法，分别是 n n onCreate(SQLiteDatabase db)和onUpgrade(SQLiteDatabase db, int oldVersion, intn n n newVersion)，前者用于初次使用软件时生成数据库表，后者用于升级软件时更新数据库表结n n 构。当调用SQLiteOpenHelper的getWritableDatabase()或者getReadableDatabase()方法获n n 取用于操作数据库的SQLiteDatabase实例的时候，如果数据库不存在，Android系统会自动生 n n 成一个数据库，接着调用onCreate()方法，onCreate()方法在初次生成数据库时才会被调用 n n ，在onCreate()方法里可以生成数据库表结构及添加一些应用使用到的初始化数据。 n n onUpgrade()方法在数据库的版本发生变化时会被调用，一般在软件升级时才需改变版本号， n n 而数据库的版本是由程序员控制的，假设数据库现在的版本是1，由于业务的变更，修改了数n n 据库表结构，这时候就需要升级软件，升级软件时希望更新用户手机里的数据库表结构，为n n 了实现这一目的，可以把原来的数据库版本设置为2(有同学问设置为3行不行？当然可以，如 n n 果你愿意，设置为100也行)，并且在onUpgrade()方法里面实现表结构的更新。当软件的版本 n n 升级次数比较多，这时在onUpgrade()方法里面可以根据原版号和目标版本号进行判断，然后 n n 作出相应的表结构及数据更新。 getWritableDatabase()和getReadableDatabase()方法都可以获取一个用于操作数据库的 n n SQLiteDatabase实例。但getWritableDatabase() 方法以读写方式打开数据库，一旦数据库n n 的磁盘空间满了，数据库就只能读而不能写，倘若使用的是getWritableDatabase() 方法就 n n 会出错。getReadableDatabase()方法先以读写方式打开数据库，如果数据库的磁盘空间满了 n n ，就会打开失败，当打开失败后会继续尝试以只读方式打开数据库。 ------------------------------------------------------------------------9.创建数据库的代码: n a.创建项目:DBSQLIte n b./DBSQLIte/src/com/credream/service/DBOpenHelter.java n n package com.credream.service; n n import android.content.Context; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteOpenHelper; import android.database.sqlite.SQLiteDatabase.CursorFactory; n n public class DBOpenHelter extends SQLiteOpenHelper { //父类没有默认构造器,需要显示调用 public DBOpenHelter(Context context) { super (context, "credream.db", null, 1); //数据库创建完成后,默认会保存在<包>/database/文件夹下 //当修改版本号时候,会触发:onUpgrade方法 //第二个:指定数据库名称, //第三个:游标工厂,用来迭代,查询后的结果集,null代表使用系统默认的 n n 游标工厂//版本号,大于0 n } /** n* 这个方法是在数据库第一次被创建的时候调用的 n*/ @Override public void onCreate(SQLiteDatabase db) { //SQLiteDatabase这个类,封装了增删改查操作,也叫做数据库操作实例 db.execSQL("CREATE TABLE person (personid integer primary keyn n n autoincrement, name varchar(20))"); //这里也可以不写name的数据类型,因为sqlite是数据类型无关的,就是写n n 了varchar(20),也可以写入超过20的内容 n n } /** n* 当数据库的版本号变更的时候被调用 n*/ @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { db.execSQL("alter table person add phone varchar(12) null"); n n } n n } --------------------------------------------------------2.在清单文件中写入测试环境 n n n Android是一种基于Linux的自由及开放源代码的操作系统，主要使用于移动设备，如智能手机和平板电脑，由Google公司和开放手机联盟领导及开发。尚未有统一中文名称，中国大陆地区较多人使用“安卓”或“安致”。Android操作系统最初由Andy Rubin开发，主要支持手机。2005年8月由Google收购注资。2007年11月，Google与84家硬件制造商、软件开发商及电信营运商组建开放手机联盟共同研发改良Android系统。随后Google以Apache开源许可证的授权方式，发布了Android的源代码。第一部Android智能手机发布于2008年10月。Android逐渐扩展到平板电脑及其他领域上，如电视、数码相机、游戏机等。2011年第一季度，Android在全球的市场份额首次超过塞班系统，跃居全球第一。2012年11月数据显示，Android占据全球智能手机操作系统市场76%的份额，中国市场占有率为90%。 中文名：安卓 外文名：Android 开发商：Google、开放手持设备联盟 发行商：Google 发行时间：2008年9月23日 编程语 言： C/C++（底层）Java等（应用 层） 系统家 族： 类Unix,Linux 源码模 式： 自由及开放源代码软件 内核类 型： 宏内核(Linux内核) 软件许 可： Apache License, GPL等 Android一词的本义指“机器人”，同时也是Google于2007年11月5日宣布的基于Linux 平台的开源手机操作系统的名称，该平台由操作系统、中间件、用户界面和应用软件组成。 Android一词最早出现于法国作家利尔亚当（Auguste Villiers de l'Isle-Adam）在1886年发 表的科幻小说《未来夏娃》（L'ève future）中。他将外表像人的机器起名为Android。 Android的Logo是由Ascender公司设计的。其中的文字使用了Ascender公司专门制作的 称之为“Droid ” 的字体。Android是一个全身绿色的机器人，绿色也是Android的标志。颜 色采用了PMS 376C和RGB中十六进制的#A4C639来绘制，这是Android操作系统的品牌 象徵。有时候，它们还会使用纯文字的Logo。 2012年7月美国科技博客网站BusinessInsider评选出二十一世纪十款最重要电子产品，Android操作系统和iPhone等榜上有名。 SQLite version 3.7.9 2011-11-01 00:52:41 Enter ".help" for instructions Enter SQL statements terminated with a ";" sqlite> create table students( ...> id integer primary key, ...> name text not null unique, ...> sex int default 1, ...> bak text); sqlite> .tables students sqlite> .help .backup ?DB? FILE Backup DB (default "main") to FILE .bail ON|OFF Stop after hitting an error. Default OFF .databases List names and files of attached databases .dump ?TABLE? ... Dump the database in an SQL text format If TABLE specified, only dump tables matching LIKE pattern TABLE. .echo ON|OFF Turn command echo on or off .exit Exit this program .explain ?ON|OFF? Turn output mode suitable for EXPLAIN on or off. With no args, it turns EXPLAIN on. .header(s) ON|OFF Turn display of headers on or off .help Show this message .import FILE TABLE Import data from FILE into TABLE .indices ?TABLE? Show names of all indices If TABLE specified, only show indices for tables matching LIKE pattern TABLE. .load FILE ?ENTRY? Load an extension library .log FILE|off Turn logging on or off. FILE can be stderr/stdout .mode MODE ?TABLE? Set output mode where MODE is one of: csv Comma-separated values column Left-aligned columns. (See .width) html HTML 第一次实验Android界面设计 一. 实验目的及实验环境 1. 实验目的 1）掌握SQLiteOpenHelper类结构 2）掌握基于SQLite数据库的应用开发过程 3）掌握Content Provider发布数据的方法 4）掌握Content Resolver获取数据的方法 2.实验环境 系统开发平Android Studio 3.0 系统开发平台：Android 7.1 运行平台：Windows10 x64 运行环境：https://www.doczj.com/doc/6c2895623.html, Framework SDK 2.0 二. 实验教材、组织方式、实验容 1.实验教材：Andorid开发与应用 2.组织方式：个人独立完成 2.实验容： 实现基于SQLite数据库的通信录应用，通过单击增加图标打开添加通信录界面，通过单击通信录中的各条信息可删除选中项。 三．方案设计 Android系统中集成了SQLite数据库，并且为数据库的操作提供了相关的类和方法，便于没有数据库开发经验的开发者编写程序。另外，Android平台中利用Content Provider机制来实现跨应用程序数据共享。一个应用程序可以通过Content Provider来发布自己的数据，其他的应用程序可以通过Content Resolver来获取共享数据。 四．运行结果 五．总结 通过这次实验掌握了SQLite OpenHelper类结构，掌握了基于SQLite数据库的应用开发过程以及Content Provider发布数据的方法和掌握Content Resolver 获取数据的方法。 六．附录：源代码 主布局文件activity_main.xml： 开源(Opensource)：这是它最强大的地方。开源，意味着你可以品读它的源码，你可以随时修改它，加入你自己的特性，而这一切完全免费的。开源，是一种精神。 实现部分 好了，现在从实现的角度来谈谈个人体会，这也是我比较关注的。 SQLite是一款优秀的嵌入式数据库管理系统，这里有两层含义：一是它经常作为动态库嵌入到应用程序； 另外一方面它通常用于嵌入式设备或其它要求较低的桌面应用。如果把它作为内存数据库，个人觉得不是很适合。毕竟，它的写并发性不是很好，此时，TimesTen也许会更好，Berkey DB也许是一个不错的选择。SQLite这样的嵌入式数据库与主存数据库的应用场景、实现以及对资源的需求都是不一样的。 (1)事务处理 事务的核心问题有两个：并发控制和恢复。解决了并发控制和恢复问题的系统，就能允许它的用户假设程序是原子的(atomically)执行的——好像没有其它的程序同时执行；而且是可靠的(reliably)——不会产生失败。原子性和可靠性的抽象，则称为事务(transaction)。其实，事务并不是DBMS的专利，任何分布式系统，都面对并发和恢复问题，而解决的方法就是事务，只不过，我们更常听到DBMS中的事务。 并发控制保证事务的原子执行，它使得交错执行的事务看起来是一个接一个的顺序执行的，完全没有交错执行。如果交错执行的结果与顺序执行的结果一致，则称为串行化(serializable)。 恢复使得数据库仅仅包含那些正常完成的事务的结果。如果事务在执行的过程中发生错误，不能继续进行，恢复算法必须清除部分完成事务产生的影响。 ?并发控制 SQLite只支持库级锁，库级锁意味着什么？——意味着同时只能允许一个写操作，也就是说，即事务T1在A表插入一条数据，事务T2在B表中插入一条数据，这两个操作不能同时进行，即使你的机器有100个CPU，也无法同时进行，而只能顺序进行。表级都不能并行，更别说元组级了——这就是库级锁。但是，SQLite尽量延迟申请X锁，直到数据块真正写盘时才申请X锁，这是非常巧妙而有效的。 ?恢复 SQLite的恢复技术是影子分页技术(shadow paging)技术的典型代表。 DBMS的常用恢复技术有影子分页技术与基于日志的技术，前者在早其数据库管理系统中用到，比如Sys tem R，现代DBMS中已经很难见到它的身影了。 影子分页技术与基于日志技术相比，优点是实现简单，消除了写日志记录的开销，恢复的速度也快(不需要redo和undo)。影子分页的缺点就是事务提交时要输出多个块，这使得提交的开销很大，而且以块为单位，很难应用到允许多个事务并发执行的情况——这是它致命的缺点。 (2)查询处理 SQLite的查询处理本质上就是一个SQL编译器和一个虚拟机。而实现这些功能只用了十多个文件，整个实现实现简单而有效，但是也存在一些问题。首先，SQLite字典数据很简单，实际上它的字典就一个表s qlite_mater，所有的信息都是通过对sqlite_master中SQL语句进行解析获取的，而解析一个SQL语句，都需要进行词法分析、语法分析、甚至虚拟机代码的生成。而这一过程是很需要时间的，而且，查询计划也没有重用。其次，查询优化还比较简单，特别是连接操作，只通过循环来做(MySQL也一样)。但是，仅仅数万代码，我们不能对它要求太苛求。 (3)存储模型 2、掌握Android的SQLite数据库设计； 3、掌握Android的Activity 和Fragement用法； 4、熟悉XML 和JSon 文件读取 三、实验内容 要求使用SQLite数据库实现用户注册和登录，读取数据库信息，退出时生成XML文件或JSON文件。 四、实验过程和结果 content_main.xml: 现在手机的操作系统主要有Android (安卓)Symbian（塞班）和windows这三种，其中以安卓最火。 我说的很详细，你看看下面的文字差不多都会明白。。。 小米手机MIUI系统：（图片） 小米手机采用Android OS v2.3+MIUI双系统，双系统之间自选（MIUI系统之间数据可以同步，原生系统与MIUI系统数据不能同步）功能上苹果的IOS比Android OS还是要好一点的，特别在优化流畅性和用户体验上面。而Android开源是最大的优势，自由度大，但是优化不足，配置低的手机用起来有点卡 联想乐Phone的系统版本是采用基于Android操作系统的乐Phone OS 平台。Android操作系统是谷歌开发的操作系统，OS即Operation System，号称第一款开源手机系统 联想手机系统：乐OS系统 独有的手写输入法基本功能方面，联想乐OS采用了独有的手写输入法，可以快速输入中英文、数字和标点符号等内容，特别适合国人使用。另外，乐OS支持自动推送功能，新闻、邮件、股票、音乐和视频等热点资讯都会在第一时间推送到手机之上，不会让你错过任何重要的信息。 Lephone 3Gw101（图片） 我的手机图片： 刷机后图片系统（小米MIUI）系统Android 2.3.9 时间过得很快，剩下一年就毕业了，平时有空闲时间多关注人为地理历史方面的知识，这样有助于提升你的阅历，跨专业跨行业了解一些东西，比如地理方面，虽然这个地方你没有去过，但是你通过网络或书籍知道这个地方的人为地理历史背景等。别人问你的时候，你也能回答上来，读万卷书不如行万里路，行万里路不如阅人无数。就是这个道理。尤其是我学工科的，更应该弥补人为方面的不足。 合肥学院 嵌入式系统设计课程 技术报告 （2014-2015第2学期） 报告题目：SQLite数据库概述和使用专业：自动化 班级：级自动化卓越班 姓名： 指导老师：干开峰 摘要 自几十年前出现的商业应用程序以来，数据库就成为软件应用程序的主要组成部分。正与数据库管理系统非常关键一样，它们也变的非常庞大，并占用相当多的系统资源。嵌入式数据库直接在应用程序进程中运行，提供了零配置运行模式，并且资源占用非常少。作为一个开源的嵌入式数据库产品，SQLite具有系统开销小，检索效率高的特性，嵌入式数据库无须独立运行的数据库引擎，它是由程序直接调用相应的API去实现对数据的存取操作。更直白的讲，嵌入式数据库是一种具备了基本数据库特性的数据文件。嵌入式数据库与其它数据库产品的区别是，前者是程序驱动式,而后者是引擎响应式。嵌入式数据库的一个很重要的特点是体积非常小，同时，很多嵌入式数据库在性能上也优于其它数据库，所以在高性能的应用上也常见嵌入式数据库的身影。SQLite是D·理查德·希普开发出来的用一个小型C库实现的一种强有力的嵌入式关系数据库管理体制。SQLite虽然很小巧，但是支持的SQL语句不会逊色于其他开源数据库。 关键词：SQLite；嵌入式；数据库 目录 1SQLite简介 (1) 2SQLite工作原理 (1) 3SQLite的功能特性 (2) 4SQLite的结构 (2) 5SQLite的使用 (4) 5.1SQLite里面的一些基本的操作： (4) 5.2SQLite的一些类的使用及说明： (5) 5.3SQLite嵌入式数据库使用注意： (10) 6总结 (11) androｉd Aｎdroid一词的本义指“机器人”,同时也是Googlｅ于２007年11月５日宣布的基于Lｉnu ｘ平台的开源手机操作系统的名称，该平台由操作系统、中间件、用户界面和应用软件组成,号称是首个为移动终端打造的真正开放和完整的移动软件。目前最好的是Andrｏｉd2.０的摩托罗拉Drｏiｄ 目录[显示］ [编辑本段］ 简介 Androiｄ是基于Ｌｉnux内核的软件平台和操作系统，早期由Ｇooglｅ开发，后由开放手机联盟(Open Handset Alliance）开发。它采用了软件堆层(softｗａre ｓt acｋ,又名为软件叠层）的架构，主要分为三部分。底层以Linux内核工作为基础，只提供基本功能;其他的应用软件则由各公司自行开发，以Jａva作为编写程序的一部分。另外，为了推广此技术,Ｇoogｌｅ和其它几十个手机公司建立了开放手机联盟。Ａnｄｒoid在未公开之前常被传闻为Googlｅ电话或gPhone。大多传闻认为Goｏg le开发的是自己的手机电话产品，而不是一套软件平台。到了2０10年1月,Ｇooｇl e开始发表自家品牌手机电话的NexuｓOne。目前最新版本为Anｄｒoid2.１。 对手机行业的影响 已经与HＴC、NTT ＤｏCoＭo、KＤＤI、Motorola等世界移动领域34家公司于免费提供达成一致。今后对于移动通讯的影响势必会进一步体现出来。但是如此广泛公司的同盟是否能够有效运作以及持久,让我们拭目以待。 Ａnｄroiｄ手机 ２0０8年9月22日,美国运营商Ｔ-MobiｌeUSA在纽约正式发布第一款Ｇoｏg ｌe手机——T-Mobiｌe Ｇ1。该款手机为台湾宏达电代工制造,是世界上第一部使用Android操作系统的手机,支持WCDMA/ＨSPＡ网络，理论下载速率７.2Mbps,并支持Wi-Fｉ。 (左图为Aｎdｒｏiｄlogｏ) [编辑本段］ SQLite数据库文件分析 前言 性急的兄弟可以跳过前言直接看第1章，特别性急的兄弟可以跳过前面各章，直接看鸣谢。最近对SQLite数据库很感兴趣，认真地学了有半个多月了，越学越觉着好玩。好玩归好玩，只是目前没什么实际用途，那就写点儿东西吧，否则半个月不是白学了嘛！ SQLite数据库包括多方面的知识，比如VDBE什么的。据说那些东西会经常变。确实，我用的是3.6.18版，我看跟其它文档中描述的3.3.6的VDBE已经很不一样了。所以决定先写文件格式，只要是3.?.?的版本，文件格式应该不会有太大变化吧。 网上介绍SQLite文件格式的文章并不少，但一般都是针对小文件：一个表，几条记录，两个页。本文准备一直分析到比较大的文件，至少B-tree和B+tree中得有内结点(就是说不能只有一个既是根又是叶的结点，就是说表中得多点记录，得建索引)，还要争取对SQLite 的各类页都做出分析。 在分析的过程中，争取把SQLite数据库关于文件格式的基本规定也都介绍一下。这样，本文既是一个综合性的技术文档，又带有实例说明，兄弟们参考时岂不是就很方便了吗？既然是技术文档，要想读懂总得先掌握点SQLite数据库的基本知识吧。所以，先介绍参考文献。 0.1 参考文献 1-The Definitive Guide to SQLite . Michael Owens：据说是比较经典的SQLite著作，我看写得是挺好的。边看边翻译了其中的主要部分，但不敢拿出来，大家还是看原文吧。 2-SQLite源代码：其实有关SQLite的最原始说明可能都在源代码中了。把此项列在第2，只是因为我是先看的书再看的代码，估计大家也会是这个顺序吧。先浏览一下代码还是很有收获的，特别是几个主要的.h文件，对本文的写作很有帮助。有关文件格式的说明主要在btreeInt.h中。 3-SQLite入门与分析：网上Arrowcat的系列文章。Arrowcat应该是一个很博学的人，看他的文章收获很大，在此也算是鸣谢吧。 4-SQLite . Chris Newman：我没看，因为也是网上能够下载到的重要资源，所以也在此列出。看目录内容应该比参考文献1简单一些，但出版日期也更早了一些。 5-NULL：在网上搜了半天，国内为什么就没有关于SQLite的好书呢？ 6- https://www.doczj.com/doc/6c2895623.html,/fileformat.html：如果这篇文章看懂了，其实我这篇东西根本就不用再看了。这是介绍SQLite文件格式的权威文档，列在最后，是因为我也是写完这篇东西后才看到的。该文档由SQLite官方网站提供，当初没看，一是因为上网少，还没仔细浏览人家的网站就开始干了(太激动)，其实归根结蒂还是因为英语不好。看到此文档这后还敢把我的东西发出来，有两个原因：一、为其他英语比我强不了多少的兄弟提供一点方便，二、我这里有例子，看起来更形象一些吧。 SQLite语法与Android数据库操作 学习android的小伙伴们在使用Android的SQLiteDatabase类进行数据库操作的时候总会有一些力不从心，特别是对于初涉数据库的小伙伴来说更是如此。 这是因为Android的SQLiteDatabase原本就不是依赖于Android而存在的，而是单独的作为一个个体而存在的，有着自己特有的体系和语言，而这就是SQL 语法了。 关于SQLite数据库的理论知识网上一搜一大片，这里就不多说。SQLite是一个轻量型的数据库，它对于大型数据库来说功能少，因此只需要学习一些通用的SQL语法就能够轻松掌握，而这些SQL语法对于其他的数据库来说也是基本不变化的。 但SQLite有个缺点，那就是作为轻量级选手的它，如果要保存大量数据会力有不及，因此它在android中适合保存个人设置等没有大量数据的信息。 好了，下面就是正式学习SQLite了，只有掌握了SQLite，掌握SQL语法，才能对Android中的数据库操作运用自如。 SQLite的数据类型 与Java语言一样，SQLite也有其特有的数据类型，当然相比MySQL来说只有5种数据类型算是很少了 NULL：空值相当于Java中的null INTEGER：带符号的整型，相当于Java中的int型 REAL：浮点数字，相当于Java中float/double型 TEXT/VARCHAR：字符串文本，相当于Java中String类 BLOB：二进制对象，相当于Java中的byte数组，用于存放图片、声音等文件 Sqlite3中的约束 SQLite的约束是什么呢?约束就是限定数据库字段的条件，如果有个student数据表，它里面有一个age年龄的属性字段，我们要求数据库保存age 这个字段的时候必须有值，不能为空，那么就可以设置为："age INTEGER NOT NULL"。这句话的意思就是age字段是不能为空的整型 NOT NULL ：非空 安卓操作系统简介 简言： Android一词的本义指“机器人”，同时也是Google于2007年11月5日宣布的基于Linux平台的开源手机操作系统的名称，该平台由操作系统、中间件、用户界面和应用软件组成，号称是首个为移动终端打造的真正开放和完整的移动软件。目前，最新版本为Android 2.4 Gingerbread和Android 3.0 Honeycomb。 系统介绍： Android是基于Linux内核的操作系统，是Google公司在2007年11月5日公布的手机操作系统，早期由Google开发，后由开放手持设备联盟（Open Handset Alliance）开发。它采用了软件堆层（software stack，又名以软件叠层）的架构，主要分为三部分。底层Linux内核只提供基本功能；其他的应用软件则由各公司自行开发，部分程序以Java编写。 2010年末数据显示，仅正式推出两年的操作系统Android已经超越称霸十年的诺基亚（Nokia）Symbian OS系统，采用Android系统主要手机厂商包括宏达电子（HTC）、三星（SAMSUNG）、摩托罗拉（MOTOROLA）、LG、Sony Ericsson、魅族M9等，使之跃居全球最受欢迎的智能手机平台，Android系统不但应用于智能手机，也在平板电脑市场急速扩张。 系统架构： 应用程序： Android以Java为编程语言，使接口到功能，都有层出不穷的变化，其中Activity 等同于J2ME的MIDlet，一个Activity 类（class）负责创建视窗（window），一个活动中的Activity就是在foreground（前景）模式，背景运行的程序叫做Service。两者之间通过由ServiceConnection和AIDL连结，达到复数程序同时运行的效果。如果运行中的Activity 全部画面被其他Activity 取代时，该Activity 便被停止（stopped），甚至被系统清除（kill）。 View等同于J2ME的Displayable，程序人员可以通过View 类与“XML layout”档将UI放置在视窗上，Android 1.5的版本可以利用View 打造出所谓的Widgets，其实Widget只是View的一种，所以可以使用xml来设计layout，HTC 的Android Hero手机即含有大量的widget。至于ViewGroup 是各种layout 的基础抽象类（abstract class），ViewGroup之内还可以有ViewGroup。View的构造函数不需要再Activity中调用，但是Displayable的是必须的，在Activity 中，要通过findViewById()来从XML中取得View，Android的View类的显示很大程度上是从XML中读取的。View 与事件（event）息息相关，两者之间通过Listener 结合在一起，每一个View都可以注册一个event listener，例如：当View要处理用户触碰（touch）的事件时，就要向Android框架注册View.OnClickListener。另外还有Image等同于J2ME的BitMap。 中介软件 操作系统与应用程序的沟通桥梁，并用分为两层：函数层（Library）和虚拟机（Virtual Machine）。Bionic是Android 改良libc的版本。Android 同时包含了Webkit，所谓的Webkit 就是Apple Safari 浏览器背后的引擎。Surface flinger 是就2D或3D的内容显示到屏幕上。Android使用工具链(Toolchain)为Google自Android学习笔记---SQLite介绍,以及使用Sqlite,进行数据库的创建,完成数据添删改查的理解
Android是一种基于Linux的自由及开放源代码的操作系统
sqlite3数据库使用实例
code insert SQL insert statements for TABLE line One value per line list Values delimited by .separator string tabs Tab-separated values tcl TCL list elements .nullvalue STRING Print STRING in place of NULL values .output FILENAME Send output to FILENAME .output stdout Send output to the screen .prompt MAIN CONTINUE Replace the standard prompts .quit Exit this program .read FILENAME Execute SQL in FILENAME
Android实验报告_基于SQLite的通信录
浅谈嵌入式SQLITE数据库实现与应用
Android 实验报告 Sqlite 数据库操作
现在手机的操作系统主要有Android
嵌入式系统技术报告(题目 SQLITE数据库的概述和使用)
android系统详细介绍
SQLite 数据库文件分析
SQLite语法与Android数据库操作
安卓操作系统简介
相关主题
文本预览