@SuppressWarnings("unchecked") private void performBeginTransaction(Subscriber<? super T> subscriber) { query.context().beginTransactionObserve(); debug("beginTransaction emitting 1"); subscriber.onNext((T) Integer.valueOf(1)); debug("emitted 1"); complete(subscriber); }
/** * Rolls back the current transaction. Throws {@link RuntimeException} if * connection is in autoCommit mode. * * @param subscriber * @param state */ @SuppressWarnings("unchecked") private void performRollback(Subscriber<? super T> subscriber, State state) { debug("rolling back"); query.context().endTransactionObserve(); Conditions.checkTrue(!Util.isAutoCommit(state.con)); Util.rollback(state.con); // must close before onNext so that connection is released and is // available to a query that might process the onNext close(state); subscriber.onNext((T) Integer.valueOf(0)); debug("rolled back"); complete(subscriber); }
@Override public void call(Subscriber<? super T> subscriber) { final State state = new State(); try { if (isBeginTransaction()) performBeginTransaction(subscriber); else { query.context().setupBatching(); getConnection(state); subscriber.add(createUnsubscriptionAction(state)); if (isCommit()) performCommit(subscriber, state); else if (isRollback()) performRollback(subscriber, state); else performUpdate(subscriber, state); } } catch (Throwable e) { query.context().endTransactionObserve(); query.context().endTransactionSubscribe(); try { close(state); } finally { handleException(e, subscriber); } } }
/** * Commits the current transaction. Throws {@link RuntimeException} if * connection is in autoCommit mode. * * @param subscriber * @param state */ @SuppressWarnings("unchecked") private void performCommit(Subscriber<? super T> subscriber, State state) { getConnection(state); query.context().endTransactionObserve(); if (subscriber.isUnsubscribed()) return; debug("committing"); Conditions.checkTrue(!Util.isAutoCommit(state.con)); Util.commit(state.con); // must close before onNext so that connection is released and is // available to a query that might process the onNext close(state); if (subscriber.isUnsubscribed()) return; subscriber.onNext((T) Integer.valueOf(1)); debug("committed"); complete(subscriber); }
return; if (query.context().batchSize() > 1 && !query.context().isTransactionOpen()) { throw new SQLRuntimeException("batching can only be performed within a transaction"); Observable<Object> depends = Observable.empty(); Observable<T> o = new QuerySelect(QuerySelect.RETURN_GENERATED_KEYS, params, depends, query.context(), query.context().resultSetTransform()) .execute(query.returnGeneratedKeysFunction()); Subscriber<T> sub = createSubscriber(subscriber);
static <T> Observable<T> get(QueryUpdate<T> queryUpdate) { if (queryUpdate.context().batchSize() > 1) { return bufferedParameters(queryUpdate) // // mark the last parameter list as such .compose(Transformers.mapLast(toFinalArrayList))// // execute query for each set of parameters .concatMap(queryUpdate.executeOnce()); } else { return bufferedParameters(queryUpdate) // // execute query for each set of parameters .concatMap(queryUpdate.executeOnce()); } }