5.数据库

数据库的操作

  • 创建数据库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))");
    2.

书上：

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

    

  1. public static final String CREATE_BOOK = "create table book ("
    2. 

  2. + "id integer primary key autoincrement, "
    3. 

  3. + "author text, "
    4. 

  4. + "price real, "
    5. 

  5. + "pages integer, "
    6. 

  6. + "name text)";
    7.

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

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

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

    

  1. public class TestCase extends AndroidTestCase {
    2. 

    3. 

  3. 	//此时测试框架还没有初始化完毕，没有虚拟上下文对象，所以不能写在这里
    4. 

  4. //	private MyOpenHelper oh = new MyOpenHelper(getContext(), "people.db", null, 1);
    5. 

  5. 	private MyOpenHelper oh;
    6. 

  6. 	private SQLiteDatabase db;
    7. 

  7. 	public void test(){
    8. 

  8. 		//getContext():获取一个虚拟的上下文
    9. 

  9. 		MyOpenHelper oh = new MyOpenHelper(getContext(), "people.db", null, 1);
    10. 

  10. 		//如果数据库不存在，先创建数据库，再获取可读可写的数据库对象，如果数据库存在，就直接打开，增删改用这个
    11. 

  11. 		SQLiteDatabase db = oh.getWritableDatabase();
    12. 

  12. 		//如果存储空间满了，那么返回只读数据库对象，查询时用这个
    13. 

  13. //		SQLiteDatabase db = oh.getReadableDatabase();
    14. 

  14. 	}
    15. 

  15. 	
    16. 

  16. 	//测试框架初始化完毕之后，在测试方法执行之前，此方法调用，这样就不需要每个测试方法都创建数据库
    17. 

  17. 	@Override
    18. 

  18. 	protected void setUp() throws Exception {
    19. 

  19. 		super.setUp();
    20. 

  20. 		oh = new MyOpenHelper(getContext(), "people.db", null, 1);
    21. 

  21. 		db = oh.getWritableDatabase();
    22. 

  22. 	}
    23. 

    24. 

  24. 	//测试方法执行完毕之后，此方法调用
    25. 

  25. 	@Override
    26. 

  26. 	protected void tearDown() throws Exception {
    27. 

  27. 		// TODO Auto-generated method stub
    28. 

  28. 		super.tearDown();
    29. 

  29. 		db.close();
    30. 

  30. 	}
    31. 

  31. 	
    32. 

  32. 	public void insert(){
    33. 

  33. 	//SQLite其实是不检测数据类型的，全部是字符串，加不加引号都无所谓，定义类型只不过给程序员看的
    34. 

  34. //		db.execSQL("insert into person (name, salary, phone)values(?, ?, ?)", new Object[]{"小志的老婆[1]", "13000", 138438});
    35. 

  35. //		db.execSQL("insert into person (name, salary, phone)values(?, ?, ?)", new Object[]{"小志的儿子", 14000, "13888"});
    36. 

  36. 		db.execSQL("insert into person (name, salary, phone)values(?, ?, ?)", new Object[]{"小志", 14000, "13888"});
    37. 

  37. 	}
    38. 

  38. 	
    39. 

  39. 	public void delete(){
    40. 

  40. 		db.execSQL("delete from person where name = ?", new Object[]{"小志"});
    41. 

  41. 	}
    42. 

  42. 	
    43. 

  43. 	public void update(){
    44. 

  44. 		db.execSQL("update person set phone = ? where name = ?", new Object[]{186666, "小志的儿子"});
    45. 

  45. 	}
    46. 

  46. 	
    47. 

  47. 	public void select(){
    48. 

  48. 		Cursor cursor = db.rawQuery("select name, salary from person", null);
    49. 

  49. 		
    50. 

  50. 		while(cursor.moveToNext()){
    51. 

  51. 			//通过列索引获取列的值，标准是第一种的写法
    52. 

  52. 			String name = cursor.getString(cursor.getColumnIndex("name"));
    53. 

  53. 			String salary = cursor.getString(1);
    54. 

  54. 			System.out.println(name + ";" + salary);
    55. 

  55. 		}
    56. 

  56. 	}
    57. 

  57. 	
    58. 

  58. 	public void insertApi(){
    59. 

  59. 		//把要插入的数据全部封装至ContentValues对象
    60. 

  60. 		ContentValues values = new ContentValues();
    61. 

  61. 		values.put("name", "游天龙");
    62. 

  62. 		values.put("phone", "15999");
    63. 

  63. 		values.put("salary", 16000);
    64. 

  64. 		db.insert("person", null, values);
    65. 

  65. 	}
    66. 

  66. 	
    67. 

  67. 	public void deleteApi(){
    68. 

  68. 		int i = db.delete("person", "name = ? and _id = ?", new String[]{"小志的儿子", "3"});
    69. 

  69. 		System.out.println(i);
    70. 

  70. 	}
    71. 

  71. 	
    72. 

  72. 	public void updateApi(){
    73. 

  73. 		ContentValues values = new ContentValues();
    74. 

  74. 		values.put("salary", 26000);
    75. 

  75. 		int i = db.update("person", values, "name = ?", new String[]{"游天龙"});
    76. 

  76. 		System.out.println(i);
    77. 

  77. 	}
    78. 

  78. 这里使用了第三、第四个参数来指定具体更新哪几行。第三个参数对应的是 SQL语句的 where部分，表示去更新所有 name等于?
的行，而?是一个占位符，可以通过第四个参数提供的一个字符串数组为第三个参数中的每个占位符指定相应的内容。因此上述代码想表达的意图就是，将名字是游天龙的工资改成 2600。
    79. 

  79. 	
    80. 

  80. 	public void selectApi(){
    81. 

  81. 		Cursor cursor = db.query("person", null, null, null, null, null, null, null);
    82. 

  82. 		while(cursor.moveToNext()){
    83. 

  83. 			String name = cursor.getString(cursor.getColumnIndex("name"));
    84. 

  84. 			String phone = cursor.getString(cursor.getColumnIndex("phone"));
    85. 

  85. 			String salary = cursor.getString(cursor.getColumnIndex("salary"));
    86. 

  86. 			System.out.println(name + ";" + phone + ";" + salary);
    87. 

  87. 		}
    88. 

  88. 	}
    89. 

  89. 	
    90. 

  90. 	public void transaction(){
    91. 

  91. 		try{
    92. 

  92. 			//开启事务
    93. 

  93. 			db.beginTransaction();
    94. 

  94. 			ContentValues values = new ContentValues();
    95. 

  95. 			values.put("salary", 12000);
    96. 

  96. 			db.update("person", values, "name = ?", new String[]{"小志"});
    97. 

  97. 			
    98. 

  98. 			values.clear();
    99. 

  99. 			values.put("salary", 16000);
    100. 

  100. 			db.update("person", values, "name = ?", new String[]{"小志的儿子"});
    101. 

  101. 			
    102. 

  102. 			int i = 3/0;//加上这句就不会执行成功
    103. 

  103. 			//设置  事务执行成功
    104. 

  104. 			db.setTransactionSuccessful();
    105. 

  105. 		}
    106. 

  106. 		finally{
    107. 

  107. 			//关闭事务，同时提交，如果已经设置事务执行成功，那么sql语句就生效了，反之，sql语句回滚
    108. 

  108. 			db.endTransaction();
    109. 

  109. 		}
    110. 

  110. 	}
    111. 

  111. }
    112.

分页查询


  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. 

  2. public class MyOpenHelper extends SQLiteOpenHelper {
    3. 

    4. 

  4. 	public MyOpenHelper(Context context) {
    5. 

  5. 		super(context, "people.db", null, 1);
    6. 

  6. 		// TODO Auto-generated constructor stub
    7. 

  7. 	}
    8. 

  8. //再其他方法中
    9. 

  9. 	oh = new MyOpenHelper(getContext());
    10.

总结：

添加数据的方法如下：

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. 

  2. 	/**
    3. 

  3. 	 * Province表建表语句
    4. 

  4. 	 */
    5. 

  5. 	public static final String CREATE_PROVINCE = "create table Province ("
    6. 

  6. 			+ "id integer primary key autoincrement, " + "province_name text, "
    7. 

  7. 			+ "province_code text)";
    8. 

  8. 	/**
    9. 

  9. 	 * City表建表语句
    10. 

  10. 	 */
    11. 

  11. 	public static final String CREATE_CITY = "create table City ("
    12. 

  12. 			+ "id integer primary key autoincrement, " + "city_name text, "
    13. 

  13. 			+ "city_code text, " + "province_id integer)";
    14. 

  14. 	/**
    15. 

  15. 	 * County表建表语句
    16. 

  16. 	 */
    17. 

  17. 	public static final String CREATE_COUNTY = "create table County ("
    18. 

  18. 			+ "id integer primary key autoincrement, " + "county_name text, "
    19. 

  19. 			+ "county_code text, " + "city_id integer)";
    20. 

    21. 

  21. 	public CoolWeatherOpenHelper(Context context, String name,
    22. 

  22. 			CursorFactory factory, int version) {
    23. 

  23. 		super(context, name, factory, version);
    24. 

  24. 	}
    25. 

    26. 

  26. 	@Override
    27. 

  27. 	public void onCreate(SQLiteDatabase db) {
    28. 

  28. 		db.execSQL(CREATE_PROVINCE); // 创建Province表
    29. 

  29. 		db.execSQL(CREATE_CITY); // 创建City表
    30. 

  30. 		db.execSQL(CREATE_COUNTY); // 创建County表
    31. 

  31. 	}
    32. 

    33. 

  33. 	@Override
    34. 

  34. 	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    35. 

  35. 	}
    36.

CoolWeatherDB

    

  1. public class CoolWeatherDB {
    2. 

  2. 	/**
    3. 

  3. 	 * 数据库名
    4. 

  4. 	 */
    5. 

  5. 	public static final String DB_NAME = "cool_weather";
    6. 

  6. 	/**
    7. 

  7. 	 * 数据库版本
    8. 

  8. 	 */
    9. 

  9. 	public static final int VERSION = 1;
    10. 

  10. 	private static CoolWeatherDB coolWeatherDB;
    11. 

  11. 	private SQLiteDatabase db;
    12. 

    13. 

  13. 	/**
    14. 

  14. 	 * 将构造方法私有化
    15. 

  15. 	 */
    16. 

  16. 	private CoolWeatherDB(Context context) {
    17. 

  17. 		CoolWeatherOpenHelper dbHelper = new CoolWeatherOpenHelper(context,
    18. 

  18. 				DB_NAME, null, VERSION);
    19. 

  19. 		db = dbHelper.getWritableDatabase();
    20. 

  20. 	}
    21. 

    22. 

  22. 	/**
    23. 

  23. 	 * 获取CoolWeatherDB的实例。
    24. 

  24. 	 */
    25. 

  25. 	public synchronized static CoolWeatherDB getInstance(Context context) {
    26. 

  26. 		if (coolWeatherDB == null) {
    27. 

  27. 			coolWeatherDB = new CoolWeatherDB(context);
    28. 

  28. 		}
    29. 

  29. 		return coolWeatherDB;
    30. 

  30. 	}
    31. 

    32. 

  32. 	/**
    33. 

  33. 	 * 将Province实例存储到数据库。
    34. 

  34. 	 */
    35. 

  35. 	public void saveProvince(Province province) {
    36. 

  36. 		if (province != null) {
    37. 

  37. 			ContentValues values = new ContentValues();
    38. 

  38. 			values.put("province_name", province.getProvinceName());
    39. 

  39. 			values.put("province_code", province.getProvinceCode());
    40. 

  40. 			db.insert("Province", null, values);
    41. 

  41. 		}
    42. 

  42. 	}
    43. 

    44. 

  44. 	/**
    45. 

  45. 	 * 从数据库读取全国所有的省份信息。
    46. 

  46. 	 */
    47. 

  47. 	public List<Province> loadProvinces() {
    48. 

  48. 		List<Province> list = new ArrayList<Province>();
    49. 

  49. 		Cursor cursor = db
    50. 

  50. 				.query("Province", null, null, null, null, null, null);
    51. 

  51. 		if (cursor.moveToFirst()) {
    52. 

  52. 			do {
    53. 

  53. 				Province province = new Province();
    54. 

  54. 				province.setId(cursor.getInt(cursor.getColumnIndex("id")));
    55. 

  55. 				province.setProvinceName(cursor.getString(cursor
    56. 

  56. 						.getColumnIndex("province_name")));
    57. 

  57. 				province.setProvinceCode(cursor.getString(cursor
    58. 

  58. 						.getColumnIndex("province_code")));
    59. 

  59. 				list.add(province);
    60. 

  60. 			} while (cursor.moveToNext());
    61. 

  61. 		}
    62. 

  62. 		return list;
    63. 

  63. 	}
    64. 

    65. 

  65. 	/**
    66. 

  66. 	 * 将City实例存储到数据库。
    67. 

  67. 	 */
    68. 

  68. 	public void saveCity(City city) {
    69. 

  69. 		if (city != null) {
    70. 

  70. 			ContentValues values = new ContentValues();
    71. 

  71. 			values.put("city_name", city.getCityName());
    72. 

  72. 			values.put("city_code", city.getCityCode());
    73. 

  73. 			values.put("province_id", city.getProvinceId());
    74. 

  74. 			db.insert("City", null, values);
    75. 

  75. 		}
    76. 

  76. 	}
    77. 

    78. 

  78. 	/**
    79. 

  79. 	 * 从数据库读取某省下所有的城市信息。
    80. 

  80. 	 */
    81. 

  81. 	public List<City> loadCities(int provinceId) {
    82. 

  82. 		List<City> list = new ArrayList<City>();
    83. 

  83. 		Cursor cursor = db.query("City", null, "province_id = ?",
    84. 

  84. 				new String[] { String.valueOf(provinceId) }, null, null, null);//如果全是null，那么查的是所有的数据，比如get(xx)查出来的是所有这列的数据，如果想根据xx去查询的话就需要这样写
    85. 

  85. 		if (cursor.moveToFirst()) {
    86. 

  86. 			do {
    87. 

  87. 				City city = new City();
    88. 

  88. 				city.setId(cursor.getInt(cursor.getColumnIndex("id")));
    89. 

  89. 				city.setCityName(cursor.getString(cursor
    90. 

  90. 						.getColumnIndex("city_name")));
    91. 

  91. 				city.setCityCode(cursor.getString(cursor
    92. 

  92. 						.getColumnIndex("city_code")));
    93. 

  93. 				city.setProvinceId(provinceId);
    94. 

  94. 				list.add(city);
    95. 

  95. 			} while (cursor.moveToNext());
    96. 

  96. 		}
    97. 

  97. 		return list;
    98. 

  98. 	}
    99. 

    100. 

  100. 	/**
    101. 

  101. 	 * 将County实例存储到数据库。
    102. 

  102. 	 */
    103. 

  103. 	public void saveCounty(County county) {
    104. 

  104. 		if (county != null) {
    105. 

  105. 			ContentValues values = new ContentValues();
    106. 

  106. 			values.put("county_name", county.getCountyName());
    107. 

  107. 			values.put("county_code", county.getCountyCode());
    108. 

  108. 			values.put("city_id", county.getCityId());
    109. 

  109. 			db.insert("County", null, values);
    110. 

  110. 		}
    111. 

  111. 	}
    112. 

    113. 

  113. 	/**
    114. 

  114. 	 * 从数据库读取某城市下所有的县信息。
    115. 

  115. 	 */
    116. 

  116. 	public List<County> loadCounties(int cityId) {
    117. 

  117. 		List<County> list = new ArrayList<County>();
    118. 

  118. 		Cursor cursor = db.query("County", null, "city_id = ?",
    119. 

  119. 				new String[] { String.valueOf(cityId) }, null, null, null);
    120. 

  120. 		if (cursor.moveToFirst()) {
    121. 

  121. 			do {
    122. 

  122. 				County county = new County();
    123. 

  123. 				county.setId(cursor.getInt(cursor.getColumnIndex("id")));
    124. 

  124. 				county.setCountyName(cursor.getString(cursor
    125. 

  125. 						.getColumnIndex("county_name")));
    126. 

  126. 				county.setCountyCode(cursor.getString(cursor
    127. 

  127. 						.getColumnIndex("county_code")));
    128. 

  128. 				county.setCityId(cityId);
    129. 

  129. 				list.add(county);
    130. 

  130. 			} while (cursor.moveToNext());
    131. 

  131. 		}
    132. 

  132. 		return list;
    133. 

  133. 	}
    134. 

    135.
升级数据库的最佳写法

    

  1. public void onCreate(SQLiteDatabase db) {
    2. 

  2. db.execSQL(CREATE_BOOK);
    3. 

  3. db.execSQL(CREATE_CATEGORY);
    4. 

  4. Toast.makeText(mContext, "Create succeeded", Toast.LENGTH_SHORT).
    5. 

  5. show();
    6. 

  6. }
    7. 

  7. public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    8. 

  8. db.execSQL("drop table if exists Book");
    9. 

  9. db.execSQL("drop table if exists Category");
    10. 

  10. onCreate(db);
    11. 

  11. }
    12.

为了保证数据库中的表是最新的，只是简单地在 onUpgrade()方法中删除掉了当前所有的表，然后强制重新执行了
一遍 onCreate()方法。这种方式在产品的开发阶段确实可以用，但是当产品真正上线了之后就绝对不行了。想象以下
场景，比如你编写的某个应用已经成功上线，并且还拥有了不错的下载量。现在由于添加新功能的原因，使得数据库也
需要一起升级，然后用户更新了这个版本之后发现以前程序中存储的本地数据全部丢失了！那么很遗憾，你的用户群体
可能已经流失一大半了。

    

  1. public void onCreate(SQLiteDatabase db) {
    2. 

  2. db.execSQL(CREATE_BOOK);
    3. 

  3. db.execSQL(CREATE_CATEGORY);
    4. 

  4. }
    5. 

  5. @Override
    6. 

  6. public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    7. 

  7. switch (oldVersion) {
    8. 

  8. case 1:
    9. 

  9. db.execSQL(CREATE_CATEGORY);
    10. 

  10. default:
    11. 

  11. }
    12.

在 onCreate()方法里新增了一条建表语句，然后又在 onUpgrade()方法中添加了一个 switch判断，如果用户当前数据库的版本号是 1，就只会创建一张 Category表。这样当用户是直接安装的第二版的程序时，就会将两张表一起创建。而当用户是使用第二版的程序覆盖安装第一版的程序时，就会进入到升级数据库的操作中，此时由于 Book表已经存在了，因此只需要创建一张 Category表即可

新的需求又来了，这次要给 Book表和 Category表之间建立关联，需要在 Book表中添加一个 category_id的字段

    

  1. ...oncreat方法和前面一样
    2. 

  2. public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    3. 

  3. switch (oldVersion) {
    4. 

  4. case 1:
    5. 

  5. db.execSQL(CREATE_CATEGORY);
    6. 

  6. case 2:
    7. 

  7. db.execSQL("alter table Book add column category_id integer");
    8. 

  8. default:
    9. 

  9. }
    10. 

  10. }
    11.

首先在 Book表的建表语句中添加了一个 category_id列，这样当用户直接安装第三版的程序时，这个新增的列就已经自动添加成功了。然而，如果用户之前已经安装了某一版本的程序，现在需要覆盖安装，就会进入到升级数据库的操作中。在 onUpgrade()方法里，添加了一个新的 case，如果当前数据库的版本号是 2，就会执行 alter命令来为Book表新增一个 category_id列。这里请注意一个非常重要的细节，switch中每一个 case的最后都是没有使用 break的，这是为了保证在跨版本升级的时候， 每一次的数据库修改都能被全部执行到。比如用户当前是从第二版程序升级到第三版程序的，那么 case 2中的逻辑就会执行。而如果用户是直接从第一版程序升级到第三版程序的，那么 case 1和 case 2中的逻辑都会执行。使用这种方式来维护数据库的升级，不管版本怎样更新，都可以保证数据库的表结构是最新的，而且表中的数据也完全不会丢失了。

来自为知笔记(Wiz)

时间： 2024-11-09 06:11:38

5.数据库的相关文章

数据库介绍与分类

目录 数据库介绍与分类... 1 1.1 数据库介绍... 2 1.1.1什么是数据库... 2 1.2数据库的种类... 2 1.2.1关系型数据库介绍... 2 1.2.2非关系型数据库介绍... 3 1.3 常用关系型数据库产品介绍... 4 1.3.1 Oracle数据库... 4 1.3.2 MySQL数据库... 5 1.3.3 MariaDB数据库... 5 1.3.4 SqlServer数据库... 6 1.3.5 Access数据库... 6 1.3.6 其他不常用数据库...

win7 64位系统 PB连接oracle数据库出现“oracle library oci.dll could not be loaded”问题的解决方法

今天与大家分享一个自己的学习笔记,希望能给遇到同样问题的人带来帮助. 不知道大家在win7 64位系统下用 PB连接oracle数据库时,是否遇到过“oracle library oci.dll could not be loaded”问题. 今天,在win7 64位系统下用 PB连接oracle数据库时,一直出现上述错误,在百度上找了很久,都没有找到一个完整的解决方案,咨询了很多人,(他们都说是我的PB和oracle没装好,但我装的时候没出现任何问题,一切都很顺利,而且PB和oracle都能正

C#与数据库访问技术总结（八）之ExecuteNonQuery方法

ExecuteNonQuery方法 ExecuteNonQuery方法主要用来更新数据. 通常使用它来执行Update.Insert和Delete语句. 该方法返回值意义如下: 对于Update.Insert和Delete语句,返回值为该命令所影响的行数. 对于所有其他类型的语句,返回值为-1. Command对象通过ExecuteNonQuery方法更新数据库的过程非常简单,需要进行的步骤如下: (1)创建数据库连接. (2)创建Command对象,并指定一个SQL Insert.Update

Oracle 10g通过创建物化视图实现不同数据库间表级别的数据同步

摘自:http://blog.csdn.net/javaee_sunny/article/details/53439980 目录(?)[-] Oracle 10g 物化视图语法如下 实例演示 主要步骤 在A节点创建原表和物化视图日志 在B节点创建连接A节点的远程链接 在B节点处创建目标表和与目标表名称相同的物化视图 在B节点处刷新物化视图 升级采用存储过程定时任务JOB方式定时刷新物化视图 进一步优化 文章更新记录 参考文章 Oracle 10g 物化视图语法如下: create materia

Linux环境下MySQL数据库用SQL语句插入中文显示 “问号或者乱码 ” 问题解决！

问题: 在普通用户权限下执行 mysql -u root -p进入mysql数据库,中间步骤省略,插入数据:insert into 库名(属性)values('汉字'); 会出现如下提示:  Query OK, 1 row affected, 1 warning (0.00 sec)    表明出现错误,没有插入成功,然后执行select * from 表名   就会出现如下的问题:显示的表中出现乱码或者问号. 如图: 解决方案: 首先重新打开一个终端窗口(方便操作),进入root用户模式 执行

WEB页面，WEB环境版本，数据库，整站备份脚本

#!/bin/bash # #WEB页面,WEB环境版本,数据库,整站备份脚本 #当发生某个原因导致整个服务器无法恢复时,利用上面备份的相关数据即可重做一台一样的服务器 date_a=`date +%Y%m%d-%H%M%S` mkdir -p /web_bak/${date_a}/conf &> /dev/null mkdir -p /web_bak/${date_a}/web &> /dev/null mkdir -p /web_bak/${date_a}/mysql &a

MySQL数据库基础知识

day02 MySQL数据库基础知识 一.基础知识概述: 基础决定你这门课程的学习成败!只有学习好这些基础知识以后,你才能真正的运用自如.才能够对数据库有更深入的了解,道路才会越走越远. 二.基础知识: 1.数据库(database):数据库就好比是一个物理的文档柜,一个容器,把我们整理好的数据表等等归纳起来. 创建数据库命令:        create database 数据库名; 2.查看数据库         show databases; 3.打开指定的数据库         use 

PL/SQL developer 连接oracle数据库报错“initialization error could not load oci.dll”

声明:PL/SQL 版本:PL/SQL Developer 9.0.6 (http://files.allroundautomations.com/plsqldev906.exe) 报错提示如图: 原因:PL/SQL只对32位OS进行支持,解决方法是额外加载一个oci.dll文件 解决办法:1.下载OCI.DLL相关库文件.地址: (需注册Oracle账号) http://www.oracle.com/technetwork/topics/winsoft-085727.html ----->  

Linux环境下启动MySQL数据库出现找不到mysqld.sock的解决办法！

问题: 在普通用户权限下运行:mysql -u root -p,回车之后如果会出现如下错误:ERROR 2002 (HY000): Can't connect to local MySQL server through socket '/var/run/mysqld/mysqld.sock' (2) 此错误的意思就是没有找到mysqld.sock文件. 解决办法: 首先进入超级用户root权限  sudo -i 或者su - root 切换到默认目录 cd /var/lib/mysql  下查看

Java精品高级课，架构课，java8新特性，P2P金融项目，程序设计，功能设计，数据库设计，第三方支付，web安全，视频教程

36套精品Java架构师,高并发,高性能,高可用,分布式,集群,电商,缓存,性能调优,设计模式,项目实战,P2P金融项目,大型分布式电商实战视频教程 视频课程包含: 高级Java架构师包含:Spring boot.Spring  cloud.Dubbo.Elasticsearch,Redis.ActiveMQ.Nginx.Mycat.Spring.MongoDB.ZeroMQ.Git.Nosql.Jvm.Mecached.Netty.Nio.Mina.java8新特性,P2P金融项目,程序设计,