Android-不能打开数据库
注意事项: 本文中文内容可能为机器翻译,如要查看英文原文请点击上面连接.
我有我的 db.sqlite 文件资产文件夹中，并尝试打开它时出现此错误：
android.database.sqlite.SQLiteCantOpenDatabaseException: unknown error (code 14): Could not open database
我试过不同的路径和名称 （带和不带扩展名），但无法做到的工作。
package com.example.APP.
import java.io.F
import java.io.FileOutputS
import java.io.IOE
import java.io.InputS
import java.io.OutputS
import android.content.C
import android.database.SQLE
import android.database.sqlite.SQLiteD
import android.database.sqlite.SQLiteE
import android.database.sqlite.SQLiteOpenH
import android.widget.T
public class DataBaseHelper extends SQLiteOpenHelper {
// The Android's default system path of your application database.
private static String DB_PATH = "/data/data/com.example.APP/databases/";
private static String DB_NAME = "app";
private SQLiteDatabase myDataB
private final Context myC
* Constructor Takes and keeps a reference of the passed context in order to
* access to the application assets and resources.
* @param context
public DataBaseHelper(Context context) {
super(context, DB_NAME, null, 1);
this.myContext =
* Creates a empty database on the system and rewrites it with your own
* database.
public void createDataBase() throws IOException {
boolean dbExist = checkDataBase();
if (dbExist) {
// do nothing - database already exist
// By calling this method and empty database will be created into
// the default system path
// of your application so we are gonna be able to overwrite that
// database with our database.
this.getReadableDatabase();
copyDataBase();
} catch (IOException e) {
throw new Error("Error copying database");
* Check if the database already exist to avoid re-copying the file each
* time you open the application.
* @return true if it exists, false if it doesn't
private boolean checkDataBase(){
boolean checkdb =
String myPath = myContext.getFilesDir().getAbsolutePath().replace("files", "databases")+File.separator + DB_NAME;
File dbfile = new File(myPath);
checkdb = dbfile.exists();
catch(SQLiteException e){
System.out.println("Database doesn't exist");
* Copies your database from your local assets-folder to the just created
* empty database in the system folder, from where it can be accessed and
* handled. This is done by transfering bytestream.
private void copyDataBase() throws IOException {
// Open your local db as the input stream
InputStream myInput = myContext.getAssets().open(DB_NAME);
// Path to the just created empty db
String outFileName = DB_PATH + DB_NAME;
// Open the empty db as the output stream
OutputStream myOutput = new FileOutputStream(outFileName);
// transfer bytes from the inputfile to the outputfile
byte[] buffer = new byte[1024];
while ((length = myInput.read(buffer)) & 0) {
myOutput.write(buffer, 0, length);
// Close the streams
myOutput.flush();
myOutput.close();
myInput.close();
public void openDataBase() throws SQLException{
//Open the database
String myPath = DB_PATH + DB_NAME;
myDataBase = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY);
public synchronized void close() {
if (myDataBase != null)
myDataBase.close();
super.close();
public void onCreate(SQLiteDatabase db) {
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
当我尝试在这里打开时出现错误：
package com.example.APP;
import android.app.A
import android.os.B
import android.widget.TextV
import com.example.APP.db.DataBaseH
public class SpeakersListActivity extends Activity {
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.mylayout);
DataBaseHelper dbHelper = new DataBaseHelper(this);
dbHelper.openDataBase();
解决方法 1:
您需要检查是否存在的数据库的文件第一次，你不是在这里
DataBaseHelper dbHelper = new DataBaseHelper(this);
dbHelper.openDataBase();
您是简单地使 DataBaseHelper 的对象，然后调用.openDataBase()
请尝试使用此构造函数：
public DataBaseHelper(Context context) {
super(context, DB_NAME, null, 1);
this.myContext =
String myPath = DB_PATH + DB_NAME; // also check the extension of you db file
File dbfile = new File(myPath);
if( dbfile.exists());
Toast.makeText(context, "database exists", Toast.LENGTH_LONG).show();
Toast.makeText(context, "cant find database", Toast.LENGTH_LONG).show();
catch(SQLiteException e){
System.out.println("Database doesn't exist");阅读(14848)
作者：Mina Samy
Android的默认数据库引擎是精简版。SQLite是一个轻量级的事务数据库引擎，磁盘存储空间和内存占用都很少，因此在Android，IOS等手机操作系统上创建数据库，它是一个完美的选择。
在处理SQLite时需要考虑的事情：
1.数据类型完整性的维护不能依赖SQLite，你可以把某一数据类型的值放在另外一种数据类型的列中（例如把字符串存在整数列)。
2.引用完整性不能依赖SQLite,没有外键(FOREIGN KEY)和JOIN语句。
3.SQLite默认安装不支持完整的Unicode，需要选装。
在本教程中，我们将创建一个简单的应用程序商店的员工数据库:
1.Employees 员工表
2.Dept 部门表
ViewEmps：显示员工和他们的相关部门。
创建SQLite数据库
默认情况下，Android中的SQLite没有管理界面或应用程序去创建和管理数据库，所以我们要用代码来创建数据库。
首先，我们将创建一个类来处理所需的所有操作，如创建数据库，创建表，插入和删除记录等数据库处理。
第一步是创建一个类，继承SQLiteOpenHelper类。这个类提供了覆盖处理与数据库的两种方法：
1. OnCreate中（SQLiteDatabase db） ：创建数据库时调用，在这里我们可以创建表和列，创建视图或触发器。
2.onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion):
当我们作出修改，如修改，删除，创建新的表的数据库调用。
我们的类有如下成员：
public class DatabaseHelper extends SQLiteOpenHelper {
static final String dbName="demoDB";
static final String employeeTable="Employees";
static final String colID="EmployeeID";
static final String colName="EmployeeName";
static final String colAge="Age";
static final String colDept="Dept";
static final String deptTable="Dept";
static final String colDeptID="DeptID";
static final String colDeptName="DeptName";
static final String viewEmps="ViewEmps";
public DatabaseHelper(Context context) {
super(context, dbName, null,33);
super类的构造函数有如下参数：
Context son: 连接到数据库的上下文
dbName：数据库的名称
CursorFactory：有时候，我们可能会使用Cursor类的扩展类来进行一些额外的验证或操作，实现对数据库运行查询。在这种情况下，我们传递CursorFactory的实例，返回要使用的默认游标，而不是返回到我们的派生类的引用。在这个例子中，我们将使用标准的游标接口，因此，我们将CursorFactory参数设置为null。
Version：数据库架构的版本。构造函数创建一个新的空白数据库时需要指定名称和版本。
创建数据库
第一个覆盖父类的方法是onCreate(SQLiteDatabase db):
public void onCreate(SQLiteDatabase db) {
// TODO Auto-generated method stub
db.execSQL("CREATE TABLE "+deptTable+" ("+colDeptID+ " INTEGER PRIMARY KEY , "+
colDeptName+ " TEXT)");
db.execSQL("CREATE TABLE "+employeeTable+"
("+colID+" INTEGER PRIMARY KEY AUTOINCREMENT, "+
colName+" TEXT, "+colAge+" Integer, "+colDept+"
INTEGER NOT NULL ,FOREIGN KEY ("+colDept+") REFERENCES
"+deptTable+" ("+colDeptID+"));");
db.execSQL("CREATE TRIGGER fk_empdept_deptid " +
" BEFORE INSERT "+
" ON "+employeeTable+
" FOR EACH ROW BEGIN"+
" SELECT CASE WHEN ((SELECT "+colDeptID+" FROM "+deptTable+"
WHERE "+colDeptID+"=new."+colDept+" ) IS NULL)"+
" THEN RAISE (ABORT,'Foreign Key Violation') END;"+
db.execSQL("CREATE VIEW "+viewEmps+
" AS SELECT "+employeeTable+"."+colID+" AS _id,"+
" "+employeeTable+"."+colName+","+
" "+employeeTable+"."+colAge+","+
" "+deptTable+"."+colDeptName+""+
" FROM "+employeeTable+" JOIN "+deptTable+
" ON "+employeeTable+"."+colDept+" ="+deptTable+"."+colDeptID
//Inserts pre-defined departments
InsertDepts(db);
该函数创建含列的表，视图和触发器。该函数在数据库创建时被调用。当数据库在磁盘上不存在时该方法被
调用，它在应用程序首次运行时执行，同一设备只执行一次。
升级数据库
有时候，我们需要通过改变架构来升级数据库，然后添加新的表或改变列的数据类型。这些在onUpgrade
(SQLiteDatabase db,int old Version,int newVerison)函数中完成。
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// TODO Auto-generated method stub
db.execSQL("DROP TABLE IF EXISTS "+employeeTable);
db.execSQL("DROP TABLE IF EXISTS "+deptTable);
db.execSQL("DROP TRIGGER IF EXISTS dept_id_trigger");
db.execSQL("DROP TRIGGER IF EXISTS dept_id_trigger22");
db.execSQL("DROP TRIGGER IF EXISTS fk_empdept_deptid");
db.execSQL("DROP VIEW IF EXISTS "+viewEmps);
onCreate(db);
该函数在构造函数中的版本号参数有所改变时被调用。
当我们想添加一些修改到我们的数据库中，我们必须更改构造函数中的版本号的数字。
因此我们可以将版本号2传递给构造函数用于代替版本1:
public DatabaseHelper(Context context) {
super(context, dbName, null,2);
// TODO Auto-generated constructor stub
原来：super(context, dbName, null,1);
应用程序会理解为你想升级数据库，onUpgrade函数被调用。该方法的一个典型应用是删除表，然后创建表
做相应修改。
管理外键约束
我们提到过，在此之前，由默认的SQLite 3不支持外键约束，但是我们可以强制使用触发器这样的约束：我们将创建一个触发器，确保插入一个新雇员时，他/她的部门值在原部门表中已经存在。创建一个触发器的SQL语句：
CREATE TRIGGER fk_empdept_deptid Before INSERT ON Employees
FOR EACH ROW BEGIN
SELECT CASE WHEN ((SELECT DeptID FROM Dept WHERE DeptID =new.Dept ) IS NULL)
THEN RAISE (ABORT,'Foreign Key Violation') END;
在onCreate方法中，我们创建这样的触发器：
db.execSQL("CREATE TRIGGER fk_empdept_deptid " +
" BEFORE INSERT "+
" ON "+employeeTable+
" FOR EACH ROW BEGIN"+
" SELECT CASE WHEN ((SELECT "+colDeptID+" FROM "+deptTable+" _
WHERE "+colDeptID+"=new."+colDept+" ) IS NULL)"+
" THEN RAISE (ABORT,'Foreign Key Violation') END;"+
执行SQL语句
现在让我们开始执行基本的SQL语句。您可以执行任何SQL语句，这不是一个查询，无论是插入，删除，更新或任何使用db.execSQL(String statement)方法一样。当我们创建数据库表时可以这样：
db.execSQL("CREATE TABLE "+deptTable+" ("+colDeptID+ " INTEGER PRIMARY KEY , "+
colDeptName+ " TEXT)");
我们使用下面的代码在数据库Dept表中插入记录：
SQLiteDatabase db=this.getWritableDatabase();
ContentValues cv=new ContentValues();
cv.put(colDeptID, 1);
cv.put(colDeptName, "Sales");
db.insert(deptTable, colDeptID, cv);
cv.put(colDeptID, 2);
cv.put(colDeptName, "IT");
db.insert(deptTable, colDeptID, cv);
db.close();
注意，我们需要调用this.getWritableDatabase()打开数据库连接进行读写。ContentValues.put有两个参数Column Name 和 value，在执行完语句后关闭数据库是一个很好的做法。
我们有两种方式执行一个update语句:
1. 执行 db.execSQL
2. 执行 db.update
public int UpdateEmp(Employee emp)
SQLiteDatabase db=this.getWritableDatabase();
ContentValues cv=new ContentValues();
cv.put(colName, emp.getName());
cv.put(colAge, emp.getAge());
cv.put(colDept, emp.getDept());
return db.update(employeeTable, cv, colID+"=?",
new String []{String.valueOf(emp.getID())});
update方法有以下参数：
1. String Table: 需要更新的表
2. ContentValues cv: 新的值
3. String where clause: WHERE子句制定更新的记录
4. String[] args: WHERE 子句参数
我们有两种方式执行delete语句：
1. 执行 db.execSQL
2. 执行 db.delete方法：
public void DeleteEmp(Employee emp)
SQLiteDatabase db=this.getWritableDatabase();
db.delete(employeeTable,colID+"=?", new String [] {String.valueOf(emp.getID())});
db.close();
delete方法的参数和update方法一样。
有两种方法执行查询：
1. 执行 db.rawQuery
2. 执行 db.query
执行一个原始的查询得到所有部门：
Cursor getAllDepts()
SQLiteDatabase db=this.getReadableDatabase();
Cursor cur=db.rawQuery("SELECT "+colDeptID+" as _id,
"+colDeptName+" from "+deptTable,new String [] {});
rawQuery方法有两个参数：
1. String query:select语句
2. String[] selection args:select语句中WHERE子句的参数。
1.查询结果返回游标对象。
2.在一个 select 语句中，如果表的主键列（ID列）有一个非_id的名称，那么你必须使用SELECT [列名] as _id，因为游标对象总是认为主键列的名称为_id，否则会抛出一个异常。
执行查询的另一种方法是，使用db.query方法。从视图中查询选择某个部门的所有员工：
public Cursor getEmpByDept(String Dept)
SQLiteDatabase db=this.getReadableDatabase();
String [] columns=new String[]{"_id",colName,colAge,colDeptName};
Cursor c=db.query(viewEmps, columns, colDeptName+"=?",
new String[]{Dept}, null, null, null);
db.query有如下参数：
1. String Table Name: 数据表名称
2. String [ ] columns: 需要查询的列
3. String WHERE clause: where 子句，如果没有，可以传递null
4. String [ ] selection args: WHERE子句的参数
5. String Group by: 指定group by 子句
6. String Having: 指定HAVING子句
7. String Order By by: 指定Order By子句
查询记录集返回在Cursor对象里，使用游标时有一些公共的方法：
boolean moveToNext(): 在记录集里将游标移到下一条记录，如果超过了最后一行则返回false.
boolean moveToFirst(): 将游标移到第一行，如果记录集为空则返回false.
boolean moveToPosition(int position): 移动游标到指定位置，如果位置不可达，则返回false
boolean moveToPrevious(): 将游标移到上一行，如果超过了第一行则返回false
boolean moveToLast(): 将游标移到最后一行，如果记录集为空则返回false.
还有一些检查游标位置的有用方法：boolean isAfterLast(), isBeforeFirst, isFirst, isLast 和 isNull(columnIndex)。此外，如果是只有一行的结果集，你需要检索的某些列的值，你可以这样做：
public int GetDeptID(String Dept)
SQLiteDatabase db=this.getReadableDatabase();
Cursor c=db.query(deptTable, new String[]{colDeptID+" as _id",colDeptName},
colDeptName+"=?", new String[]{Dept}, null, null, null);
//Cursor c=db.rawQuery("SELECT "+colDeptID+" as _id FROM "+deptTable+"
//WHERE "+colDeptName+"=?", new String []{Dept});
c.moveToFirst();
return c.getInt(c.getColumnIndex("_id"));
我们用 Cursor.getColumnIndex(String ColumnName) 得到列的索引号，然后通过Cursor.getInt(int ColumnIndex)得到列的值。
还有，可以用getShort, getString, getDouble, getBlob得到字节数组的值。使用完游标后用close()关闭是一个好习惯。
A few years ago I'd have to pay someone for this initfmaoron.
只需一步手机，刷软件下载量，会上网就可日赚零花钱，想赚钱加微信
(非注册用户请填昵称)
(非注册用户请留空)
您还没有登录,请或
访问：30977次
积分：68分
排名：第56名
asdfasfdas:三星的机子4.0.4的
asdfasfdas:帅哥，我有个古怪的问题，processOnClick&& 第41行的判断做完，m...
微笑:只需一步手机，刷软件下载量，会上网就可日赚零花钱，想赚钱加微信
Iijeecaas:A few years ago I'd have to pay someone for th...
Lynn:Way to use the internet to help people solve prlsm...
Eren:I am trying to dedice on a WR since Nicks keeps le...
阅读排行榜
评论排行榜[Android] SQLite的使用入门
也提供了几种方法用来保存数据，使得这些数据即使在程序结束以后依然不会丢失。这些方法有：　　　　　
文本文件：
　　可以保存在应用程序自己的目录下，安装的每个app都会在/data/data/目录下创建个文件夹，名字和应用程序中AndroidManifest.xml文件中的package一样。　　　
SDcard保存：
Preferences保存：
　　这也是一种经常使用的数据存储方法，因为它们对于用户而言是透明的，并且从应用安装的时候就存在了。
Assets保存：
　　用来存储一些只读数据，Assets是指那些在assets目录下的文件，这些文件在你将你的应用编译打包之前就要存在，并且可以在应用程序运行的时候被访问到。
但有时候我们需要对保存的数据进行一些复杂的操作，或者数据量很大，超出了文本文件和Preference的性能能的范围，所以需要一些更加高效的方法来管理，从Android1.5开始，Android就自带SQLite了。
　　SQLite它是一个独立的，无需服务进程，支持事务处理，可以使用SQL语言的数据库。
SQLite的特性
1、 ACID事务 　　　
　　指数据库事务正确执行的四个基本要素的缩写。包含：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）。一个支持事务（Transaction）的数据库，必需要具有这四种特性，否则在事务过程（Transaction processing）当中无法保证数据的正确性，交易过程极可能达不到交易方的要求。
2、 零配置 & 无需安装和管理配置 　
3、储存在单一磁盘文件中的一个完整的数据库 　
4、数据库文件可以在不同字节顺序的机器间自由的共享
5、支持数据库大小至2TB 　
6、 足够小, 大致3万行C代码, 250K 　
7、比一些流行的数据库在大部分普通数据库操作要快 　
8、简单, 轻松的API 　
9、 包含TCL绑定, 同时通过Wrapper支持其他语言的绑定 　
10、良好注释的源代码, 并且有着90%以上的测试覆盖率
11、 独立: 没有额外依赖
12、 Source完全的Open, 你可以用于任何用途, 包括出售它
13、支持多种开发语言，C，，Perl，，ASP.NET，
Android 中使用 SQLite
　　Activites 可以通过 Content Provider 或者 Service 访问一个数据库。
创建数据库
　　Android 不自动提供数据库。在 Android 应用程序中使用 SQLite，必须自己创建数据库，然后创建表、索引，填充数据。Android 提供了 SQLiteOpenHelper 帮助你创建一个数据库，你只要继承 SQLiteOpenHelper 类根据开发应用程序的需要，封装创建和更新数据库使用的逻辑就行了。　
　　SQLiteOpenHelper 的子类，至少需要实现三个方法：　
public class DatabaseHelper extends SQLiteOpenHelper {
* @param context
上下文环境（例如，一个 Activity）
* @param name
数据库名字
* @param factory
一个可选的游标工厂（通常是 Null）
* @param version
数据库模型版本的整数
* 会调用父类 SQLiteOpenHelper的构造函数
public DatabaseHelper(Context context, String name, CursorFactory factory, int version) {
super(context, name, factory, version);
在数据库第一次创建的时候会调用这个方法
*根据需要对传入的SQLiteDatabase 对象填充表和初始化数据。
public void onCreate(SQLiteDatabase db) {
* 当数据库需要修改的时候（两个数据库版本不同），Android会主动的调用这个方法。
* 一般我们在这个方法里边删除数据库表，并建立新的数据库表.
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
//三个参数，一个 SQLiteDatabase 对象，一个旧的版本号和一个新的版本号
public void onOpen(SQLiteDatabase db) {
// 每次成功打开数据库后首先被执行
super.onOpen(db);
继承SQLiteOpenHelper之后就拥有了以下两个方法：
getReadableDatabase() 　创建或者打开一个查询数据库
getWritableDatabase()　创建或者打开一个可写数据库
DatabaseHelper database = new DatabaseHelper(context);//传入一个上下文参数
SQLiteDatabase db =
db = database.getWritableDatabase();
上面这段代码会返回一个 SQLiteDatabase 类的实例，使用这个对象，你就可以查询或者修改数据库。　
SQLiteDatabase类为我们提供了很多种方法，而较常用的方法如下：
(int) delete(String table,String whereClause,String[] whereArgs)
删除数据行
(long) insert(String table,String nullColumnHack,ContentValues values)
添加数据行
(int) update(String table, ContentValues values, String whereClause, String[] whereArgs)
更新数据行
(void) execSQL(String sql)
执行一个SQL语句，可以是一个select或其他的sql语句
(void) close()
关闭数据库
(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注入）
　　当你完成了对数据库的操作（例如你的 Activity 已经关闭），需要调用 SQLiteDatabase 的 Close() 方法来释放掉数据库连接。
创建表和索引
　　为了创建表和索引，需要调用 SQLiteDatabase 的 execSQL() 方法来执行 DDL 语句。如果没有异常，这个方法没有返回值。
　　例如，你可以执行如下代码：
db.execSQL(&CREATE TABLE user(_id INTEGER PRIMARY KEY
AUTOINCREMENT, username TEXT, password TEXT);&);
　　这条语句会创建一个名为 user的表，表有一个列名为 _id，并且是主键，这列的值是会自动增长的整数。另外还有两列：username( 字符 ) 和 password( 字符 )。 SQLite 会自动为主键列创建索引。
　　通常情况下，第一次创建数据库时创建了表和索引。要 删除表和索引，需要使用 execSQL() 方法调用 DROP INDEX 和 DROP TABLE 语句。
添加数据　
有两种方法可以给表添加数据。
①可以使用 execSQL() 方法执行 INSERT, UPDATE, DELETE 等语句来更新表的数据。execSQL() 方法适用于所有不返回结果的 SQL 语句。例如：
String sql = &insert into user(username,password) values ('finch',';);//插入操作的SQL语句
db.execSQL(sql);//执行SQL语句
②使用 SQLiteDatabase 对象的 insert()。
ContentValues cv = new ContentValues();
cv.put(&username&,&finch&);//添加用户名
cv.put(&password&,&123456&); //添码
db.insert(&user&,null,cv);//执行插入操作
更新数据（修改）
①使用SQLiteDatabase 对象的 update()方法。
ContentValues cv = new ContentValues();
cv.put(&password&,&654321&);//添加要更改的字段及内容
String whereClause = &username=?&;//修改条件
String[] whereArgs = {&finch&};//修改条件的参数
db.update(&user&,cv,whereClause,whereArgs);//执行修改
该方法有四个参数：　
　　表名；
　　列名和值的 ContentValues 对象；　
　　可选的 WHERE 条件；　
　　可选的填充 WHERE 语句的字符串，这些字符串会替换 WHERE 条件中的&？&标记，update() 根据条件，更新指定列的值.　
②使用execSQL方式的实现
String sql = &update [user] set password = '; where username=&finch&;//修改的SQL语句
db.execSQL(sql);//执行修改
①使用SQLiteDatabase 对象的delete()方法。
String whereClause = &username=?&;//删除的条件
String[] whereArgs = {&finch&};//删除的条件参数
db.delete(&user&,whereClause,whereArgs);//执行删除
②使用execSQL方式的实现
String sql = &delete from user where username=&finch&;//删除操作的SQL语句
db.execSQL(sql);//执行删除操作
①使用 rawQuery() 直接调用 SELECT 语句
Cursor c = db.rawQuery(&select * from user where username=?&,new Stirng[]{&finch&});
if(cursor.moveToFirst()) {
String password = c.getString(c.getColumnIndex(&password&));
返回值是一个 cursor 对象，这个对象的方法可以迭代查询结果。
如果查询是动态的，使用这个方法就会非常复杂。例如，当你需要查询的列在程序编译的时候不能确定，这时候使用 query() 方法会方便很多。
②通过query实现查询
　　query() 方法用 SELECT 语句段构建查询。
　　SELECT 语句内容作为 query() 方法的参数，比如：要查询的表名，要获取的字段名，WHERE 条件，包含可选的位置参数，去替代 WHERE 条件中位置参数的值，GROUP BY 条件，HAVING 条件。
　　除了表名，其他参数可以是 null。所以代码可写成：
Cursor c = db.query(&user&,null,null,null,null,null,null);//查询并获得游标
if(c.moveToFirst()){//判断游标是否为空
for(int i=0;i
不管你如何执行查询，都会返回一个 Cursor，这是 Android 的 SQLite 数据库游标，使用游标，你可以：　　
通过使用 getCount() 方法得到结果集中有多少记录；　
通过 moveToFirst(), moveToNext(), 和 isAfterLast() 方法遍历所有记录；
通过 getColumnNames() 得到字段名；
通过 getColumnIndex() 转换成字段号；
通过 getString()，getInt() 等方法得到给定字段当前记录的值；
通过 requery() 方法重新执行查询得到游标；
通过 close() 方法释放游标资源；
例如，下面代码遍历 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();
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467142',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'}