625 lines
17 KiB
JavaScript
625 lines
17 KiB
JavaScript
const cds = require('@sap/cds/lib')
|
|
const { expect } = cds.test
|
|
const { cdr } = cds.ql
|
|
const Foo = { name: 'Foo' }
|
|
const Books = { name: 'capire.bookshop.Books' }
|
|
|
|
|
|
const STAR = cdr ? '*' : { ref: ['*'] }
|
|
const skip = {to:{eql:()=>skip}}
|
|
const srv = new cds.Service
|
|
let cqn
|
|
|
|
expect.plain = (cqn) => !cqn.SELECT.one && !cqn.SELECT.distinct ? expect(cqn) : skip
|
|
expect.one = (cqn) => !cqn.SELECT.distinct ? expect(cqn) : skip
|
|
|
|
describe('cds.ql → cqn', () => {
|
|
//
|
|
|
|
for (let each of ['SELECT', 'SELECT one', 'SELECT distinct']) {
|
|
let SELECT; beforeEach(()=> SELECT = (
|
|
each === 'SELECT distinct' ? cds.ql.SELECT.distinct :
|
|
each === 'SELECT one' ? cds.ql.SELECT.one :
|
|
cds.ql.SELECT
|
|
))
|
|
describe(`${each}...`, () => {
|
|
|
|
test(`from Foo`, () => {
|
|
expect(cqn = SELECT `from Foo`)
|
|
.to.eql(SELECT.from `Foo`)
|
|
.to.eql(SELECT.from('Foo'))
|
|
.to.eql(SELECT.from(Foo))
|
|
.to.eql(SELECT`Foo`)
|
|
.to.eql(SELECT('Foo'))
|
|
.to.eql(SELECT(Foo))
|
|
expect.plain(cqn)
|
|
.to.eql(CQL`SELECT from Foo`)
|
|
.to.eql(srv.read `Foo`)
|
|
.to.eql(srv.read('Foo'))
|
|
.to.eql(srv.read(Foo))
|
|
.to.eql({
|
|
SELECT: { from: { ref: ['Foo'] } },
|
|
})
|
|
})
|
|
|
|
|
|
test('from Foo [<key>]', () => {
|
|
|
|
expect(cqn = SELECT`from Foo[11]`)
|
|
.to.eql(SELECT`from Foo[${11}]`)
|
|
.to.eql(SELECT.from `Foo[11]`)
|
|
.to.eql(SELECT.from `Foo[${11}]`)
|
|
.to.eql(SELECT`Foo[11]`)
|
|
expect.plain(cqn)
|
|
.to.eql(CQL`SELECT from Foo[11]`)
|
|
.to.eql(srv.read`Foo[11]`)
|
|
.to.eql({
|
|
SELECT: { from: {
|
|
ref: [{ id: 'Foo', where: [{ val: 11 }] }]
|
|
}},
|
|
})
|
|
|
|
if (cdr) expect.plain (cqn)
|
|
.to.eql(srv.read`Foo[${11}]`)
|
|
.to.eql(SELECT`Foo[${11}]`)
|
|
|
|
expect((cqn = SELECT`from Foo[ID=11]`))
|
|
.to.eql(SELECT`from Foo[ID=${11}]`)
|
|
.to.eql(SELECT.from `Foo[ID=11]`)
|
|
.to.eql(SELECT.from `Foo[ID=${11}]`)
|
|
.to.eql(SELECT`Foo[ID=11]`)
|
|
expect.plain(cqn)
|
|
.to.eql(CQL`SELECT from Foo[ID=11]`)
|
|
.to.eql(srv.read`Foo[ID=11]`)
|
|
.to.eql({
|
|
SELECT: { from: {
|
|
ref: [{ id: 'Foo', where: [{ ref: ['ID'] }, '=', { val: 11 }] }],
|
|
}},
|
|
})
|
|
|
|
if (cdr) expect.plain (cqn)
|
|
.to.eql(SELECT`Foo[ID=${11}]`)
|
|
.to.eql(srv.read`Foo[ID=${11}]`)
|
|
|
|
// Following implicitly resolve to SELECT.one
|
|
expect(cqn = SELECT.from(Foo,11))
|
|
.to.eql(SELECT.from(Foo,{ID:11}))
|
|
.to.eql(SELECT.from(Foo).byKey(11))
|
|
.to.eql(SELECT.from(Foo).byKey({ID:11}))
|
|
expect.one(cqn)
|
|
.to.eql({
|
|
SELECT: {
|
|
one: true,
|
|
from: { ref: ['Foo'] },
|
|
where: [{ ref: ['ID'] }, '=', { val: 11 }],
|
|
},
|
|
})
|
|
|
|
})
|
|
|
|
test('from Foo {...}', () => {
|
|
|
|
expect(cqn = SELECT `*,a,b as c` .from `Foo`)
|
|
.to.eql(SELECT `*,a,b as c`. from(Foo))
|
|
.to.eql(SELECT('*','a',{b:'c'}).from`Foo`)
|
|
.to.eql(SELECT('*','a',{b:'c'}).from(Foo))
|
|
.to.eql(SELECT(['*','a',{b:'c'}]).from(Foo))
|
|
.to.eql(SELECT.columns('*','a',{b:'c'}).from(Foo))
|
|
.to.eql(SELECT.columns(['*','a',{b:'c'}]).from(Foo))
|
|
.to.eql(SELECT.columns((foo) => { foo`.*`, foo.a, foo.b`as c` }).from(Foo))
|
|
.to.eql(SELECT.columns((foo) => { foo('*'), foo.a, foo.b.as('c') }).from(Foo))
|
|
.to.eql(SELECT.from(Foo).columns('*','a',{b:'c'}))
|
|
.to.eql(SELECT.from(Foo).columns(['*','a',{b:'c'}]))
|
|
.to.eql(SELECT.from(Foo).columns((foo) => { foo`.*`, foo.a, foo.b`as c` }))
|
|
.to.eql(SELECT.from(Foo).columns((foo) => { foo('*'), foo.a, foo.b.as('c') }))
|
|
.to.eql(SELECT.from(Foo,['*','a',{b:'c'}]))
|
|
.to.eql(SELECT.from(Foo, (foo) => { foo`.*`, foo.a, foo.b`as c` }))
|
|
.to.eql(SELECT.from(Foo, (foo) => { foo('*'), foo.a, foo.b.as('c') }))
|
|
|
|
expect.plain(cqn)
|
|
.to.eql({
|
|
SELECT: {
|
|
from: { ref: ['Foo'] },
|
|
columns: [ STAR, { ref: ['a'] }, { ref: ['b'], as: 'c' }],
|
|
},
|
|
})
|
|
|
|
cdr && expect.plain(cqn)
|
|
.to.eql(CQL`SELECT *,a,b as c from Foo`)
|
|
.to.eql(CQL`SELECT from Foo {*,a,b as c}`)
|
|
|
|
// Test combination with key as second argument to .from
|
|
expect(cqn = SELECT.from(Foo, 11, ['a']))
|
|
.to.eql(SELECT.from(Foo, 11, foo => foo.a))
|
|
expect.one(cqn)
|
|
.to.eql({
|
|
SELECT: {
|
|
one: true,
|
|
from: { ref: ['Foo'] },
|
|
columns: [{ ref: ['a'] }],
|
|
where: [{ ref: ['ID'] }, '=', { val: 11 }],
|
|
},
|
|
})
|
|
|
|
})
|
|
|
|
test('with nested expands', () => {
|
|
// SELECT from Foo { *, x, bar.*, car{*}, boo { *, moo.zoo } }
|
|
expect(cqn =
|
|
SELECT.from (Foo, foo => {
|
|
foo`*`, foo.x, foo.car`*`, foo.boo (b => {
|
|
b`*`, b.moo.zoo(
|
|
x => x.y.z
|
|
)
|
|
})
|
|
})
|
|
).to.eql(
|
|
SELECT.from (Foo, foo => {
|
|
foo('*'), foo.x, foo.car('*'), foo.boo (b => {
|
|
b('*'), b.moo.zoo(
|
|
x => x.y.z
|
|
)
|
|
})
|
|
})
|
|
)
|
|
|
|
expect.plain(cqn)
|
|
.to.eql({
|
|
SELECT: {
|
|
from: { ref: ['Foo'] },
|
|
columns: [
|
|
STAR,
|
|
{ ref: ['x'] },
|
|
{ ref: ['car'], expand: ['*'] },
|
|
{
|
|
ref: ['boo'],
|
|
expand: [ '*', { ref: ['moo', 'zoo'], expand: [{ ref: ['y', 'z'] }] }],
|
|
},
|
|
],
|
|
},
|
|
})
|
|
})
|
|
|
|
|
|
test('with nested inlines', () => {
|
|
// SELECT from Foo { *, x, bar.*, car{*}, boo { *, moo.zoo } }
|
|
expect.plain(
|
|
SELECT.from (Foo, foo => {
|
|
foo.bar `*`,
|
|
foo.bar `.*`, //> leading dot indicates inline
|
|
foo.boo(_ => _.moo.zoo), //> underscore arg name indicates inline
|
|
foo.boo(x => x.moo.zoo)
|
|
})
|
|
).to.eql({
|
|
SELECT: {
|
|
from: { ref: ['Foo'] },
|
|
columns: [
|
|
{ ref: ['bar'], expand: ['*'] },
|
|
{ ref: ['bar'], inline: ['*'] },
|
|
{ ref: ['boo'], inline: [{ ref: ['moo', 'zoo'] }] },
|
|
{ ref: ['boo'], expand: [{ ref: ['moo', 'zoo'] }] },
|
|
],
|
|
},
|
|
})
|
|
})
|
|
|
|
})}
|
|
|
|
describe ('SELECT where...', ()=>{
|
|
|
|
it('should correctly handle { ... and:{...} }', () => {
|
|
expect(SELECT.from(Foo).where({ x: 1, and: { y: 2, or: { z: 3 } } })).to.eql({
|
|
SELECT: {
|
|
from: { ref: ['Foo'] },
|
|
where: cdr ? [
|
|
{ ref: ['x'] },
|
|
'=',
|
|
{ val: 1 },
|
|
'and',
|
|
// '(',
|
|
{xpr:[
|
|
{ ref: ['y'] },
|
|
'=',
|
|
{ val: 2 },
|
|
'or',
|
|
{ ref: ['z'] },
|
|
'=',
|
|
{ val: 3 },
|
|
]},
|
|
// ')',
|
|
] : [
|
|
{ ref: ['x'] },
|
|
'=',
|
|
{ val: 1 },
|
|
'and',
|
|
'(',
|
|
// {xpr:[
|
|
{ ref: ['y'] },
|
|
'=',
|
|
{ val: 2 },
|
|
'or',
|
|
{ ref: ['z'] },
|
|
'=',
|
|
{ val: 3 },
|
|
// ]},
|
|
')',
|
|
],
|
|
},
|
|
})
|
|
})
|
|
|
|
test ('where, and, or', ()=>{
|
|
expect (
|
|
SELECT.from(Foo).where({x:1,and:{y:2}})
|
|
).to.eql (
|
|
CQL`SELECT from Foo where x=1 and y=2`
|
|
) .to.eql ({ SELECT: {
|
|
from: {ref:['Foo']},
|
|
where: [
|
|
{ref:['x']}, '=', {val:1},
|
|
'and',
|
|
{ref:['y']}, '=', {val:2}
|
|
]
|
|
}})
|
|
|
|
expect (
|
|
SELECT.from(Foo).where({x:1,or:{y:2}})
|
|
).to.eql (
|
|
CQL`SELECT from Foo where x=1 or y=2`
|
|
).to.eql ({ SELECT: {
|
|
from: {ref:['Foo']},
|
|
where: [
|
|
{ref:['x']}, '=', {val:1},
|
|
'or',
|
|
{ref:['y']}, '=', {val:2}
|
|
]
|
|
}})
|
|
|
|
expect (
|
|
SELECT.from(Foo).where({x:1,and:{y:2}}).or({z:3})
|
|
).to.eql (
|
|
CQL`SELECT from Foo where x=1 and y=2 or z=3`
|
|
)
|
|
|
|
if (cdr) expect (
|
|
SELECT.from(Foo).where({x:1}).and({y:2,or:{z:3}})
|
|
).to.eql (
|
|
CQL`SELECT from Foo where x=1 and ( y=2 or z=3 )`
|
|
)
|
|
|
|
if (cdr) expect (
|
|
SELECT.from(Foo).where({1:1}).and({x:1,or:{x:2}}).and({y:2,or:{z:3}})
|
|
).to.eql (
|
|
CQL`SELECT from Foo where 1=1 and ( x=1 or x=2 ) and ( y=2 or z=3 )`
|
|
)
|
|
|
|
if (cdr) expect (
|
|
SELECT.from(Foo).where({x:1,or:{x:2}}).and({y:2,or:{z:3}})
|
|
).to.eql (
|
|
CQL`SELECT from Foo where ( x=1 or x=2 ) and ( y=2 or z=3 )`
|
|
)
|
|
})
|
|
|
|
test('where ( ... cql | {x:y} )', () => {
|
|
const args = [`foo`, "'bar'", 3]
|
|
const ID = 11
|
|
|
|
// using simple predicate objects
|
|
// (Note: this doesn't support paths in left-hand-sides, nor references in arrays)
|
|
expect(
|
|
SELECT.from(Foo).where({
|
|
ID,
|
|
args,
|
|
and: { x: { like: '%x%' }, or: { y: { '>=': 9 } } },
|
|
})
|
|
).to.eql({
|
|
SELECT: {
|
|
from: { ref: ['Foo'] },
|
|
where: cdr ? [
|
|
{ ref: ['ID'] },
|
|
'=',
|
|
{ val: ID },
|
|
'and',
|
|
{ ref: ['args'] },
|
|
'in',
|
|
{ list: args.map(val => ({ val })) },
|
|
'and',
|
|
{
|
|
xpr: [
|
|
{ ref: ['x'] },
|
|
'like',
|
|
{ val: '%x%' },
|
|
'or',
|
|
{ ref: ['y'] },
|
|
'>=',
|
|
{ val: 9 },
|
|
]
|
|
},
|
|
] : [
|
|
{ ref: ['ID'] },
|
|
'=',
|
|
{ val: ID },
|
|
'and',
|
|
{ ref: ['args'] },
|
|
'in',
|
|
{ list: args.map(val => ({ val })) },
|
|
'and',
|
|
'(',
|
|
{ ref: ['x'] },
|
|
'like',
|
|
{ val: '%x%' },
|
|
'or',
|
|
{ ref: ['y'] },
|
|
'>=',
|
|
{ val: 9 },
|
|
')',
|
|
],
|
|
}
|
|
})
|
|
|
|
// using CQL fragments -> uses cds.parse.expr
|
|
const is_v2 = !!cds.parse.expr('(1,2)').list
|
|
if (is_v2) expect((cqn = CQL`SELECT from Foo where ID=11 and x in ( foo, 'bar', 3)`)).to.eql({
|
|
SELECT: {
|
|
from: { ref: ['Foo'] },
|
|
where: [
|
|
{ ref: ['ID'] },
|
|
'=',
|
|
{ val: ID },
|
|
'and',
|
|
{ ref: ['x'] },
|
|
'in',
|
|
{list:[
|
|
{ ref: ['foo'] },
|
|
{ val: 'bar' },
|
|
{ val: 3 },
|
|
]}
|
|
],
|
|
},
|
|
})
|
|
else expect((cqn = CQL`SELECT from Foo where ID=11 and x in ( foo, 'bar', 3)`)).to.eql({
|
|
SELECT: {
|
|
from: { ref: ['Foo'] },
|
|
where: [
|
|
{ ref: ['ID'] },
|
|
'=',
|
|
{ val: ID },
|
|
'and',
|
|
{ ref: ['x'] },
|
|
'in',
|
|
'(',
|
|
{ ref: ['foo'] },
|
|
',',
|
|
{ val: 'bar' },
|
|
',',
|
|
{ val: 3 },
|
|
')',
|
|
],
|
|
},
|
|
})
|
|
|
|
if (!is_v2) expect(
|
|
SELECT.from(Foo).where(`x=`, 1, `or y.z is null and (a>`, 2, `or b=`, 3, `)`)
|
|
).to.eql(CQL`SELECT from Foo where x=1 or y.z is null and (a>2 or b=3)`)
|
|
|
|
expect(SELECT.from(Foo).where(`x between`, 1, `and`, 9)).to.eql(
|
|
CQL`SELECT from Foo where x between 1 and 9`
|
|
)
|
|
})
|
|
|
|
test('w/ sub selects', () => {
|
|
// in where causes
|
|
expect(SELECT.from(Foo).where({ x: SELECT('y').from('Bar') })).to.eql(
|
|
CQL`SELECT from Foo where x in (SELECT y from Bar)`
|
|
)
|
|
|
|
// using query api
|
|
expect(SELECT.from('Books').where(
|
|
`author.name in`, SELECT('name').from('Authors'))).to.eql(CQL`SELECT from Books where author.name in (SELECT name from Authors)`
|
|
)
|
|
|
|
// in classical semi joins
|
|
expect(
|
|
SELECT('x').from(Foo) .where ( `exists`,
|
|
SELECT(1).from('Bar') .where ({ y: { ref: ['x'] } })
|
|
) // prettier-ignore
|
|
).to.eql(CQL`SELECT x from Foo where exists (SELECT 1 from Bar where y=x)`)
|
|
|
|
// in select clauses
|
|
cqn = CQL`SELECT from Foo { x, (SELECT y from Bar) as y }`
|
|
cds.version >= '3.33.3' &&
|
|
expect(
|
|
SELECT.from(Foo, (foo) => {
|
|
foo.x, foo(SELECT.from('Bar', (b) => b.y)).as('y')
|
|
})
|
|
).to.eql(cqn)
|
|
cds.version >= '3.33.3' &&
|
|
expect(
|
|
SELECT.from(Foo, ['x', Object.assign(SELECT('y').from('Bar'), { as: 'y' })])
|
|
).to.eql(cqn)
|
|
})
|
|
|
|
test('w/ plain SQL', () => {
|
|
expect(SELECT.from(Books) + 'WHERE ...').to.eql(
|
|
'SELECT * FROM capire_bookshop_Books WHERE ...'
|
|
)
|
|
})
|
|
|
|
it('should consistently handle *', () => {
|
|
if (!cdr) return
|
|
expect({
|
|
SELECT: { from: { ref: ['Foo'] }, columns: ['*'] },
|
|
})
|
|
.to.eql(CQL`SELECT * from Foo`)
|
|
.to.eql(CQL`SELECT from Foo{*}`)
|
|
.to.eql(SELECT('*').from(Foo))
|
|
.to.eql(SELECT.from(Foo,['*']))
|
|
})
|
|
|
|
it('should consistently handle lists', () => {
|
|
if (!cdr) return
|
|
const ID = 11, args = [{ref:['foo']}, "bar", 3]
|
|
const cqn = CQL`SELECT from Foo where ID=11 and x in (foo,'bar',3)`
|
|
expect(SELECT.from(Foo).where`ID=${ID} and x in ${args}`).to.eql(cqn)
|
|
expect(SELECT.from(Foo).where(`ID=`, ID, `and x in`, args)).to.eql(cqn)
|
|
expect(SELECT.from(Foo).where({ ID, x:args })).to.eql(cqn)
|
|
})
|
|
|
|
//
|
|
})
|
|
|
|
describe(`INSERT...`, () => {
|
|
test('entries ({a,b}, ...)', () => {
|
|
const entries = [{ foo: 1 }, { boo: 2 }]
|
|
expect(INSERT(...entries).into(Foo))
|
|
.to.eql(INSERT(entries).into(Foo))
|
|
.to.eql(INSERT.into(Foo).entries(...entries))
|
|
.to.eql(INSERT.into(Foo).entries(entries))
|
|
.to.eql({
|
|
INSERT: { into: 'Foo', entries },
|
|
})
|
|
})
|
|
|
|
test('rows ([1,2], ...)', () => {
|
|
expect(
|
|
INSERT.into(Foo)
|
|
.columns('a', 'b')
|
|
.rows([
|
|
[1, 2],
|
|
[3, 4],
|
|
])
|
|
)
|
|
.to.eql(INSERT.into(Foo).columns('a', 'b').rows([1, 2], [3, 4]))
|
|
.to.eql({
|
|
INSERT: {
|
|
into: 'Foo',
|
|
columns: ['a', 'b'],
|
|
rows: [
|
|
[1, 2],
|
|
[3, 4],
|
|
],
|
|
},
|
|
})
|
|
})
|
|
|
|
test('values (1,2)', () => {
|
|
expect(INSERT.into(Foo).columns('a', 'b').values([1, 2]))
|
|
.to.eql(INSERT.into(Foo).columns('a', 'b').values(1, 2))
|
|
.to.eql({
|
|
INSERT: { into: 'Foo', columns: ['a', 'b'], values: [1, 2] },
|
|
})
|
|
})
|
|
|
|
test('w/ plain SQL', () => {
|
|
expect(INSERT.into(Books) + 'VALUES ...').to.eql(
|
|
'INSERT INTO capire_bookshop_Books VALUES ...'
|
|
)
|
|
})
|
|
})
|
|
|
|
describe(`UPDATE...`, () => {
|
|
test('entity (..., <key>)', () => {
|
|
expect(UPDATE(Books, 4711))
|
|
.to.eql(UPDATE(Books, { ID: 4711 }))
|
|
.to.eql(UPDATE(Books).byKey(4711))
|
|
.to.eql(UPDATE(Books).byKey({ ID: 4711 }))
|
|
.to.eql(UPDATE(Books).where({ ID: 4711 }))
|
|
.to.eql(UPDATE(Books).where(`ID=`, 4711))
|
|
.to.eql(UPDATE.entity(Books, 4711))
|
|
.to.eql(UPDATE.entity(Books, { ID: 4711 }))
|
|
// etc...
|
|
.to.eql({
|
|
UPDATE: {
|
|
entity: 'capire.bookshop.Books',
|
|
where: [{ ref: ['ID'] }, '=', { val: 4711 }],
|
|
},
|
|
})
|
|
})
|
|
|
|
/*
|
|
UPDATE.with allows to pass in plain data payloads, e.g. as obtained from REST clients.
|
|
In addition, UPDATE.with supports specifying expressions, either in CQL fragements
|
|
notation or as simple expression objects.
|
|
|
|
UPDATE.data allows to pass in plain data payloads, e.g. as obtained from REST clients.
|
|
The passed in object can be modified subsequently, e.g. by adding or modifying values
|
|
before the query is finally executed.
|
|
*/
|
|
test('with + data', () => {
|
|
if (cds.version < '4.1.0') return
|
|
const o = {}
|
|
const q = UPDATE(Foo).data(o).with(`bar-=`, 22)
|
|
o.foo = 11
|
|
expect(q)
|
|
.to.eql(UPDATE(Foo).with(`foo=`, 11, `bar-=`, 22))
|
|
.to.eql(UPDATE(Foo).with({ foo: 11, bar: { '-=': 22 } }))
|
|
.to.eql({
|
|
UPDATE: {
|
|
entity: 'Foo',
|
|
data: { foo: 11 },
|
|
with: {
|
|
bar: { xpr: [{ ref: ['bar'] }, '-', { val: 22 }] },
|
|
},
|
|
},
|
|
})
|
|
|
|
// some more
|
|
expect(UPDATE(Foo).with(`bar = coalesce(x,y), car = 'foo''s bar, car'`)).to.eql({
|
|
UPDATE: {
|
|
entity: 'Foo',
|
|
data: {
|
|
car: "foo's bar, car",
|
|
},
|
|
with: {
|
|
bar: { func: 'coalesce', args: [{ ref: ['x'] }, { ref: ['y'] }] },
|
|
},
|
|
},
|
|
})
|
|
})
|
|
|
|
test('w/ plain SQL', () => {
|
|
expect(UPDATE(Books) + 'SET ...').to.eql('UPDATE capire_bookshop_Books SET ...')
|
|
})
|
|
})
|
|
|
|
describe(`DELETE...`, () => {
|
|
test('from (..., <key>)', () => {
|
|
expect(DELETE(Books, 4711))
|
|
.to.eql(DELETE(Books, { ID: 4711 }))
|
|
.to.eql(DELETE.from(Books, 4711))
|
|
.to.eql(DELETE.from(Books, { ID: 4711 }))
|
|
.to.eql(DELETE.from(Books).byKey(4711))
|
|
.to.eql(DELETE.from(Books).byKey({ ID: 4711 }))
|
|
.to.eql(DELETE.from(Books).where({ ID: 4711 }))
|
|
.to.eql(DELETE.from(Books).where(`ID=`, 4711))
|
|
.to.eql({
|
|
DELETE: {
|
|
from: 'capire.bookshop.Books',
|
|
where: [{ ref: ['ID'] }, '=', { val: 4711 }],
|
|
},
|
|
})
|
|
})
|
|
|
|
test('/w plain SQL', () => {
|
|
expect(DELETE.from(Books) + 'WHERE ...').to.eql(
|
|
'DELETE FROM capire_bookshop_Books WHERE ...'
|
|
)
|
|
})
|
|
})
|
|
|
|
describe(`cds.ql etc...`, () => {
|
|
it('should keep null and undefined', () => {
|
|
for (let each of [null, undefined]) {
|
|
expect(SELECT.from(Foo).where({ ID: each })).to.eql({
|
|
SELECT: {
|
|
from: { ref: ['Foo'] },
|
|
where: [{ ref: ['ID'] }, '=', { val: each }],
|
|
},
|
|
})
|
|
}
|
|
})
|
|
})
|
|
|
|
//
|
|
})
|