@sap/cds-dk 9.9.3 → 10.0.3

package/node_modules/@sap/cds/lib/ql/SELECT.js

@@ -0,0 +1,207 @@
+const { pipeline } = require('stream/promises')
+const Whereable = require('./Whereable')
+const Query = require('./cds.ql-Query')
+const is_number = x => !isNaN(x)
+const cds = require('../index')
+const $ = Object.assign
+
+class SELECT extends Whereable {
+
+  /** @type import('./cqn').SELECT['SELECT'] */
+  SELECT = {}
+
+  static call = (..._) => (new this)._select_or_from(..._) // SELECT `x`...
+  static API = {
+    columns:      (..._) => (new this).columns(..._),
+    from:       $((..._) => (new this).from(..._), {
+      localized:  (..._) => (new this).localized.from(..._)
+    }),
+    localized:  $((..._) => (new this).localized._select_or_from(..._),{
+      columns:    (..._) => (new this).localized.columns(..._),
+      from:       (..._) => (new this).localized.from(..._),
+    }),
+    distinct:   $((..._) => (new this).distinct._select_or_from(..._),{
+      localized:  (..._) => (new this).distinct.localized.from(..._),
+      columns:    (..._) => (new this).distinct.columns(..._),
+      from:       (..._) => (new this).distinct.from(..._),
+    }),
+    one:        $((..._) => (new this).one._select_or_from(..._),{
+      localized:  (..._) => (new this).one.localized.from(..._),
+      columns:    (..._) => (new this).one.columns(..._),
+      from:       (..._) => (new this).one.from(..._),
+    }),
+    read:         (..._) => (new this)._select_or_from(..._),
+    class: this
+  }
+
+  get localized() { this.SELECT.localized = true; return this }
+  get distinct() { this.SELECT.distinct = true; return this }
+  get one() { this.SELECT.one = true; return this }
+
+  /** @private */ _select_or_from (x,...etc) {
+    if (!x) return this
+    else if (x == '*') return this.columns (x,...etc)
+    else switch (typeof x) {
+      case 'string': {
+        if (etc.length) return this._ambiguous (x,...etc)
+        else (x = [x]).raw = x // single arg -> resolve in case 'object' block below
+      }
+      case 'object': { // eslint-disable-line no-fallthrough
+        if (x.raw) { // TODO: We might add a cache and reuse parsed [cqn,params] ...
+          const SELECT = cds.parse._select('',[x,...etc]), {columns:cols} = SELECT
+          if (SELECT.from || cols.length > 1 || !cols[0].ref) // SELECT `from Foo` | `a,b` | `max(a)`
+            return this._assign (SELECT)
+          const { columns:[{ expand, ...from }], ...more_clauses } = SELECT
+          if (expand) more_clauses.columns = expand  // SELECT `Foo {a,b}`
+          if (0 in Object.keys(more_clauses))       // SELECT `Foo where x=1`
+            return this._assign ({from}, more_clauses)
+          else return this._ambiguous (x,...etc)
+        }
+        else if (Array.isArray(x)) return this.columns(x)
+        else if (x.kind === 'element') return this.columns (x,...etc)
+        else if (x.name) return this.from (x,...etc)
+        else if (x.ref) return this._ambiguous (x,...etc)
+        else if (x.from) return this._assign(x)
+        else if (x.SELECT || x.SET) return this.from(x)
+        else break
+      }
+      default: return this.columns(x)
+    }
+    throw this._expected `Argument for SELECT(${{x}}) to be a valid argument for SELECT.from or .columns`
+  }
+
+  /** @private */ _ambiguous (...xy) {
+    const {SELECT:_} = this, {one} = _
+    this.from(...xy)._set('from', (...the_real_target) => {
+      if (!one) delete _.one; delete _.columns; delete this.from
+      return this.from (...the_real_target) .columns (...xy)
+    })
+    return this
+  }
+
+  columns (...cols) {
+    if (cols[0]) this._add ('columns', cds.ql.columns(...cols))
+    return this
+  }
+
+  from (...args) {
+    const [target] = args
+    if (target.raw) {
+      let { from, ...more } = cds.parse._select ('from',args)
+      this.SELECT.from = this._target4 (from)
+      return this._assign(more)
+    }
+    this.SELECT.from = this._target4 (target)
+    const [,second,third] = args
+    if (second !== undefined) {
+      if (third) {
+        this.byKey(second)
+        this.columns(third)
+      } else {
+        if (Array.isArray(second) || typeof second === 'function') this.columns(second)
+        else this.byKey(second)
+      }
+    }
+    return this
+  }
+
+  /** @deprecated */ fullJoin  (other, as) { return this.join (other, as, 'full') }
+  /** @deprecated */ leftJoin  (other, as) { return this.join (other, as, 'left') }
+  /** @deprecated */ rightJoin (other, as) { return this.join (other, as, 'right') }
+  /** @deprecated */ innerJoin (other, as) { return this.join (other, as, 'inner') }
+  /** @deprecated */ 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 })
+  }
+  /** @deprecated */ on (...args) {
+    const {from} = this.SELECT
+    if (!from?.join) throw new Error(`Invalid call of "SELECT.on()" without prior call of "SELECT.join()"`)
+    // string values in on clause are interpreted as refs, not vals
+    const [o] = args; if (typeof o === 'object' && !o.raw && !Array.isArray(o)) {
+      for (let a in o) if (typeof o[a] === 'string') o[a] = {ref:o[a].split('.')}
+    }
+    return this._where (args,'on',from)
+  }
+
+  having(...args) {
+    return this._where (args,'having')
+  }
+
+  search (...args) {
+    let _xpr=[]; for (let val of args) _xpr.push('or',{val})
+    this.SELECT.search = _xpr.slice(1)
+    return this
+  }
+
+  groupBy (...args) {
+    if (!args[0]) return this
+    const cqn = args[0].raw ? cds.parse._select('from X group by', args).groupBy : args.map(cds.parse.ref)
+    return this._add('groupBy',cqn)
+  }
+
+  orderBy (...args) {
+    if (!args[0]) return this
+    return this._add('orderBy', cds.ql.orders(...args))
+  }
+
+  limit (rows, offset) {
+    if (is_number(rows) || rows) this.SELECT.limit = rows.rows ? rows : { rows: {val:rows} }
+    if (is_number(offset)) (this.SELECT.limit = (this.SELECT.limit || {})) .offset = { val: offset }
+    return this
+  }
+
+  forUpdate ({ of, wait = cds.env.sql.lock_acquire_timeout || -1, ignoreLocked } = {}) {
+    const sfu = this.SELECT.forUpdate = {}
+    if (of) sfu.of = of.map (c => ({ref:c.split('.')}))
+    if (ignoreLocked) sfu.ignoreLocked = true
+    else if (wait >= 0) sfu.wait = wait
+    return this
+  }
+
+  /** @deprecated */ forShareLock () {
+    this.SELECT.forShareLock = true
+    return this
+  }
+
+  async foreach(callback) {
+    for await (const row of this) {
+      callback(row)
+    }
+  }
+
+  /**
+   * Convenience for streaming individual rows with async iteration. @example
+   * for await (let row of await query.stream(true)) ...
+   * for await (let row of query) ... // convenience by this method
+   */
+  [Symbol.asyncIterator]() {
+    const res = this.stream (true)
+    return async function* () { yield* await res }()
+  }
+
+  pipeline (...args_or_inserts) { if (!args_or_inserts.length) return this.stream() //> 4 compat only
+    const args = args_or_inserts.map (a => a instanceof Query ? s => a.entries(s) : a)
+    return this.stream() .then (stream => pipeline (stream, ...args))
+  }
+
+  stream (objectMode = false) {
+    const srv = this._srv || cds.db || cds.error`Can't execute query as no primary database is connected.`
+    return srv.send ({ query:this, iterator:true, objectMode })
+  }
+
+  hints (...args) {
+    if (args.length) this.SELECT.hints = args.flat()
+    return this
+  }
+
+  valueOf() { return super.valueOf('SELECT * FROM') }
+  get _subject(){ return this.SELECT.from }
+  get elements() { return this.elements = cds.infer.elements (this) }
+  set elements(e) { this._set('elements',e) }
+}
+
+
+/** @type SELECT.API & (...columns:string[]) => SELECT */
+module.exports = SELECT.init()

package/node_modules/@sap/cds/lib/ql/UPDATE.js

@@ -0,0 +1,111 @@
+const Whereable = require('./Whereable')
+const cds = require('../index')
+
+class UPDATE extends Whereable {
+
+  /** @type import('./cqn').UPDATE['UPDATE'] */
+  UPDATE = {}
+
+  static call = (..._) => (new this).entity(..._)
+  static API = { class:this,
+    entity: (..._) => (new this).entity(..._)
+  }
+
+  entity (e, ...etc) {
+    this.UPDATE.entity = this._target4 (e, ...etc) // supporting tts
+    if (!e.raw && etc.length) this.byKey(etc[0])
+    return this
+  }
+
+  data (d) {
+    this.UPDATE.data = d
+    return this
+  }
+
+  set (...args) { // .set() is an alias for .with()
+    return this.with (...args)
+  }
+
+  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) {
+      const [ strings, ...values ] = args
+      const vals = values.map (v => typeof v === 'string' ? `'${v}'` : v)
+      _add (this, ..._parse_set_expr (this, String.raw(strings, ...vals)))
+    }
+
+    // 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])) {
+        _add (this, ..._parse_set_expr (this, each))
+      }
+    }
+
+    // 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 || v instanceof RegExp)) {
+          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
+  }
+
+  get _subject(){ return this.UPDATE.entity }
+}
+
+
+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
+}
+
+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] }
+  }
+  all.push(s.slice(start))
+  return all
+}
+
+const _parse_set_expr = (q,expr) => {
+  const [,lhs,rhs] = /^\s*(\w+)\s*=\s*(.*)/.exec(expr)
+    || q._expected `${{expr}} to contain expressions of form 'column = <expr>'`
+  return [ lhs, '=', cds.parse.expr(rhs) ]
+}
+
+const operators = { '=':1, '-=':2, '+=':2, '*=':2, '/=':2, '%=':2 }
+
+
+/** @type UPDATE.API & (...entries:[]) => UPDATE */
+module.exports = UPDATE.init()

package/node_modules/@sap/cds/lib/ql/UPSERT.js

@@ -0,0 +1,17 @@
+const { class:INSERT } = require('./INSERT')
+class UPSERT extends INSERT {
+
+  /** @type import('./cqn').UPSERT['UPSERT'] */
+  UPSERT = {}
+
+  constructor() { delete super().INSERT }
+  static call = (..._) => (new this).entries(..._)
+  static API = { class:this,
+    into: (..._) => (new this).into(..._)
+  }
+
+  get _subject(){ return this.UPSERT.into }
+}
+
+/** @type UPSERT.API & (...entries:[]) => UPSERT */
+module.exports = UPSERT.init()

package/node_modules/@sap/cds/lib/ql/Whereable.js

@@ -0,0 +1,58 @@
+const cds = require('../index')
+const Query = require('./cds.ql-Query')
+
+
+class Whereable extends Query {
+
+  where (...args) { return this._where (args) }
+  and (...args) { return this._and_or ('and',args) }
+  or (...args) { return this._and_or ('or',args) }
+
+  /** @protected */
+  _where (args, clause='where', cqn=this[this.kind]) {
+    let tail = cds.ql.predicate(...args); if (!tail?.length) return this
+    let head = cqn[clause]
+    if (!head) cqn[clause] = tail
+    else { //> always wrap ORs on subsequent .where() calls, as these happen somewhere else
+      if (head.includes('or')) head = [{xpr:head}]
+      if (tail.includes('or')) tail = [{xpr:tail}]
+      cqn[clause] = [ ...head, 'and', ...tail ]
+    }
+    this._clause = this._direct = clause
+    return this
+  }
+
+  /** @private */
+  _and_or (ao, args) {
+    const $ = this[this.kind]
+    let clause = this._clause ??= ( //> some projects use .and()/.or() with manually filled in .where
+      $.having ? 'having' :
+      $.where ? 'where' :
+      $.from?.on ? 'on' :
+      cds.error `Unexpected use of .${ao}() without prior .where(), .having(), or .on()`
+    )
+    let tail = cds.ql.predicate(...args); if (!tail?.length) return this
+    let cqn = clause === 'on' ? $.from : $
+    let head = cqn[clause], direct = this._direct; delete this._direct
+    if (direct && ao === 'and') //> wrap ORs for .and() directly following .where()
+      if (head.includes('or')) head = [{xpr:head}]
+    if (tail.includes('or')) tail = [{xpr:tail}]
+    cqn[clause] = [ ...head, ao, ...tail ]
+    return this
+  }
+
+  byKey (key) {
+    if (typeof key !== 'object' || key === null)
+      key = cds.env.features.keys_as_val ? { val: key } : { [Object.keys(this._target.keys||{ID:1})[0]]: key }
+    if (this.SELECT) this.SELECT.one = true
+    if (cds.env.features.keys_into_where) return this.where(key)
+    const {ref} = this._subject
+    ref[ref.length-1] = { id: ref.at(-1), where: cds.ql.predicate(key) }
+    return this
+  }
+
+  /** @private */ set _clause (clause) { this._set('_clause',clause) }
+  /** @private */ set _direct (clause) { this._set('_direct',clause) }
+}
+
+module.exports = Whereable

package/node_modules/@sap/cds/lib/ql/cds-ql.js

@@ -0,0 +1,228 @@
+const cds = require ('../index')
+
+/**
+ * This is the default export, accessible to users through cds.ql.
+ * It's a function turning given input into an instance of cds.ql.Query.
+ *
+ * - If input is already a Query, it is returned as is.
+ * - If input is a string, it is parsed into a CQN object.
+ * - If input is a CQN object, an instance of the corresponding
+ *   Query subclass is contructed and returned.
+ *
+ * Use it in a cast-like way like this:
+ *
+ * @example
+ *  let q = cds.ql ({ SELECT: { from: {ref:[ Books.name ]} }})
+ *  let q = cds.ql (CQL`SELECT from ${Books}`)
+ *  let q = cds.ql `SELECT from ${Books}`
+ *
+ * @returns { import('./SELECT').class }, or any other subclass of Query; but IntelliSense doen't allow to specify this
+ */
+const ql = module.exports = exports = (q,...etc) => {
+  if (q instanceof Query) return q
+  if (q.raw || typeof q === 'string') return ql (cds.parse.cql(q,...etc))
+  for (let k in q) if (k in ql) return new ql[k](q[k])
+  return q //> no-op
+}
+
+// Base class and subclasses for all kinds of queries...
+const Query  = exports.Query = require('./cds.ql-Query');
+exports.SELECT = require('./SELECT')
+exports.INSERT = require('./INSERT')
+exports.UPSERT = require('./UPSERT')
+exports.UPDATE = require('./UPDATE')
+exports.DELETE = require('./DELETE')
+exports.CREATE = require('./CREATE')
+exports.DROP   = require('./DROP')
+
+exports.predicate = require('./cds.ql-predicates')
+exports.columns = require('./cds.ql-projections')
+/** @import cqn from './cqn' */
+
+
+/**
+ * Constructs a CXN `{ref}` object from given input, which can be one of:
+ *
+ * - several path segment strings
+ * - a single array of the same
+ * - a tagged template literal in CXL path syntax
+ *
+ * @returns {cqn.ref}
+ */
+exports.ref = function (...ref) {
+  if (ref[0].raw) ref = String.raw(...ref).split('.')
+  return {ref}
+}
+
+
+/**
+ * Constructs CXN `{val}` object from given input, which can be one of:
+ * - a single `string`, `number`, `boolean`, or `null`
+ * - a tagged template literal in CXL literal syntax
+ *
+ * @example
+ * val(`foo`) //> {val:'foo'}`
+ * val`foo`  //> {val:'foo'}
+ * val`11`   //> {val:11}
+ * val(11)   //> {val:11}
+ *
+ * @returns {cqn.val}
+ */
+exports.val = (...val) => {
+  if (val?.[0]?.raw) val = String.raw(...val)
+  else [val] = val
+  return {val}
+}
+
+
+/**
+ * Constructs a CXN `xpr` object from given input, which can be one of:
+ *
+ * - multiple CXN `expr` objects, or strings representing keywords or operators
+ * - a single array of the same
+ * - a tagged template literal in CXL syntax
+ *
+ * @example
+ * xpr([ref`foo`,'=',val(11)]) //> {xpr:[{ref:['foo']},'=',{val:11}]}
+ * xpr(ref`foo`,'=',val(11))   //> {xpr:[{ref:['foo']},'=',{val:11}]}
+ * xpr`foo = 11`               //> {xpr:[{ref:['foo']},'=',{val:11}]}
+ * xpr`foo`                    //> {xpr:[{ref:['foo']}]}
+ * xpr`'foo'`                  //> {xpr:[{val:'foo'}]}
+ * xpr`11`                     //> {xpr:[{val:11}]}
+ * xpr('=')                    //> {xpr:['=']}
+ * xpr('like')                 //> {xpr:['like']}
+ *
+ * @see {@link ql.expr `expr`}
+ * @returns {cqn.xpr}
+ */
+exports.xpr = (...xpr) => {
+  const x = ql.expr(...xpr)
+  return x.xpr ? x : {xpr:[x]} // always returns an `{xpr}` object
+}
+
+
+/**
+ * Same as {@link ql.xpr `xpr`}, but if the result contains only single
+ * entries these are returned as is.
+ *
+ * @example
+ * expr([ref`foo`,'=',val(11)]) //> {xpr:[{ref:['foo']},'=',{val:11}]}
+ * expr(ref`foo`,'=',val(11))   //> {xpr:[{ref:['foo']},'=',{val:11}]}
+ * expr`foo = 11`               //> {xpr:[{ref:['foo']},'=',{val:11}]}
+ * expr`foo`                    //> {ref:['foo']}
+ * expr`11`                     //> {val:11}
+ *
+ * @returns { cqn.ref & cqn.val & cqn.xpr & cqn.list & cqn.func } the constructed CXN `expr` object.
+ */
+exports.expr = (...xpr) => {
+  const [x] = xpr; if (x?.raw) return cds.parse.expr(...xpr) //> tagged template literal
+  else if (is_array(x)) xpr = x //> entries are supposed to be CXN objects
+  return xpr.length === 1 ? xpr[0] : {xpr} //> single entries are returned as is
+}
+
+
+/**
+ * Constructs a CXN `list` object from given input, with can be one of:
+ *
+ * - multiple CXN `expr` objects, or values turned into `{val}`s, including strings
+ * - a single array of the same
+ *
+ * @example
+ * list([`foo`,11]) //> {list:[{val:'foo'},{val:11}]}
+ * list(`foo`,11)   //> {list:[{val:'foo'},{val:11}]}
+ * expr`'foo',11`   //> {list:[{val:'foo'},{val:11}]}
+ * expr`foo,11`     //> {list:[{ref:['foo']},{val:11}]}
+ *
+ * @see Use {@link ql.expr `expr()`} to get the same via a tagged template literal.
+ * @returns {cqn.list}
+ */
+exports.list = (...args) => {
+  const [x] = args; if (is_array(x)) args = x
+  return { list: args.map (_cqn_or_val) }
+}
+
+
+/**
+ * Constructs a CXN `func` object from given input. The first argument is the
+ * function name, the remaining `args` can the same as in {@link ql.list `list()`},
+ * and are handled the same way.
+ *
+ * @example
+ *   func('substring',[`foo`,1]) //> {func:'substring',args:[{val:'foo'},{val:1}]}
+ *   func('substring',`foo`,1)   //> {func:'substring',args:[{val:'foo'},{val:1}]}
+ *   expr`substring('foo',1)`    //> {func:'substring',args:[{val:'foo'},{val:1}]}
+ *   expr`substring(foo,1)`      //> {func:'substring',args:[{ref:['foo']},{val:1}]}
+ *   expr`substring(foo,1)`      //> {func:'substring',args:[{ref:['foo']},{val:1}]}
+ *
+ * @see Use {@link ql.expr `expr()`} to get the same via a tagged template literal.
+ * @returns {cqn.func}
+ */
+exports.func = (func,...args) => {
+  const [x] = args; if (is_array(x)) args = x
+  return { func, args: args.map (_cqn_or_val) }
+}
+
+
+/** @returns { cqn.ref & cqn.as & cqn.infix &{ columns: cqn.column[] }} */
+exports.nested = (ref, ...args) => {
+  if (ref.raw) return ql.nested (ql.ref(ref,...args))
+  else if (!ref.ref) ref = ql.ref(ref)
+  for (let each of args) {
+    if (each.as || each.where || each.orderBy || each.limit) ref = {...ref, ...each}
+    else ref.columns = ql.columns(each)
+  }
+  ref.columns ??= ['*']
+  return ref
+}
+
+exports.expand = (...args) => {
+  let { columns, ...rest } = ql.nested (...args)
+  return { ...rest, expand: columns }
+}
+
+exports.inline = (...args) => {
+  let { columns, ...rest } = ql.nested (...args)
+  return { ...rest, inline: columns }
+}
+
+/** @returns {{ where: cqn.xo[] }} */
+exports.where = (...args) => ({where: ql.predicate(...args)})
+
+/** @returns {{ orderBy: cqn.order[] }} */
+exports.orderBy = (...args) => ({orderBy: ql.orders(...args)})
+exports.orders = (...args) => {
+  const [x] = args; if (x.raw) return cds.parse._select('from X order by',args).orderBy
+  if (is_array(x)) args = x
+  else if (is_object(x) && !x.ref) {
+    return Object.entries(x) .map (each => _ordering_term (...each))
+  }
+  return args.map (each => {
+    if (each.ref) return each
+    if (typeof each === 'string') return _ordering_term (...each.split(' '))
+  })
+  function _ordering_term (ref,sort) {
+    const ot = cds.parse.ref(ref)
+    if (sort) ot.sort = sort == 1 ? 'asc' : sort == -1 ? 'desc' : sort
+    return ot
+  }
+}
+
+/** @returns {{ limit: { rows: { val: any; }; offset?: { val: any; }; }; }} */
+exports.limit = (...args) => {
+  const [ limit, offset ] = args; if (limit?.raw) return {limit: cds.parse._select('from X limit',args).limit }
+  if (!offset) return { limit: { rows: { val: limit } } }
+  else return { limit: { rows: { val: +limit }, offset: { val: +offset } } }
+};
+
+const _cqn_or_val = x => typeof x === 'object' ? x : {val:x}
+const is_object = x => typeof x === 'object'
+const is_array = Array.isArray
+
+
+/**
+ * Returns a new instance of Query for the given input,
+ * that has the given one as prototype.
+ */
+exports.clone = function (q,_) {
+  return Query.prototype.clone.call(q,_)
+}