Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.j256.ormlite.examples.simple;
  
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertNotNull;
  import static org.junit.Assert.assertNull;
  import static org.junit.Assert.assertTrue;
  import static org.junit.Assert.fail;
  
 import java.util.List;
 import java.util.Map;
 
Main sample routine to show how to do basic operations with the package.

NOTE: We use asserts in a couple of places to verify the results but if this were actual production code, we would have proper error handling.

 
 public class Main {
 
 	// we are using the in-memory H2 database
 	private final static String DATABASE_URL = "jdbc:h2:mem:account";
 
 	private Dao<AccountIntegeraccountDao;
 
 	public static void main(String[] argsthrows Exception {
 		// turn our static method into an instance of Main
 		new Main().doMain(args);
 	}
 
 	private void doMain(String[] argsthrows Exception {
 		JdbcConnectionSource connectionSource = null;
 		try {
 			// create our data-source for the database
 			connectionSource = new JdbcConnectionSource();
 			// setup our database and DAOs
 			setupDatabase(connectionSource);
 			// read and write some data
 			// do a bunch of bulk operations
 			// show how to use the SelectArg object
 			// show how to use the SelectArg object
 			useTransactions(connectionSource);
 			..println("\n\nIt seems to have worked\n\n");
 		} finally {
 			// destroy the data source which should close underlying connections
 			if (connectionSource != null) {
 				connectionSource.close();
 			}
 		}
 	}

Setup our database and DAOs
 
 	private void setupDatabase(ConnectionSource connectionSourcethrows Exception {
 
 		 = DaoManager.createDao(connectionSourceAccount.class);
 
 		// if you need to create the table
 		TableUtils.createTable(connectionSourceAccount.class);
 	}

Read and write some example data.
 
 	private void readWriteData() throws Exception {
 		// create an instance of Account
 		String name = "Jim Coakley";
 		Account account = new Account(name);
 
 		// persist the account object to the database
 		.create(account);
 		int id = account.getId();
 		verifyDb(idaccount);
 
 		// assign a password
 		account.setPassword("_secret");
 		// update the database after changing the object
 		.update(account);
 		verifyDb(idaccount);
 
 		// query for all items in the database
		assertEquals("Should have found 1 account matching our query", 1, accounts.size());
		verifyAccount(accountaccounts.get(0));
		// loop through items in the database
		int accountC = 0;
		for (Account account2 : ) {
			verifyAccount(accountaccount2);
			accountC++;
		}
		assertEquals("Should have found 1 account in for loop", 1, accountC);
		// construct a query using the QueryBuilder
		// shouldn't find anything: name LIKE 'hello" does not match our account
		statementBuilder.where().like(."hello");
		accounts = .query(statementBuilder.prepare());
		assertEquals("Should not have found any accounts matching our query", 0, accounts.size());
		// should find our account: name LIKE 'Jim%' should match our account
		statementBuilder.where().like(.name.substring(0, 3) + "%");
		accounts = .query(statementBuilder.prepare());
		assertEquals("Should have found 1 account matching our query", 1, accounts.size());
		verifyAccount(accountaccounts.get(0));
		// delete the account since we are done with it
		// we shouldn't find it now
		assertNull("account was deleted, shouldn't find any".queryForId(id));
	}

Example of reading and writing a large(r) number of objects.
	private void readWriteBunch() throws Exception {
		Map<StringAccountaccounts = new HashMap<StringAccount>();
		for (int i = 1; i <= 100; i++) {
			String name = Integer.toString(i);
			Account account = new Account(name);
			// persist the account object to the database, it should return 1
			accounts.put(nameaccount);
		}
		// query for all items in the database
		assertEquals("Should have found same number of accounts in map"accounts.size(), all.size());
		for (Account account : all) {
			assertTrue("Should have found account in map"accounts.containsValue(account));
			verifyAccount(accounts.get(account.getName()), account);
		}
		// loop through items in the database
		int accountC = 0;
		for (Account account : ) {
			assertTrue("Should have found account in map"accounts.containsValue(account));
			verifyAccount(accounts.get(account.getName()), account);
			accountC++;
		}
		assertEquals("Should have found the right number of accounts in for loop"accounts.size(), accountC);
	}

Example of created a query with a ? argument using the com.j256.ormlite.stmt.SelectArg object. You then can set the value of this object at a later time.
	private void useSelectArgFeature() throws Exception {
		String name1 = "foo";
		String name2 = "bar";
		String name3 = "baz";
		SelectArg selectArg = new SelectArg();
		// build a query with the WHERE clause set to 'name = ?'
		statementBuilder.where().like(.selectArg);
		PreparedQuery<AccountpreparedQuery = statementBuilder.prepare();
		// now we can set the select arg (?) and run the query
		selectArg.setValue(name1);
		List<Accountresults = .query(preparedQuery);
		assertEquals("Should have found 1 account matching our query", 1, results.size());
		assertEquals(name1results.get(0).getName());
		selectArg.setValue(name2);
		results = .query(preparedQuery);
		assertEquals("Should have found 1 account matching our query", 1, results.size());
		assertEquals(name2results.get(0).getName());
		selectArg.setValue(name3);
		results = .query(preparedQuery);
		assertEquals("Should have found 1 account matching our query", 1, results.size());
		assertEquals(name3results.get(0).getName());
	}

Example of created a query with a ? argument using the com.j256.ormlite.stmt.SelectArg object. You then can set the value of this object at a later time.
	private void useTransactions(ConnectionSource connectionSourcethrows Exception {
		String name = "trans1";
		final Account account = new Account(name);
		TransactionManager transactionManager = new TransactionManager(connectionSource);
		try {
			// try something in a transaction
			transactionManager.callInTransaction(new Callable<Void>() {
				public Void call() throws Exception {
					// we do the delete
					// 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
		}
	}

Verify that the account stored in the database was the same as the expected object.
	private void verifyDb(int idAccount expectedthrows SQLExceptionException {
		// make sure we can read it back
		Account account2 = .queryForId(id);
		if (account2 == null) {
			throw new Exception("Should have found id '" + id + "' in the database");
		}
		verifyAccount(expectedaccount2);
	}

Verify that the account is the same as expected.
	private static void verifyAccount(Account expectedAccount account2) {
		assertEquals("expected name does not equal account name"expectedaccount2);
		assertEquals("expected password does not equal account name"expected.getPassword(), account2.getPassword());
	}
New to GrepCode? Check out our FAQ X