2014-09-01 17:18:45 +02:00
'use strict' ;
2014-08-11 12:25:39 +02:00
// Oracle Query Builder & Compiler
// ------
module . exports = function ( client ) {
var _ = require ( 'lodash' ) ;
var inherits = require ( 'inherits' ) ;
var QueryBuilder = require ( '../../query/builder' ) ;
var QueryCompiler = require ( '../../query/compiler' ) ;
2014-08-27 10:10:20 +02:00
var helpers = require ( '../../helpers' ) ;
2014-08-11 12:25:39 +02:00
var ReturningHelper = require ( './utils' ) . ReturningHelper ;
// Query Builder
// -------
// Extend the QueryBuilder base class to include the "Formatter"
// which has been defined on the client, as well as the
function QueryBuilder _Oracle ( ) {
this . client = client ;
QueryBuilder . apply ( this , arguments ) ;
}
inherits ( QueryBuilder _Oracle , QueryBuilder ) ;
// Query Compiler
// -------
// Set the "Formatter" to use for the queries,
// ensuring that all parameterized values (even across sub-queries)
// are properly built into the same query.
function QueryCompiler _Oracle ( ) {
this . formatter = new client . Formatter ( ) ;
QueryCompiler . apply ( this , arguments ) ;
}
inherits ( QueryCompiler _Oracle , QueryCompiler ) ;
2014-08-20 09:34:32 +02:00
// for single commands only
QueryCompiler _Oracle . prototype . _addReturningToSqlAndConvert = function ( sql , returning , tableName ) {
2014-08-13 21:37:22 +02:00
var res = {
sql : sql
} ;
2014-08-20 09:34:32 +02:00
if ( ! returning ) {
return res ;
2014-08-11 12:25:39 +02:00
}
2014-08-20 09:34:32 +02:00
var returningValues = _ . isArray ( returning ) ? returning : [ returning ] ;
var returningHelper = new ReturningHelper ( returningValues . join ( ':' ) ) ;
res . sql = sql + ' returning ROWID into ' + this . formatter . parameter ( returningHelper ) ;
res . returningSql = 'select ' + this . formatter . columnize ( returning ) + ' from ' + tableName + ' where ROWID = :1' ;
res . outParams = [ returningHelper ] ;
res . returning = returning ;
2014-08-13 21:37:22 +02:00
return res ;
2014-08-11 12:25:39 +02:00
} ;
// Compiles an "insert" query, allowing for multiple
// inserts using a single query statement.
QueryCompiler _Oracle . prototype . insert = function ( ) {
2014-08-13 21:37:22 +02:00
var self = this ;
var returning = self . single . returning ;
2014-08-20 09:34:32 +02:00
// always wrap returning argument in array
if ( returning && ! _ . isArray ( returning ) ) {
returning = [ returning ] ;
}
2014-08-27 10:10:20 +02:00
if ( _ . isEmpty ( self . single . insert ) && ! _ . isFunction ( this . single . insert ) ) {
2014-08-20 09:34:32 +02:00
return self . _addReturningToSqlAndConvert ( 'insert into ' + self . tableName + ' (' + self . formatter . wrap ( self . single . returning ) + ') values (default)' , returning , self . tableName ) ;
2014-08-13 21:37:22 +02:00
}
var insertData = self . _prepInsert ( self . single . insert ) ;
if ( _ . isString ( insertData ) ) {
return self . _addReturningToSqlAndConvert ( 'insert into ' + self . tableName + ' ' + insertData , returning ) ;
}
if ( insertData . values . length === 1 ) {
2014-08-20 09:34:32 +02:00
return self . _addReturningToSqlAndConvert ( 'insert into ' + self . tableName + ' (' + self . formatter . columnize ( insertData . columns ) + ') values (' + self . formatter . parameterize ( insertData . values [ 0 ] ) + ')' , returning , self . tableName ) ;
2014-08-11 12:25:39 +02:00
}
2014-08-13 21:37:22 +02:00
var sql = { } ;
sql . sql = 'begin ' +
_ . map ( insertData . values , function ( value ) {
2014-08-20 09:34:32 +02:00
var returningHelper ;
2014-08-13 21:37:22 +02:00
var parameterizedValues = self . formatter . parameterize ( value ) ;
2014-08-20 09:34:32 +02:00
var returningValues = _ . isArray ( returning ) ? returning : [ returning ] ;
if ( returning ) {
returningHelper = new ReturningHelper ( returningValues . join ( ':' ) ) ;
sql . outParams = ( sql . outParams || [ ] ) . concat ( returningHelper ) ;
}
var subSql = 'insert into ' + self . tableName + ' (' + self . formatter . columnize ( insertData . columns ) + ') values (' + parameterizedValues + ')' + ( returning ? ' returning ROWID into ' + self . formatter . parameter ( returningHelper ) : '' ) ;
2014-08-13 21:37:22 +02:00
// pre bind position because subSql is an execute immediate parameter
// later position binding will only convert the ? params
subSql = self . formatter . client . positionBindings ( subSql ) ;
2014-08-20 09:34:32 +02:00
return 'execute immediate \'' + subSql . replace ( /'/g , "''" ) + '\' using ' + parameterizedValues + ( returning ? ', out ?' : '' ) + ';' ;
2014-08-13 21:37:22 +02:00
}
) . join ( ' ' ) +
'end;' ;
2014-08-20 09:34:32 +02:00
if ( returning ) {
sql . returning = returning ;
// generate select statement with special order by to keep the order because 'in (..)' may change the order
sql . returningSql = 'select ' + this . formatter . columnize ( returning ) +
' from ' + self . tableName +
' where ROWID in (' + sql . outParams . map ( function ( v , i ) { return ':' + ( i + 1 ) ; } ) . join ( ', ' ) + ')' +
' order by case ROWID ' + sql . outParams . map ( function ( v , i ) { return 'when CHARTOROWID(:' + ( i + 1 ) + ') then ' + i ; } ) . join ( ' ' ) + ' end' ;
}
2014-08-11 12:25:39 +02:00
return sql ;
} ;
// Update method, including joins, wheres, order & limits.
QueryCompiler _Oracle . prototype . update = function ( ) {
var updates = this . _prepUpdate ( this . single . update ) ;
var where = this . where ( ) ;
return 'update ' + this . tableName +
' set ' + updates . join ( ', ' ) +
2014-08-27 10:10:20 +02:00
( where ? ' ' + where : '' ) ;
2014-08-11 12:25:39 +02:00
} ;
// Compiles a `truncate` query.
QueryCompiler _Oracle . prototype . truncate = function ( ) {
return 'truncate table ' + this . tableName ;
} ;
QueryCompiler _Oracle . prototype . forUpdate = function ( ) {
return 'for update' ;
} ;
QueryCompiler _Oracle . prototype . forShare = function ( ) {
2014-08-27 10:10:20 +02:00
// lock for share is not directly supported by oracle
// use LOCK TABLE .. IN SHARE MODE; instead
helpers . warn ( 'lock for share is not supported by oracle dialect' ) ;
return '' ;
2014-08-11 12:25:39 +02:00
} ;
// Compiles a `columnInfo` query.
QueryCompiler _Oracle . prototype . columnInfo = function ( ) {
var column = this . single . columnInfo ;
return {
sql : 'select COLUMN_NAME, DATA_TYPE, CHAR_COL_DECL_LENGTH, NULLABLE from USER_TAB_COLS where TABLE_NAME = :1' ,
bindings : [ this . single . table ] ,
output : function ( resp ) {
var out = _ . reduce ( resp , function ( columns , val ) {
columns [ val . COLUMN _NAME ] = {
type : val . DATA _TYPE ,
maxLength : val . CHAR _COL _DECL _LENGTH ,
nullable : ( val . NULLABLE === 'Y' )
} ;
return columns ;
} , { } ) ;
return column && out [ column ] || out ;
}
} ;
} ;
QueryCompiler _Oracle . prototype . limit = function ( ) {
// throw new Error("This function should never be called for oracle");
} ;
QueryCompiler _Oracle . prototype . offset = function ( ) {
// throw new Error("This function should never be called for oracle");
} ;
function surroundQueryWithLimitAndOffset ( self , query , limit , offset ) {
if ( ! limit && ! offset ) {
return query ;
}
query = query || "" ;
if ( limit && ! offset ) {
return "select * from (" + query + ") where rownum <= " + self . formatter . parameter ( limit ) ;
}
var endRow = + ( offset ) + ( + limit || 10000000000000 ) ;
return "select * from " +
"(select row_.*, ROWNUM rownum_ from (" + query + ") row_ " +
"where rownum <= " + self . formatter . parameter ( endRow ) + ") " +
"where rownum_ > " + self . formatter . parameter ( offset ) ;
}
var components = [
'columns' , 'join' , 'where' , 'union' , 'group' ,
'having' , 'order' , /*'limit', 'offset', */ 'lock'
] ;
// Compiles the `select` statement, or nested sub-selects
// by calling each of the component compilers, trimming out
// the empties, and returning a generated query string.
2014-08-21 23:39:12 +02:00
QueryCompiler _Oracle . prototype . first =
2014-08-11 12:25:39 +02:00
QueryCompiler _Oracle . prototype . select = function ( ) {
var self = this ;
var statements = _ . map ( components , function ( component ) {
return self [ component ] ( self ) ;
} ) ;
var query = _ . compact ( statements ) . join ( ' ' ) ;
return surroundQueryWithLimitAndOffset ( self , query , this . single . limit , this . single . offset ) ;
} ;
QueryCompiler _Oracle . prototype . aggregate = function ( stmt ) {
var val = stmt . value ;
var splitOn = val . toLowerCase ( ) . indexOf ( ' as ' ) ;
// Allows us to speciy an alias for the aggregate types.
if ( splitOn !== - 1 ) {
var col = val . slice ( 0 , splitOn ) ;
var alias = val . slice ( splitOn + 4 ) ;
return stmt . method + '(' + this . formatter . wrap ( col ) + ') ' + this . formatter . wrap ( alias ) ;
}
return stmt . method + '(' + this . formatter . wrap ( val ) + ')' ;
} ;
// Set the QueryBuilder & QueryCompiler on the client object,
// incase anyone wants to modify things to suit their own purposes.
client . QueryBuilder = QueryBuilder _Oracle ;
client . QueryCompiler = QueryCompiler _Oracle ;
} ;