Network Powering Makers

    rdbreadmetest

    1.1.1 • Public • Published

    All examples below are found at npmjs.org/package/rdb-demo.
    Documentation and examples

    Connecting
    connect to postgres
    connect to mySql
    pool size
    end pool
    end all pools
    logging
    Basic querying
    getById
    tryGetById
    tryGetFirst
    join
    hasMany
    hasOne
    composite keys
    getById eagerly
    tryGetFirst eagerly
    toDto
    toDto with strategy
    toDto with orderBy
    toDto with orderBy descending
    toDto ignoring columns
    toJSON
    toJSON with strategy
    getMany
    getMany lazily
    getMany eagerly
    (many)ToDto
    (many)ToDto with strategy
    (many)ToJSON
    (many)ToJSON with strategy
    Streaming
    streaming rows
    streaming json
    Persistence
    update
    insert
    delete
    cascade delete
    bulk delete
    bulk cascade delete
    default values
    conventions
    update a join-relation
    update a hasOne-relation
    update a hasMany-relation

    Filters
    equal
    notEqual
    not
    lessThan
    lessThanOrEqual
    greaterThan
    greaterThanOrEqual
    between
    in
    startsWith
    endsWith
    contains
    iEqual
    iStartsWith
    iEndsWith
    iContains
    exists
    or
    and
    or alternative syntax
    and alternative syntax
    sub filter
    composite filter
    raw sql filter

    Contents

    connect to postgres

    var rdb = require('rdb');
    var db = rdb('postgres://postgres:postgres@localhost/test');
    //will use pool with 10 connections by default
    //alternatively: var db = rdb.pg('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    connect to mySql

    var rdb = require('rdb');
    var db = rdb.mySql('mysql://root@localhost/rdbDemo?multipleStatements=true');
    //will use pool with 10 connections by default
     
    db.transaction()
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    pool size

    var rdb = require('rdb');
     
    var poolOptions = {size: 20};
    var db = rdb('postgres://postgres:postgres@localhost/test', poolOptions);
     
    db.transaction()
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function onOk() {
        console.log('Success. Created pool with max 20 connections.');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    end pool

    var rdb = require('rdb');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(db.end)
        .then(onOk, onFailed);
     
    function onOk() {
        console.log('Pool ended.');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    end all pools

    var rdb = require('rdb');
     
    var dbPg = rdb('postgres://postgres:postgres@localhost/test');
    var dbMySql = rdb.mySql('mysql://root@localhost/rdbDemo?multipleStatements=true');
     
    connectPg()
        .then(connectMySql)
        .then(rdb.end)
        .then(onOk, onFailed);
     
     
    function connectPg() {
        return dbPg.transaction()
            .then(rdb.commit)
            .then(null, rdb.rollback);
    }
     
    function connectMySql() {
        return dbMySql.transaction()
            .then(rdb.commit)
            .then(null, rdb.rollback);
    }
     
    function onOk() {
        console.log('Pools ended.');
    }
     
    function onFailed(err) {
        console.log(err.stack);
    }
     

    logging

    var rdb = require('rdb');
    rdb.log(console.log); //will log sql and parameters
     
    var Customer = rdb.table('_customer');
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getById)
        .then(update)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getById() {
        return Customer.getById('a0000000-0000-0000-0000-000000000000');
    }
     
    function update(customer) {
        customer.name = 'Ringo'; 
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    getById

    var rdb = require('rdb');
     
    var Customer = rdb.table('_customer');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
    Customer.column('cBalance').numeric().as('balance');
    Customer.column('cRegdate').date().as('registeredDate');
    Customer.column('cIsActive').boolean().as('isActive');
    Customer.column('cPicture').binary().as('picture');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getById)
        .then(printCustomer)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getById() {
        return Customer.getById('a0000000-0000-0000-0000-000000000000');
    }
     
    function printCustomer(customer) {
        var format = 'Customer Id: %s, name: %s, Balance: %s, Registered Date: %s, Is Active: %s, Picture: %s'; 
        var args = [format, customer.id, customer.name, customer.balance, customer.registeredDate, customer.isActive, customer.picture];
        console.log.apply(null,args);
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    tryGetById

    var rdb = require('rdb');
     
    var Customer = rdb.table('_customer');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
    Customer.column('cBalance').numeric().as('balance');
    Customer.column('cRegdate').date().as('registeredDate');
    Customer.column('cIsActive').boolean().as('isActive');
    Customer.column('cPicture').binary().as('picture');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(tryGetById)
        .then(printCustomer)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function tryGetById() {
        return Customer.tryGetById('a0000000-0000-0000-0000-000000000000');
    }
     
    function printCustomer(customer) {
        if (customer) {
            var format = 'Customer Id: %s, name: %s, Balance: %s, Registered Date: %s, Is Active: %s, Picture: %s'; 
            var args = [format, customer.id, customer.name, customer.balance, customer.registeredDate, customer.isActive, customer.picture];
            console.log.apply(null,args);
        }
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    tryGetFirst

    var rdb = require('rdb');
     
    var Customer = rdb.table('_customer');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(tryGetFirst)
        .then(printCustomer)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function tryGetFirst() {
        var filter = Customer.name.equal('John');
        return Customer.tryGetFirst(filter);
    }
     
    function printCustomer(customer) {
        if (customer) {
            console.log('Customer Id: %s, name: %s', customer.id, customer.name);;
        }
        else
            console.log('customer not found');
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    join

    var rdb = require('rdb');
     
    var Customer = rdb.table('_customer');
    var Order = rdb.table('_order');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
    Order.column('oCustomerId').guid().as('customerId');
    Order.join(Customer).by('oCustomerId').as('customer');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getOrder)
        .then(printOrder)
        .then(printCustomer)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getOrder() {
        return Order.getById('a0000000-a000-0000-0000-000000000000');
    }
     
    function printOrder(order) {
        var format = 'Order Id: %s, Order No: %s, Customer Id: %s'; 
        var args = [format, order.id, order.orderNo, order.customerId];
        console.log.apply(null,args);
        return order.customer; //this is a promise
    }
     
    function printCustomer(customer) {
        if (!customer)
            return;
        var format = 'Customer Id: %s, name: %s'; 
        var args = [format, customer.id, customer.name];
        console.log.apply(null,args);
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    hasMany

    var rdb = require('rdb');
     
    var Order = rdb.table('_order');
    var OrderLine = rdb.table('_orderLine');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
     
    OrderLine.primaryColumn('lId').guid().as('id');
    OrderLine.column('lOrderId').guid().as('orderId');
    OrderLine.column('lProduct').string().as('product');
     
    var line_order_relation = OrderLine.join(Order).by('lOrderId').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getOrder)
        .then(printOrder)
        .then(printLines)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getOrder() {
        return Order.getById('b0000000-b000-0000-0000-000000000000');
    }
     
    function printOrder(order) {
        var format = 'Order Id: %s, Order No: %s'; 
        var args = [format, order.id, order.orderNo];
        console.log.apply(null,args);
        return order.lines; //this is a promise
    }
     
    function printLines(lines) {
        lines.forEach(printLine);
     
        function printLine(line) {
            var format = 'Line Id: %s, Order Id: %s, Product: %s'; 
            var args = [format, line.id, line.orderId, line.product];
            console.log.apply(null,args);
        }    
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    hasOne

    var rdb = require('rdb');
     
    var Order = rdb.table('_order');
    var DeliveryAddress = rdb.table('_deliveryAddress');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
     
    DeliveryAddress.primaryColumn('dId').guid().as('id');
    DeliveryAddress.column('dOrderId').string().as('orderId');
    DeliveryAddress.column('dName').string().as('name');
    DeliveryAddress.column('dStreet').string().as('street');
     
    var deliveryAddress_order_relation = DeliveryAddress.join(Order).by('dOrderId').as('order');
    Order.hasOne(deliveryAddress_order_relation).as('deliveryAddress');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getOrder)
        .then(printOrder)
        .then(printDeliveryAddress)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getOrder() {
        return Order.getById('b0000000-b000-0000-0000-000000000000');
    }
     
    function printOrder(order) {
        var format = 'Order Id: %s, Order No: %s'; 
        var args = [format, order.id, order.orderNo];
        console.log.apply(null,args);
        return order.deliveryAddress; //this is a promise
    }
     
    function printDeliveryAddress(address) {
        var format = 'DeliveryAddress Id: %s, Order Id: %s, %s'; 
        var args = [format, address.id, address.orderId, address.name, address.street];
        console.log.apply(null,args);
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    composite keys

    var rdb = require('rdb');
     
    var Order = rdb.table('_compositeOrder');
    var OrderLine = rdb.table('_compositeOrderLine');
     
    Order.primaryColumn('oCompanyId').numeric().as('companyId');
    Order.primaryColumn('oOrderNo').numeric().as('orderNo');
     
    OrderLine.primaryColumn('lCompanyId').numeric().as('companyId');
    OrderLine.primaryColumn('lOrderNo').numeric().as('orderNo');
    OrderLine.primaryColumn('lLineNo').numeric().as('lineNo');
    OrderLine.column('lProduct').string().as('product');
     
    var line_order_relation = OrderLine.join(Order).by('lCompanyId', 'lOrderNo').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getOrder)
        .then(printOrder)
        .then(printLines)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getOrder() {
        var companyId = 1,
            orderId = 1001;
        return Order.getById(companyId, orderId);
    }
     
    function printOrder(order) {
        console.log('Company Id: %s, Order No: %s', order.companyId, order.orderNo)
        return order.lines; //this is a promise
    }
     
    function printLines(lines) {
        lines.forEach(printLine);
     
        function printLine(line) {
            var format = 'Company Id: %s, Order No: %s, Line No: %s, Product: %s'; 
            var args = [format, line.companyId, line.orderNo, line.lineNo, line.product];
            console.log.apply(null,args);
        }    
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    getById eagerly

    var rdb = require('rdb');
     
    var Customer = rdb.table('_customer');
    var Order = rdb.table('_order');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
    Order.column('oCustomerId').guid().as('customerId');
    Order.join(Customer).by('oCustomerId').as('customer');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getOrderWithCustomer)
        .then(printOrder)
        .then(printCustomer)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getOrderWithCustomer() {
        var fetchingStrategy = {customer : null}; //alternatively: {customer : {}} 
        return Order.getById('a0000000-a000-0000-0000-000000000000', fetchingStrategy);
    }
     
    function printOrder(order) {
        var format = 'Order Id: %s, Order No: %s, Customer Id: %s'; 
        var args = [format, order.id, order.orderNo, order.customerId];
        console.log.apply(null,args);
        return order.customer; //this is a promise
    }
     
    function printCustomer(customer) {
        if (!customer)
            return;
        console.log('Customer Id: %s, name: %s', customer.id, customer.name);
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    tryGetFirst eagerly

    var rdb = require('rdb');
     
    var Customer = rdb.table('_customer');
    var Order = rdb.table('_order');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
    Order.column('oCustomerId').guid().as('customerId');
     
    Order.join(Customer).by('oCustomerId').as('customer');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(tryGetFirstOrderWithCustomer)
        .then(printOrder)
        .then(printCustomer)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function tryGetFirstOrderWithCustomer() {
        var filter = Order.customer.name.equal('John');
        var strategy = {customer : null};
        return Order.tryGetFirst(filter, strategy);
    }
     
    function printOrder(order) {
        if (!order) {
            console.log('order not found');
            return;
        }
        var format = 'Order Id: %s, Order No: %s, Customer Id: %s'; 
        var args = [format, order.id, order.orderNo, order.customerId];
        console.log.apply(null,args);
        return order.customer;
    }
     
    function printCustomer(customer) {
        if (!customer) 
            return;
        console.log('Customer Id: %s, name: %s', customer.id, customer.name);
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    toDto

    var rdb = require('rdb');
     
    var Order = rdb.table('_order');
    var Customer = rdb.table('_customer');
    var OrderLine = rdb.table('_orderLine');
    var DeliveryAddress = rdb.table('_deliveryAddress');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
    Order.column('oCustomerId').string().as('customerId');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    OrderLine.primaryColumn('lId').guid().as('id');
    OrderLine.column('lOrderId').string().as('orderId');
    OrderLine.column('lProduct').string().as('product');
     
    DeliveryAddress.primaryColumn('dId').guid().as('id');
    DeliveryAddress.column('dOrderId').string().as('orderId');
    DeliveryAddress.column('dName').string().as('name');
    DeliveryAddress.column('dStreet').string().as('street');
     
    var order_customer_relation = Order.join(Customer).by('customerId').as('customer');
     
    var line_order_relation = OrderLine.join(Order).by('lOrderId').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var deliveryAddress_order_relation = DeliveryAddress.join(Order).by('dOrderId').as('order');
    Order.hasOne(deliveryAddress_order_relation).as('deliveryAddress');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getOrder)
        .then(toDto)
        .then(print)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getOrder() {
        return Order.getById('b0000000-b000-0000-0000-000000000000');
    }
     
    function toDto(order) {
        return order.toDto(/*strategy*/);
        //default strategy, expand all hasOne and hasMany relations
    }
     
    function print(dto) {
        console.log(dto);
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    toDto with strategy

    var rdb = require('rdb');
     
    var Order = rdb.table('_order');
    var Customer = rdb.table('_customer');
    var OrderLine = rdb.table('_orderLine');
    var DeliveryAddress = rdb.table('_deliveryAddress');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
    Order.column('oCustomerId').string().as('customerId');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    OrderLine.primaryColumn('lId').guid().as('id');
    OrderLine.column('lOrderId').guid().as('orderId');
    OrderLine.column('lProduct').string().as('product');
     
    DeliveryAddress.primaryColumn('dId').guid().as('id');
    DeliveryAddress.column('dOrderId').string().as('orderId');
    DeliveryAddress.column('dName').string().as('name');
    DeliveryAddress.column('dStreet').string().as('street');
     
    var order_customer_relation = Order.join(Customer).by('oCustomerId').as('customer');
     
    var line_order_relation = OrderLine.join(Order).by('lOrderId').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var deliveryAddress_order_relation = DeliveryAddress.join(Order).by('dOrderId').as('order');
    Order.hasOne(deliveryAddress_order_relation).as('deliveryAddress');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getOrder)
        .then(toDto)
        .then(print)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getOrder() {
        return Order.getById('b0000000-b000-0000-0000-000000000000');
    }
     
    function toDto(order) {
        var strategy = {customer : null, lines : null, deliveryAddress : null};
        return order.toDto(strategy);
    }
     
    function print(dto) {
        console.log(dto);
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    toDto with orderBy

    var rdb = require('rdb');
     
    var Order = rdb.table('_order');
    var OrderLine = rdb.table('_orderLine');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
     
    OrderLine.primaryColumn('lId').guid().as('id');
    OrderLine.column('lOrderId').string().as('orderId');
    OrderLine.column('lProduct').string().as('product');
     
    var line_order_relation = OrderLine.join(Order).by('lOrderId').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getOrder)
        .then(toDto)
        .then(print)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getOrder() {
        return Order.getById('b0000000-b000-0000-0000-000000000000');
    }
     
    function toDto(order) {
        var strategy = {
            lines: {
                orderBy: ['product'] 
                //alternative: orderBy: ['product asc']
            }
        };
        return order.toDto(strategy);
    }
     
    function print(dto) {
        console.log(dto);
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    toDto with orderBy descending

    var rdb = require('rdb');
     
    var Order = rdb.table('_order');
    var OrderLine = rdb.table('_orderLine');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
     
    OrderLine.primaryColumn('lId').guid().as('id');
    OrderLine.column('lOrderId').string().as('orderId');
    OrderLine.column('lProduct').string().as('product');
     
    var line_order_relation = OrderLine.join(Order).by('lOrderId').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getOrder)
        .then(toDto)
        .then(print)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getOrder() {
        return Order.getById('b0000000-b000-0000-0000-000000000000');
    }
     
    function toDto(order) {
        var strategy = {
            lines: {
                orderBy: ['product desc'] 
            }
        };
        return order.toDto(strategy);
    }
     
    function print(dto) {
        console.log(dto);
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    toDto ignoring columns

    var rdb = require('rdb');
     
    var User = rdb.table('_User');
    User.primaryColumn('uId').guid().as('id');
    User.column('uUserId').string().as('userId');
    User.column('uPassword').string().as('password').serializable(false);
    User.column('uEmail').string().as('email');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getUser)
        .then(toDto)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getUser() {
        return User.getById('87654400-0000-0000-0000-000000000000');
    }
     
    function toDto(user) {
        return user.toDto().then(console.log);
        //will print all properties except password
        //because it is not serializable
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    toJSON

    var rdb = require('rdb');
     
    var Order = rdb.table('_order');
    var Customer = rdb.table('_customer');
    var OrderLine = rdb.table('_orderLine');
    var DeliveryAddress = rdb.table('_deliveryAddress');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
    Order.column('oCustomerId').string().as('customerId');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    OrderLine.primaryColumn('lId').guid().as('id');
    OrderLine.column('lOrderId').string().as('orderId');
    OrderLine.column('lProduct').string().as('product');
     
    DeliveryAddress.primaryColumn('dId').guid().as('id');
    DeliveryAddress.column('dOrderId').string().as('orderId');
    DeliveryAddress.column('dName').string().as('name');
    DeliveryAddress.column('dStreet').string().as('street');
     
    var order_customer_relation = Order.join(Customer).by('customerId').as('customer');
     
    var line_order_relation = OrderLine.join(Order).by('lOrderId').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var deliveryAddress_order_relation = DeliveryAddress.join(Order).by('dOrderId').as('order');
    Order.hasOne(deliveryAddress_order_relation).as('deliveryAddress');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getOrder)
        .then(toJSON)
        .then(print)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getOrder() {
        return Order.getById('b0000000-b000-0000-0000-000000000000');
    }
     
    function toJSON(order) {
        return order.toJSON(/*strategy*/);
        //default strategy, expand all hasOne and hasMany relations
    }
     
    function print(json) {
        console.log(json);
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    toJSON with strategy

    var rdb = require('rdb');
     
    var Order = rdb.table('_order');
    var Customer = rdb.table('_customer');
    var OrderLine = rdb.table('_orderLine');
    var DeliveryAddress = rdb.table('_deliveryAddress');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
    Order.column('oCustomerId').string().as('customerId');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    OrderLine.primaryColumn('lId').guid().as('id');
    OrderLine.column('lOrderId').guid().as('orderId');
    OrderLine.column('lProduct').string().as('product');
     
    DeliveryAddress.primaryColumn('dId').guid().as('id');
    DeliveryAddress.column('dOrderId').string().as('orderId');
    DeliveryAddress.column('dName').string().as('name');
    DeliveryAddress.column('dStreet').string().as('street');
     
    var order_customer_relation = Order.join(Customer).by('oCustomerId').as('customer');
     
    var line_order_relation = OrderLine.join(Order).by('lOrderId').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var deliveryAddress_order_relation = DeliveryAddress.join(Order).by('dOrderId').as('order');
    Order.hasOne(deliveryAddress_order_relation).as('deliveryAddress');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getOrder)
        .then(toJSON)
        .then(print)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getOrder() {
        return Order.getById('b0000000-b000-0000-0000-000000000000');
    }
     
    function toJSON(order) {
        var strategy = {customer : null, lines : null, deliveryAddress : null};
        return order.toJSON(strategy);
    }
     
    function print(json) {
        console.log(json);
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    getMany

    var rdb = require('rdb');
     
    var Customer = rdb.table('_customer');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getAllCustomers)
        .then(printCustomers)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getAllCustomers() {
        return Customer.getMany();
    }
     
    function printCustomers(customers) {
        customers.forEach(printCustomer);
     
        function printCustomer(customer) {
            console.log('Customer Id: %s, name: %s', customer.id, customer.name);
        }
    }
     
    function print(json) {
        console.log(json);
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    getMany lazily

    var rdb = require('rdb'),
        promise = require('promise');
     
    var Order = rdb.table('_order');
    var OrderLine = rdb.table('_orderLine');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
     
    OrderLine.primaryColumn('lId').guid().as('id');
    OrderLine.column('lOrderId').guid().as('orderId');
    OrderLine.column('lProduct').string().as('product');
     
    var line_order_relation = OrderLine.join(Order).by('lOrderId').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getAllOrders)
        .then(printOrders)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getAllOrders() {
        return Order.getMany();
    }
     
    function printOrders(orders) {
        var printAllLines = [];
        orders.forEach(printOrder);
     
        function printOrder(order) {
            var format = 'Order Id: %s, Order No: %s'; 
            var args = [format, order.id, order.orderNo];
            console.log.apply(null,args);
            printAllLines.push(order.lines.then(printLines));
        }
        return promise.all(printAllLines);
    }
     
    function printLines(lines) {
        lines.forEach(printLine);
     
        function printLine(line) {
            var format = 'Line Id: %s, Order Id: %s, Product: %s'; 
            var args = [format, line.id, line.orderId, line.product];
            console.log.apply(null,args);
        }    
    }
     
    function onOk() {
        console.log('success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    getMany eager

    var rdb = require('rdb'),
        promise = require('promise');
     
    var Order = rdb.table('_order');
    var OrderLine = rdb.table('_orderLine');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
     
    OrderLine.primaryColumn('lId').guid().as('id');
    OrderLine.column('lOrderId').guid().as('orderId');
    OrderLine.column('lProduct').string().as('product');
     
    var line_order_relation = OrderLine.join(Order).by('lOrderId').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getAllOrders)
        .then(printOrders)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getAllOrders() {
        var emptyFilter;
        var strategy = {lines : null};
        return Order.getMany(emptyFilter, strategy);
    }
     
    function printOrders(orders) {
        var printAllLines = [];
        orders.forEach(printOrder);
     
        function printOrder(order) {
            var format = 'Order Id: %s, Order No: %s'; 
            var args = [format, order.id, order.orderNo];
            console.log.apply(null,args);
            printAllLines.push(order.lines.then(printLines));
        }
        return promise.all(printAllLines);
    }
     
    function printLines(lines) {
        lines.forEach(printLine);
     
        function printLine(line) {
            var format = 'Line Id: %s, Order Id: %s, Product: %s'; 
            var args = [format, line.id, line.orderId, line.product];
            console.log.apply(null,args);
        }    
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    (many)ToDto

    var rdb = require('rdb'),
        inspect = require('util').inspect;
     
    var Order = rdb.table('_order');
    var Customer = rdb.table('_customer');
    var OrderLine = rdb.table('_orderLine');
    var DeliveryAddress = rdb.table('_deliveryAddress');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
    Order.column('oCustomerId').string().as('customerId');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    OrderLine.primaryColumn('lId').guid().as('id');
    OrderLine.column('lOrderId').guid().as('orderId');
    OrderLine.column('lProduct').string().as('product');
     
    DeliveryAddress.primaryColumn('dId').guid().as('id');
    DeliveryAddress.column('dOrderId').string().as('orderId');
    DeliveryAddress.column('dName').string().as('name');
    DeliveryAddress.column('dStreet').string().as('street');
     
    var order_customer_relation = Order.join(Customer).by('customerId').as('customer');
     
    var line_order_relation = OrderLine.join(Order).by('lOrderId').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var deliveryAddress_order_relation = DeliveryAddress.join(Order).by('dOrderId').as('order');
    Order.hasOne(deliveryAddress_order_relation).as('deliveryAddress');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getOrders)
        .then(toDto)
        .then(print)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getOrders() {
        return Order.getMany();
    }
     
    function toDto(orders) {
        return orders.toDto(/*strategy*/);
        //default strategy, expand all hasOne and hasMany relations
    }
     
    function print(dto) {
        console.log(inspect(dto,false,10));
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    (many)ToDto with strategy

    var rdb = require('rdb'),
        inspect = require('util').inspect;
     
    var Order = rdb.table('_order');
    var Customer = rdb.table('_customer');
    var OrderLine = rdb.table('_orderLine');
    var DeliveryAddress = rdb.table('_deliveryAddress');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
    Order.column('oCustomerId').string().as('customerId');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    OrderLine.primaryColumn('lId').guid().as('id');
    OrderLine.column('lOrderId').guid().as('orderId');
    OrderLine.column('lProduct').string().as('product');
     
    DeliveryAddress.primaryColumn('dId').guid().as('id');
    DeliveryAddress.column('dOrderId').string().as('orderId');
    DeliveryAddress.column('dName').string().as('name');
    DeliveryAddress.column('dStreet').string().as('street');
     
    var order_customer_relation = Order.join(Customer).by('oCustomerId').as('customer');
     
    var line_order_relation = OrderLine.join(Order).by('lOrderId').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var deliveryAddress_order_relation = DeliveryAddress.join(Order).by('dOrderId').as('order');
    Order.hasOne(deliveryAddress_order_relation).as('deliveryAddress');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getOrders)
        .then(toDto)
        .then(print)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getOrders() {
        return Order.getMany();
    }
     
    function toDto(orders) {
        var strategy = {customer : null, lines : null, deliveryAddress : null};
        return orders.toDto(strategy);
    }
     
    function print(dto) {
        console.log(inspect(dto,false,10));
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    (many)ToJSON

    var rdb = require('rdb');
     
    var Order = rdb.table('_order');
    var Customer = rdb.table('_customer');
    var OrderLine = rdb.table('_orderLine');
    var DeliveryAddress = rdb.table('_deliveryAddress');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
    Order.column('oCustomerId').string().as('customerId');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    OrderLine.primaryColumn('lId').guid().as('id');
    OrderLine.column('lOrderId').guid().as('orderId');
    OrderLine.column('lProduct').string().as('product');
     
    DeliveryAddress.primaryColumn('dId').guid().as('id');
    DeliveryAddress.column('dOrderId').string().as('orderId');
    DeliveryAddress.column('dName').string().as('name');
    DeliveryAddress.column('dStreet').string().as('street');
     
    var order_customer_relation = Order.join(Customer).by('customerId').as('customer');
     
    var line_order_relation = OrderLine.join(Order).by('lOrderId').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var deliveryAddress_order_relation = DeliveryAddress.join(Order).by('dOrderId').as('order');
    Order.hasOne(deliveryAddress_order_relation).as('deliveryAddress');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getOrders)
        .then(toJSON)
        .then(print)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getOrders() {
        return Order.getMany();
    }
     
    function toJSON(orders) {
        return orders.toJSON(/*strategy*/);
        //default strategy, expand all hasOne and hasMany relations
    }
     
    function print(json) {
        console.log(json);
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    (many)ToJSON with strategy

    var rdb = require('rdb');
     
    var Order = rdb.table('_order');
    var Customer = rdb.table('_customer');
    var OrderLine = rdb.table('_orderLine');
    var DeliveryAddress = rdb.table('_deliveryAddress');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
    Order.column('oCustomerId').string().as('customerId');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    OrderLine.primaryColumn('lId').guid().as('id');
    OrderLine.column('lOrderId').guid().as('orderId');
    OrderLine.column('lProduct').string().as('product');
     
    DeliveryAddress.primaryColumn('dId').guid().as('id');
    DeliveryAddress.column('dOrderId').string().as('orderId');
    DeliveryAddress.column('dName').string().as('name');
    DeliveryAddress.column('dStreet').string().as('street');
     
    var order_customer_relation = Order.join(Customer).by('oCustomerId').as('customer');
     
    var line_order_relation = OrderLine.join(Order).by('lOrderId').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var deliveryAddress_order_relation = DeliveryAddress.join(Order).by('dOrderId').as('order');
    Order.hasOne(deliveryAddress_order_relation).as('deliveryAddress');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getOrders)
        .then(toJSON)
        .then(print)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getOrders() {
        return Order.getMany();
    }
     
    function toJSON(orders) {
        var strategy = {customer : null, lines : null, deliveryAddress : null};
        return orders.toJSON(strategy);
    }
     
    function print(json) {
        console.log(json);
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    streaming rows

    var rdb = require('rdb');
     
    var Order = rdb.table('_order');
    var OrderLine = rdb.table('_orderLine');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
     
    OrderLine.primaryColumn('lId').guid().as('id');
    OrderLine.column('lOrderId').guid().as('orderId');
    OrderLine.column('lProduct').string().as('product');
     
    var line_order_relation = OrderLine.join(Order).by('lOrderId').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    var emptyFilter;
    var strategy = {
        lines: {
            orderBy: ['product']
        },
        orderBy: ['orderNo'],
        limit: 5,
    };
     
    Order.createReadStream(db, emptyFilter, strategy).on('data', printOrder);
     
    function printOrder(order) {
        var format = 'Order Id: %s, Order No: %s';
        console.log(format, order.id, order.orderNo);
        order.lines.forEach(printLine);
    }
     
    function printLine(line) {
        var format = 'Line Id: %s, Order Id: %s, Product: %s';
        console.log(format, line.id, line.orderId, line.product);
    }

    streaming json

    var rdb = require('rdb');
     
    var Order = rdb.table('_order');
    var OrderLine = rdb.table('_orderLine');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
     
    OrderLine.primaryColumn('lId').guid().as('id');
    OrderLine.column('lOrderId').guid().as('orderId');
    OrderLine.column('lProduct').string().as('product');
     
    var line_order_relation = OrderLine.join(Order).by('lOrderId').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    var emptyFilter;
    var strategy = {
        lines: {
            orderBy: ['product']
        },
        orderBy: ['orderNo'],
        limit: 5,
    };
     
    Order.createJSONReadStream(db, emptyFilter, strategy).pipe(process.stdout);

    update

    var rdb = require('rdb');
     
    var Customer = rdb.table('_customer');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getById)
        .then(update)
        .then(getById) //will use cache
        .then(verifyUpdated)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getById() {
        return Customer.getById('a0000000-0000-0000-0000-000000000000');
    }
     
    function update(customer) {
        customer.name = 'Ringo'; 
    }
     
    function verifyUpdated(customer) {
        if (customer.name !== 'Ringo')
            throw new Error('this will not happen');
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    insert

    var rdb = require('rdb');
     
    var Customer = rdb.table('_customer');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(insert)
        .then(getById) //will use cache
        .then(verifyInserted)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function insert() {
        var customer = Customer.insert('abcdef00-0000-0000-0000-000000000000')
        customer.name = 'Paul';
    }
     
    function getById() {
        return Customer.getById('abcdef00-0000-0000-0000-000000000000');
    }
     
    function verifyInserted(customer) {
        if (customer.name !== 'Paul')
            throw new Error('this will not happen');
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err);
    }

    delete

    var rdb = require('rdb');
     
    var Customer = rdb.table('_customer');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
    Customer.column('cBalance').numeric().as('balance');
    Customer.column('cRegdate').date().as('registeredDate');
    Customer.column('cIsActive').boolean().as('isActive');
    Customer.column('cPicture').binary().as('picture');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getById)
        .then(deleteCustomer)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getById() {    
        return Customer.getById('87654321-0000-0000-0000-000000000000');
    }
     
    function deleteCustomer(customer) {
        customer.delete();
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err.stack);
    }

    cascadeDelete

    var rdb = require('rdb');
     
    var Customer = rdb.table('_customer');
    var Order = rdb.table('_order');
    var OrderLine = rdb.table('_orderLine');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
     
    Order.primaryColumn('oId').guid().as('id');
    Order.column('oOrderNo').string().as('orderNo');
    Order.column('oCustomerId').guid().as('customerId');
     
    OrderLine.primaryColumn('lId').guid().as('id');
    OrderLine.column('lOrderId').guid().as('orderId');
     
    var orderToCustomer = Order.join(Customer).by('oCustomerId').as('customer');
    Customer.hasMany(orderToCustomer).as('orders');
     
    var line_order_relation = OrderLine.join(Order).by('lOrderId').as('order');
    Order.hasMany(line_order_relation).as('lines');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(getById)
        .then(deleteCustomer)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function getById() {
        return Customer.getById('87654399-0000-0000-0000-000000000000');
    }
     
    function deleteCustomer(customer) {
        customer.cascadeDelete();
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err.stack);
    }

    bulk delete

    var rdb = require('rdb');
     
    var Customer = rdb.table('_customer');
     
    Customer.primaryColumn('cId').guid().as('id');
    Customer.column('cName').string().as('name');
    Customer.column('cBalance').numeric().as('balance');
    Customer.column('cRegdate').date().as('registeredDate');
    Customer.column('cIsActive').boolean().as('isActive');
    Customer.column('cPicture').binary().as('picture');
     
    var db = rdb('postgres://postgres:postgres@localhost/test');
     
    db.transaction()
        .then(deleteCustomer)
        .then(rdb.commit)
        .then(null, rdb.rollback)
        .then(onOk, onFailed);
     
    function deleteCustomer() {    
        var filter = Customer.id.eq('87654321-0000-0000-0000-000000000000');
        return Customer.delete(filter);
    }
     
    function onOk() {
        console.log('Success');
        console.log('Waiting for connection pool to teardown....');
    }
     
    function onFailed(err) {
        console.log('Rollback');
        console.log(err.stack);
    }

    bulk cascadeDelete

    var rdb = require('rdb');
     
    var Customer = rdb.table('_customer');
    var Order = rdb.table('_order');
    var OrderLine = rdb.table('_orderLine')