/**
* Store a list of records. A record that already exists will be updated. A transaction will be
* used. If there is a problem with storing one of the records the whole operation will be rolled
* back.
*
* @param records - the records to store or update
* @throws DBException in case of a database problem
* @throws IllegalArgumentException when the given record cannot be stored
* @throws IllegalStateException when the columns that are part of the primary key have not all
* been assigned a value
*/
public void store(List<Record> records)
throws DBException, IllegalArgumentException, IllegalStateException {
Boolean[] insert = new Boolean[records.size()];
startTransaction();
int r = 0;
try {
for (Record record : records)
if (isStorable(record)) insert[r++] = doStore(record);
else
throw new IllegalArgumentException(
String.format("Record (%s) cannot be stored!", record.toString(false)));
} catch (Exception e) {
rollbackTransactions();
throw new DBException(e);
}
commitTransaction();
// Inform client:
r = 0;
for (Record record : records) {
Boolean inserted = insert[r++];
if (inserted == null) continue; // record was unchanged
else if (inserted) client.storageEvent(RecordOperation.Inserted, record.getReference(), this);
else client.storageEvent(RecordOperation.Updated, record.getReference(), this);
}
}
/**
* Stores a single record, if it already exists it is updated. Note that this method does not
* start a new transaction. If this is a desired the client code should take care of that by first
* calling {@link #startTransaction()}. However, if an error occurs any open transaction will be
* rolled back!
*
* @param record - the record to store or update; records of internal schemata will be rejected
* @throws DBConstraintException when a table/index constraint is violated
* @throws DBException in case of a database problem
* @throws IllegalArgumentException when the given record cannot be stored
* @throws IllegalStateException when the columns that are part of the primary key have not all
* been assigned a value
*/
public void store(Record record)
throws DBException, IllegalArgumentException, IllegalStateException {
if (!isStorable(record))
throw new IllegalArgumentException(
String.format("Record (%s) cannot be stored!", record.toString(false)));
Boolean insert = null;
try {
insert = doStore(record);
} catch (DBException e) {
rollbackTransactions(); // !!!
throw e;
}
// Inform client:
if (insert == null) return; // record was unchanged
else if (insert) client.storageEvent(RecordOperation.Inserted, record.getReference(), this);
else client.storageEvent(RecordOperation.Updated, record.getReference(), this);
}
/**
* Deletes a single record. Note that this method does not start a new transaction. If this is a
* desired the client code should take care of that by first calling {@link #startTransaction()}.
* However, if an error occurs any open transaction will be rolled back!
*
* @param record - the record to delete
* @throws DBException
*/
public void delete(Record record) throws DBException {
if (!isStorable(record)) return;
try {
doDelete(record);
} catch (DBException e) {
rollbackTransactions(); // !!!
throw e;
}
// Inform client:
client.storageEvent(RecordOperation.Deleted, record.getReference(), this);
}
/**
* Insert a single record, if it already exists a DuplicateException will be thrown. Note that
* this method does not start a new transaction. If this is a desired the client code should take
* care of that by first calling {@link #startTransaction()}. However, if an error occurs any open
* transaction will be rolled back!
*
* @param record
* @throws DBPrimaryKeyException when the record already exists
* @throws DBConstraintException when a table/index constraint is violated
* @throws DBException in case of another database problem
* @throws IllegalArgumentException when the given record cannot be stored
* @throws IllegalStateException when the columns that are part of the primary key have not all
* been assigned a value
*/
public void insert(Record record)
throws DBPrimaryKeyException, DBConstraintException, DBException, IllegalArgumentException,
IllegalStateException {
if (!isStorable(record))
throw new IllegalArgumentException(
String.format("Record (%s) cannot be inserted!", record.toString(false)));
boolean inserted = false;
try {
inserted = doInsert(record);
} catch (DBException e) {
rollbackTransactions(); // !!!
throw e;
}
// Inform client if a real insert happened:
if (inserted) client.storageEvent(RecordOperation.Inserted, record.getReference(), this);
}
/**
* Deletes a series of records. A transaction will be used. Upon an error the whole operation will
* be rolled back.
*
* @param records - the records to delete
* @throws DBException
*/
public void delete(Collection<Record> records) throws DBException {
startTransaction();
List<Record> deleted = new ArrayList<Record>(records.size());
try {
for (Record record : records)
if (isStorable(record)) {
if (doDelete(record)) deleted.add(record);
}
} catch (DBException e) {
rollbackTransactions();
throw e;
}
commitTransaction();
// Inform client:
for (Record record : deleted)
client.storageEvent(RecordOperation.Deleted, record.getReference(), this);
}