warsawjs-nodejs-and-oracle

o czym będzie

o czym będzie

• o Node.js
• o driverach i abstrakcjach dla Oracle
• o moich doświadczeniach z w/w technologiami

czym się zajmuję

czym się zajmuję

• utrzymanie i rozwój Hurtowni Danych
• rozwijanie aplikacji back office (intranet/ekstranet)
• SQL, PL/SQL, PHP, JavaScript, HTML, CSS

dlaczego Node.js?

dlaczego Node.js?

• asynchroniczny (nieblokujące I/O) = wydajność
• event driven
• strumienie
• natywne moduły
• zawsze demon
• NPM
• JIT compiler (V8), Adaptive optimization, Inline expansion
• JavaScript

Asynchroniczny Node.js

Wrzesień 2014 - Proof of Concept

Wrzesień 2014 - Proof of Concept

• Node.js (Express, oracle, generic-pool, passport, itd...)
• nodemon
• forever
• Nginx
• Sencha ExtJS (frontend)

• z głównymi modułami
• restart procesu noda przy zmianie w dowolnym pliku projektu
• zapewnia automatyczny start procesu w przypadku awarii
• jako reverse proxy do backendu + serwowanie statycznego kontentu, terminowanie sesji SSL
• programowanie w JavaScript, SPA, cała aplikacja ładowana przy pierwszym requescie

npm install oracle

Projekt w Github: joeferner/node-oracle

moduł oracle

• moduł natywny C++ wymagający bibliotek Oracle
• opublikowany 20.12.2011
• strumieniowe odczyty/zapisy
• brak wbudowanej puli połączeń
• niestabilność przy odczycie CLOB-ów
• niskopoziomowe API

Proof of Concept - wynik

Marzec 2015 - Nowy projekt

Marzec 2015 - Nowy projekt

• ponad 40 formularzy
• eksport danych do Excela
• import danych z plików txt
• edycja danych formularzy przez przeglądarkę
• udostępniona dla ponad 360 firm
• ok 1000 użytkowników
• akumulacja sesji w końcówce terminów sprawozdawczych

Architektura nowego systemu

Marzec 2015 - Nowy projekt - wynik

• powstały 3 usługi w Node.js v0.10.38 (100% JS)
• system oddany do testów UAT 3 m-ce od startu
• uruchomienie produkcyjne 30.06.2015
• serwer: CentOS 6, 2GB RAM, 2 cory (maszyna VM)
• system bardzo wydajny i stabilny
• minimalne obciążenie systemu operacyjnego

Drivery Oracle w Node.js

• nowy ważny projekt - wybór Node.js
• najpierw wybór drivera - oracledb (mimo wielu braków)
• decyzja o własnej abstrakcji

Drivery Oracle w Node.js

• nowy ważny projekt - wybór Node.js
• najpierw wybór drivera - oracledb (mimo wielu braków)
• decyzja o własnej abstrakcji

Drivery Oracle w Node.js

• nowy ważny projekt - wybór Node.js
• najpierw wybór drivera - oracledb (mimo wielu braków)
• decyzja o własnej abstrakcji

Instalacja natywnego drivera

• Oracle Instant Client lub Oracle Client
• Python (używany przez node-gyp)
• libaio (Linux)
• C++ Compiler (GCC, Visual Studio lub inny)
• Zmienne środowiskowe (OCI_LIB_DIR, OCI_INCLUDE_DIR, OCI_VERSION, NLS_LANG)

oracledb w Node.js v4.x.x

oficjalnie jeszcze nie wspierany (jest procesowany PR)

npm install https://github.com/Bigous/node-oracledb.git

Decyzja o publikacji własnej abstrakcji

Powody budowy abstrakcji

• brak sensownej abstrakcji w NPM (początek 2015)
• nie wiadomo, który driver będzie lepszy
• niskopoziomowe API driverów
• braki funkcjonalne driverów
• dodatkowe testy jednostkowe dla driverów
• pisanie abstrakcji jest fajne pozwala zrozumieć lepiej driver

• brak - na moment startu projektu
• w przyszłości
• np. konieczność każdorazowego zwalniania połączenia (zwrot do puli)
• stronicowanie, rowset bez strumieni, CLOB-y, CLOB-y bez strumieni, pula bez kolejki
• dla komunikacji z Oracle, casy używane w aplikacji

Teraz poprzez przykłady omówię wybrane (ważniejsze) problemy, z którymi zetknąłem się realizując 2 projekty.

Przykład 1a. Pobranie pojedynczej wartości (oracledb)

pool.getConnection(function(err, connection) {
    if (err) {
        cb(new Error(err));
        return;
    }
    connection.execute('SELECT SYSDATE FROM DUAL',
                       [],
                       function(err, result) {
        if (err) {
            cb(new Error(err));
            connection.release(function(err) {
                if (err) {
                    cb(new Error(err), {only_log: true});
                }
            });
            return;
        }

        cb(null, result.rows[0][0]);

        connection.release(function(err) {
            if (err) {
                cb(new Error(err), {only_log: true});
            }
        });
    });
});

Przykład 1b. Pobranie pojedynczej wartości (node-dal)

dal.selectOneValueSql('SELECT SYSDATE FROM DUAL', [],
                      function(err, result) {
    if(err) {
        cb(new Error(err));
        return;
    }
    cb(null, result);
});

dal.selectOneValue('DUAL', 'SYSDATE', [], function(err, result) {
    if(err) {
        cb(new Error(err));
        return;
    }
    cb(null, result);
});

Przykład 2a. Pobranie wielu wierszy (oracledb)

var oracledb = require('oracledb');
oracledb.maxRows = 100; // (wartość domyślna)

connection.execute("SELECT * FROM employees", [], { maxRows: 1000 },
                   function(err, result) {
    // result.rows.length <= 1000
});

Przykład 2b. Pobranie wielu wierszy (oracledb)

var oracledb = require('oracledb');
oracledb.prefetchRows = 100; // (wartość domyślna)

connection.execute("SELECT * FROM employees", [],
                   { resultSet: true, prefetchRows: 200 },
                   function(err, result) {
    var allRows = [];

    function fetch() {
        var max = 200;
        result.resultSet.getRows(max, function(err, rows) {
            allRows = allRows.concat(rows);
            if (rows.length === max) {
                fetch();
            } else {
                result.resultSet.close(function(err) {
                    connection.release(function(err) {
                        cb(null, allRows);
                    });
                });
            }
        });
    }
    fetch();
});

Przykład 2b. Pobranie wielu wierszy (node-dal)

dal.selectAllRowsSql("SELECT * FROM employees", [],
                     function(err, result) {
    cb(null, allRows);
});

dal.selectAllRows({
    tbl: 'employees',
    opt: { limit:10, page:5 },
    cb:  function(err, results) {
        cb(null, results);
    }
});

Przykład 3a. Przekroczenie puli (oracledb)

var async    = require('async'),
    oracledb = require('oracledb'),
    cfg  = {
        user:           "username",
        password:       "password",
        connectString:  "localhost/XE",
        poolMax:        10,
        poolMin:        2
    },
    sqls = [],
    i    = 15;

while(i--) { sqls.push('SELECT SYSDATE FROM DUAL'); }

oracledb.createPool(cfg, function(err, pool) {
    var executeSql = function(sql, cb) {
        pool.getConnection(function(err, connection) {
            connection.execute(sql, [], function(err, results) {
                cb(null, results.rows[0][0]);
            });
        });
    };

    async.map(sqls, executeSql, function(err, results) {
        callback(null, results);
    });
});

Wynik: ORA-24418: Nie można otworzyć kolejnych sesji.

Przykład 3b. Przekroczenie puli (node-dal)

var async      = require('async'),
    dalFactory = require('node-dal'),
    cfg        = {
        connection: {
            user:           "testy",
            password:       "testy123",
            connectString:  "localhost/XE",
            poolMax:        10,
            poolMin:        1
        },
        getConnMaxProbes:   100, // times
        getConnWaitMinTime: 200, // miliseconds
        getConnWaitMaxTime: 500  // miliseconds
    },
    sqls = [],
    i    = 15;

while(i--) { sqls.push('SELECT SYSDATE FROM DUAL'); }

dalFactory('oracledb', cfg, function(err, dal) {
    var executeSql = function(sql, cb) {
        dal.selectOneValueSql(sql, [], function(err, result) {
            cb(null, result);
        });
    };

    async.map(sqls, executeSql, function(err, results) {
        callback(null, results);
    });
});

Wynik: [data1, data2, ... , data15]

Alternatywne metody - Noradle

Alternatywne metody - Noradle

• komunikacja bez driverów bazujących na OCI
• Node.js jako HTTP Gateway
• Oracle tworzy pulę połączeń TCP do Node.js (UTL_TCP)
• składowane w bazie procedury PL/SQL są uruchamiane jako servlety http
• cała logika manipulacji danymi znajduje się po stronie bazy danych
• brak zależności - tylko JavaScript i baza Oracle
• spora część dokumentacji po chińsku

• http://docs.noradle.com/readme.html https://github.com/kaven276/noradle-demo
• Noradle - ma niezaprzeczalną zaletę: tylko Node i Oracle (nic więcej) - wada: spora część dokumentacji po chińsku
• https://github.com/doberkofler/node_plsql

Alternatywne metody - node_plsql

• podejście podobne do noradle
• alternatywa typu open-source dla mod_plsql
• wykorzystanie technik OWA i APEX do budowania aplikacji
• kontent serwowany przez Node.js HTTP Server (express)
• konieczność kompilacji natywnych modułów (analogicznie jak dla OCI)
• w moich testach na Ubuntu aplikacja demo działała bardzo wolno

OWA - PL/SQL Web Toolkit APEX - Oracle Application Express

linki

• https://github.com/joeferner/node-oracle
• https://github.com/oracle/node-oracledb
• https://github.com/strongloop/strong-oracle
• http://visjs.org A dynamic, browser based visualization library.
• http://docs.noradle.com/concept/introduction.html
• https://github.com/doberkofler/node_plsql
• https://github.com/marlic7/node-dal

http://marlic7.github.io/warsawjs-nodejs-and-oracle

Dzięki!

czas na pytania ???