result = db.queryObject(new Customer("jjohnson"));
if (result.hasNext())
{
Customer customer = result.next();
customer.setPassword("newPasswd");
db.saveObject(customer);
// or we could just update the column
// result.setColumnValue("password", "newPasswd");
// result.updateRow();
}
result = db.queryObject(Customer.class);
for (Customer c : result)
System.out.println(c);
}
finally
{
// Always close as soon as possible when connection pooled
db.close();
}
}
/* Stored Procedures
*
* EJP even makes working with stored procedures and functions easy to handle. Simply use
* the JDBC stored procedure syntax:
*
*
* {?= call [(?, ?, ?, ...)]}
* {call [(?, ?, ?, ...)]}
*
*
* and one or more of InParameter, OutParameter, and InOutParameter. storedprocedure()
* returns a Result that may have one or more results and/or update counts that can be
* accessed with getMoreResults(), isUpdateCount(), getUpdateCount().
*
* When done, you can access the out parameters by retrieving the CallableStatement with
* getStatement().
*/
static void storedProcedures(DatabaseManager dbm) throws DatabaseException, SQLException
{
Database db = dbm.getDatabase();
try
{
Result result = db.storedProcedure("{call getCustomerOrdersAndSupport(?,?)}",
new InParameter(1, "deisenhower"),
new OutParameter(2, Types.DOUBLE, 2));
// Map orders from the orders cursor
for (Order order : (Result)result.getResultSetWithClass(Order.class))
{
order.setStatus("verified");
db.saveObject(order);
System.out.println(order);
}
result.getMoreResults();
// Map support from the support cursor
for (Support s : (Result)result.getResultSetWithClass(Support.class))
System.out.println(s);
System.out.println("Order total: " + ((CallableStatement)result.getStatement()).getDouble(2));
}
finally { db.close(); }
}
/* Transactions
*
* With ejp.DatabaseManager, saveObject() is always enclosed in a transaction. The object being
* saved, and its associations, are all inclosed in the transaction.
*
* With ejp.Database, transactions are automatic when auto commit is true (the default state). Otherwise,
* saveObject(), executeUpdate(), and parameterizedUpdated() will all be enclosed in the transaction that
* was started when auto commit became false (beginTransaction()).
*
* when you need more transaction control you can use ejp.TransactionManager or you can use
* ejp.Database's beginTransaction(), commit(), rollback(), setSavepoint(), and endTransaction().
*
* When using ejp.TransactionManager, you have to use ejp.TransactionManager's methods saveObject(), commit(),
* rollback(), setSavepoint(). You can also get the handle to the ejp.Database that is being used with
* getDatabase().
*/
static void transactions(DatabaseManager dbm) throws DatabaseException
{
new TransactionManager(dbm)
{
public void run()
{
// do your work
}
}.executeTransaction();
// or
Database db = dbm.getDatabase();
try
{
db.beginTransaction();
// do your work
db.endTransaction();
}
finally { db.close(); }
}
/*
* Obviously, we're just touching upon the functionality and all the things you can do with EJP,
* but the above is the majority of what you would do from day to day and project to project.
*/
public static void main(String[] args) throws DatabaseException
{
DatabaseManager dbm = getTheDatabaseManager();
// creates an in-memory database for us to play with
CreateDatabase.createHSQLDatabase(dbm);
insertingAndUpdatingObjects(dbm);
databaseManagerQueries(dbm);
theEjpDatabaseWay(dbm);
}
}