码迷，mamicode.com
首页 > 数据库 > 详细

5.数据库

时间：2015-10-26 15:28:02      阅读：280      评论：0      收藏：0      [点我收藏+]

标签：

数据库的操作

  • 创建数据库create database mydb ;
  • 查看创建数据库的语句show create database mydb ;
  • 改变当前的数据库use mydb ;
  • 删除数据库drop database mydb ;
  • 查看所有的数据库show databases ;
  • 修改数据库mydb1的字符集为utf8
  • alter database mydb1 character set utf8 ;

针对表的操作

  • 创建表t

create table t(
id int ,
name varchar(30)
) ;

  • 查看创建表的源码

show create table t ;

  • 创建表t1,使用字符集gbk

create table t1(
id int ,
name varchar(30)
)character set gbk ;


  • 插入数据

设置客户端的字符集为gbk
set character_set_client=gbk; 设置结果集的字符集为gbk
set character_set_results=gbk ;

insert into t4(id,name) values(1,‘张无忌‘) ;
insert t4(id,name) values(2,‘乔峰‘) ;
*省略字段，意味着所有的字段都必须给值(自增例外)
insert t4 values(3,‘杨过‘,‘2014-4-3‘) ;

  • 更新

将表t4的第三条记录姓名字段改为杨康
update t4 set name=‘杨康‘ where id = 3 ; 将所有记录的名字都改为东方不败
update t4 set name = ‘东方不败‘ ;
*修改多个字段
update t4 set id=6,name=‘萧峰‘ where id = 2 ;

  • 删除

delete from t4 where id = 4 ;
删除所有的记录
delete from t4 ; 删除所有的记录
truncate table t4 ;

  • 给表t4增加一个字段address

alter table t4 add address varchar(100) ;
*删除字段address
alter table t4 drop column address ;

  • 查找

查看所有数据
select from stu ;
查看小龙女的信息
select from stu where id = 2 ;
select from stu where name=‘小龙女‘ ;

 查看年龄在20~30之间的人
select from stu where age >=20 and age <=30 ;
select from stu where age between 20 and 30 ; # 包括20和30
查看所有的的姓名
select name from stu ; 

查看所有的的姓名,年龄，性别
select name,age,sex from stu ;


android中的数据库SQLite

  •  android中建立数据的过程：

      a)首先进行自定义一个类进行继承SQLiteOpenHelper,  因为如果继承SQLiteDatabase那么会，要覆盖其中的许多的方法。如果已经有数据库，就不需要sqliteopenhelper

     (1)MysqlLite(Context context, String name,  CursorFactory factory,int version)

        传入当前的应用环境,数据库的名称，游标的工厂,版本号,让底层为你进行创建数据库

     (2)oncreate(SQLiteDatabase db):

      当数据库创建好之后进行运行的函数，主要是在数据库创建好之后进行创建表

  1. 	db.execSQL("create table person(_id integer primary key autoincrement, name char(10), salary char(20), phone integer(20))");

书上：

 integer表示整型，real表示浮点型，text表示文本类型，blob表示二进制类型。另外， primary key将 id列设为主键，并用 autoincrement关键字表示 id列是自增长的。

  1. public static final String CREATE_BOOK = "create table book ("
  2. + "id integer primary key autoincrement, "
  3. + "author text, "
  4. + "price real, "
  5. + "pages integer, "
  6. + "name text)";

(3)onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion):

       当数据库进行更新后需要进行执行的函


       b)使用测试类进行测试创建数据库：

  1. public class TestCase extends AndroidTestCase {
  3. 	//此时测试框架还没有初始化完毕，没有虚拟上下文对象，所以不能写在这里
  4. //	private MyOpenHelper oh = new MyOpenHelper(getContext(), "people.db", null, 1);
  5. 	private MyOpenHelper oh;
  6. 	private SQLiteDatabase db;
  7. 	public void test(){
  8. 		//getContext():获取一个虚拟的上下文
  9. 		MyOpenHelper oh = new MyOpenHelper(getContext(), "people.db", null, 1);
  10. 		//如果数据库不存在，先创建数据库，再获取可读可写的数据库对象，如果数据库存在，就直接打开，增删改用这个
  11. 		SQLiteDatabase db = oh.getWritableDatabase();
  12. 		//如果存储空间满了，那么返回只读数据库对象，查询时用这个
  13. //		SQLiteDatabase db = oh.getReadableDatabase();
  14. 	}
  15. 	
  16. 	//测试框架初始化完毕之后，在测试方法执行之前，此方法调用，这样就不需要每个测试方法都创建数据库
  17. 	@Override
  18. 	protected void setUp() throws Exception {
  19. 		super.setUp();
  20. 		oh = new MyOpenHelper(getContext(), "people.db", null, 1);
  21. 		db = oh.getWritableDatabase();
  22. 	}
  24. 	//测试方法执行完毕之后，此方法调用
  25. 	@Override
  26. 	protected void tearDown() throws Exception {
  27. 		// TODO Auto-generated method stub
  28. 		super.tearDown();
  29. 		db.close();
  30. 	}
  31. 	
  32. 	public void insert(){
  33. 	//SQLite其实是不检测数据类型的，全部是字符串，加不加引号都无所谓，定义类型只不过给程序员看的
  34. //		db.execSQL("insert into person (name, salary, phone)values(?, ?, ?)", new Object[]{"小志的老婆[1]", "13000", 138438});
  35. //		db.execSQL("insert into person (name, salary, phone)values(?, ?, ?)", new Object[]{"小志的儿子", 14000, "13888"});
  36. 		db.execSQL("insert into person (name, salary, phone)values(?, ?, ?)", new Object[]{"小志", 14000, "13888"});
  37. 	}
  38. 	
  39. 	public void delete(){
  40. 		db.execSQL("delete from person where name = ?", new Object[]{"小志"});
  41. 	}
  42. 	
  43. 	public void update(){
  44. 		db.execSQL("update person set phone = ? where name = ?", new Object[]{186666, "小志的儿子"});
  45. 	}
  46. 	
  47. 	public void select(){
  48. 		Cursor cursor = db.rawQuery("select name, salary from person", null);
  49. 		
  50. 		while(cursor.moveToNext()){
  51. 			//通过列索引获取列的值，标准是第一种的写法
  52. 			String name = cursor.getString(cursor.getColumnIndex("name"));
  53. 			String salary = cursor.getString(1);
  54. 			System.out.println(name + ";" + salary);
  55. 		}
  56. 	}
  57. 	
  58. 	public void insertApi(){
  59. 		//把要插入的数据全部封装至ContentValues对象
  60. 		ContentValues values = new ContentValues();
  61. 		values.put("name", "游天龙");
  62. 		values.put("phone", "15999");
  63. 		values.put("salary", 16000);
  64. 		db.insert("person", null, values);
  65. 	}
  66. 	
  67. 	public void deleteApi(){
  68. 		int i = db.delete("person", "name = ? and _id = ?", new String[]{"小志的儿子", "3"});
  69. 		System.out.println(i);
  70. 	}
  71. 	
  72. 	public void updateApi(){
  73. 		ContentValues values = new ContentValues();
  74. 		values.put("salary", 26000);
  75. 		int i = db.update("person", values, "name = ?", new String[]{"游天龙"});
  76. 		System.out.println(i);
  77. 	}
  78. 这里使用了第三、第四个参数来指定具体更新哪几行。第三个参数对应的是 SQL语句的 where部分，表示去更新所有 name等于?
的行，而?是一个占位符，可以通过第四个参数提供的一个字符串数组为第三个参数中的每个占位符指定相应的内容。因此上述代码想表达的意图就是，将名字是游天龙的工资改成 2600。
  79. 	
  80. 	public void selectApi(){
  81. 		Cursor cursor = db.query("person", null, null, null, null, null, null, null);
  82. 		while(cursor.moveToNext()){
  83. 			String name = cursor.getString(cursor.getColumnIndex("name"));
  84. 			String phone = cursor.getString(cursor.getColumnIndex("phone"));
  85. 			String salary = cursor.getString(cursor.getColumnIndex("salary"));
  86. 			System.out.println(name + ";" + phone + ";" + salary);
  87. 		}
  88. 	}
  89. 	
  90. 	public void transaction(){
  91. 		try{
  92. 			//开启事务
  93. 			db.beginTransaction();
  94. 			ContentValues values = new ContentValues();
  95. 			values.put("salary", 12000);
  96. 			db.update("person", values, "name = ?", new String[]{"小志"});
  97. 			
  98. 			values.clear();
  99. 			values.put("salary", 16000);
  100. 			db.update("person", values, "name = ?", new String[]{"小志的儿子"});
  101. 			
  102. 			int i = 3/0;//加上这句就不会执行成功
  103. 			//设置  事务执行成功
  104. 			db.setTransactionSuccessful();
  105. 		}
  106. 		finally{
  107. 			//关闭事务，同时提交，如果已经设置事务执行成功，那么sql语句就生效了，反之，sql语句回滚
  108. 			db.endTransaction();
  109. 		}
  110. 	}
  111. }

分页查询

  Cursor cs = db.query("person", null, null, null, null, null, null, "0, 10"）；

query最短的一个方法重载也需要传入七个参数。第一个参数是表名，表示希望从哪张表中查
询数据。第二个参数用于指定去查询哪几列，如果不指定则默认查询所有列。第三、第四个参数用于去约束查
询某一行或某几行的数据，不指定则默认是查询所有行的数据。第五个参数用于指定需要去 group by的列，
不指定则表示不对查询结果进行 group by操作。第六个参数用于对group by之后的数据进行进一步的过滤，
不指定则表示不进行过滤。第七个参数用于指定查询结果的排序方式，不指定则表示使用默认的排序方式

总结：这个数据SQLiteOpenHelper类和SQLiteDatabase什么关系；

      主要是通过SQLiteOpenHelper类进行创建SQLiteDatabase类。如果有数据库就不需要这个SQLiteOpenHelper类了

  注意：

          在SQLiteOpenHelper的实现的类中注意创建表的时候名称和你实现插入数据时的表的名称一致性。

  

  1. //这样就写死
  2. public class MyOpenHelper extends SQLiteOpenHelper {
  4. 	public MyOpenHelper(Context context) {
  5. 		super(context, "people.db", null, 1);
  6. 		// TODO Auto-generated constructor stub
  7. 	}
  8. //再其他方法中
  9. 	oh = new MyOpenHelper(getContext());
总结：
添加数据的方法如下：
db.execSQL("insert into Book (name, author, pages, price) values(?, ?, ?, ?)",
new String[] { "The Da Vinci Code", "Dan Brown", "454", "16.96" });
db.execSQL("insert into Book (name, author, pages, price) values(?, ?, ?, ?)",
new String[] { "The Lost Symbol", "Dan Brown", "510", "19.95" });
更新数据的方法如下：
db.execSQL("update Book set price = ? where name = ?", new String[] { "10.99",
"The Da Vinci Code" });
删除数据的方法如下：
db.execSQL("delete from Book where pages > ?", new String[] { "500" });
查询数据的方法如下：
db.rawQuery("select * from Book", null);
可以看到，除了查询数据的时候调用的是 SQLiteDatabase的 rawQuery()方法，其他的操作都是调用的 execSQL()方法。
数据库常用操作
用到数据库就要想到
  1. 数据库单例，保证只要一个实例
  2. 定义javaben对象
  3. 将Javaben对象存到数据库
  4. 从数据库读取
实例：
CoolWeatherOpenHelper
  1. public class CoolWeatherOpenHelper extends SQLiteOpenHelper {
  2. 	/**
  3. 	 * Province表建表语句
  4. 	 */
  5. 	public static final String CREATE_PROVINCE = "create table Province ("
  6. 			+ "id integer primary key autoincrement, " + "province_name text, "
  7. 			+ "province_code text)";
  8. 	/**
  9. 	 * City表建表语句
  10. 	 */
  11. 	public static final String CREATE_CITY = "create table City ("
  12. 			+ "id integer primary key autoincrement, " + "city_name text, "
  13. 			+ "city_code text, " + "province_id integer)";
  14. 	/**
  15. 	 * County表建表语句
  16. 	 */
  17. 	public static final String CREATE_COUNTY = "create table County ("
  18. 			+ "id integer primary key autoincrement, " + "county_name text, "
  19. 			+ "county_code text, " + "city_id integer)";
  21. 	public CoolWeatherOpenHelper(Context context, String name,
  22. 			CursorFactory factory, int version) {
  23. 		super(context, name, factory, version);
  24. 	}
  26. 	@Override
  27. 	public void onCreate(SQLiteDatabase db) {
  28. 		db.execSQL(CREATE_PROVINCE); // 创建Province表
  29. 		db.execSQL(CREATE_CITY); // 创建City表
  30. 		db.execSQL(CREATE_COUNTY); // 创建County表
  31. 	}
  33. 	@Override
  34. 	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
  35. 	}
CoolWeatherDB 
  1. public class CoolWeatherDB {
  2. 	/**
  3. 	 * 数据库名
  4. 	 */
  5. 	public static final String DB_NAME = "cool_weather";
  6. 	/**
  7. 	 * 数据库版本
  8. 	 */
  9. 	public static final int VERSION = 1;
  10. 	private static CoolWeatherDB coolWeatherDB;
  11. 	private SQLiteDatabase db;
  13. 	/**
  14. 	 * 将构造方法私有化
  15. 	 */
  16. 	private CoolWeatherDB(Context context) {
  17. 		CoolWeatherOpenHelper dbHelper = new CoolWeatherOpenHelper(context,
  18. 				DB_NAME, null, VERSION);
  19. 		db = dbHelper.getWritableDatabase();
  20. 	}
  22. 	/**
  23. 	 * 获取CoolWeatherDB的实例。
  24. 	 */
  25. 	public synchronized static CoolWeatherDB getInstance(Context context) {
  26. 		if (coolWeatherDB == null) {
  27. 			coolWeatherDB = new CoolWeatherDB(context);
  28. 		}
  29. 		return coolWeatherDB;
  30. 	}
  32. 	/**
  33. 	 * 将Province实例存储到数据库。
  34. 	 */
  35. 	public void saveProvince(Province province) {
  36. 		if (province != null) {
  37. 			ContentValues values = new ContentValues();
  38. 			values.put("province_name", province.getProvinceName());
  39. 			values.put("province_code", province.getProvinceCode());
  40. 			db.insert("Province", null, values);
  41. 		}
  42. 	}
  44. 	/**
  45. 	 * 从数据库读取全国所有的省份信息。
  46. 	 */
  47. 	public List<Province> loadProvinces() {
  48. 		List<Province> list = new ArrayList<Province>();
  49. 		Cursor cursor = db
  50. 				.query("Province", null, null, null, null, null, null);
  51. 		if (cursor.moveToFirst()) {
  52. 			do {
  53. 				Province province = new Province();
  54. 				province.setId(cursor.getInt(cursor.getColumnIndex("id")));
  55. 				province.setProvinceName(cursor.getString(cursor
  56. 						.getColumnIndex("province_name")));
  57. 				province.setProvinceCode(cursor.getString(cursor
  58. 						.getColumnIndex("province_code")));
  59. 				list.add(province);
  60. 			} while (cursor.moveToNext());
  61. 		}
  62. 		return list;
  63. 	}
  65. 	/**
  66. 	 * 将City实例存储到数据库。
  67. 	 */
  68. 	public void saveCity(City city) {
  69. 		if (city != null) {
  70. 			ContentValues values = new ContentValues();
  71. 			values.put("city_name", city.getCityName());
  72. 			values.put("city_code", city.getCityCode());
  73. 			values.put("province_id", city.getProvinceId());
  74. 			db.insert("City", null, values);
  75. 		}
  76. 	}
  78. 	/**
  79. 	 * 从数据库读取某省下所有的城市信息。
  80. 	 */
  81. 	public List<City> loadCities(int provinceId) {
  82. 		List<City> list = new ArrayList<City>();
  83. 		Cursor cursor = db.query("City", null, "province_id = ?",
  84. 				new String[] { String.valueOf(provinceId) }, null, null, null);//如果全是null，那么查的是所有的数据，比如get(xx)查出来的是所有这列的数据，如果想根据xx去查询的话就需要这样写
  85. 		if (cursor.moveToFirst()) {
  86. 			do {
  87. 				City city = new City();
  88. 				city.setId(cursor.getInt(cursor.getColumnIndex("id")));
  89. 				city.setCityName(cursor.getString(cursor
  90. 						.getColumnIndex("city_name")));
  91. 				city.setCityCode(cursor.getString(cursor
  92. 						.getColumnIndex("city_code")));
  93. 				city.setProvinceId(provinceId);
  94. 				list.add(city);
  95. 			} while (cursor.moveToNext());
  96. 		}
  97. 		return list;
  98. 	}
  100. 	/**
  101. 	 * 将County实例存储到数据库。
  102. 	 */
  103. 	public void saveCounty(County county) {
  104. 		if (county != null) {
  105. 			ContentValues values = new ContentValues();
  106. 			values.put("county_name", county.getCountyName());
  107. 			values.put("county_code", county.getCountyCode());
  108. 			values.put("city_id", county.getCityId());
  109. 			db.insert("County", null, values);
  110. 		}
  111. 	}
  113. 	/**
  114. 	 * 从数据库读取某城市下所有的县信息。
  115. 	 */
  116. 	public List<County> loadCounties(int cityId) {
  117. 		List<County> list = new ArrayList<County>();
  118. 		Cursor cursor = db.query("County", null, "city_id = ?",
  119. 				new String[] { String.valueOf(cityId) }, null, null, null);
  120. 		if (cursor.moveToFirst()) {
  121. 			do {
  122. 				County county = new County();
  123. 				county.setId(cursor.getInt(cursor.getColumnIndex("id")));
  124. 				county.setCountyName(cursor.getString(cursor
  125. 						.getColumnIndex("county_name")));
  126. 				county.setCountyCode(cursor.getString(cursor
  127. 						.getColumnIndex("county_code")));
  128. 				county.setCityId(cityId);
  129. 				list.add(county);
  130. 			} while (cursor.moveToNext());
  131. 		}
  132. 		return list;
  133. 	}


升级数据库的最佳写法
  1. public void onCreate(SQLiteDatabase db) {
  2. db.execSQL(CREATE_BOOK);
  3. db.execSQL(CREATE_CATEGORY);
  4. Toast.makeText(mContext, "Create succeeded", Toast.LENGTH_SHORT).
  5. show();
  6. }
  7. public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
  8. db.execSQL("drop table if exists Book");
  9. db.execSQL("drop table if exists Category");
  10. onCreate(db);
  11. }
为了保证数据库中的表是最新的，只是简单地在 onUpgrade()方法中删除掉了当前所有的表，然后强制重新执行了
一遍 onCreate()方法。这种方式在产品的开发阶段确实可以用，但是当产品真正上线了之后就绝对不行了。想象以下
场景，比如你编写的某个应用已经成功上线，并且还拥有了不错的下载量。现在由于添加新功能的原因，使得数据库也
需要一起升级，然后用户更新了这个版本之后发现以前程序中存储的本地数据全部丢失了！那么很遗憾，你的用户群体
可能已经流失一大半了。
  1. public void onCreate(SQLiteDatabase db) {
  2. db.execSQL(CREATE_BOOK);
  3. db.execSQL(CREATE_CATEGORY);
  4. }
  5. @Override
  6. public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
  7. switch (oldVersion) {
  8. case 1:
  9. db.execSQL(CREATE_CATEGORY);
  10. default:
  11. }
在 onCreate()方法里新增了一条建表语句，然后又在 onUpgrade()方法中添加了一个 switch判断，如果用户当前数据库的版本号是 1，就只会创建一张 Category表。这样当用户是直接安装的第二版的程序时，就会将两张表一起创建。而当用户是使用第二版的程序覆盖安装第一版的程序时，就会进入到升级数据库的操作中，此时由于 Book表已经存在了，因此只需要创建一张 Category表即可

新的需求又来了，这次要给 Book表和 Category表之间建立关联，需要在 Book表中添加一个 category_id的字段
  1. ...oncreat方法和前面一样
  2. public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
  3. switch (oldVersion) {
  4. case 1:
  5. db.execSQL(CREATE_CATEGORY);
  6. case 2:
  7. db.execSQL("alter table Book add column category_id integer");
  8. default:
  9. }
  10. }
首先在 Book表的建表语句中添加了一个 category_id列，这样当用户直接安装第三版的程序时，这个新增的列就已经自动添加成功了。然而，如果用户之前已经安装了某一版本的程序，现在需要覆盖安装，就会进入到升级数据库的操作中。在 onUpgrade()方法里，添加了一个新的 case，如果当前数据库的版本号是 2，就会执行 alter命令来为Book表新增一个 category_id列。这里请注意一个非常重要的细节，switch中每一个 case的最后都是没有使用 break的，这是为了保证在跨版本升级的时候， 每一次的数据库修改都能被全部执行到。比如用户当前是从第二版程序升级到第三版程序的，那么 case 2中的逻辑就会执行。而如果用户是直接从第一版程序升级到第三版程序的，那么 case 1和 case 2中的逻辑都会执行。使用这种方式来维护数据库的升级，不管版本怎样更新，都可以保证数据库的表结构是最新的，而且表中的数据也完全不会丢失了。



   








5.数据库

标签：

原文地址：http://www.cnblogs.com/liuyu0529/p/4911083.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！