ORM数据库框架 ORMLite

其他 2018-08-16 07:38:07 阅读次数: 0

简介


Android中现在最常见、最常用的SQLite数据库框架是ORMLite和GreenDAO，相比GreenDAO来说，ORMLite是一个更加轻量级的框架，而且学习成本更低。

Gradle配置： 
implementation 'com.j256.ormlite:ormlite-android:4.48'
implementation 'com.j256.ormlite:ormlite-core:4.48'
2
2
 
1 
implementation 'com.j256.ormlite:ormlite-android:4.48'
2 
implementation 'com.j256.ormlite:ormlite-core:4.48'

也可以手动下载  ormlite-core  软件包，需要通过 JDBC 连接连接到SQL数据库的用户应下载 ormlite-jdbc  软件包，在 Android 中使用还需下载  ormlite-android 软件包。

注解

@DatabaseTable
标记要存储在数据库中的类的注解。仅在您要标记类[mark the class]或更改其默认tableName时才需要它。您可以在要保留到数据库的类上方指定此注解。
使用此包持久化的类，必须具有 至少包级可见[package visibility]的无参数构造函数，以便在执行查询时可以创建此类的对象。 
@Target(TYPE)
@Retention(RUNTIME)
public @interface DatabaseTable {
	String tableName() default ""; //数据库中列的名称。 如果未设置，则名称取自小写的类名。
	Class<?> daoClass() default Void.class; //与此类对应的DAO类。DaoManager 在内部构造DAO时使用它。
}
6
6
 
1 
@Target(TYPE)
2 
@Retention(RUNTIME)
3 
public @interface DatabaseTable {
4 
    String tableName() default ""; //数据库中列的名称。 如果未设置，则名称取自小写的类名。
5 
    Class<?> daoClass() default Void.class; //与此类对应的DAO类。DaoManager 在内部构造DAO时使用它。
6 
}

@DatabaseField
DatabaseField：代表数据表中的一个字段
用于标识一个类中，与数据库中的列对应，且将被持久化的字段。 瞬态字段或其他临时字段[transient or other temporary fields]应不被持久化。
常用属性： 
id：当前字段是不是id字段，一个实体类中只能设置一个id字段
columnName：数据库中列的名称。如果未设置，则从字段名称中获取名称
generatedId：设置属性值在数据表中的数据是否自增，generatedId 和 id 和 generatedIdSequence 只能指定其中一个
useGetSet：是否使用Getter/Setter方法来访问这个字段
canBeNull：字段是否可以为空，默认值是true
unique：是否唯一
defaultValue：用于创建表的字段的默认值。默认为none。注意：如果该字段具有空值，则当您调用 Dao＃create(Object) 时，该值将插入其位置
foreignColumnName：外键约束指向的类中的属性名
foreign：当前字段是否是外键
foreignAutoRefresh：如果这个属性设置为true，在关联查询的时候就不需要再调用refresh()方法了
index：默认为false，将此设置为true以使数据库为此字段添加索引。这将创建一个名为 columnName + "_ idx" 的索引
indexName：默认为none，给此值设置为一个字符串可使数据库使用此名称为此字段添加索引。您不需要指定 index() 值。要在一个索引中将多个字段一起索引，每个字段应具有相同的indexName值。
12
 
1 
id：当前字段是不是id字段，一个实体类中只能设置一个id字段
2 
columnName：数据库中列的名称。如果未设置，则从字段名称中获取名称
3 
generatedId：设置属性值在数据表中的数据是否自增，generatedId 和 id 和 generatedIdSequence 只能指定其中一个
4 
useGetSet：是否使用Getter/Setter方法来访问这个字段
5 
canBeNull：字段是否可以为空，默认值是true
6 
unique：是否唯一
7 
defaultValue：用于创建表的字段的默认值。默认为none。注意：如果该字段具有空值，则当您调用 Dao＃create(Object) 时，该值将插入其位置
8 
foreignColumnName：外键约束指向的类中的属性名
9 
foreign：当前字段是否是外键
10 
foreignAutoRefresh：如果这个属性设置为true，在关联查询的时候就不需要再调用refresh()方法了
11 
index：默认为false，将此设置为true以使数据库为此字段添加索引。这将创建一个名为 columnName + "_ idx" 的索引
12 
indexName：默认为none，给此值设置为一个字符串可使数据库使用此名称为此字段添加索引。您不需要指定 index() 值。要在一个索引中将多个字段一起索引，每个字段应具有相同的indexName值。
除此之外，还有很多不常用的字段，这里就不介绍了。

ForeignCollectionField：一对多关联，表示一个UserBean关联着多个ArticleBean（必须使用ForeignCollection集合）

常用API

添加数据 
int create(T t) throws SQLException;    
int create(Collection<T> var1) throws SQLException;
T createIfNotExists(T t) throws SQLException;
3
3
1 
int create(T t) throws SQLException;    
2 
int create(Collection<T> var1) throws SQLException;
3 
T createIfNotExists(T t) throws SQLException;

删除数据 
int delete(T t) throws SQLException;    
int deleteById(Intenger id) throws SQLException;    
int delete(Collection<T> var1) throws SQLException;    
int deleteIds(Collection<Intenger>  ids) throws SQLException;
4
4
 
1 
int delete(T t) throws SQLException;    
2 
int deleteById(Intenger id) throws SQLException;    
3 
int delete(Collection<T> var1) throws SQLException;    
4 
int deleteIds(Collection<Intenger>  ids) throws SQLException;  

更新数据 
int update(T var1) throws SQLException;
int updateId(T var1, ID var2) throws SQLException;
x
1 
int update(T var1) throws SQLException;
2 
int updateId(T var1, ID var2) throws SQLException;

查询数据 
T queryForId(ID var1) throws SQLException;    
List<T> queryForAll() throws SQLException;
2
2
 
1 
T queryForId(ID var1) throws SQLException;    
2 
List<T> queryForAll() throws SQLException;

Builder
DAO 中提供了几个相关的 Builder 方法，可以进行按条件操作，使用方式相似： 
QueryBuilder<T, ID>  queryBuilder();  
UpdateBuilder<T, ID> updateBuilder();    
DeleteBuilder<T, ID> deleteBuilder();
3
3
1 
QueryBuilder<T, ID>  queryBuilder();  
2 
UpdateBuilder<T, ID> updateBuilder();    
3 
DeleteBuilder<T, ID> deleteBuilder();

QueryBuilder对象常用方法 
QueryBuilder<User, Integer> builder = userDao.queryBuilder()
		.distinct()// 排重
		.groupBy("id")  //分组
		.limit(10L)//限制数量
		.offset(3L) //偏移
		.orderBy("date", true); //排序
List<User> list = builder.where().like("string", "%包青天%").query();//条件查询
x
 
1 
QueryBuilder<User, Integer> builder = userDao.queryBuilder()
2 
        .distinct()// 排重
3 
        .groupBy("id")  //分组
4 
        .limit(10L)//限制数量
5 
        .offset(3L) //偏移
6 
        .orderBy("date", true); //排序
7 
List<User> list = builder.where().like("string", "%包青天%").query();//条件查询

事物管理 
DatabaseConnection dc = userDao.startThreadConnection();//也可以 new AndroidDatabaseConnection
dc.setAutoCommit(false); //设置不自动提交

Savepoint savePoint = dc.setSavePoint("savePointName");//设置回滚点，参数是一个名字，没什么影响
for (User user : new User[]{user, user}) {
	userDao.createOrUpdate(user);
}
dc.commit(savePoint);//提交事务。保存大量数据时以事务的方式提交，可以大幅提高速度
userDao.endThreadConnection(dc);
1 
DatabaseConnection dc = userDao.startThreadConnection();//也可以 new AndroidDatabaseConnection
2 
dc.setAutoCommit(false); //设置不自动提交
3
4 
Savepoint savePoint = dc.setSavePoint("savePointName");//设置回滚点，参数是一个名字，没什么影响
5 
for (User user : new User[]{user, user}) {
6 
    userDao.createOrUpdate(user);
7 
}
8 
dc.commit(savePoint);//提交事务。保存大量数据时以事务的方式提交，可以大幅提高速度
9 
userDao.endThreadConnection(dc);

完整案例

SqliteOpenHelper 
public class DbHelper extends OrmLiteSqliteOpenHelper {
	private static final String TABLE_NAME = "sqlite-test.db";
	private static final int DATABASE_VERSION = 1;
	private Dao<User, Integer> userDao = null;
	private RuntimeExceptionDao<User, Integer> userRuntimeDao;
	
	public DbHelper(Context context) {
		super(context, TABLE_NAME, null, DATABASE_VERSION);
	}
	
	@Override
	public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
		try {
			Log.i("bqt", "onCreate，版本：" + DATABASE_VERSION);
			
			TableUtils.createTable(connectionSource, User.class);
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	@Override
	public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
		try {
			Log.i("bqt", "onUpgrade，旧版本：" + oldVersion + "，新版本：" + newVersion);
			
			TableUtils.dropTable(connectionSource, User.class, true);
			
			onCreate(database, connectionSource);
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	@Override
	public void close() {
		super.close();
		userDao = null;
	}
	
	public Dao<User, Integer> getUserDao() throws SQLException {
		return userDao == null ? getDao(User.class) : userDao;
	}
	
	public RuntimeExceptionDao<User, Integer> getUserRuntimeDao() {
		return userRuntimeDao == null ? getRuntimeExceptionDao(User.class) : userRuntimeDao;
	}
}
x
 
1 
public class DbHelper extends OrmLiteSqliteOpenHelper {
2 
    private static final String TABLE_NAME = "sqlite-test.db";
3 
    private static final int DATABASE_VERSION = 1;
4 
    private Dao<User, Integer> userDao = null;
5 
    private RuntimeExceptionDao<User, Integer> userRuntimeDao;
6
7 
    public DbHelper(Context context) {
8 
        super(context, TABLE_NAME, null, DATABASE_VERSION);
9 
    }
10
11 
    @Override
12 
    public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
13 
        try {
14 
            Log.i("bqt", "onCreate，版本：" + DATABASE_VERSION);
15
16 
            TableUtils.createTable(connectionSource, User.class);
17 
        } catch (SQLException e) {
18 
            e.printStackTrace();
19 
        }
20 
    }
21
22 
    @Override
23 
    public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
24 
        try {
25 
            Log.i("bqt", "onUpgrade，旧版本：" + oldVersion + "，新版本：" + newVersion);
26
27 
            TableUtils.dropTable(connectionSource, User.class, true);
28
29 
            onCreate(database, connectionSource);
30 
        } catch (SQLException e) {
31 
            e.printStackTrace();
32 
        }
33 
    }
34
35 
    @Override
36 
    public void close() {
37 
        super.close();
38 
        userDao = null;
39 
    }
40
41 
    public Dao<User, Integer> getUserDao() throws SQLException {
42 
        return userDao == null ? getDao(User.class) : userDao;
43 
    }
44
45 
    public RuntimeExceptionDao<User, Integer> getUserRuntimeDao() {
46 
        return userRuntimeDao == null ? getRuntimeExceptionDao(User.class) : userRuntimeDao;
47 
    }
48 
}
User 
public class User {
	@DatabaseField(generatedId = true) public int id;
	@DatabaseField(index = true) public String string;
	@DatabaseField public Date date;
	
	public User() { //必须具有至少包机可见[package visibility]的无参数构造函数，以便在执行查询时可以创建此类的对象
	}
	
	private User(Builder builder) {
		id = builder.id;
		string = builder.string;
		date = builder.date;
	}
    ...
}
x
1 
public class User {
2 
    @DatabaseField(generatedId = true) public int id;
3 
    @DatabaseField(index = true) public String string;
4 
    @DatabaseField public Date date;
5
6 
    public User() { //必须具有至少包机可见[package visibility]的无参数构造函数，以便在执行查询时可以创建此类的对象
7 
    }
8
9 
    private User(Builder builder) {
10 
        id = builder.id;
11 
        string = builder.string;
12 
        date = builder.date;
13 
    }
14 
    ...
15 
}
Activity 
public class ORMLiteActivity extends ListActivity {
	private DbHelper helper;
	private Dao<User, Integer> userDao;
	private RuntimeExceptionDao<User, Integer> userRuntimeDao;
	
	private User user;
	
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		String[] array = {"0、添加：create",
				"1、添加：createIfNotExists",
				"2、添加：createOrUpdate",
				"3、事务操作：使用DatabaseConnection",
				"4、事务操作：使用AndroidDatabaseConnection",
				"5、更新：update、updateId",
				"6、删除：delete、deleteIds、deleteById",
				"7、QueryBuilder、UpdateBuilder、DeleteBuilder",
				"8、其他API",
				"9、查询并清除所有数据：queryForAll",};
		
		setListAdapter(new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, Arrays.asList(array)));
		
		user = User.newBuilder().date(new Date()).date(new Date()).string("====包青天====").build();
		try {
			helper = new DbHelper(this);
			userDao = helper.getUserDao();
			userRuntimeDao = helper.getUserRuntimeDao();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	@Override
	protected void onDestroy() {
		super.onDestroy();
		helper.close();
	}
	
	@Override
	protected void onListItemClick(ListView l, View v, int position, long id) {
		user.string = "【包青天" + id + "】" + System.currentTimeMillis();
		
		try {
			switch (position) {
				case 0:
					int updatNum1 = userDao.create(user);
					boolean isEqual1 = userDao.objectsEqual(user, userDao.queryForId(1));
					int updatNum2 = userDao.create(user);//[注意]对于同一个对象，不管是否存在，每次就会添加一条新的数据
					boolean isEqual2 = userDao.objectsEqual(user, userDao.queryForId(1));
					boolean isEqual3 = userDao.objectsEqual(user, userDao.queryForId(2));
					Log.i("bqt", "是否为同一对象：" + Arrays.asList(isEqual1, isEqual2, isEqual3));//[true, false, true]
					
					int updatNum3 = userDao.create(User.newBuilder().id(100).string("包青天0").build());//[注意]设置id无效
					Log.i("bqt", "更新数量：" + Arrays.asList(updatNum1, updatNum2, updatNum3));//[1, 1, 1]
					break;
				case 1://如果指定的对象不存在则插入，如果存在则不插入
					User newUser1 = userDao.createIfNotExists(user);//[垃圾]上面添加了多个，但这里只返回了最后一个
					//[注意]因为user已经存在，所以不会添加，也不更新数据库中对象的数据；并且返回的是数据库中的对象(旧的数据)
					boolean isEqual11 = userDao.objectsEqual(newUser1, user);
					boolean isEqual12 = userDao.objectsEqual(newUser1, userDao.queryForId(2));
					Log.i("bqt", "是否为同一对象：" + Arrays.asList(isEqual11, isEqual12));//[false, true]
					
					User newUser2 = userDao.createIfNotExists(User.newBuilder().string("包青天1").build());
					Log.i("bqt", new Gson().toJson(Arrays.asList(newUser1, newUser2)));
					break;
				case 2:
					Dao.CreateOrUpdateStatus status1 = userDao.createOrUpdate(user);//[注意]上面添加了多个，但这里只更改了最后一个
					Log.i("bqt", "是否为同一对象：" + userDao.objectsEqual(user, userDao.queryForId(2)));//true
					
					Dao.CreateOrUpdateStatus status2 = userDao.createOrUpdate(User.newBuilder().string("包青天2").build());
					//[{"created":false,"numLinesChanged":1,"updated":true},{"created":true,"numLinesChanged":1,"updated":false}]
					Log.i("bqt", new Gson().toJson(Arrays.asList(status1, status2)));
					break;
				case 3://使用DatabaseConnection
					DatabaseConnection dc = userDao.startThreadConnection();//也可以 new AndroidDatabaseConnection
					dc.setAutoCommit(false); //设置不自动提交
					
					Savepoint savePoint = dc.setSavePoint("savePointName");//设置回滚点，参数是一个名字，没什么影响
					for (User user : new User[]{user, user}) {
						userDao.createOrUpdate(user);
					}
					dc.commit(savePoint);//提交事务。保存大量数据时以事务的方式提交，可以大幅提高速度
					userDao.endThreadConnection(dc);
					break;
				case 4://使用AndroidDatabaseConnection
					AndroidDatabaseConnection adc = new AndroidDatabaseConnection(helper.getWritableDatabase(), true);
					userRuntimeDao.setAutoCommit(adc, false);// 设置不自动提交
					Savepoint savePoint4 = adc.setSavePoint("savePointName");//设置回滚点，参数是一个名字，没什么影响
					for (User user : new User[]{user, User.newBuilder().string("包青天4").build()}) {
						userDao.createOrUpdate(user);
					}
					adc.commit(savePoint4);
					adc.rollback(savePoint4); // 回滚事物。一般用于在发生异常时进行回滚
					break;
				case 5:
					int uNum1 = userDao.update(user);//[注意]同样更新的是最后添加的数据
					int uNum2 = userDao.update(User.newBuilder().build());
					int uNum3 = userDao.updateId(user, 100);//[注意]新添加的数据的id将从最大值开始
					int uNum4 = userDao.updateId(userDao.queryForId(3), -100);//[注意]值可以为负值
					Log.i("bqt", new Gson().toJson(Arrays.asList(uNum1, uNum2, uNum3, uNum4)));//[1,0,1,1]
					break;
				case 6:
					int dNum1 = userDao.delete(user);//[注意]这个删掉的也是最后一个添加的数据，前面添加的数据已经和user脱离关联了
					int dNum2 = userDao.delete(user);
					int dNum3 = userDao.delete(Arrays.asList(user, User.newBuilder().build()));
					int dNum4 = userDao.deleteById(3);
					int dNum5 = userDao.deleteIds(Arrays.asList(5, 6, 7, 8));
					Log.i("bqt", new Gson().toJson(Arrays.asList(dNum1, dNum2, dNum3, dNum4, dNum5)));//[1,0,0,1,1]
					break;
				case 7:
					QueryBuilder<User, Integer> builder = userDao.queryBuilder()
							.distinct()// 排重
							.groupBy("id")  //分组
							.limit(10L)//限制数量
							.offset(3L) //偏移
							.orderBy("date", true); //排序
					List<User> list = builder.where().like("string", "%包青天%").query();//条件查询
					Log.i("bqt", "查询到的数据：" + new Gson().toJson(list));
					break;
				case 8:
					User data = userDao.queryForId(1);//如果不存在则返回 null
					long count = userDao.countOf();//总数量
					Log.i("bqt", count + " " + new Gson().toJson(data));
					Log.i("bqt", userDao.isTableExists() + " " + userDao.isUpdatable() + " " + userDao.idExists(1));
				case 9:
					userDao.delete(userDao.queryForAll());
					break;
			}
			Log.i("bqt", "全部数据：" + new Gson().toJson(userDao.queryForAll()));
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
}
134
1 
public class ORMLiteActivity extends ListActivity {
2 
    private DbHelper helper;
3 
    private Dao<User, Integer> userDao;
4 
    private RuntimeExceptionDao<User, Integer> userRuntimeDao;
5
6 
    private User user;
7
8 
    protected void onCreate(Bundle savedInstanceState) {
9 
        super.onCreate(savedInstanceState);
10 
        String[] array = {"0、添加：create",
11 
                "1、添加：createIfNotExists",
12 
                "2、添加：createOrUpdate",
13 
                "3、事务操作：使用DatabaseConnection",
14 
                "4、事务操作：使用AndroidDatabaseConnection",
15 
                "5、更新：update、updateId",
16 
                "6、删除：delete、deleteIds、deleteById",
17 
                "7、QueryBuilder、UpdateBuilder、DeleteBuilder",
18 
                "8、其他API",
19 
                "9、查询并清除所有数据：queryForAll",};
20
21 
        setListAdapter(new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, Arrays.asList(array)));
22
23 
        user = User.newBuilder().date(new Date()).date(new Date()).string("====包青天====").build();
24 
        try {
25 
            helper = new DbHelper(this);
26 
            userDao = helper.getUserDao();
27 
            userRuntimeDao = helper.getUserRuntimeDao();
28 
        } catch (SQLException e) {
29 
            e.printStackTrace();
30 
        }
31 
    }
32
33 
    @Override
34 
    protected void onDestroy() {
35 
        super.onDestroy();
36 
        helper.close();
37 
    }
38
39 
    @Override
40 
    protected void onListItemClick(ListView l, View v, int position, long id) {
41 
        user.string = "【包青天" + id + "】" + System.currentTimeMillis();
42
43 
        try {
44 
            switch (position) {
45 
                case 0:
46 
                    int updatNum1 = userDao.create(user);
47 
                    boolean isEqual1 = userDao.objectsEqual(user, userDao.queryForId(1));
48 
                    int updatNum2 = userDao.create(user);//[注意]对于同一个对象，不管是否存在，每次就会添加一条新的数据
49 
                    boolean isEqual2 = userDao.objectsEqual(user, userDao.queryForId(1));
50 
                    boolean isEqual3 = userDao.objectsEqual(user, userDao.queryForId(2));
51 
                    Log.i("bqt", "是否为同一对象：" + Arrays.asList(isEqual1, isEqual2, isEqual3));//[true, false, true]
52
53 
                    int updatNum3 = userDao.create(User.newBuilder().id(100).string("包青天0").build());//[注意]设置id无效
54 
                    Log.i("bqt", "更新数量：" + Arrays.asList(updatNum1, updatNum2, updatNum3));//[1, 1, 1]
55 
                    break;
56 
                case 1://如果指定的对象不存在则插入，如果存在则不插入
57 
                    User newUser1 = userDao.createIfNotExists(user);//[垃圾]上面添加了多个，但这里只返回了最后一个
58 
                    //[注意]因为user已经存在，所以不会添加，也不更新数据库中对象的数据；并且返回的是数据库中的对象(旧的数据)
59 
                    boolean isEqual11 = userDao.objectsEqual(newUser1, user);
60 
                    boolean isEqual12 = userDao.objectsEqual(newUser1, userDao.queryForId(2));
61 
                    Log.i("bqt", "是否为同一对象：" + Arrays.asList(isEqual11, isEqual12));//[false, true]
62
63 
                    User newUser2 = userDao.createIfNotExists(User.newBuilder().string("包青天1").build());
64 
                    Log.i("bqt", new Gson().toJson(Arrays.asList(newUser1, newUser2)));
65 
                    break;
66 
                case 2:
67 
                    Dao.CreateOrUpdateStatus status1 = userDao.createOrUpdate(user);//[注意]上面添加了多个，但这里只更改了最后一个
68 
                    Log.i("bqt", "是否为同一对象：" + userDao.objectsEqual(user, userDao.queryForId(2)));//true
69
70 
                    Dao.CreateOrUpdateStatus status2 = userDao.createOrUpdate(User.newBuilder().string("包青天2").build());
71 
                    //[{"created":false,"numLinesChanged":1,"updated":true},{"created":true,"numLinesChanged":1,"updated":false}]
72 
                    Log.i("bqt", new Gson().toJson(Arrays.asList(status1, status2)));
73 
                    break;
74 
                case 3://使用DatabaseConnection
75 
                    DatabaseConnection dc = userDao.startThreadConnection();//也可以 new AndroidDatabaseConnection
76 
                    dc.setAutoCommit(false); //设置不自动提交
77
78 
                    Savepoint savePoint = dc.setSavePoint("savePointName");//设置回滚点，参数是一个名字，没什么影响
79 
                    for (User user : new User[]{user, user}) {
80 
                        userDao.createOrUpdate(user);
81 
                    }
82 
                    dc.commit(savePoint);//提交事务。保存大量数据时以事务的方式提交，可以大幅提高速度
83 
                    userDao.endThreadConnection(dc);
84 
                    break;
85 
                case 4://使用AndroidDatabaseConnection
86 
                    AndroidDatabaseConnection adc = new AndroidDatabaseConnection(helper.getWritableDatabase(), true);
87 
                    userRuntimeDao.setAutoCommit(adc, false);// 设置不自动提交
88 
                    Savepoint savePoint4 = adc.setSavePoint("savePointName");//设置回滚点，参数是一个名字，没什么影响
89 
                    for (User user : new User[]{user, User.newBuilder().string("包青天4").build()}) {
90 
                        userDao.createOrUpdate(user);
91 
                    }
92 
                    adc.commit(savePoint4);
93 
                    adc.rollback(savePoint4); // 回滚事物。一般用于在发生异常时进行回滚
94 
                    break;
95 
                case 5:
96 
                    int uNum1 = userDao.update(user);//[注意]同样更新的是最后添加的数据
97 
                    int uNum2 = userDao.update(User.newBuilder().build());
98 
                    int uNum3 = userDao.updateId(user, 100);//[注意]新添加的数据的id将从最大值开始
99 
                    int uNum4 = userDao.updateId(userDao.queryForId(3), -100);//[注意]值可以为负值
100 
                    Log.i("bqt", new Gson().toJson(Arrays.asList(uNum1, uNum2, uNum3, uNum4)));//[1,0,1,1]
101 
                    break;
102 
                case 6:
103 
                    int dNum1 = userDao.delete(user);//[注意]这个删掉的也是最后一个添加的数据，前面添加的数据已经和user脱离关联了
104 
                    int dNum2 = userDao.delete(user);
105 
                    int dNum3 = userDao.delete(Arrays.asList(user, User.newBuilder().build()));
106 
                    int dNum4 = userDao.deleteById(3);
107 
                    int dNum5 = userDao.deleteIds(Arrays.asList(5, 6, 7, 8));
108 
                    Log.i("bqt", new Gson().toJson(Arrays.asList(dNum1, dNum2, dNum3, dNum4, dNum5)));//[1,0,0,1,1]
109 
                    break;
110 
                case 7:
111 
                    QueryBuilder<User, Integer> builder = userDao.queryBuilder()
112 
                            .distinct()// 排重
113 
                            .groupBy("id")  //分组
114 
                            .limit(10L)//限制数量
115 
                            .offset(3L) //偏移
116 
                            .orderBy("date", true); //排序
117 
                    List<User> list = builder.where().like("string", "%包青天%").query();//条件查询
118 
                    Log.i("bqt", "查询到的数据：" + new Gson().toJson(list));
119 
                    break;
120 
                case 8:
121 
                    User data = userDao.queryForId(1);//如果不存在则返回 null
122 
                    long count = userDao.countOf();//总数量
123 
                    Log.i("bqt", count + " " + new Gson().toJson(data));
124 
                    Log.i("bqt", userDao.isTableExists() + " " + userDao.isUpdatable() + " " + userDao.idExists(1));
125 
                case 9:
126 
                    userDao.delete(userDao.queryForAll());
127 
                    break;
128 
            }
129 
            Log.i("bqt", "全部数据：" + new Gson().toJson(userDao.queryForAll()));
130 
        } catch (SQLException e) {
131 
            e.printStackTrace();
132 
        }
133 
    }
134 
}
2018-8-16

猜你喜欢

转载自www.cnblogs.com/baiqiantao/p/9484918.html
今日推荐
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
周排行
rbac——界面、权限
Apache CXF + SpringMVC 整合发布WebService
so插件化
Vue.js实战系列---图标字体制作（svg格式）
PAT乙级 1007 素数对猜想(孪生素数对) (20分) ---（C语言 + 详细注释）
被IRM保护的文档，打开失败
Calendar和Date计算日期差的小问题
win10子系统ubuntu18.4安装docker
利用Wrap Shell Script定位Android Native内存泄漏
MySQL: Transaction (Part I - Basic Concept)
每日归档
更多
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022