• Usage

• Features

• API

• Database

• SQLite3

• Statement

SQLite Database

The SQLite database provides a way to store databases that can be queried using various SQL statements. Each Tizen application can store multiple databases and each one of them can store multiple tables. Databases can be accessed using the SQL language, which is a common standard for these kinds of applications.

Note

When working with the SQL database, this API provide Synchronous database API only.

• To start an operation, you must wait for the previous one to be completed. This approach can be used with promise.

Usage

const url = `ws://${DB_HOSTNAME}:${DB_PORT}${DB_PATH}`;

  const sqlite3 = new SQLite3(url);
  const db = await sqlite3.open(DB_SOURCE, (err) => {
    if (err) {
      return;
    }
  });

  {
    const q = `CREATE TABLE user (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name text,
            email text UNIQUE,
            password text,
            CONSTRAINT email_unique UNIQUE (email)
            )`;

    await db.run(q, [], (err) => {
      if (err) {
          `run: error: ${JSON.stringify(
            err
          )}: Table User exists in the current database. To fix, remove ${DB_SOURCE}`
        );
        return;
      }
    });
  }

Features

• Provide native SQLite database binding using JavaScript WebAPI.

• Straightforward query and parameter binding interface.

API

• 
  

  Database

  all
  close
  configure
  each
  exec
  get
  on
  prepare
  removeAllListeners
  removeListener
  run

  
  

• 
  

  SQLite3

  verbose

  
  

• 
  

  Statement

  all
  bind
  each
  finalize
  get
  reset
  run

  
  

Database

new Database(filename, modeopt) ? {Promise.<Database>}

Example

let db = await new sqlite3.Database('filename.db');  

Parameters:

Throws:
Throw an error object if an error occurred.

Returns:
A promise containing a database object.
Type  Promise.<Database>

Methods

all(query, …paramopt) ? {Promise.<Array.<Object>>}

Parameters:

Throws:
Throw an error object if an error occurred.

Returns:
A promise containing an array of rows. If the result set is empty, it will be an empty array, otherwise it will have an object for each result row which in turn contains the values of that row, like the Database#get function.

Type  Promise.<Array.<Object>>

close() ? {Promise.<undefined>}

Returns:
Type   Promise.<undefined>

configure(option, value) ? {Promise.<undefined>}

• busyTimeout: provide an integer as a value. Sets a busy handler that sleeps for a specified amount of time when a table is locked. The handler will sleep multiple times until at least "ms" milliseconds of sleeping have accumulated. After at least "ms" milliseconds of sleeping, the handler returns 0 which causes sqlite3_step() to return SQLITE_BUSY. Calling this routine with an argument less than or equal to zero turns off all busy handlers.

Parameters:

Returns:
Type   Promise.<undefined>

each(query, …paramopt, callbackopt) ? {Promise.<Integer>}

There is currently no way to abort execution.

Parameters:

Throws:
Throw an error object if an error occurred.

Returns:
A promise containing the number of retrieved rows.
Type   Promise.<Integer>

exec(query) ? {Promise.<undefined>}

Note

This function will only execute statements up to the first NULL byte. Comments are not allowed and will lead to runtime errors.

Parameters:

Throws:
Throw an error object if an error occurred.

Returns:
Type   Promise.<undefined>

get(query, …paramopt) ? {Promise.<(undefined|Object)>}

Parameters:

Throws:
Throw an error object if an error occurred.

Returns:
A promise containing undefined, if the result set is empty, otherwise an object containing the values for the first row. The property names correspond to the column names of the result set. It is impossible to access them by column index; the only supported way is by column name.

Type  Promise.<(undefined|Object)>

on(event, callback) ? {Promise.<undefined>}

To enable event handling, call sqlite3.verbose() before registering callbacks.

Parameters:

Returns:
Type   Promise.<undefined>

prepare(query) ? {Promise.<Statement>}

Parameters:

Throws:
Throw an error object if an error occurred.

Returns:
A promise containing a statement object.
Type  Promise.<Statement>

removeAllListeners(event)? {Promise.<undefined>}

Parameters:

Returns:
Type  Promise.<undefined>

removeListener(event, callback)? {Promise.<undefined>}

Parameters:

Returns:
Type  Promise.<undefined>

run(query, …paramopt) ? {Promise.<Statement>}

Parameters:

Throws:
Throw an error object if an error occurred.

Returns:
A promise containing an executed statement
Type   Promise.<Statement>

SQLite3

Methods

(async) verbose() ? {Promise.<undefined>}

Returns:
Type   Promise.<undefined>

Statement

Methods

all(…paramopt) ? {Promise.<Array.<Object>>}

Throws:
Throw an error object if an error occurred.

Returns:
A promise containing an array, that contains an object for each result row which in turn contains the values of that row.
Type   Promise.<Array.<Object>>

bind(…paramopt) ? {Promise.<null>}

Parameters:

Throws:
Throw an error object if an error occurred.

Returns:
Type  Promise.<null>

each(…paramopt, callbackopt) ? {Promise.<Integer>}

If you know that a query only returns a very limited number of rows, it might be more convenient to use Statement#all to retrieve all rows at once. There is currently no way to abort execution!

Parameters:

Throws:
Throw an error object if an error occurred.

Returns:
A promise containing the number of retrieved rows.
Type   Promise.<Integer>

finalize() ? {Promise.<null>}

Throws:
Throw an error object if an error occurred.

Returns:
Type   Promise.<null>

get(…paramopt) ? {Promise.<Object>}

Using this method can leave the database locked, as the database awaits further calls to Statement#get to retrieve subsequent rows. To inform the database that you are finished retrieving rows, you should either finalize (with Statement#finalize) or reset (with Statement#reset) the statement.

Parameters:

Throws:
Throw an error object if an error occurred.

Returns:
A promise containing an object that contains the values for the first row.
Type  Promise.<Object>

reset() ? {Promise.<null>}

Throws:
Throw an error object if an error occurred.

Returns:
Type   Promise.<null>

run(…paramopt) ? {Promise.<Statement>}

The behavior is identical to the Database#run method with the difference that the statement will not be finalized after it is run. This means you can run it multiple times.

Parameters:

Throws:
Throw an error object if an error occurred.

Returns:
A promise containing an executed statement
Type   Promise.<Statement>