使用的是sqlite，想问一下更新一列的多个数值怎么写应该_sql吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：34,166贴子：
使用的是sqlite，想问一下更新一列的多个数值怎么写应该收藏
RT，比如表明为train，列名为axis和id，现在有78行，id自动生成到了78号，而axis的每一行都有不同的值，比如‘，....，2317’，数据没有规律，我想问怎样把这些数据一条语句就能更新到表中呢？
登录百度帐号推荐应用
为兴趣而生，贴吧更懂你。或SQLite保存数据 和更新显示 - 开源中国社区
当前访客身份：游客 [
当前位置：
发布于 日 16时,
SQLite保存数据&和更新显示
代码片段(1)
1.&[代码][其他]代码&&&&
package com.example.
import java.io.FileNotFoundE
import java.io.InputS
import java.io.OutputS
import java.util.L
import com.dao.ProductD
import com.entity.P
import android.os.B
import android.app.A
import android.content.I
import android.content.SharedP
import android.content.SharedPreferences.E
import android.view.M
import android.view.V
import android.view.ViewG
import android.view.View.OnClickL
import android.widget.BaseA
import android.widget.B
import android.widget.EditT
import android.widget.TextV
import android.widget.T
public class MainActivity extends Activity {
private EditText edtname,edtprice,edtcount,
private Button btnSave,btnS
private ProductD
List&Product& proL
public void init(){
edtname=(EditText) findViewById(R.id.edtname);
edtprice=(EditText) findViewById(R.id.edtprice);
edtcount=(EditText) findViewById(R.id.edtcount);
edtaddress=(EditText) findViewById(R.id.edtaddress);
btnSave=(Button) findViewById(R.id.btnSave);
btnSelect=(Button) findViewById(R.id.btnSelect);
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
dao=new ProductDao(getApplicationContext(), null, null, 0);
btnSave.setOnClickListener(new OnClickListener() {
public void onClick(View arg0) {
product=new Product();
product.setProName(edtname.getText().toString());
product.setProPrice(Float.parseFloat(edtprice.getText().toString()));
product.setProCount(Integer.parseInt(edtcount.getText().toString()));
product.setProAddr(edtaddress.getText().toString());
dao.add(product);
Toast toast=Toast.makeText(getApplicationContext(), "保存成功", 2000);
toast.show();
btnSelect.setOnClickListener(new OnClickListener() {
public void onClick(View arg0) {
Intent intent=new Intent();
intent.setClass(getApplicationContext(), SelectActivity.class);
startActivity(intent);
package com.example.
import java.util.ArrayL
import java.util.L
import junit.runner.V
import com.dao.ProductD
import com.entity.P
import android.app.A
import android.content.I
import android.opengl.V
import android.os.B
import android.util.L
import android.view.V
import android.view.View.*;
import android.view.ViewG
import android.widget.BaseA
import android.widget.B
import android.widget.LinearL
import android.widget.ListV
import android.widget.TextV
import android.widget.T
public class SelectActivity extends Activity {
private ListV
private ProductD
private List&Product& proL
private MyA
public void init(){
listinfo=(ListView) findViewById(R.id.listinfo);
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.selectinfo);
dao=new ProductDao(getApplicationContext(), null, null, 1);
adapter=new MyAdapter();
listinfo.setAdapter(adapter);
public class MyAdapter extends BaseAdapter{
public int getCount() {
// TODO Auto-generated method stub
proList=dao.query();
return proList.size();
public Object getItem(int arg0) {
// TODO Auto-generated method stub
public long getItemId(int arg0) {
// TODO Auto-generated method stub
public View getView(int arg0, View arg1, ViewGroup arg2) {
// TODO Auto-generated method stub
View v=getLayoutInflater().inflate(R.layout.item, null);
TextView txtid=(TextView) v.findViewById(R.id.txtid);
TextView txtname=(TextView) v.findViewById(R.id.txtname);
TextView txtprice=(TextView) v.findViewById(R.id.txtprice);
TextView txtcount=(TextView) v.findViewById(R.id.txtcount);
TextView txtaddresss=(TextView) v.findViewById(R.id.txtaddresss);
Button but1=(Button)v.findViewById(R.id.but1);
Button but2=(Button)v.findViewById(R.id.but2);
final Product
product=proList.get(arg0);
txtid.setText(product.get_id()+"");
txtname.setText(product.getProName()+"");
txtprice.setText(product.getProPrice()+"");
txtcount.setText(product.getProCount()+"");
txtaddresss.setText(product.getProAddr()+"");
//txtid.setVisibility(View.INVISIBLE);
but1.setOnClickListener(new OnClickListener() {
public void onClick(View arg0) {
Toast toast=Toast.makeText(getApplicationContext(), "正在删除"+product.getProName(), 1000);
toast.show();
dao.delById(product.get_id());
notifyDataSetChanged();
but2.setOnClickListener(new OnClickListener() {
public void onClick(View arg0) {
Intent intent=new Intent();
Bundle b=new Bundle();
b.putString("id", product.get_id()+"");
b.putString("proName", product.getProName()+"");
b.putString("proPrice", product.getProPrice()+"");
b.putString("proCoune", product.getProCount()+"");
b.putString("proAddr", product.getProAddr()+"");
intent.putExtras(b);
intent.setClass(getApplicationContext(), UpdateActivity.class);
startActivity(intent);
package com.example.
import java.util.L
import com.dao.ProductD
import com.entity.P
import android.app.A
import android.content.I
import android.os.B
import android.view.V
import android.view.View.OnClickL
import android.widget.B
import android.widget.EditT
public class UpdateActivity extends Activity {
private EditText edtname,edtprice,edtcount,
private Button btnSave,btnS
private ProductD
List&Product& proL
public void init(){
edtname=(EditText) findViewById(R.id.etname);
edtprice=(EditText) findViewById(R.id.etprice);
edtcount=(EditText) findViewById(R.id.etcount);
edtaddress=(EditText) findViewById(R.id.etaddress);
btnSave=(Button) findViewById(R.id.bnSave);
btnSelect=(Button) findViewById(R.id.bnSelect);
private void show() {
// TODO Auto-generated method stub
Bundle bundle=this.getIntent().getExtras();
String name=bundle.getString("proName");
proList=dao.queryByName(name);
edtname.setText(proList.get(0).getProName());
edtprice.setText(proList.get(0).getProName());
edtcount.setText(proList.get(0).getProCount());
edtaddress.setText(proList.get(0).getProAddr());
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.update);
dao=new ProductDao(this, null, null, 0);
btnSave.setOnClickListener(new OnClickListener() {
public void onClick(View arg0) {
// TODO Auto-generated method stub
product=new Product();
product.setProName(edtname.getText().toString());
product.setProPrice(Float.parseFloat(edtprice.getText().toString()));
product.setProCount(Integer.parseInt(edtcount.getText().toString()));
product.setProAddr(edtaddress.getText().toString());
dao.updateByName(product);
btnSelect.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
// TODO Auto-generated method stub
startActivity(new Intent(UpdateActivity.this,SelectActivity.class));
package com.
public class Product {
private int _
private String proN
private double proP
private int proC
private String proA
public int get_id() {
public void set_id(int _id) {
this._id = _
public String getProName() {
return proN
public void setProName(String proName) {
this.proName = proN
public double getProPrice() {
return proP
public void setProPrice(double proPrice) {
this.proPrice = proP
public int getProCount() {
return proC
public void setProCount(int proCount) {
this.proCount = proC
public String getProAddr() {
return proA
public void setProAddr(String proAddr) {
this.proAddr = proA
package com.
import java.util.ArrayL
import java.util.L
import com.entity.P
import android.content.C
import android.database.C
import android.database.sqlite.SQLiteD
import android.database.sqlite.SQLiteDatabase.CursorF
import android.database.sqlite.SQLiteOpenH
public class ProductDao extends SQLiteOpenHelper{
private static final String DataName="data.db";
private static final int VERSIN=1;
public ProductDao(Context context, String name, CursorFactory factory,
int version) {
super(context, DataName, factory, VERSIN);
// TODO Auto-generated constructor stub
public void onCreate(SQLiteDatabase db) {
// TODO Auto-generated method stub
String sqlstr="create table Product(_id integer primary key autoincrement," +
"proName text,proPrice real,proCount integer,proAddr text)";
String sql0="create table product(_id int identity(1,1)
primary key ,proName varchar(20),proPrice double,proCount int,proAddr varchar(20))";
String sql2="CREATE TABLE [product]("
+"[_id] AUTOINC,"
+"[proName] varchar(20) not null on conflict fail,"
+"[proPrice] double"
+"[proCount] int"
+"[proAddr] varchar(20)"
+"constraint[sqllite_autoindex_t_contacts_1 primary key([_id]))";
String sql = "create table product(_id integer primary key autoincrement," +
"proName text,proPrice real,proCount integer,proAddr text)";
db.execSQL(sqlstr);
public void onUpgrade(SQLiteDatabase db, int arg1, int arg2) {
// TODO Auto-generated method stub
String sql="drop table if exists product";
db.execSQL(sql);
db.close();
public void add(Product p){
String sql="insert into product(proName,proPrice,proCount,proAddr) values(?,?,?,?)";
SQLiteDatabase db=getWritableDatabase();
db.execSQL(sql, new Object[]{
p.getProName(),
p.getProPrice(),
p.getProCount(),
p.getProAddr()
db.close();
//通过id删
public void delById(int id){
String sql="delete from product where _id =?";
SQLiteDatabase db=getWritableDatabase();
db.execSQL(sql, new Object[]{id});
db.close();
public List&Product& query(){
List&Product& list=new ArrayList&Product&();
String sql="select * from product";
SQLiteDatabase db=getReadableDatabase();
Cursor cursor=db.rawQuery(sql,null);
while(cursor.moveToNext()){
Product p=new Product();
p.set_id(cursor.getInt(0));
p.setProName(cursor.getString(1));
p.setProPrice(cursor.getDouble(2));
p.setProCount(cursor.getInt(3));
p.setProAddr(cursor.getString(4));
list.add(p);
db.close();
cursor.close();
//通过proname删除
public void delbyName(String proName) {
String sql="delete from product where proName =?";
SQLiteDatabase db=getWritableDatabase();
db.execSQL(sql, new Object[]{proName});
db.close();
//通过proName更新
public void updateByName(Product p){
String sql="update product set proPrice=?,proCount=?,proAddr=? where proName = ?";
SQLiteDatabase db=getWritableDatabase();
db.execSQL(sql, new Object[]{
p.getProPrice(),
p.getProCount(),
p.getProAddr(),
p.getProName(),
db.close();
//通过name查
public List&Product& queryByName(String name){
List&Product& list=new ArrayList&Product&();
String sql="select * from product";
SQLiteDatabase db=getReadableDatabase();
Cursor cursor=db.rawQuery(sql,new String []{name});
while(cursor.moveToNext()){
Product p=new Product();
p.set_id(cursor.getInt(0));
p.setProName(cursor.getString(1));
p.setProPrice(cursor.getDouble(2));
p.setProCount(cursor.getInt(3));
p.setProAddr(cursor.getString(4));
list.add(p);
db.close();
cursor.close();
开源中国-程序员在线工具：
相关的代码(166)
0回/1296阅
开源从代码分享开始
不知不觉就这样的其它代码Android SQLite 数据库升级代码怎么写
前言：最近苦思冥想一个问题，热爱技术的人怎么能够在一个充满规章制度的氛围里好好的生存下去并能初心不改呢？这就像为啥拍一集电视剧的报酬就是你好几年的收入一样，毕竟现实就是这么个情况，想不明白就来写写文章吧。
不登高山不知天之大，不临深谷不知地之厚。
在升级时，不同的数据库版本表结构是不同的，那么怎么确保数据库升级后用户的数据不会丢失呢?比如 V1.0表A有10列，V1.1由于业务需求表A需要增加两列，在升级时我们该怎么做?
二、传统写法
* @author lh
* @deprecated
public class DBHelper extends SQLiteOpenHelper {
private static final String DB_NAME = &video.db&;//数据库名
private static final int DB_VERSION = 1;//数据库当前版本号
public DBHelper(Context context) {
super(context, DB_NAME, null, DB_VERSION);
public void onCreate(SQLiteDatabase db) {
//第一次安装app会执行这个方法
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
//数据库版本升级时会执行这个方法
//第一步将表A重命名为temp_A
//第二步创建新表A,此时表结构已加了2列
//第三步讲temp_A表中的数据插入到表A
//第四步删除临时表temp_A
代码很简单，但是这样就真解决问题了吗？数据库从1升级到2要写一个业务变化，从2升级到3也要写一个业务变化，那是否考虑过数据库版本从1升级到3应该先升级到2再升级到3这种情况呢？不论正确与否，这种写法毫无扩展性可言，每次表结构发生变化都要改动这个类。下面看下模板写法。
三、模板写法
* @author lh
public class DBHelper extends SQLiteOpenHelper {
private static final String DB_NAME = &video.db&;
private static final int DB_VERSION = VersionFactory.getCurrentDBVersion();
private static volatile DBHelper instance =
private DBHelper(Context context) {
super(context, DB_NAME, null, DB_VERSION);
public static DBHelper getDBHelper(Context context) {
if (instance == null) {
synchronized (DBHelper.class) {
if (instance == null)
instance = new DBHelper(context);
public void onCreate(SQLiteDatabase db) {
/**创建视频信息表*/
db.execSQL(SqlUtil.createSqlForVideo());
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
update(db, oldVersion, newVersion);
* 数据库版本递归更新
* @param oldVersion 数据库当前版本号
* @param newVersion 数据库升级后的版本号
* @author lh
* @retrun void
public static void update(SQLiteDatabase db, int oldVersion, int newVersion) {
Upgrade upgrade =
if (oldVersion & newVersion) {
oldVersion++;
upgrade = VersionFactory.getUpgrade(oldVersion);
if (upgrade == null) {
upgrade.update(db);
update(db, oldVersion, newVersion);
DBHelper.update方法是一个递归实现，主要是解决数据库跨版本升级。下面看一下Upgrade类
* @author lh
public abstract class Upgrade {
public abstract void update(SQLiteDatabase db);
Upgrade是一个抽象类，就定义了一个数据库升级的方法update(SQLiteDatabase db)，以后数据库版本每升级一次，就创建一个子类继承Upgrade类，实现update方法，在方法内执行你的业务逻辑，比如表结构变更;
接着我们来看一下工厂类VersionFactory,他的作用就是提供一个工厂方法构建对象。
原始工厂写法：
* @author lh
* @deprecated
public class VersionFactory {
* 根据数据库版本号获取对象
* @param i
* @return upgrade
public static Upgrade getUpgrade(int i) {
Upgrade upgrade =
switch (i) {
upgrade = new VersionSecond();
upgrade = new VersionThird();
upgrade = new VersionFourth();
这样写虽然达到了分别创建对象的效果，但是每次升级还是要来修改这个类，我就遇到一次，我同事在写分支语句的时候漏掉了break,导致对象创建出错，从而对应版本号的数据库升级逻辑未能执行导致app升级安装出错。自那以后我就决定要优化这玩意儿，减少出错的风险。我先贴一个Upgrade的实现类VersionSecond帮助大家理解
* @author lh
public class VersionSecond extends Upgrade {
public void update(SQLiteDatabase db) {
//数据库版本升级时会执行这个方法
//第一步将表A重命名为temp_A
//第二步创建新表A,此时表结构已加了2列
//第三步讲temp_A表中的数据插入到表A
//第四步删除临时表temp_A
紧接着我们来看一下优化后的工厂模式写法
* @author lh
public class VersionFactory {
* 根据数据库版本号获取对应的对象
* @param i
public static Upgrade getUpgrade(int i) {
Upgrade upgrade =
// List<class& list = ClassUtil.getClasses(&com.upsoft.ep.app.module.dbupdate&);
if (null != list && list.size() & 0) {
for (String className : list) {
Class cls =
cls = Class.forName(className);
if (Upgrade.class == cls.getSuperclass()) {
VersionCode versionCode = cls.getAnnotation(VersionCode.class);
if (null == versionCode) {
throw new IllegalStateException(cls.getName() + &类必须使用VersionCode类注解&);
if (i == versionCode.value()) {
upgrade = (Upgrade) cls.newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
throw new IllegalStateException(&没有找到类名,请检查list里面添加的类名是否正确！&);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
static Set list = new LinkedHashSet&&();
list.add(&com.upsoft.ep.app.module.dbupdate.VersionSecond&);
list.add(&com.upsoft.ep.app.module.dbupdate.VersionThird&);
list.add(&com.upsoft.ep.app.module.dbupdate.VersionFourth&);
list.add(&com.upsoft.ep.app.module.dbupdate.VersionFifth&);
* 得到当前数据库版本
public static int getCurrentDBVersion() {
return list.size() + 1;
先看getUpgrade方法，我注释了一句代码
// List<class& list = ClassUtil.getClasses(&com.upsoft.ep.app.module.dbupdate&);</class
这句代码的作用是获取包名下的所有java文件，试想一下，数据库表结构发生更新，我们就创建一个对应的Upgrade的子类去实现数据库操作的相关逻辑，而这个子类是在固定的包名下进行创建，我们如果获取了这个包的所有java文件，就意味着我们获取到了数据库更新的次数，这个次数再加上1是不是就是我们当前的数据库版本号呢？如果是这样，那么我们的数据库版本号就做到了根据算法自动叠加，想想就有点小激动呢~我可以负责任的告诉大家答案就是这样的。不过：
android毕竟是android,包建强（App研发录作者，10几年移动开发经验）说过程序员做不好，Java程序员也做不好Android,因为各自都有自己的一套规则，不深入是不能够理解的。当然也不排除有全能的~
在Java里是可以获取到某个包名下的java文件，但是在Android里却不行，因为Android把java文件编译成了dex文件，所以运行时状态下就不存在这样的文件了，这也是我注释掉这句代码的原因，因为没用，获取到的永远都为空~~~
接着往下看：
遍历存放Upgrade子类全路径的集合，
通过反射的方式获取类对象
判断是否是Upgrade的子类
接着获取VersionCode注解
VersionCode versionCode = cls.getAnnotation(VersionCode.class);
我们来看看VersionCode是个什么鬼？
* @author lh
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface VersionCode {
int value() default 1;
该注解的作用是定义Upgrade子类的数据库版本号，在子类使用，例如：
* @author lh
@VersionCode(2)
public class VersionSecond extends Upgrade {
public void update(SQLiteDatabase db) {
//数据库版本升级时会执行这个方法
//第一步将表A重命名为temp_A
//第二步创建新表A,此时表结构已加了2列
//第三步讲temp_A表中的数据插入到表A
//第四步删除临时表temp_A
回到getUpdate方法
获取到Update子类的注解后，我们将其和传入的数据库版本号进行比较，如果相等，则返回该对象，否则继续遍历直到获取到正确的对象为止。
if (Upgrade.class == cls.getSuperclass()) {
VersionCode versionCode = cls.getAnnotation(VersionCode.class);
if (null == versionCode) {
throw new IllegalStateException(cls.getName() + &类必须使用VersionCode类注解&);
if (i == versionCode.value()) {
upgrade = (Upgrade) cls.newInstance();
getCurrentDBVersion这个方法就比较简单，直接返回的Upgrade子类列表的数量加1作为数据库的当前版本号
本版本实现的优势：
1、首先采用了单例模式，如果不懂什么单例以及线程安全请自行google。
2、采用递归的方式解决了数据库跨越升级的问题
3、采用工厂模式达到了易扩展
4、采用注解和反射优化了工厂模式的短板
5、数据库当前的版本也是由VersionFactory.getCurrentDBVersion()动态获得，再也不用担心数据库升级直接操作DBHelper类导致的代码错误风险。
另每次创建Upgrade子类都需要添加到list列表里面去，这样的话还是会修改到VersionFactory类（虽然做了异常检查处理），你们具体实现的时候可以做成可配置的比如写在XML文件里，使用时进行XML解析即可。
那眼尖的童鞋又会问Android里不是应该少用注解吗？会影响性能~我可以放心的告诉大家，经过测试，我模拟了200次的数据库更新操作，用正常的方式实现和用反射+注解的方式实现相差时间在毫秒级别（10毫秒左右），基本可以忽略。
(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'2015年7月 移动开发大版内专家分月排行榜第二2015年5月 移动开发大版内专家分月排行榜第二
2015年7月 扩充话题大版内专家分月排行榜第三2015年5月 扩充话题大版内专家分月排行榜第三
2014年6月 移动开发大版内专家分月排行榜第一2014年3月 移动开发大版内专家分月排行榜第一
2014年11月 移动开发大版内专家分月排行榜第二2014年4月 移动开发大版内专家分月排行榜第二2014年2月 移动开发大版内专家分月排行榜第二
匿名用户不能发表回复！|
每天回帖即可获得10分可用分！小技巧：
你还可以输入10000个字符
(Ctrl+Enter)
请遵守CSDN，不得违反国家法律法规。
转载文章请注明出自“CSDN（www.csdn.net）”。如是商业用途请联系原作者。