Well, it’s a recommendation, but it’s actually a database component that I wrote to introduce to you. This is the first edition, we hope you can use it at the same time to give comments, or put forward requirements.
To solve the pain points
The database components address the following categories of pain points:
- SQL statements are required when creating a table. If the table structure is complex, SQL statements are prone to write errors. Deepsql makes table building easier in three ways. Passing in the Model class directly, or JSON or Map, is more suitable for the actual use scenario.
- When inserting data, you can directly insert data using model or JSON or map without writing SQL statements
- Update and delete have encapsulation, operation is more simple.
use
Just rely on
compile 'com. Deep: deepsqllib: 1.1'
Copy the code
Can. Here’s how to use it:
Initialize the
DeepSQL.getInstance().init(getApplication(),"demo.db".1);
Copy the code
The first parameter is Application the second parameter is the database name and the third parameter is the version number.
Build table
Use classes to build tables
We often convert the data in the database to a modal type, if you can use this class to build a table, is not very convenient. For example, we have a class:
public class Person implements Serializable{
private String name;
private int age;
public String getName(a) {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge(a) {
return age;
}
public void setAge(int age) {
this.age = age; }}Copy the code
Create a table based on this class:
DeepSQL.getInstance().create(Person.class);
Copy the code
The table name will use the class name
The map building table
Sometimes we need to create a table based on a map:
HashMap<String,Object> map = new HashMap<String, Object>();
map.put("name"."dog");
map.put("age".16);
DeepSQL.getInstance().create("animal",map);
Copy the code
The first parameter is the table name
File built table
If you do not need any of the preceding methods, you can also use the JSON method in Asset to create a table: Place a JSON file in the Assets folder
{
"name1":"String"."name2":"int"."name3":"boolean"."name4":"float"."name5":"double"."name6":"long"
}
Copy the code
Then call:
DeepSQL.getInstance().create(MainActivity.this."names.json");
Copy the code
The table name is named after the JSON file name
Json building table
If you are not comfortable with the JSON form of assets, you can also use JSON:
DeepSQL.getInstance().create(MainActivity.this, json);
Copy the code
insert
Json insert
DeepSQL.getInstance().insert("person",jsonObject);
Copy the code
- The first parameter is the table name
- The second parameter is the inserted JSON
Insert a map
DeepSQL.getInstance().insert("animal",map);
Copy the code
- The first parameter is the table name
- The second parameter is the inserted map
Instantiate insert
Person person = new Person();
person.setName("john");
person.setAge(age);
DeepSQL.getInstance().insert(person);
Copy the code
Database query
Query all
ArrayList<Object> list = DeepSQL.getInstance().selectObjects(Person.class,"person");
Copy the code
- The first parameter is the class
- The second parameter is the table name
Returns Json based on the condition
JSONArray array = DeepSQL.getInstance().selectJsonArryBySQL("select * from person where id = 5");
Copy the code
Return Object based on the condition
ArrayList<Object> list = DeepSQL.getInstance().selectObjectsBySQL(Person.class,"select * from person where id = 5");
Copy the code
update
Json update
DeepSQL.getInstance().update("person"."id=?",new String[]{"5"},jsonObject);
Copy the code
The object update
DeepSQL.getInstance().update("person"."id=?",new String[]{"5"},person);
Copy the code
delete
DeepSQL.getInstance().del("person"."id=?",new String[]{"6"});
Copy the code
Delete table
DeepSQL.getInstance().dropTable("person");
Copy the code
Execute SQL statements directly
The query
DeepSQL.getInstance().exec("sql");
Copy the code
- Parameter is SQL statement
The query
Cursor c =DeepSQL.getInstance().queryBySQL("sql");
Copy the code
- Parameter is SQL statement
Database upgrade or degradation processing
DeepSQL.getInstance().sqlInterface = new SqlInterface() {
@Override
public void onUpgrade(SQLiteDatabase sqLiteDatabase, int oldVersion, int newVersion) {
Logger.single(C.E,"onUpgrade myself");
}
@Override
public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
Logger.single(C.E,"onUpgrade myself"); }};Copy the code
Note that this method needs to be called before init.
Special instructions
Write open source library for the first time, ability is limited, welcome everyone to put forward opinions. Also welcome to pay attention to my public number, after will recommend more easy to use component library.