代码拉取完成，页面将自动刷新
LitePal is an open source openharmony library that allows developers to use SQLite database extremely easy. You can finish most of the database operations without writing even a SQL statement, including create or upgrade tables, crud operations, aggregate functions, etc. The setup of LitePal is quite simple as well, you can integrate it into your project in less than 5 minutes.
Experience the magic right now and have fun!
Edit your build.gradle file and add below dependency.
dependencies {
implementation 'io.openharmony.tpc.thirdlib:LitePal:1.0.2'
}
Create a file in the assets folder of your project and name it as litepal.xml. Then copy the following codes into it.
<?xml version="1.0" encoding="utf-8"?>
<litepal>
<!--
Define the database name of your application.
By default each database name should be end with .db.
If you didn't name your database end with .db,
LitePal would plus the suffix automatically for you.
For example:
<dbname value="demo" />
-->
<dbname value="demo" />
<!--
Define the version of your database. Each time you want
to upgrade your database, the version tag would helps.
Modify the models you defined in the mapping tag, and just
make the version value plus one, the upgrade of database
will be processed automatically without concern.
For example:
<version value="1" />
-->
<version value="1" />
<!--
Define your models in the list with mapping tag, LitePal will
create tables for each mapping class. The supported fields
defined in models will be mapped into columns.
For example:
<list>
<mapping class="com.test.model.Reader" />
<mapping class="com.test.model.Magazine" />
</list>
-->
<list>
</list>
<!--
Define where the .db file should be. "internal" means the .db file
will be stored in the database folder of internal storage which no
one can access. "external" means the .db file will be stored in the
path to the directory on the primary external storage device where
the application can place persistent files it owns which everyone
can access. "internal" will act as default.
For example:
<storage value="external" />
-->
</litepal>
This is the only configuration file, and the properties are simple.
You don't want to pass the Context param all the time. To makes the APIs simple, just configure the AbilityPackage in config.json as below:
{
"module": {
"name": "org.litepal.LitePalApplication",
...
}
}
Of course you may have your own AbilityPackage and has already configured here, like:
{
"module": {
"name": ".MyAbilityPackage",
...
}
}
That's OK. LitePal can still live with that. Just call LitePal.initialize(context) in your own AbilityPackage:
public class MyAbilityPackage extends AbilityPackage {
@Override
public void onInitialize() {
super.onInitialize();
org.litepal.LitePal.initialize(getApplicationContext());
}
...
}
Make sure to call this method as early as you can. In the onInitialize() method of AbilityPackage will be fine. And always remember to use the application context as parameter. Do not use any instance of Ability or AbilityService as parameter, or memory leaks might happen.
After setup, you can experience the powerful functions now.
Define the models first. For example you have two models, Album and Song. The models can be defined as below:
public class Album extends LitePalSupport {
@Column(unique = true, defaultValue = "unknown")
private String name;
@Column(index = true)
private float price;
private List<Song> songs = new ArrayList<>();
// generated getters and setters.
...
}
public class Song extends LitePalSupport {
@Column(nullable = false)
private String name;
private int duration;
@Column(ignore = true)
private String uselessField;
private Album album;
// generated getters and setters.
...
}
Then add these models into the mapping list in litepal.xml:
<list>
<mapping class="org.litepal.litepalsample.model.Album" />
<mapping class="org.litepal.litepalsample.model.Song" />
</list>
OK! The tables will be generated next time you operate database. For example, gets the RdbStore with following codes:
RdbStore db = LitePal.getDatabase();
Now the tables will be generated automatically with SQLs like this:
CREATE TABLE album (
id integer primary key autoincrement,
name text unique default 'unknown',
price real
);
CREATE TABLE song (
id integer primary key autoincrement,
name text not null,
duration integer,
album_id integer
);
Upgrade tables in LitePal is extremely easy. Just modify your models anyway you want:
public class Album extends LitePalSupport {
@Column(unique = true, defaultValue = "unknown")
private String name;
@Column(ignore = true)
private float price;
private Date releaseDate;
private List<Song> songs = new ArrayList<>();
// generated getters and setters.
...
}
A releaseDate field was added and price field was annotated to ignore. Then increase the version number in litepal.xml:
<!--
Define the version of your database. Each time you want
to upgrade your database, the version tag would helps.
Modify the models you defined in the mapping tag, and just
make the version value plus one, the upgrade of database
will be processed automatically without concern.
For example:
<version value="1" />
-->
<version value="2" />
The tables will be upgraded next time you operate database. A releasedate column will be added into album table and the original price column will be removed. All the data in album table except those removed columns will be retained.
But there are some upgrading conditions that LitePal can't handle and all data in the upgrading table will be cleaned:
unique = true.unique = true.nullable = false.Be careful of the above conditions which will cause losing data.
The saving API is quite object oriented. Each model which inherits from LitePalSupport would have the save() method for free.
Java:
Album album = new Album();
album.setName("album");
album.setPrice(10.99f);
album.setCover(getCoverImageBytes());
album.save();
Song song1 = new Song();
song1.setName("song1");
song1.setDuration(320);
song1.setAlbum(album);
song1.save();
Song song2 = new Song();
song2.setName("song2");
song2.setDuration(356);
song2.setAlbum(album);
song2.save();
Kotlin:
val album = Album()
album.name = "album"
album.price = 10.99f
album.cover = getCoverImageBytes()
album.save()
val song1 = Song()
song1.name = "song1"
song1.duration = 320
song1.album = album
song1.save()
val song2 = Song()
song2.name = "song2"
song2.duration = 356
song2.album = album
song2.save()
This will insert album, song1 and song2 into database with associations.
The simplest way, use save() method to update a record found by find().
Java:
Album albumToUpdate = LitePal.find(Album.class, 1);
albumToUpdate.setPrice(20.99f); // raise the price
albumToUpdate.save();
Kotlin:
val albumToUpdate = LitePal.find<Album>(1)
albumToUpdate.price = 20.99f // raise the price
albumToUpdate.save()
Each model which inherits from LitePalSupport would also have update() and updateAll() method. You can update a single record with a specified id.
Java:
Album albumToUpdate = new Album();
albumToUpdate.setPrice(20.99f); // raise the price
albumToUpdate.update(id);
Kotlin:
val albumToUpdate = Album()
albumToUpdate.price = 20.99f // raise the price
albumToUpdate.update(id)
Or you can update multiple records with a where condition.
Java:
Album albumToUpdate = new Album();
albumToUpdate.setPrice(20.99f); // raise the price
albumToUpdate.updateAll("name = ?", "album");
Kotlin:
val albumToUpdate = Album()
albumToUpdate.price = 20.99f // raise the price
albumToUpdate.updateAll("name = ?", "album")
You can delete a single record using the static delete() method in LitePal.
Java:
LitePal.delete(Song.class, id);
Kotlin:
LitePal.delete<Song>(id)
Or delete multiple records using the static deleteAll() method in LitePal.
Java:
LitePal.deleteAll(Song.class, "duration > ?" , "350");
Kotlin:
LitePal.deleteAll<Song>("duration > ?" , "350")
Find a single record from song table with specified id.
Java:
Song song = LitePal.find(Song.class, id);
Kotlin:
val song = LitePal.find<Song>(id)
Find all records from song table.
Java:
List<Song> allSongs = LitePal.findAll(Song.class);
Kotlin:
val allSongs = LitePal.findAll<Song>()
Constructing complex query with fluent query.
Java:
List<Song> songs = LitePal.where("name like ? and duration < ?", "song%", "200").order("duration").find(Song.class);
Kotlin:
val songs = LitePal.where("name like ? and duration < ?", "song%", "200").order("duration").find<Song>()
If your app needs multiple databases, LitePal support it completely. You can create as many databases as you want at runtime. For example:
LitePalDB litePalDB = new LitePalDB("demo2", 1);
litePalDB.addClassName(Singer.class.getName());
litePalDB.addClassName(Album.class.getName());
litePalDB.addClassName(Song.class.getName());
LitePal.use(litePalDB);
This will create a demo2 database with singer, album and song tables.
If you just want to create a new database but with same configuration as litepal.xml, you can do it with:
LitePalDB litePalDB = LitePalDB.fromDefault("newdb");
LitePal.use(litePalDB);
You can always switch back to default database with:
LitePal.useDefault();
And you can delete any database by specified database name:
LitePal.deleteDatabase("newdb");
LitePal support transaction for atomic db operations. All operations in the transaction will be committed or rolled back together.
Java usage:
LitePal.beginTransaction();
boolean result1 = // db operation1
boolean result2 = // db operation2
boolean result3 = // db operation3
if (result1 && result2 && result3) {
LitePal.setTransactionSuccessful();
}
LitePal.endTransaction();
Kotlin usage:
LitePal.runInTransaction {
val result1 = // db operation1
val result2 = // db operation2
val result3 = // db operation3
result1 && result2 && result3
}
If you are using ProGuard you might need to add the following option:
-keep class org.litepal.** {
*;
}
-keep class * extends org.litepal.crud.DataSupport {
*;
}
-keep class * extends org.litepal.crud.LitePalSupport {
*;
}
Copyright (C) Tony Green, LitePal Framework Open Source Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。
1. 开源生态
2. 协作、人、软件
3. 评估模型