WebSimpleDB API

3.2.1. Opening a database connection

var db = new DatabaseSync('AddressBook', '1', 'Address Book', function(txn, db) {...});

The synchronous API for databases blocks the calling thread until a DatabaseSync object is ready to return. Moreover, this API also throws a DatabaseException if an error occurs while the database is being opened.

[Constructor(in          DOMString       name, 
             in          DOMString       version, 
             in          DOMString       displayName, 
             in optional UpgradeCallback upgrade)]
interface DatabaseSync : Database {
  ObjectStoreSync getObjectStore(in          DOMString      name,
                                 in optional unsigned short mode) 
                                 raises      DatabaseException;
  IndexSync       getIndex(      in          DOMString name, 
                                 in          DOMString storeName) 
                                 raises      DatabaseException;
  TransactionSync transaction(   in optional DOMStringList storeNames, 
                                 in optional unsigned int  timeout) 
                                 raises      DatabaseException;
};

The DatabaseSync constructor takes the following arguments: a database name, a database version, a display name, and optionally an upgrade callback and isolation level. When this constructor is invoked, the user agent must run the following steps:

1. Perform the database opening steps, and call its result as result.
2. If the steps were aborted due to an error, then throw a newly constructed DatabaseException exception with the code of that error and abort these steps.
3. Return result.

When the user agent is to perform database opening steps, with a database name, a database version, a display name, and optionally an upgrade callback, it must perform the following steps with all but the first two and the last steps being run atomically:

1. Pick the appropriate steps

   If this method is invoked from an active document

   Let origin be the origin of the active document from which the method was invoked.

   If this method is invoked from a worker

   Let origin be the origin of the scripts in the worker.

2. If there is already a database with the given name from the origin origin, then let db be that database.
3. If the database version provided is not the empty string, and the db's version is different than the version provided to these steps, then set the needs upgrade flag.
4. If no database with the given name from the origin origin exists, then
   1. Create the database db with the name and display name passed to these steps, and let db's version be the empty string.
   2. Set the needs upgrade flag.
5. If needs upgrade flag is set and no upgrade callback is passed to these steps, then abort these steps with INVALID_STATE_ERR.
6. Pick the appropriate steps:

   If these steps are performed to synchronously open a database

   Let result be a newly constructed DatabaseSync object representing a connection to db.

   If these steps are performed to asynchronously open a database

   Let result be a newly constructed Database object representing a connection to db.

7. If needs upgrade is true, then perform the following steps:
   1. Create an exclusive transaction for result.
   2. If a system-level timeout duration is exceeded when creating the transaction, then abort these steps with TIMEOUT_ERR.
   3. Create a new Upgrade object called upgrade for the transaction just created.

   4. Queue a task to invoke the upgrade callback with upgrade and result as its arguments.

      If the callback throws an exception, abort these steps with UNKNOWN_ERR.

   5. Wait for task to be completed.
   6. Commit the transaction for upgrade.
   7. Store the verson passed to this method in db.
8. Return result.

getObjectStore()

This method returns an ObjectStoreSync object to access the object store identified by the given name in the database to which this DatabaseSync object is connected. The mode passed to this method is used to create the

If an object store with the given name, compared in a case-sensitive manner, does not already exist in the database, then this method will throw a newly constructed DatabaseException exception with code NOT_FOUND_ERR.

getIndex()

This method returns an IndexSync object representing the named index on the given object store in this database.

If an index with the given name, compared in a case-sensitive manner, does not already exist, then this method will throw a newly constructed DatabaseException exception with code NOT_FOUND_ERR.

transaction()

Perform the transaction creation steps with the array of database objects for acquiring locks required in this transaction and an optional timeout duration, and return the resulting TransactionSync object.

3.2.2. Upgrading databases

var dbReq = new DatabaseRequest();
var upgrade = 
  function(changes, db) {
    changes.createObjectStore('Contact', 'id');
    // after this - db.version === '1'          
  };
dbReq.open('AddressBook', '1', 'Address Book', upgrade);

var upgrade = 
  function(changes, db) {
    // db.version === '1'
    changes.createIndex('ContactName', 'Contact', 'name', Index.MANY_TO_ONE);
    // after this - db.version === '2'
  };
var db = new DatabaseSync('AddressBook', '2', 'Address Book', upgrade);

interface Upgrade {
  void createObjectStore(in          DOMString name, 
                         in          DOMString primaryKeyPath, 
                         in optional boolean   autoIncrement) 
                         raises DatabaseException;
  void createIndex(      in          DOMString      name, 
                         in          DOMString      storeName,
                         in          DOMString      keyPath, 
                         in optional unsigned short cardinality) 
                         raises DatabaseException;

  void removeObjectStore(in DOMString storeName) raises DatabaseException;
  void removeIndex(     in DOMString indexName, 
                        in DOMString storeName) 
                        raises DatabaseException;
};

[Callback=FunctionOnly, NoInterfaceObject]
interface UpgradeCallback {
  void upgrade(in Upgrade  txn,
               in Database db);
};

createObjectStore()

This method creates a new object store with the given name. The path of the primary key in objects stored in this object store is required to correctly create a unique identifier for each object. This path cannot be the empty string. If an optional sequence name is also provided, then the named sequence is used to populate a value in the object at the key path and that value is stored as the key value for the object.

If an object store with the same name, compared in a case-sensitive manner, already exists, then this method will throw a newly constructed DatabaseException exception with code CONSTRAINT_ERR. If a sequence name is given for generating primary keys but a sequence with that name does not exist, then this method will throw a newly constructed DatabaseException exception with code NOT_FOUND_ERR.

createIndex()

This method is used to define a new index on this object store. An index is created using four required parameters - name, object store name, key path, and cardinality - and two optional parameters - action to be performed when related object is deleted, and the name of the related object.

If an index with the same name, compared in a case-sensitive manner, already exists, then this method will throw a newly constructed DatabaseException exception with code CONSTRAINT_ERR. If the object store with the given name does not exist, then this method will throw a newly constructed DatabaseException exception with code NOT_FOUND_ERR.

removeObjectStore()

This method is used to destroy the object store as well as all associated indices.

If an object store with the given name, compared in a case-sensitive manner, does not already exist, then this method will throw a newly constructed DatabaseException exception with code NOT_FOUND_ERR.

removeIndex()

This method is used to destroy the named index on the given object store.

If an index with the given name does not exist on the named object store, then this method will throw a newly constructed DatabaseException exception with code NOT_FOUND_ERR.

3.2.3. Object Store

An object store is a persistent structure that holds key-value pairs sorted by keys so as to enable fast insertion and look up as well as ordered retrieval. The store provides a mechanism by which to read and write stored objects. Operations on an object store must follow the transaction used to create or obtain the object store.

Each ObjectStore object provides access to a set of key/value pairs, which are sometimes called items. Values can be any data type supported by the structured clone algorithm [HTML5]. Keys themselves can be of any simple data type. They can be extracted from objects being stored or generated from a monotonic sequence.

An object store does not allow multiple items to be stored with the same primary. key. If the same key is used to store a different item, then it will replace the object currently stored with the same key.

var upgrade = function(changes, db) {
                changes.createObjectStore('Contact', 'id', true);
              });

var db = new DatabaseSync('AddressBook', '1', 'Address Book', upgrade);

var store = db.getObjectStore('Contact');

var lincoln = {name: 'Lincoln', number: '7012'};
var contact = store.put(lincoln);
// contact.id === 1

var contact = store.get(1);
// contact.name === 'Lincoln'

var abraham = {id: 1, name: 'Abraham', number: '2107'};
store.put(abraham);

var contact = store.get(1);
// contact.id === 1 && contact.name === 'Abraham';

var range = new CursorRange(2, 4, CursorRange.INCLUDE_START & CursorRange.INCLUDE_END);
var count = store.forEach(function(key, cursor, value) {
              // each value is a contact and each key is the id for that  
              // contact whose id is between 2 and 4, both inclusive
              }, range);

An object store arranges stored objects by their key, also referred to as the primary key. Each object contains the value of its primary key. Additionally, object stores may also have one or more secondary keys declared for stored objects. Indices store data about secondary keys and refer to a primary key somewhere in the object store.

interface ObjectStore {  
           const     unsigned short READ_WRITE    = 1;
           const     unsigned short READ_ONLY     = 2;
           const     unsigned short DETACHED_READ = 6;

  readonly attribute DOMString      name;
  readonly attribute DOMString      keyPath;
  readonly attribute DOMStringList  indexNames;
  readonly attribute unsigned short mode;
};

interface ObjectStoreSync : ObjectStore {
  unsigned long long forEach(in          CursorCallback callback,
                             in optional CursorRange    range, 
                             in optional unsigned short direction);

  any                put(    in any obj) raises DatabaseException;
  void               delete( in any key) raises DatabaseException;
  any                get(    in any key) raises DatabaseException;
};

On getting, name will provide the name of the object store.

On getting, keyPath will provide the path of the key used as the primary key of objects stored in this object store. This path can be the empty string if the object value is used as the key.

On getting, indexNames will provide a list of the names of indexes on objects in this object store.

The put() method is used to store the given object in the object store. Insert the object by performing the insertion steps.

The get() method is used to retrieve the object associated with the given key in the object store. The following steps must be run for retrieving the object with the following parameters: key.

1. If key is not defined or null, then throw a newly constructed DatabaseException exception with code NOT_FOUND_ERR and terminate these steps.
2. Use the key to look up an object in the object store. Let value be that object.
3. If object is not found in the object store, then throw a newly constructed DatabaseException exception with code NOT_FOUND_ERR and terminate these steps.

The delete() method is used to delete the object associated with the given key in the object store. Delete the object by performing the deletion steps.

3.2.4. Index

Usually database objects are retrieved by means of the object's key. However, the key used for an object will not always contain the information required to provide rapid access to the data that may be needed.

var upgrade = function(changes, db) {
                changes.createObjectStore('Contact', 'id', true);
                changes.createIndex('ContactName', 'Contact', 'name', Index.MANY_TO_ONE);
              });

var index = db.getIndex('ContactName', 'Contact');
var id = index.get('Lincoln');
// id === 1

var index = db.getIndex('ContactName', 'Contact');
var contact = index.getObject('Lincoln');
// contact.id === 1

var range = new CursorRange('L', 'M');
var count = index.forEachObject(function(key, cursor, value) {
              // each value is a contact and each key is the name for that  
              // contact whose name's first letter is either L or M
              }, range);

var range = new CursorRange('L', 'M');
var count = index.forEach(function(key, cursor) {
              // each key is the id of a contact  
              // whose name's first letter is either L or M
              }, range);

interface Index {  
           const     unsigned short ONE_TO_ONE = 0;
           const     unsigned short MANY_TO_ONE = 1;
           const     unsigned short ONE_TO_MANY = 2;
           const     unsigned short MANY_TO_MANY = 3;

  readonly attribute DOMString      name;
  readonly attribute DOMString      keyPath;
  readonly attribute unsigned short cardinality;
};

interface IndexSync: Index { 
  unsigned long long forEach(      in          CursorCallback callback,
                                   in optional CursorRange    range, 
                                   in optional unsigned short direction);
  unsigned long long forEachObject(in          CursorCallback callback,
                                   in optional CursorRange    range, 
                                   in optional unsigned short direction);
  any                get(          in          any            key) raises DatabaseException;
  any                getObject(    in          any            key) raises DatabaseException;
  void               delete(       in          any            key) raises DatabaseException;
};

The ONE_TO_ONE cardinality option indicates that the secondary key is unique to the object. If an object is stored with a secondary key that already exists in the object store.

The MANY_TO_ONE cardinality option indicates the secondary key may be used for multiple objects in the object store. That is, the key appears more than once, but for each stored object it can be used only once.

The ONE_TO_MANY cardinality option indicates that the secondary key might be used more than once for a given object. Secondary keys themselves are assumed to be unique, but multiple instances of the secondary key can be used per object.

The MANY_TO_MANY cardinality option indicates there can be multiple keys for any given object, and for any given key there can be many related objects.

On getting, name will provide the name of the index.

On getting, keyPath will provide the path of the key used as the secondary key of objects stored in this index. This path can be the empty string if the object value is used as the key.

On getting, cardinality will describe whether duplicate objects can be found in the index for a given secondary key. If the cardinality is ONE_TO_ONE or ONE_TO_MANY, duplicates will not occur. For the other cardinality levels, duplicates may occur.

The get() method is used to retrieve the object associated with the given secondary key in the object store by looking up the primary keys for the given secondary key and performing the retrieval steps for each of the primary keys.

The delete() method is used to delete the object associated with the given secondary key in the object store. by looking up the primary keys for the given secondary key and performing the deletion steps for each of the primary keys.

3.2.5. Cursor

Cursors are a mechanism by which applications iterate over the records in a database. Cursors can be used to get, put, and delete database records. If a database allows duplicate records, then cursors are the only mechanism by which to access anything other than the first duplicate for a given key. Although storage operations can be performed on a cursor, a cursor itself is a transient object with all the real storage happening in objects that yield the cursor.

The initial position of a cursor is set by specifying the direction in which the cursor should iterate over matching items. Once the cursor is created, it yield items only in that direction.

var objects = ...
var cursor = objects.forEach(function(object) {;
  // act on each object and return true to exit the cursor  
});

var objects = ...
var count = objects.forEach(function(object) {;
  // act on each object and return true to exit the cursor  
}, Cursor.PREV);

var objects = ...
var range = new CursorRange(CursorRange.INDIVIDUAL, key);
objects.forEach(function(object) {
  // act on each object and return true to exit the cursor  
}, range, Cursor.NEXT_NO_DUPLICATE);

var objects = ...
var range = new CursorRange(CursorRange.INCLUDE_START & CursorRange.INCLUDE_END, start, end);
objects.forEach(function(object) {
  // act on each object and return true to exit the cursor  
}, range);

interface Cursor {
           const     unsigned short     NEXT = 0;
           const     unsigned short     NEXT_NO_DUPLICATE = 1;
           const     unsigned short     PREV = 2;
           const     unsigned short     PREV_NO_DUPLICATE = 3;
  
  readonly attribute unsigned short     direction;
  readonly attribute unsigned long long count;

  void    continue(in optional CursorRange skipTo);
  boolean update(  in          any         obj);
  void    delete();
};

[Constructor(in unsigned short mode, in optional any start, in optional end)]
interface CursorRange {
           const     unsigned short INCLUDE_START = 1;
           const     unsigned short INCLUDE_END = 2;
           const     unsigned short INDIVIDUAL = 4;
  
  readonly attribute any            start;
  readonly attribute any            end;
  readonly attribute unsigned short mode;
};

[FunctionOnly, NoInterfaceObject]
interface CursorCallback {
  bool handle(in          any    key, 
              in          Cursor cursor,
              in optional any    value);
};

On getting count, the user agent returns the total number of objects that share the current key.

On getting direction, the user agent returns the the traversal direction of the cursor.

The forEach() method is used to navigate items in a cursor in the direction identified by the direction parameter, which can be either of NEXT, NEXT_NO_DUPLICATE, PREV, or PREV_NO_DUPLICATE. If direction is unspecified, then the cursor uses the NEXT direction. The parameters inclusiveFrom and inclusiveTo are used to signal whether ranges are open or closed on the range boundaries.

For each object that matches the cursor condition, the user agent calls the CursorCallback. This callback is passed two parameters - the object that matches the cursor condition, and a Cursor object to make changes to the database at the Cursor position. If this callback returns a true value, then the cursor traversal is exited whether or not the range conditions have been satisfied.

The NEXT direction indicates that cursor should yield all values, including duplicates starting from the beginning of the range to its end.

The NEXT_NO_DUPLICATE direction indicates that cursor should return all values, skipping over duplicate objects for every key starting from the beginning of the range to its end. For every key with duplicate values, only the first value is yielded.

The PREV direction indicates that cursor should yield all values, including duplicates starting from the end of the range to its beginning.

The PREV_NO_DUPLICATE direction indicates that cursor should return all values, skipping over duplicate objects for every key starting from the end of the range to its beginning. For every key with duplicate values, only the first value is yielded.

The update() method is used to update the object at which the cursor is currently positioned. If the object is updated, then this method returns true. The update method is only allowed if the Cursor is obtained from an object store. The key of the object parameter must match the key in the current cursor position. Otherwise, the database will throw a newly constructed DatabaseException exception with code DATA_ERR.

The delete() method is used to delete the object at which the cursor is currently positioned. The delete() method will return false if this method is called more than once inside a CursorCallback.

3.2.6. Transaction

A transaction represents an atomic and durable set of database access and mutation operations. Transactions offer data protection from application or system failures.

A transaction may be used to store multiple data items or to conditionally modify certain data items.

A Database object may have at most one transaction at any given time.

Transactions are expected to be short lived. Conforming user agents may terminate transactions that take too long to complete in order to free up storage resources that are locked by a long running transaction.

interface TransactionSync {  
  void abort()  raises DatabaseException;
  void commit() raises DatabaseException;
};

abort()

This method is used to signal the need to cancel the effects of database operations performed in a transaction. To perform this method, the database ignores all the changes performed in this transaction through calls to this Transaction object.

commit()

This method is used to signal the normal and satisfactory completion of a transaction to the database. At this point, the database durably stores the result of all the operations performed in this transaction through calls to this Transaction object.

The API for a transaction consists of mechanisms for committing and rolling back the effects of database operations performed in that transaction. However, asynchronous databases also automatically commit a transaction whenever the transaction callback completes. Asynchronous databases also automatically rollback a transaction if an error occurs inside the transaction callback.

When the user agent is to create a Transaction object it must run the following steps:

1. Pick the appropriate steps:

   If these steps are not called with an array of database objects

   Acquire a lock on the entire database.

   If these steps are called with a non-empty array of database objects

   1. If any of the objects in this array is not a database object, then set code to NON_TRANSIENT_ERR and jump to the last step.
   2. Acquire appropriate locks on each of the database objects and the objects they depend on in an ordered sequence.
      Note

      If the database does not allow fine grained locking, then a user agent may obtain a shared or exclusive lock on the database.

   If these steps are called with an empty array of database objects

   Do not acquire locks on any database objects now. Locks are obtained as the application attempts to access those objects.

   Note

   Using the database in this style may lead to deadlocks. Programmers must use caution to acquire and release database objects in the same global order to avoid deadlocks.

2. If a timeout duration is passed to these steps and is exceeded when acquiring locks, then set code to TIMEOUT_ERR and jump to the last step.
3. Open a new transaction to the database, and create a Transaction object that represents that transaction. Let transaction be this object.
4. Set the current transaction of this Database object to transaction.
5. Return transaction. End these steps.
6. This step is only performed in case of error. If this step is performed asynchronously, then run the database failure steps with the code code. Otherwise, raise a newly constructed DatabaseException exception exception with the code code.

Once a transaction is aborted or committed, that Transaction object can no longer be used. If any calls are made on that object, then the database will throw a newly constructed DatabaseException exception with code NON_TRANSIENT_ERR. To perform database operations under the control of a new transaction, a fresh Transaction object is needed.

3.3.1. Event summary

Events are fired during asynchronous database access as database objects are created and data is consumed from these objects. As requests for database objects are made, the user agent loads information about them into memory and when the required object handle is available, it alerts the application through the firing of events. The events are as follows:

3.3.2. The DatabaseRequest Interface

This interface provides methods for opening databases and accessing database objects using event handler attributes [DOM3Events].

var dbReq = new DatabaseRequest();
dbReq.onsuccess = function(evt) {...};
dbReq.onerror = function(evt) {...};
dbReq.open('AddressBook', '1', 'Address Book', function(txn, db) {...});

This API uses an event handler mechanism to obtain database objects. If an error occurs while opening the database, an error handler is invoked. Otherwise, a success handler is invoked.

interface DatabaseRequest : DBRequest{
  readonly attribute Database database;
  
  void open(in          DOMString       name, 
            in          DOMString       version, 
            in          DOMString       displayName, 
            in optional UpgradeCallback upgrade,
            in optional unsigned short  isolation);
};

The open() method takes the following arguments: a database name, a database version, a display name, an optional upgrade callback, and an optional isolation level. When called, this method must return immediately and asynchronously perform the following steps, with all but the first two and last steps being run atomically:

1. Queue a task to fire an event with the name success, with no namespace, which does not bubble, is not cancelable, and which uses the DatabaseEvent interface and result at each Window or WorkerUtils object.

The database failure steps performed with an error code are as follows:

1. Create a DatabaseError object error where code is the error code passed to these steps and status is 0.
2. Queue a task to fire an event with the name error, with no namespace, which does not bubble, is not cancelable, and which uses the DatabaseErrorEvent interface and error at each Window or WorkerUtils object.

The task source for these tasks is the database access task source.

3.3.3. Object Store

var store = storeReq = null;
var dbReq = new DatabaseRequest();
dbReq.onsuccess = 
  function() {
    storeReq = new ObjectStoreRequest(dbReq.database);
    storeReq.open('Contact');
  };
var upgrade = 
  function(upgrade, db) {
    upgrade.createObjectStore('Contact', 'id');
  });
dbReq.open('AddressBook', '1', 'Address Book');

function saveContact(contact, success) {
  storeReq.onsuccess = success;
  storeReq.put(contact);
};

var lincoln = {id: 1, name: 'Lincoln', number: '7012'};
saveContact(lincoln, function() {
  //storeReq.result.id == 1
});

function loadContact(id, success) {
  storeReq.onsuccess = success;
  storeReq.get(id);
};

loadContact(1, function() {
  // storeReq.result.id === 1 && storeReq.result.name === 'Lincoln';
});

[Constructor(in Database db)]
interface ObjectStoreRequest : DBRequest {
  readonly attribute any result;
  
  void open(  in          DOMString      name,
              in optional unsigned short mode);
  void put(   in          any            obj);
  void get(   in          any            key);
  void delete(in          any            key);
};

The put() method is used to store the given object in the object store. Insert the object by performing the insertion steps.

The get() method is used to retrieve the object associated with the given key in the object store. The following steps must be run for retrieving the object with the following parameters: key.

The delete() method is used to delete the object associated with the given key in the object store. Delete the object by performing the deletion steps.

3.3.4. Index

[Constructor(in Database db)]
interface IndexRequest : DBRequest {
  readonly attribute any result;
  
  void open(     in DOMString name,
                 in DOMString storeName,
                 in optional boolean forReadonly); 
  void get(      in any key);
  void getObject(in any key);
  void delete(   in any key);
};

3.3.5. Cursor

[Constructor(in Database db)]
interface CursorRequest : DBRequest {
  readonly attribute unsigned long long count;
           attribute CursorCallback     callback;
           
  void readStore(      in          DOMString      storeName, 
                       in optional CursorRange    range, 
                       in optional unsigned short direction);
  void readIndex(      in          DOMString      storeName, 
                       in          DOMString      indexName,
                       in optional CursorRange    range, 
                       in optional unsigned short direction);
  void readIndexObject(in          DOMString      storeName, 
                       in          DOMString      indexName,
                       in optional CursorRange    range, 
                       in optional unsigned short direction);
};

3.3.6. Transaction

interface Transaction : TransactionSync {
// events
            attribute Function oncommitted;
            attribute Function onaborted;
};

[Constructor(in Database db)]
interface TransactionRequest : DBRequest {
  readonly attribute Transaction transaction;
  
  void open(in optional DOMStringList storeNames,
            in optional unsigned int  timeout);
};

open() When called, this method must immediately return and then asynchronously perform the transaction steps.

The transaction steps are as follows. These steps are invoked with a transaction callback, and the following optional arguments - a success callback, an error callback, an array of database objects for acquiring locks required in this transaction, and a timeout duration.

1. Perform the transaction creation steps with the array of database objects and timeout duration passed to these steps. Let the resulting Transaction object be transaction.
2. Queue a task to invoke the transaction callback with transaction as its only argument, and wait for that task to be run.
3. If the callback couldn't be called (e.g. it was null), or if the callback was invoked and raised an exception, jump to the last step.
4. Queue a task to invoke the success callback.
5. End these steps.
6. This step is only used when something goes wrong.
   1. If transaction is still not committed or rolled back, then rollback the transaction.
   2. If an error callback was passed to these steps, then queue a task to invoke the it with a newly constructed DatabaseError with code UNKNOWN_ERR.

3.3.7. Events

The following are the event handlers (and their corresponding event handler event types) that must be supported, as IDL attributes, by objects implementing the various interfaces:

3.4.1. Insertion steps

1. Let key be the property of the object at the key path.
2. If key is defined and not null, then skip the next step.
3. If the sequence name is defined for the insertion steps, then perform the following steps.
   1. If the database does not contain a sequence whose name matches, compared in a case-sensitive manner, with sequence name, then throw a newly constructed DatabaseException exception with code CONSTRAINT_ERR and terminate these steps.
   2. Let sequence be the Sequence object for the sequence name
   3. From the sequence get the next value. Store that value as key.
   4. Store key as the property value for the object at the key path.
4. If the key is not defined or null, then throw a newly constructed DatabaseException exception with code DATA_ERR and terminate these steps.
5. Insert the object with key as its key. If any indexes are maintained for objects in this object store, then perform the following steps for each index. These steps must be run with three parameters: object, key path, and index.
   1. Let value be the property of the object at the key path.
   2. Let index key path be the key path of index.
   3. Let key be the property of the object at the index key path.
   4. Insert the value with key as its key in the index.
6. Return the key.

3.4.2. Retrieval steps

The retrieval steps are as follows. These steps must be run for retrieving the object with the following parameters: key.

1. If key is not defined or null, then throw a newly constructed DatabaseException exception with code NOT_FOUND_ERR and terminate these steps.
2. Use the key to look up an object in the object store. Let value be that object.
3. If object is not found in the object store, then throw a newly constructed DatabaseException exception with code NOT_FOUND_ERR and terminate these steps.

3.4.3. Deletion steps

The deletion steps are as follows. These steps must be run with one parameter: key, key path, and optional sequence name.

1. If key is not defined or null, then throw a newly constructed DatabaseException exception with code NOT_FOUND_ERR and terminate these steps.
2. Use the key to look up an object in the object store. Let object be that object.
3. If any indexes are maintained for objects in this object store, then perform the following steps for each index. These steps must be run with three parameters: object, key path, and index.
   1. Let index key path be the key path of index.
   2. Let value be the property of the object at the index key path.
   3. Delete the record for value from index.
4. Delete the object stored with the key key in the object store.