Jag är inte riktigt nöjd med förra inlägget därför väljer jag att beskriva Jaxers databashantering liter mer djupare.

Det är viktigt att notera att just nu så har inte Jaxers API stöd för ORM och allt annat än ren SQL.
Gruppen som utvecklar Jaxer har valt att inte implementera det i BETA versionen.

Managed Access

Enklaste sättet att få databasfunktionaliteten är att använda sig av ”pre-configured”, statisk (icke objektorienterad) API.

Jaxer levereras med en inbyggd SQLite3 databas och en SQLite3 ”driver” samt en MySQL 5 ”driver”.
Den ”defaulta” konfigurationen av Jaxer använder just den inbyggda SQLite3 databasen.
För att enklast få tillgång till databasen så behöver man bara köra lite SQL frågor, till exempel:

Jaxer.DB.execute('CREATE TABLE IF NOT EXIST user (user_id INTEGER PRIMARY_KEY AUTO_INCREMENT, username VARCHAR(45))');
Jaxer.DB.execute('INSERT INTO user(username) VALUES("mikwiat")');
Jaxer.DB.execute('INSERT INTO user(username) VALUES("nisse")');
Jaxer.DB.execute('INSERT INTO user(username) VALUES("karl")');
var result = Jaxer.DB.execute('SELECT username FROM user');

API är ganska så enkel – Jaxer.DB.execute() returnerar en Jaxer.DB.ResultSet.
SQL strängen är obligatorisk.

För att ha tillgång till den senaste radens id så använder man sig utav Jaxer.DB.lastInsertId, eller Jaxer.DB.lastInsertRowId som returnerar ett nummer.

Egentligen så är det så här:

Jaxer skapar en (per en Jaxer process) uppkoppling mot databasen som är specifierad i filen config.js och använder denna för att exekvera förfrågor mot databasen och returnera data som Jaxer.DB.ResultSet.
Detta kallas för en ”managed access” för att uppkoppling hanteras automatiskt av Jaxer – den öppnas automatiskt, stängs (beroende på inställningar) automatiskt efter varje förfråga, för varje sida eller efter servern stängs när.  Eftersom uppkopplingen innehåller ingen annan data än Jaxer.DB.lastInsertId, eller Jaxer.DB.lastInsertRowId så är den säker.

Om man vill att denna ”Managed access” skall bli konfigurerad på ett annar sätt så öppnar man config.js filen och ändrar i den, den ligger i jaxer_local katalogen.

Som jag nämnde förr så levereras Jaxer med två stycken ”drivers”, en för MySQLite3 och en för MySQL 5.
Om man vill så kan man konfigurera dem hur man vill, här är ett exempel för MySQLite3:

Config.DB_IMPLEMENTATION = 'SQLite';
Config.DB_CONNECTION_PARAMS =
{
	PATH: 'c:\\sokvag\\till\\min\\fil.sqlite',
	CLOSE_AFTER_EXECUTE: false, // stänger uppkoppling efter exekvering av Jaxer.DB.execute() (ej obligatorisk)
	CLOSE_AFTER_REQUEST: true,  // stänger uppkoppling efter varje request (ej obligatorisk)
	MAX_NUM_TRIES: 100, 	// om raderna är låsta, upprepa så många gånger (ej obligatorisk)
	MILLIS_BETWEEN_TRIES: 37 // antal millisekunder mellan varje försök (ej obligatorisk)
};

och här är ett för MySQL 5:

Config.DB_IMPLEMENTATION = 'MySQL';
Config.DB_CONNECTION_PARAMS =
{
    HOST: '127.0.0.1',
    PORT: 3306,        // serverns port
    NAME: 'schema', // namnet av databasen
    USER: 'root', // användarnamnet
    PASS: 'pass' // lösenord
};

Dynamisk, konfigurbar Access

Om man behöver något mer flexibet än en ”pre-configured”, ”managed” uppkoppling mot databas så kan man faktiskt välja att använda den dynamiska Jaxer DB API:et.

För att göra det så skapar man enklast ett objekt och anropar dess metoder, till exempel (MySQLite):

var connection_parameters = {PATH 'c:\\sokvag\\till\min\\fil.sqlite'};
Jaxer.DB.SQLite.createDB(connection_parameters); // behövs då databasinstansen inte existerar
var connection = new Jaxer.DB.SQLite.Connection(connection_parameters);

connection.open();
connection.execute('CREATE TABLE IF NOT EXIST user (user_id INTEGER PRIMARY_KEY AUTO_INCREMENT, username VARCHAR(45))');
connection.execute('INSERT INTO user(username) VALUES("mikwiat")');
connection.execute('INSERT INTO user(username) VALUES("nisse")');
connection.execute('INSERT INTO user(username) VALUES("karl")');
var result = connection.execute('SELECT username FROM user');
connection.close();

Liknande ser det ut för MySQL 5:

var connection_parameters =
{
    HOST: '127.0.0.1',
    PORT: 3306,        // serverns port
    NAME: 'schema', // namnet av databasen
    USER: 'root', // användarnamnet
    PASS: 'pass' // lösenord
};
Jaxer.DB.MySQL.createDB(connection_parameters); // behövs då databasinstansen inte existerar
var connection = new Jaxer.DB.MySQL.Connection(connection_parameters);

connection.open();
connection.execute('CREATE TABLE IF NOT EXIST user (user_id INTEGER PRIMARY_KEY AUTO_INCREMENT, username VARCHAR(45))');
connection.execute('INSERT INTO user(username) VALUES("mikwiat")');
connection.execute('INSERT INTO user(username) VALUES("nisse")');
connection.execute('INSERT INTO user(username) VALUES("karl")');
var result = connection.execute('SELECT username FROM user');
connection.close();

Eftersom det är användaren som hanterar uppkopplingar så har man ingen större behov av CLOSE_EFTER_EXECUTE samt CLOSE_EFTER_REQUEST parametrar.
Man skall även inte glömma att connection_parameters är ”case-sensitive”.

Förfrågor som returnerar data

När man skall hämta data ur databasen så använder man sig utav en SELECT SQL-fråga som skickas till databasen med hjälp av execute() metoden som returnerar en resultat av typen Jaxer.DB.ResultSet, det nämnde jag förr.

Objektet innehåller all data som returnerades från databasen efter förfrågan, så man kan använda den efter uppkopplingen stängs ner och det ändras inte även om datan har blivit ändrat i databasen.

Resultatet erbjuder användaren att nå dess data på olika sätt.
Enklaste sättet är nog att komma åt data med hjälp av row egenskapen, vilken är en array av objekt, en per varje rad.

TIll exempel:

var result = connection.execute('SELECT username FROM user');
var first_username = result.rows[0].username; // i detta fall returneras 'mikwiat'

Om man vill få reda på antalet rader som returnerades från databasen så använder man helt enkelt rows.length, till exempel:

var result = connection.execute('SELECT username FROM user');
var number_of_returner_rows = result.rows.length; // returnerar '3' i detta fall

Om man vet att SQL-frågan kommer att returnera bara en rad, eller om man bara vill ha en rad av resultatet så kan man använda sig utav egenskapen singleResult, till exempel:

var single_result = connection.execute('SELECT COUNT(*) AS count FROM user').singleResult;

Den returnerar alltid null om det inte finns någon data i resultatet.
Om man vill kolla om resultatet innehåller någon data, och sedan returnera den så gör man på följande sätt:

var single_result = connection.execute('SELECT COUNT(*) AS count FROM user').singleResult;

if(single_result.hasData)
{
     return single_result;
}
else
{
     return 'no data';
}

Jag tänker faktiskt inte ge mig in på datatyper, om man vill så kan man läsa mer om det här.

Jag har även märkt att texten på denna sida innehåller en del stavfel, samt fel i koden, men har mailat supporten, får se vad de svarar :)