/** * Save all the beans from an Iterator. */ public static int save(Iterator<?> iterator) throws OptimisticLockException { return serverMgr.getPrimaryServer().save(iterator); }
@Override public void update(Object bean, Transaction t) throws OptimisticLockException { delegate.update(bean, t); }
/** * Delete the bean. * <p> * If there is no current transaction one will be created and committed for * you automatically. * </p> */ public static void delete(Object bean) throws OptimisticLockException { serverMgr.getPrimaryServer().delete(bean); }
@Override protected void doEndTxIfActive(Object delegate) { Transaction tx = ebean.currentTransaction(); if (null == tx) { return; } if (TxContext.readOnly()) { ebeanReadOnly.endTransaction(); } else { ebean.commitTransaction(); } }
@Override protected void doRollbackTx(Object delegate, Throwable cause) { Transaction tx = ebean.currentTransaction(); if (null == tx) { return; } if (TxContext.readOnly()) { ebeanReadOnly.endTransaction(); } else { logger.warn(cause, "Roll back transaction"); ebean.rollbackTransaction(); } }
List<EBeanAccount> accounts = db.find(EBeanAccount.class).where().eq("type", "player").findList(); List<String> names = new LinkedList<>(); db.beginTransaction(); db.update(account); } else { log.info("No UUID found for player " + name); db.commitTransaction(); db.endTransaction(); } catch (Exception e) { log.log(Level.WARNING,
@Override public Integer getProjectsCount() { return ebean.find(ProjectEntity.class).findCount(); } }
private List<Object> findIdsByParentIdList(List<Object> parentIdist, Transaction t) { String rawWhere = deriveWhereParentIdSql(true); String inClause = targetIdBinder.getIdInValueExpr(parentIdist.size()); String expr = rawWhere+inClause; EbeanServer server = getBeanDescriptor().getEbeanServer(); Query<?> q = (Query<?>)server.find(getPropertyType()) .where().raw(expr); for (int i = 0; i < parentIdist.size(); i++) { bindWhereParendId(q, parentIdist.get(i)); } return server.findIds(q, t); }
/** * Create a transaction if one is not already active and set its batch mode * and batch size. */ protected void initTransactionIfRequired() { transaction = server.currentTransaction(); if (transaction == null || !transaction.isActive()) { transaction = server.beginTransaction(); createdTransaction = true; if (persistBatchSize > 1) { logger.info("Creating transaction, batchSize[" + persistBatchSize + "]"); transaction.setBatchMode(true); transaction.setBatchSize(persistBatchSize); } else { // explicitly turn off JDBC batching in case // is has been turned on globally transaction.setBatchMode(false); logger.info("Creating transaction with no JDBC batching"); } } }
EbeanServer server = Ebean.getServer(null); Transaction transaction = server.beginTransaction(); try { // Use JDBC batch API with a batch size of 100 transaction.setBatchSize(100); // Don't bother getting generated keys transaction.setBatchGetGeneratedKeys(false); // Skip cascading persist transaction.setPersistCascade(false); // persist your beans ... Iterator<YourEntity> it = null; // obviously should not be null while (it.hasNext()) { YourEntity yourEntity = it.next(); server.save(yourEntity); } transaction.commit(); } finally { transaction.end(); }
public <T> Query<T> createQuery(Class<T> beanType, String eql) { return delegate.createQuery(beanType, eql); }
/** * Start a transaction additionally specifying the isolation level. * * @param isolation * the Transaction isolation level * */ public static Transaction beginTransaction(TxIsolation isolation) { return serverMgr.getPrimaryServer().beginTransaction(isolation); }
List<DerbyDAO.DerbyAccountChest> chests = derbyDAO.getChestsRaw(); db.beginTransaction(); for (DerbyDAO.DerbyAccount da : accounts) { EBeanAccount acc = new EBeanAccount(); acc.setCents(da.cents); db.insert(acc); chest.setAccount(dac.account); db.insert(chest); db.commitTransaction();
/** * Create a <a href="SqlQuery.html">SqlQuery</a> for executing native sql * query statements. * <p> * Note that you can use raw SQL with entity beans, refer to the SqlSelect * annotation for examples. * </p> */ public static SqlQuery createSqlQuery(String sql) { return serverMgr.getPrimaryServer().createSqlQuery(sql); }
/** * Create a sql update for executing native dml statements. * <p> * Use this to execute a Insert Update or Delete statement. The statement will * be native to the database and contain database table and column names. * </p> * <p> * See {@link SqlUpdate} for example usage. * </p> */ public static SqlUpdate createSqlUpdate(String sql) { return serverMgr.getDefaultServer().createSqlUpdate(sql); }
@Override public void drop() { String sql = "DELETE from " + tableName; SqlUpdate sqlUpdate = ebean_(false).createSqlUpdate(sql); ebean_(false).execute(sqlUpdate); }
/** * Returns the current transaction or null if there is no current transaction * in scope. */ public static Transaction currentTransaction() { return serverMgr.getDefaultServer().currentTransaction(); }
/** * Commit the current transaction. */ public static void commitTransaction() { serverMgr.getPrimaryServer().commitTransaction(); }
/** * Retrieves an entity by ID. * <p> * Equivalent to {@link EbeanServer#find(Class, Object)} */ @Nullable public T byId(I id) { return db().find(type, id); }
private List<Object> findIdsByParentId(Object parentId, Transaction t) { String rawWhere = deriveWhereParentIdSql(false); List<Object> bindValues = new ArrayList<>(); bindWhereParentId(bindValues, parentId); EbeanServer server = getBeanDescriptor().getEbeanServer(); Query<?> q = server.find(getPropertyType()) .where() .raw(rawWhere, bindValues.toArray()) .query(); return server.findIds(q, t); }