The OnCreate method and the Onupgrade method in the application of SQLite in Android--

Original: http://blog.csdn.net/jiangwei0910410003/article/details/46536329

Today in the database upgrade, encountered a problem, is the OnCreate method and the implementation of the Onupgrade method of the timing of the problem, this time in operation, did not find out, is confused, so write code when there are a lot of problems, so there is no way to get the source code to see. But before that I explained an article about database upgrade, but there is no detailed explanation of the timing of the implementation of these two methods, so here is a separate talk

Article about database Upgrade: http://blog.csdn.net/jiangwei0910410003/article/details/39670813

Not much to say, the following directly into the topic:

First we look at the source code of Sqliteopenhelper class:

There is an important method in it:getdatabaselocked

Here we see that when our mname variable is null, a memory database is created and the life cycle of the data is application level, and this mname is the name of the file that created the database.

Of course, normally, we will pass in a database file name, so this method is generally not executed, then go to the following code. The following code is to open a database directly. But what we see is that the creation of a database is related to the context. Let's look at the code in the context. But here we know that the context is an abstract class, and we will generally look at his subclass Contextimpl implementations:

Take a look at the Getdatabasepath method and the openorcreatedatabase method:

First look at the openorcreatedatabase method:

[Java]View Plaincopy

2. @Override
4. Public sqlitedatabase openorcreatedatabase (String name, int mode, Cursorfactory factory,
6. Databaseerrorhandler ErrorHandler) {
8. File f = validatefilepath (name, true);
10. int flags = sqlitedatabase.create_if_necessary;
12. if (mode & mode_enable_write_ahead_logging)! = 0) {
14. Flags |= sqlitedatabase.enable_write_ahead_logging;
16. }
18. Sqlitedatabase db = Sqlitedatabase.opendatabase (F.getpath (), factory, flags, ErrorHandler);
20. Setfilepermissionsfrommode (F.getpath (), mode, 0);
22. return DB;
24. }

Here we see that the OpenDatabase method of Sqlitedatabase is actually called.

Let's take a look at the Getdatabasepath method:

[Java]View Plaincopy

1. @Override
2. Public File Getdatabasepath (String name) {
3. return Validatefilepath (name, false);
4. }

We see that both methods have a central approach:Validatefilepath

[Java]View Plaincopy

2. Private File Validatefilepath (String name, boolean createdirectory) {
4. File dir;
6. File F;
10. if (Name.charat (0) = = File.separatorchar) {
12. String Dirpath = name.substring (0, Name.lastindexof (File.separatorchar));
14. dir = new File (Dirpath);
16. Name = Name.substring (Name.lastindexof (File.separatorchar));
18. f = new File (dir, name);
20. } Else {
22. dir = Getdatabasesdir ();
24. f = Makefilename (dir, name);
26. }
30. if (createdirectory &&!dir.isdirectory () && Dir.mkdir ()) {
32. Fileutils.setpermissions (Dir.getpath (),
34. fileutils.s_irwxu| Fileutils.s_irwxg| Fileutils.s_ixoth,
36. -1,-1);
38. }
42. return F;
44. }

This method is very simple, that is, by passing the name of the database, and then build a database file object return.

So here are a few ways we can summarize the function:

Create a file object by passing the database name named Name, and then get the path to the database file: In the OpenDatabase method passed to SQLDatabase, open the database file

Let's continue to look at that process:

[Java]View Plaincopy

2. Final int version = Db.getversion ();
4. if (version! = mnewversion) {
6. if (db.isreadonly ()) {
8. throw New Sqliteexception ("Can ' t upgrade read-only database from version" +
10. Db.getversion () + "to" + Mnewversion + ":" + mname);
12. }
16. Db.begintransaction ();
18. try {
20. if (Version = = 0) {
22. OnCreate (DB);
24. } Else {
26. if (Version > mnewversion) {
28. Ondowngrade (db, version, mnewversion);
30. } Else {
32. Onupgrade (db, version, mnewversion);
34. }
36. }
38. Db.setversion (mnewversion);
40. Db.settransactionsuccessful ();
42. } finally {
44. Db.endtransaction ();
46. }
48. }

When we opened the database file, we began to operate, the main content of today's speech is the above judgment:

The current version of the database is obtained first, and when the version number is 0, the OnCreate method is executed (the version number is 0 when the database file is first created) If the version number is not 0 and is compared with the latest version number, if it is greater then the upgrade operation Onupgrade method is performed, otherwise the demotion Ondowngrade method is performed, but the demotion method implementation is simple:

Throws an exception directly, that is, the database does not allow the demotion operation, this also conforms to the normal situation.

All right. From the above analysis, we will summarize these two methods:

public abstract void OnCreate (Sqlitedatabase db);
public abstract void Onupgrade (Sqlitedatabase db,int oldversion,int newversion);

Sqliteopenhelper automatically detects whether the database file exists. If present, the database is opened, in which case the OnCreate () method is not called. If the database file does not exist, Sqliteopenhelper first creates a database file, opens the database, and finally calls the OnCreate () method. Therefore, the OnCreate () method is typically used to create a database build of tables, views, and so on in a newly created database.

This means that the OnCreate () method is called when the database file is first created.

First look at the construction method of the Sqliteopenhelper class and then explain when the OnUpdate () method is called.
Public Sqliteopenhelper (Context context,string name,cursorfactory factory,int version);
Where the name parameter represents the database file name (not including the file path), Sqliteopenhelper creates the database file based on the file name. Version indicates the release number of the database. If the current incoming database version number is higher than the last created or upgraded version number, Sqliteopenhelper calls the OnUpdate () method. That is, when the database is first created, there will be an initial version number. You can increase the version number and recreate them when you need to upgrade the tables, views, and so on in the database. Now summarize the OnCreate () and Onupgrade () call procedures.

1. If the database file does not exist, Sqliteopenhelper will call the OnCreate () method after the database is automatically created, and in this method it is common to create components such as tables, views, and so on. The database is generally empty before it is created, so you do not need to delete the related components in the database first.
2. If the database file exists and the current version number is higher than the last created or promoted version number, Sqliteopenhelper calls the Onupgrade () method, and the version number of the database is updated when the method is called. In addition to creating components such as tables, views, and so on, in the Onupgrade () method, these related components need to be removed before the Onupgrade () method is called, so the database is present and many database builds are restored.

Combining the two points above, a conclusion can be drawn:

If the database file does not exist, only OnCreate () is called (the method is called once when the database is created). If the database file exists, the Onupgrade () method is called to upgrade the database and update the version number.

OnCreate method and Onupgrade method in SQLite in Android--(GO)