import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
/**
 * 查询数据库中的所有已添加的城市
 *
 * @return 结果集中只包括城市信息，天气数据不在其中
 * @throws SQLException
 */
public List<Weather> queryAllSaveCity() throws SQLException {

    return TransactionManager.callInTransaction(WeatherDatabaseHelper.getInstance(context).getConnectionSource(), () -> {

        List<Weather> weatherList = weatherDaoOperation.queryForAll();
        for (Weather weather : weatherList) {
            String cityId = weather.getCityId();
            weather.setAirQualityLive(apiDaoOperation.queryForId(cityId));
            weather.setWeatherForecasts(forecastDaoOperation.queryForEq(WeatherForecast.CITY_ID_FIELD_NAME, cityId));
            weather.setLifeIndexes(lifeIndexesDaoOperation.queryForEq(WeatherForecast.CITY_ID_FIELD_NAME, cityId));
            weather.setWeatherLive(realTimeDaoOperation.queryForId(cityId));
        }
        return weatherList;
    });
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
public void updateContact(final ContactItem contact) {
    try {
        TransactionManager.callInTransaction(getConnectionSource(),
                new Callable<Void>() {
                    public Void call() throws Exception {
                        List<ContactItem> contacts = DatabaseHelper.this
                                .getDao(ContactItem.class).queryForEq(
                                        "username", contact.username);
                        if (contacts != null)
                            DatabaseHelper.this.getDao(ContactItem.class)
                                    .createOrUpdate(contact);
                        return null;
                    }
                });
        return;
    } catch (SQLException localSQLException) {
        localSQLException.printStackTrace();
    }
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
public void updateContactStatus(final String jid, final String status,
                                final int mood) {
    try {
        TransactionManager.callInTransaction(getConnectionSource(),
                new Callable<Void>() {
                    public Void call() throws Exception {

                        UpdateBuilder<ContactItem, ?> builder = getDao(
                                ContactItem.class).updateBuilder();
                        builder.updateColumnValue("status", status);
                        builder.updateColumnValue("mood", mood);
                        builder.where().eq("username",
                                JidCreate.bareFrom(jid));
                        getDao(ContactItem.class).update(builder.prepare());

                        return (Void) null;
                    }
                });
        return;
    } catch (SQLException localSQLException) {
        localSQLException.printStackTrace();
    }
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
public void updateContacts(final Collection<ContactItem> contactList) {
    if (contactList == null || contactList.size() == 0)
        return;
    try {
        TransactionManager.callInTransaction(getConnectionSource(),
                new Callable<Void>() {
                    public Void call() throws Exception {
                        Dao<ContactItem, ?> localDao = DatabaseHelper.this
                                .getDao(ContactItem.class);
                        for (ContactItem contact : contactList) {
                            localDao.createOrUpdate(contact);
                        }
                        return null;
                    }
                });
        return;
    } catch (SQLException localSQLException) {
        localSQLException.printStackTrace();
    }
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
/**
 * 数据批量处理
 *
 * @param list      要处理的数据集合
 * @param batchType 操作类型
 * @return
 */
private boolean doBatchInTransaction(final List<T> list, final int batchType) {
    boolean doBatch = false;
    ConnectionSource connectionSource = ormLiteDao.getConnectionSource();
    TransactionManager transactionManager = new TransactionManager(connectionSource);
    Callable<Boolean> callable = new Callable<Boolean>() {
        @Override
        public Boolean call() throws Exception {
            return doBatch(list, batchType);
        }
    };
    try {
        doBatch = transactionManager.callInTransaction(callable);
    } catch (SQLException e) {
        LogUtils.e(e);
    }
    return doBatch;
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
public static void createMessages(final ZulipApp app,
                                  final List<Message> messages) {
    try {
        TransactionManager.callInTransaction(app.getDatabaseHelper()
                .getConnectionSource(), new Callable<Void>() {
            public Void call() throws Exception {
                RuntimeExceptionDao<Message, Object> messageDao = app.getDao(Message.class);

                for (Message m : messages) {
                    Person person = Person.getOrUpdate(app, m.getSenderEmail(), m.getSenderFullName(), m.getAvatarUrl(), m.getSenderId());
                    m.setSender(person);
                    Stream stream = null;
                    if (m.getType() == MessageType.STREAM_MESSAGE) {
                        stream = Stream.getByName(app, m.getRecipients());
                    }
                    m.setStream(stream);
                    messageDao.createOrUpdate(m);
                }
                return null;
            }
        });
    } catch (SQLException e) {
        throw new RuntimeException(e);
    }
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
/**
 * Fills the Emoji Table with the existing emoticons saved in the assets folder.
 */
private void setupEmoji() {
    try {
        final RuntimeExceptionDao<Emoji, Object> dao = getDao(Emoji.class);
        if (dao.queryForAll().size() != 0) return;
        final String emojis[] = getAssets().list("emoji");
        TransactionManager.callInTransaction(getDatabaseHelper()
                        .getConnectionSource(),
                new Callable<Void>() {
                    public Void call() throws Exception {
                        for (String newEmoji : emojis) {
                            //currently emojis are in png format
                            newEmoji = newEmoji.replace(".png", "");
                            dao.create(new Emoji(newEmoji));
                        }
                        return null;
                    }
                });
    } catch (SQLException | IOException e) {
        ZLog.logException(e);
    }
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
private RnRForm createInitRnrForm(final RnRForm rnrForm) throws LMISException {
    try {
        TransactionManager.callInTransaction(LmisSqliteOpenHelper.getInstance(context).getConnectionSource(), new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                create(rnrForm);
                List<StockCard> stockCards = stockRepository.getStockCardsBeforePeriodEnd(rnrForm);
                rnrFormItemRepository.batchCreateOrUpdate(generateRnrFormItems(rnrForm, stockCards));
                regimenItemRepository.batchCreateOrUpdate(generateRegimeItems(rnrForm));
                baseInfoItemRepository.batchCreateOrUpdate(generateBaseInfoItems(rnrForm));
                genericDao.refresh(rnrForm);
                return null;
            }
        });
    } catch (SQLException e) {
        throw new LMISException(e);
    }

    assignCategoryForRnrItems(rnrForm);

    return rnrForm;
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
public void createOrUpdateProgramWithProduct(final List<Program> programs) throws LMISException {
    try {
        TransactionManager.callInTransaction(LmisSqliteOpenHelper.getInstance(context).getConnectionSource(), new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                for (Program program : programs) {
                    createOrUpdate(program);
                    for (Product product : program.getProducts()) {
                        productRepository.createOrUpdate(product);
                    }
                }
                return null;
            }
        });
    } catch (SQLException e) {
        throw new LMISException(e);
    }
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
public void addStockMovementAndUpdateStockCard(final StockMovementItem stockMovementItem) {
    try {
        TransactionManager.callInTransaction(LmisSqliteOpenHelper.getInstance(context).getConnectionSource(), new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                StockCard stockcard = stockMovementItem.getStockCard();
                createOrUpdate(stockcard);
                stockMovementRepository.batchCreateStockMovementItemAndLotItems(stockMovementItem);
                return null;
            }
        });
    } catch (SQLException e) {
        new LMISException(e).reportToFabric();
    }

}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
public void batchCreateSyncDownStockCardsAndMovements(final List<StockCard> stockCards) {
    try {
        TransactionManager.callInTransaction(LmisSqliteOpenHelper.getInstance(context).getConnectionSource(), new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                for (StockCard stockCard : stockCards) {
                    if (stockCard.getId() <= 0) {
                        saveStockCardAndBatchUpdateMovements(stockCard);
                    } else {
                        stockMovementRepository.batchCreateOrUpdateStockMovementsAndLotMovements(stockCard.getStockMovementItemsWrapper());
                    }
                }
                return null;
            }
        });
    } catch (SQLException e) {
        new LMISException(e).reportToFabric();
    }
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
/**
 * Execute a script in a SQLiteDatabase.
 *
 * @param context           Context of the application.
 * @param connectionSource  ConnectionSource.
 * @param database          SQLiteDatabase where the script must be executed.
 * @param sqlScriptFilename Name of the script to execute.
 * @throws IOException
 * @throws SQLException
 */
private static void executeSqlScript(final Context context, final ConnectionSource connectionSource, final SQLiteDatabase database, final String sqlScriptFilename) throws IOException, SQLException {
    final BufferedReader reader = new BufferedReader(new InputStreamReader(context.getAssets().open(sqlScriptFilename)));
    TransactionManager.callInTransaction(connectionSource, (new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            String line;
            while ((line = reader.readLine()) != null) {
                Timber.i("executing sql : %s", line);
                database.execSQL(line);
            }
            return null;
        }
    }));
    reader.close();
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
public int saveHist(final WeightHistory savedEntity) {
    int ret = 0;

    try {
        ret = TransactionManager.callInTransaction(mDao.getConnectionSource(), new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {

                Dao.CreateOrUpdateStatus status = mDao.createOrUpdate(savedEntity);
                return status.getNumLinesChanged();
            }
        });
    } catch (SQLException e) {
        e.printStackTrace();
    }

    return ret;
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
public boolean erase(final WeightHistory historyEntity) {
    boolean ret = false;

    try {
        ret = TransactionManager.callInTransaction(mDao.getConnectionSource(), new Callable<Boolean>() {
            @Override
            public Boolean call() throws Exception {

                int affected = mDao.delete(historyEntity);

                return affected > 0 ? true : false;
            }
        });
    } catch (SQLException e) {
        e.printStackTrace();
    }

    return ret;
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
/**
 * Deletes a BusinessObject
 *
 * @param bo the BusinessObject to delete
 *
 * @return Status code if it was successful
 *
 * @throws SQLException
 */
@Override
public STATUS_CODE delete(final BusinessObjectType bo) throws SQLException
{
	return TransactionManager.callInTransaction(
			this.db.getConnectionSource(), new Callable<STATUS_CODE>()
	{
		@Override
		public STATUS_CODE call() throws SQLException
		{
			beforeDelete(bo);
			if (dao.delete(bo) == 1) {
				afterDelete(bo);
				return STATUS_CODE.OK;
			}

			return STATUS_CODE.FAIL;
		}
	}
	);
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
/**
 * Soft deletes (set deleted to 1) a BusinessObject
 *
 * @param bo the BusinessObject to soft-delete
 *
 * @return Status code if it was successful
 *
 * @throws SQLException
 */
public STATUS_CODE softDelete(final BusinessObjectType bo) throws SQLException
{
	return TransactionManager.callInTransaction(
			this.db.getConnectionSource(),
			new Callable<STATUS_CODE>()
			{
				@Override
				public STATUS_CODE call() throws SQLException
				{
					beforeSoftDelete(bo);
					bo.setDeleted(true);
					if (dao.update(bo) == 1) {
						afterSoftDelete(bo);
						return STATUS_CODE.OK;
					}

					return STATUS_CODE.FAIL;
				}
			}
	);
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
/**
 * Saves a BusinessObject to DB
 *
 * @param bo the BusinessObject to save
 *
 * @return Status code if it was successful
 *
 * @throws SQLException
 */
@Override
public STATUS_CODE save(final BusinessObjectType bo) throws SQLException
{
	return TransactionManager.callInTransaction(
			this.db.getConnectionSource(), new Callable<STATUS_CODE>()
	{
		@Override
		public STATUS_CODE call() throws SQLException
		{
			beforeSave(bo);
			Dao.CreateOrUpdateStatus status = dao.createOrUpdate(bo);
			if (status.isCreated() || status.isUpdated()) {
				afterSave(bo);
				return STATUS_CODE.OK;
			}

			return STATUS_CODE.FAIL;
		}
	}
	);
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
public void saveReceive(final Receive receive) throws Exception{
        TransactionManager.callInTransaction(LmisSqliteOpenHelper.getInstance(context).getConnectionSource(), new
                Callable<Object>() {
                    @Override
                    public Object call() throws Exception {
                        GenericDao<Receive> receiveDao = new GenericDao<>(Receive.class, context);
                        receiveDao.create(receive);
                        saveReceiveItems(receive.getReceiveItems());

                        if (receive.getAllocation() != null) {
                            Allocation allocation = receive.getAllocation();
                            allocation.setReceived(true);
                            if (!allocation.isDummy()) {
                                allocationService.update(allocation);
                                alertsService.deleteAllocationAlert(allocation);
                            } else {
                                allocationService.createAllocation(allocation);
                                EventBus.getDefault().post(new AllocationCreateEvent(receive.getAllocation()));
                            }
                        }
                        return null;
                    }
                });
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
/**
 * Example of created a query with a ? argument using the {@link SelectArg} object. You then can set the value of
 * this object at a later time.
 */
private void useTransactions(ConnectionSource connectionSource) throws Exception {
	String name = "trans1";
	final Account account = new Account(name);
	assertEquals(1, accountDao.create(account));

	TransactionManager transactionManager = new TransactionManager(connectionSource);
	try {
		// try something in a transaction
		transactionManager.callInTransaction(new Callable<Void>() {
			@Override
			public Void call() throws Exception {
				// we do the delete
				assertEquals(1, accountDao.delete(account));
				assertNull(accountDao.queryForId(account.getId()));
				// but then (as an example) we throw an exception which rolls back the delete
				throw new Exception("We throw to roll back!!");
			}
		});
		fail("This should have thrown");
	} catch (SQLException e) {
		// expected
	}

	assertNotNull(accountDao.queryForId(account.getId()));
}
 

import com.j256.ormlite.misc.TransactionManager; //导入依赖的package包/类
public void testAutoCommitOff() throws Exception {
	final Dao<Foo, Integer> dao = createDao(Foo.class, true);
	final Foo foo = new Foo();
	foo.stuff = "stuffery";
	DatabaseConnection conn = dao.startThreadConnection();
	try {
		dao.setAutoCommit(conn, false);
		TransactionManager.callInTransaction(connectionSource, new Callable<Void>() {
			public Void call() throws Exception {
				assertEquals(1, dao.create(foo));
				return null;
			}
		});
		// close and open the connection
		closeConnectionSource();
		openConnectionSource();
		Foo result = dao.queryForId(foo.id);
		assertNotNull(result);
		assertEquals(foo.stuff, result.stuff);
	} finally {
		dao.endThreadConnection(conn);
	}
}