@sap/cds 5.4.6 → 5.5.0

package/lib/ql/SELECT.js

@@ -1,87 +1,120 @@
-const Whereable = require('./Whereable'), { parse, _where } = Whereable
-const $ = Object.assign
+const Whereable = require('./Whereable'), { parse, predicate4 } = Whereable
+const defaults = global.cds.env.sql
+
 
 module.exports = class SELECT extends Whereable {
 
-  static get _() {
-    return $((..._) => (new this).columns(..._), {
-      from: (..._) => (new this).from(..._),
-      distinct: $((...x) => $((new this).distinct.from(...x),
-        { from: (..._) => (new this).distinct.from(..._).columns(...x) }
-      ),{ from: (..._) => (new this).distinct.from(..._) }),
-      one: $((...x) => $((new this).one.from(...x),
-        { from: (..._) => (new this).one.from(..._).columns(...x) }
-      ),{ from: (..._) => (new this).one.from(..._) }),
+  static _api() {
+    const $ = Object.assign
+    return $((..._)       => new this()._select_or_from(..._), {
+      one: $((...x)       => new this({one:true})._select_or_from(...x),{
+        columns: (..._)   => new this({one:true}).columns(..._),
+        from: (..._)      => new this({one:true}).from(..._),
+      }),
+      distinct: $((...x)  => new this({distinct:true})._select_or_from(...x),{
+        columns: (..._)   => new this({distinct:true}).columns(..._),
+        from: (..._)      => new this({distinct:true}).from(..._),
+      }),
+      columns: (..._)     => new this().columns(..._),
+      from: (..._)        => new this().from(..._),
     })
   }
 
-  get distinct() {
-    this._.distinct = true
-    return this
+  _select_or_from (cols, ...more) { // srv.read`title`.from`Books` or srv.read`Books` ?
+    if (!cols) return this
+    else if (is_number(cols)) return this.columns(...arguments) //> numbers can't be from
+    else if (cols.name) return this.from (...arguments) //> clearly a from
+    else if (cols.raw) { // tagged template string
+      if (cols[0].startsWith('from ')) { // SELECT`from ...`, with an arbitrary long CQL tail...
+        Object.assign (this.SELECT, SELECT_(' ',arguments))
+        return this
+      } else if (cols[0][0] === '{') {  // SELECT`{a,b}`... -> it's columns
+        let {columns:c} = SELECT_('from X', arguments)
+        return this._add('columns',c)
+      } else {                          // SELECT`Foo` -> ambiguous -> try parsing as columns...
+        let {columns:c} = SELECT_('from X {', arguments, '}')
+        if (c.length > 1 || !c[0].ref) return this._add('columns',c)
+        // else cols = c[0] //> goes on below...
+      }
+    } else {                          // SELECT('Foo'|'*',[...]|(foo)=>{})
+      if (cols === '*') return this.columns(...arguments)
+      const c = _columns_or_not (cols)
+      if (c) return this._add('columns',c)
+    }
+
+    // return a proxy assuming it's a from and switching to
+    // columns on a subsequent call of .from, if any.
+    const {SELECT:_} = this, {one} = _
+    return Object.defineProperties (this.from (cols, ...more), {
+      from: { configurable:true, value:(...args) => { delete this.from
+        if (!one) delete _.one; delete _.columns; delete _.where
+        return this.from (...args) .columns (cols, ...more)
+      }}
+    })
   }
-  get one() {
-    this._.one = true
+
+  columns (...cols) {
+    if (cols[0]) this._add ('columns', _columns(cols))
     return this
   }
 
-  from(entity, second, third) {
-    this._.from = { ref: [this.target(entity).name] }
-    if (is_projection(second)) this.columns(second)
-    else if (second) {
-      if (second) this.byKey(second)
+  from (target, second, third) {
+    this.SELECT.from = target === '*' || this._target_ref4 (...arguments)
+    if (!target.raw && second) {
+      const cols = _columns_or_not (second)
+      cols ? this._add('columns',cols) : this.byKey(second)
       if (third) this.columns(third)
     }
     return this
   }
 
-  columns(...x) {
-    const p = projection(x)
-    this._.columns = this._.columns ? this._.columns.concat(p) : p
-    return this
-  }
-
-  expand(ref, x, _kind = 'expand') {
-    const cols = this._.columns || (this._.columns = [])
-    cols.push({ ref: ref.split('.'), [_kind]: projection(x) })
-    return this
+  fullJoin  (other, as) { return this.join (other, as, 'full') }
+  leftJoin  (other, as) { return this.join (other, as, 'left') }
+  rightJoin (other, as) { return this.join (other, as, 'right') }
+  innerJoin (other, as) { return this.join (other, as, 'inner') }
+  join (other, as, kind='inner') {
+    const [, target, alias = as] = /(\S+)(?:\s+(?:as)?\s+(\S+))?/i.exec(other)
+    const ref = { ref: [target] }
+    if (alias) ref.as = alias
+    this.SELECT.from = { join:kind, args: [this.SELECT.from, ref] }
+    return Object.defineProperty(this, '_where_or_having', { value: 'on', configurable: true })
   }
-
-  inline(ref, cols) {
-    return this.expand(ref, cols, 'inline')
+  on (...args) {
+    if (!this.SELECT.from || !this.SELECT.from.join)
+      throw new Error(`Invalid call of "SELECT.on()" without prior call of "SELECT.join()"`)
+    return this._where (args,'and','on')
   }
 
-  excluding(...x) {
-    this._.excluding = x
-    return this
+  having(...x) {
+    return this._where (x,'and','having')
   }
 
-  groupBy(...x) {
-    this._.groupBy = x.map((x) => parse.expr(x))
-    return this
+  groupBy (...args) {
+    if (!args[0]) return this
+    const cqn = args[0].raw ? SELECT_('from X group by', args).groupBy : args.map(parse.expr)
+    return this._add('groupBy',cqn)
   }
 
-  having(...x) {
-    this._.having = _where(x)
-    return this
+  orderBy (...args) {
+    if (!args[0]) return this
+    return this._add('orderBy',_order_by(args))
   }
 
-  orderBy(...x) {
-    this._.orderBy = order_by(x)
+  limit (rows, offset) {
+    if (is_number(rows) || rows) this.SELECT.limit = rows.rows ? rows : { rows: {val:rows} }
+    if (is_number(offset)) this.SELECT.limit.offset = { val: offset }
     return this
   }
 
-  limit(rows, offset) {
-    const _ = this._.limit = { rows:{val:rows} }
-    if (offset) _.offset = {val:offset}
+  forUpdate ({ of, wait = defaults.lock_acquire_timeout || -1 } = {}) {
+    const sfu = this.SELECT.forUpdate = {}
+    if (of) sfu.of = of.map (c => ({ref:c.split('.')}))
+    if (wait >= 0) sfu.wait = wait
     return this
   }
 
-  redirectedTo(entity) {
-    return this.clone().from(entity)
-  }
-
-  foreach(callback) {
-    return this.then((rows) => rows.map(callback))
+  foreach (callback) {
+    return this.then(rows => rows.map(callback))
   }
 
   valueOf() {
@@ -89,89 +122,91 @@ module.exports = class SELECT extends Whereable {
   }
 }
 
-const is_projection = (x) => typeof x === 'function' || is_array(x)
-const column_expr = (x) => {
-  if (x === '*' || x === undefined || x.xpr || x.ref || x.val || x.func || x.SELECT) return x
-  if (typeof x === 'object') for (let one in x) {
-    const r = parse.expr(one); r.as = x[one]
-    return r
-  }
-  return typeof x === 'string' ? parse.column(x) : {val:x}
+
+const _columns = (args) => {
+  if (args[0].raw) {
+    if (args[0][0] === '{') return SELECT_('from X ',args).columns
+    else                    return SELECT_('from X {',args,'}').columns
+  } else return _columns_or_not(args[0]) || args.map(_column_expr)
 }
 
-const projection = (x) => {
-  if (is_projection(x[0])) x = x[0]
-  if (!x || x === '*') return ['*']
-  if (is_array(x)) return x.map(column_expr)
-  if (typeof x === 'function') {
-    const columns = []
-    x(
-      new Proxy(x, {
-        // handle top-level projections or subselects such as
-        // (foo)=>{ foo('*'), foo(SELECT...).as('bar') }
-        apply: (_, __, [x]) => {
-          columns.push(x)
-          return { as: (alias) => (x.as = alias) }
-        },
-        // handle top-level paths like (foo)=>{ foo.bar }
+const _columns_or_not = (x) => {
+  if (typeof x === 'function') return _projection4(x)
+  if (typeof x === 'string' && x[0] === '{') return parse.cql('SELECT from X '+ x).SELECT.columns
+  if (Array.isArray(x)) return x.map(_column_expr)
+}
+
+const _column_expr = (x) => {
+  if (is_cqn(x)) return x
+  if (typeof x === 'string') return parse.column(x)
+  if (typeof x === 'object') for (let one in x) return Object.assign(parse.expr(one),{as:x[one]})
+  else return {val:x}
+}
+
+const _projection4 = (fn) => {
+  const columns=[]; fn (new Proxy (fn,{
+    apply: (_, __, args) => { // handle top-level projections such as (foo)=>{ foo('*') }
+      if (!args.length) return columns.push('*')
+      let [x] = Array.isArray(args[0]) ? args[0] : args
+      columns.push (x === '*' || x === '.*' ? '*' : is_cqn(x) ? x : {ref:[x]})
+      return { as: (alias) => (x.as = alias) }
+    },
+    get: (_, p) => { // handle top-level paths like (foo)=>{ foo.bar }
+      const col = {ref:[p]}; columns.push(col)
+      const nested = new Proxy(fn,{ // handle n-fold paths like (foo)=>{ foo.bar.car }
         get: (_, p) => {
-          const col = { ref: [p] }
-          columns.push(col)
-          const nested = new Proxy(x, {
-            // handle n-fold paths like (foo)=>{ foo.bar.car }
-            get: (_, p) => {
-              if (p === 'where') return (x) => ((col.where = _where(x)), nested)
-              if (p === 'as') return (alias) => ((col.as = alias), nested)
-              else col.ref.push(p)
-              return nested
-            },
-            // handle nested projections e.g. (foo)=>{ foo.bar (b=>{ ... }) }
-            apply: (_, __, args) => {
-              const [a, b] = args
-              if (!a) col.expand = ['*']
-              else if (a === '*') col.expand = ['*']
-              else if (a === '.*') col.inline = ['*']
-              else {
-                let x = (col[/^\(?_\b/.test(a) ? 'inline' : 'expand'] = projection(args))
-                if (b && b.levels)
-                  while (--b.levels) x.push({ ...col, expand: (x = [...x]) })
-              }
-              return nested
-            },
-          })
+          if (p === 'where') return (x) => ((col.where = predicate4([x])), nested)
+          if (p === 'as') return (alias) => ((col.as = alias), nested)
+          else return col.ref.push(p), nested
+        },
+        apply: (_, __, args) => { // handle nested projections e.g. (foo)=>{ foo.bar (b=>{ ... }) }
+          const [a, b] = args
+          if (!a) col.expand = ['*']
+          else if (a.raw) {
+            if (a[0] === '*') col.expand = ['*']
+            else if (a[0] === '.*') col.inline = ['*']
+            else {
+              let {columns} = SELECT_(col.ref[col.ref.length-1] +' ', args, ' from X')
+              Object.assign (col, columns[0])
+            }
+          }
+          else if (Array.isArray(a)) col.expand = _columns(a)
+          else if (a === '*') col.expand = ['*']
+          else if (a === '.*') col.inline = ['*']
+          else {
+            let x = (col[/^\(?_\b/.test(a) ? 'inline' : 'expand'] = _projection4(a))
+            if (b && b.levels) while (--b.levels) x.push({ ...col, expand: (x = [...x]) })
+          }
           return nested
         },
       })
-    )
-    return columns
-  }
+      return nested
+    },
+  }))
+  return columns
 }
 
-const order_by = (args) => (is_object(args) ? _order_by_object : _order_by_fluid)(args)
-
-// e.g. .orderBy ({ x:'asc', y:'desc', y:-1 })
-const _order_by_object = ([arg]) => {
-  const all = []
-  for (let each in arg) {
-    const order = parse.expr(each)
-    all.push(order)
-    const ad = arg[each]
-    order[ad === 1 ? 'asc' : ad === -1 ? 'desc' : ad] = true
+const _order_by = (args) => {
+  if (args[0].raw) return SELECT_('from X order by', args).orderBy
+  if (Array.isArray(args[0])) args = args[0]
+  const cqn=[], _add = (ref,ad) => {
+    const obx = parse.expr(ref); cqn.push(obx)
+    if (ad) obx.sort = ad == 1 ? 'asc' : ad == -1 ? 'desc' : ad
   }
-  return all
-}
-
-// e.g. .orderBy ('x asc','y desc')
-const _order_by_fluid = (args) => {
-  const all = []
   for (let each of args) {
-    const order = parse.expr(each)
-    all.push(order)
-    if (each.endsWith(' asc')) order.asc = true
-    if (each.endsWith(' desc')) order.desc = true
+    if (each.ref) cqn.push(each)
+    else if (typeof each === 'string') _add (...each.split(' '))
+    else for (let ref in each) _add (ref, each[ref])
   }
-  return all
+  return cqn
+}
+
+const {CQL} = parse, SELECT_ = (prefix, [ strings, ...more ], suffix) => {
+  const tts = [...strings]; tts.raw = true
+  if (prefix) tts[0] = `SELECT ${prefix} ${tts[0]}`
+  if (suffix) tts[tts.length-1] += ` ${suffix}`
+  return CQL(tts,...more).SELECT
 }
 
-const is_object = (args) => args.length === 1 && typeof args[0] === 'object'
-const is_array = Array.isArray
+const is_cqn = x => x === undefined || x === '*' || x.val !== undefined || x.xpr || x.ref || x.list || x.func || x.SELECT
+const is_number = x => !isNaN(x)

package/lib/ql/UPDATE.js

@@ -1,65 +1,97 @@
-const Whereable = require('./Whereable'), {parse} = Whereable
-const is_object = (args) => args.length === 1 && typeof args[0] === 'object'
-const is_array = Array.isArray
-const $ = Object.assign
+const Whereable = require('./Whereable')
+const { parse } = require('../index')
 
 module.exports = class UPDATE extends Whereable {
-  static get _() {
-    return $((..._) => new this().entity(..._), {
-      entity: (..._) => new this().entity(..._),
+
+  static _api() {
+    return Object.assign ((..._) => (new this).entity(..._), {
+      entity: (..._) => (new this).entity(..._),
     })
   }
 
-  entity(e, key) {
-    this._.entity = this.target(e).name
+  entity (e, key) {
+    this.UPDATE.entity = this._target_name4 (e)
     if (key) this.byKey(key)
     return this
   }
 
-  with(...args) {
-    this._.with = (is_object(args) ? _with_object : _with_fluid)(args)
+  data (d) {
+    this.UPDATE.data = d
     return this
   }
 
-  data(data) {
-    this._.data = data
-    return this
+  set (...args) { // .set() is an alias for .with()
+    return this.with (...args)
   }
 
-  get _set() {
-    //> .set is an alias to .with
-    return this.with
-  }
+  with (...args) {
+    if (args.length === 0) return this
+
+    // A tagged template string with a single expression, e.g. .with `my.stock -= 1`
+    if (args[0].raw) {
+      let [lhs,op,...rhs] = parse.CXL(...args).xpr || this._expected `${{args}} to contain expressions of form 'column = <expr>'`
+      _add (this, lhs.ref.join('.'), op, ...rhs)
+    }
+
+    // Alternating expr fragment / values args, e.g. .with ('my.stock -=',1, 'lastOrder =', '$now')
+    else if (args.length > 1) {
+      for (let i = 0; i < args.length; ++i) {
+        const [, col, op] = /\s*([\w.]+)\s*([%*+-]?=)/.exec(args[i])
+        _add (this, col, op, { val: args[++i] })
+      }
+    }
+
+    // A single string with comma-separated expressions, e.g. .with ('my.stock -= 1, lastOrder = $now')
+    else if (typeof args[0] === 'string') {
+      for (let each of _comma_separated_exprs(args[0])) {
+        let [lhs,op,...rhs] = parse.expr(each).xpr || this._expected `${{args}} to contain expressions of form 'column = <expr>'`
+        _add (this, lhs.ref.join('.'), op, ...rhs)
+      }
+    }
 
-  valueOf() {
-    return super.valueOf('UPDATE')
+    // A column - value / expr object, e.g. .with ({ stock:{'-=':1}, lastOrder:{'=':'$now'} })
+    else if (typeof args[0] === 'object') {
+      const o = args[0]
+      for (let col in o) {
+        let op = '=', v = o[col]
+        if (typeof v === 'object' && !(v === null || v.map || v.pipe || v instanceof Buffer || v instanceof Date)) {
+          let o = Object.keys(v)[0] || this._expected `${{v}} to be an object with an operator as single key`
+          if (o in operators) v = v[op=o]
+        }
+        _add (this, col, op, v && (v.val !== undefined || v.ref || v.xpr || v.func || v.SELECT) ? v : {val:v})
+      }
+    }
+
+    return this
   }
 }
 
-// .with ({ stock:{'-=':1}, lastOrder:{'=':'$now'} })
-const _with_object = ([arg]) => {
-  const _set = {}
-  for (let lhs in arg) {
-    let rhs = arg[lhs]
-    if (typeof rhs === 'object' && !is_array(rhs))
-      for (let op in rhs) _set[lhs] = _value(lhs, op, rhs[op])
-    else _set[lhs] = _value(lhs, '=', rhs)
-  }
-  return _set
+
+const _add = (q, col, op, ...xpr) => {
+  const {UPDATE} = q, v =
+    op === '=' ? xpr.length === 1 ? xpr[0] : { xpr } :
+    op in operators ? { xpr: [ {ref:[col]}, op[0], ...xpr] } :
+    q._expected `${{op}} to be one of ${Object.keys(operators)}`
+  if ('val' in v) (UPDATE.data || (UPDATE.data={}))[col] = v.val
+  else (UPDATE.with || (UPDATE.with={}))[col] = v
 }
 
-// .with ('my.stock -=',1, 'lastOrder =', '$now')
-const _with_fluid = (args) => {
-  const _set = {}
-  for (let i = 0; i < args.length; ++i) {
-    const [, lhs, op] = /\s*([\w.]+)\s*(=|-=|\+=)/i.exec(args[i])
-    _set[lhs] = _value(lhs, op, args[++i])
+const _comma_separated_exprs = (s) => {
+  let all=[], start=0, scope=0, close, stack = [close]
+  for (let i=0; i < s.length; ++i) {
+    const c = s[i]
+    if (c === "'") while (i < s.length) { if (s[++i] === "'") {
+      if (s[i+1] === "'") ++i // double '' is a quoted '
+      else break
+    }}
+    else if (c === ',' && scope === 0) { all.push(s.slice(start,i)); start = i+1 }
+    else if (c === '(') { scope++; stack.unshift(close = ')') }
+    else if (c === '[') { scope++; stack.unshift(close = ']') }
+    else if (c === '{') { scope++; stack.unshift(close = '}') }
+    else if (c === close) { scope--; stack.shift(); close = stack[0] }
   }
-  return _set
+  all.push(s.slice(start))
+  return all
 }
 
-const _value = (lhs, op, rhs) => {
-  if (op === '-=') return { xpr: [parse.expr(lhs), '-', parse.expr(rhs)] }
-  if (op === '+=') return { xpr: [parse.expr(lhs), '+', parse.expr(rhs)] }
-  else return parse.expr(rhs) || {val:rhs}
-}
+const operators = { '=':1, '-=':2, '+=':2, '*=':2, '/=':2, '%=':2 }