@cap-js/db-service 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Change Log
+
+- All notable changes to this project are documented in this file.
+- The format is based on [Keep a Changelog](http://keepachangelog.com/).
+- This project adheres to [Semantic Versioning](http://semver.org/).
+
+## Version 1.0.0 - 2023-06-23
+
+- Initial Release

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,5 @@
+# CDS base database service
+
+Welcome to the new base database service for [SAP Cloud Application Programming Model](https://cap.cloud.sap) Node.js, based on new, streamlined database architecture.
+
+Find documentation at https://cap.cloud.sap/docs/guides/databases.

package/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  DatabaseService: require('./lib/common/DatabaseService'),
+  SQLService: require('./lib/SQLService'),
+}

package/lib/InsertResults.js

@@ -0,0 +1,95 @@
+const iterator = Symbol.iterator
+
+// eslint-disable-next-line no-unused-vars
+const USAGE_SAMPLE = async () => {
+  // from https://cap.cloud.sap/docs/node.js/services?q=Emily#srv-run
+  const { Authors, Books } = {}
+  const [Emily, Charlotte] = await INSERT.into(Authors, [{ name: 'Emily Brontëe' }, { name: 'Charlotte Brontëe' }])
+  await INSERT.into(Books, [
+    { title: 'Wuthering Heights', author: Emily },
+    { title: 'Jane Eyre', author: Charlotte },
+  ])
+}
+
+module.exports = class InsertResult {
+  constructor(query, results) {
+    this.query = query
+    this.results = results
+  }
+
+  /*
+   * Lazy access to auto-generated keys.
+   */
+  get [iterator]() {
+    // For INSERT.as(SELECT.from(...)) return a dummy iterator with correct length
+    const { INSERT } = this.query
+    if (INSERT.as) {
+      return (super[iterator] = function* () {
+        for (let i = 0; i < this.affectedRows; i++) yield {}
+      })
+    }
+
+    const { target } = this.query
+    if (!target?.keys) return (super[iterator] = this.results[iterator])
+    const keys = Object.keys(target.keys),
+      [k1] = keys
+
+    // For INSERT.entries() with generated keys in there return these keys
+    const { entries } = INSERT
+    if (entries && k1 in entries[0]) {
+      return (super[iterator] = function* () {
+        for (const each of entries)
+          yield keys.reduce((p, k) => {
+            p[k] = each[k]
+            return p
+          }, {})
+      })
+    }
+
+    // For INSERT.rows/values() with generated keys in there return these keys
+    const { columns } = INSERT
+    if (columns && columns.includes(k1)) {
+      return (super[iterator] = function* () {
+        const indices = keys.reduce((p, k) => {
+          let i = columns.indexOf(k)
+          if (i >= 0) p[k] = i
+          return p
+        }, {})
+        for (const each of INSERT.rows || [INSERT.values])
+          yield keys.reduce((p, k) => {
+            p[k] = each[indices[k]]
+            return p
+          }, {})
+      })
+    }
+
+    // If no generated keys in entries/rows/values we might have database-generated keys
+    const rows = this.results.slice(0, this.affectedRows) // only up to # of root entries
+    return (super[iterator] = function* () {
+      for (const each of rows) yield { [k1]: this.insertedRowId4(each) } // REVISIT: sqlite only returns a single lastID per row -> how is that with others?
+    })
+  }
+
+  /*
+   * the number of inserted (root) entries or the number of affectedRows in case of INSERT into SELECT
+   */
+  get affectedRows() {
+    const { INSERT: _ } = this.query
+    if (_.as) return (super.affectedRows = this.affectedRows4(this.results[0] || this.results))
+    else return (super.affectedRows = _.entries?.length || _.rows?.length || this.results.length || 1)
+  }
+
+  /*
+   * for checks such as res > 2
+   */
+  valueOf() {
+    return this.affectedRows
+  }
+
+  insertedRowId4(result) {
+    return result.lastID
+  }
+  affectedRows4(result) {
+    return result.changes
+  }
+}

package/lib/SQLService.js

@@ -0,0 +1,288 @@
+const cds = require('@sap/cds/lib'),
+  DEBUG = cds.debug('sql|db')
+const { resolveView } = require('@sap/cds/libx/_runtime/common/utils/resolveView')
+const DatabaseService = require('./common/DatabaseService')
+const cqn4sql = require('./cqn4sql')
+
+class SQLService extends DatabaseService {
+  init() {
+    this.on(['SELECT'], this.transformStreamFromCQN)
+    this.on(['UPDATE'], this.transformStreamIntoCQN)
+    this.on(['INSERT', 'UPSERT', 'UPDATE', 'DELETE'], require('./fill-in-keys')) // REVISIT should be replaced by correct input processing eventually
+    this.on(['INSERT', 'UPSERT', 'UPDATE', 'DELETE'], require('./deep-queries').onDeep)
+    this.on(['SELECT'], this.onSELECT)
+    this.on(['INSERT'], this.onINSERT)
+    this.on(['UPSERT'], this.onUPSERT)
+    this.on(['UPDATE'], this.onUPDATE)
+    this.on(['DELETE', 'CREATE ENTITY', 'DROP ENTITY'], this.onSIMPLE)
+    this.on(['BEGIN', 'COMMIT', 'ROLLBACK'], this.onEVENT)
+    this.on(['STREAM'], this.onSTREAM)
+    this.on(['*'], this.onPlainSQL)
+    return super.init()
+  }
+
+  async transformStreamFromCQN({ query }, next) {
+    if (!query._streaming) return next()
+    const cqn = STREAM.from(query.SELECT.from).column(query.SELECT.columns[0].ref[0])
+    if (query.SELECT.where) cqn.STREAM.where = query.SELECT.where
+    const stream = await this.run(cqn)
+    return stream && { value: stream }
+  }
+
+  async transformStreamIntoCQN({ query, data, target }, next) {
+    let col, type, etag
+    const elements = query._target?.elements || target?.elements
+    if (!elements) next()
+    for (const key in elements) {
+      const element = elements[key]
+      if (element['@Core.MediaType'] && data[key]?.pipe) col = key
+      if (element['@Core.IsMediaType'] && data[key]) type = key
+      if (element['@odata.etag'] && data[key]) etag = key
+    }
+
+    if (!col) return next()
+
+    const cqn = STREAM.into(query.UPDATE.entity).column(col).data(data[col])
+    if (query.UPDATE.where) cqn.STREAM.where = query.UPDATE.where
+    const result = await this.run(cqn)
+    if (type || etag) {
+      const d = { ...data }
+      delete d[col]
+      const cqn = UPDATE.entity(query.UPDATE.entity).with(d)
+      if (query.UPDATE.where) cqn.UPDATE.where = query.UPDATE.where
+      await this.run(cqn)
+    }
+
+    return result
+  }
+
+  /** Handler for SELECT */
+  async onSELECT({ query, data }) {
+    // REVISIT: disable this for queries like (SELECT 1)
+    // Will return multiple rows with objects inside
+    query.SELECT.expand = 'root'
+    const { sql, values, cqn } = this.cqn2sql(query, data)
+    let ps = await this.prepare(sql)
+    let rows = await ps.all(values)
+    if (rows.length)
+      if (cqn.SELECT.expand) rows = rows.map(r => (typeof r._json_ === 'string' ? JSON.parse(r._json_) : r._json_ || r))
+    if (cqn.SELECT.count) rows.$count = await this.count(query, rows)
+    return cqn.SELECT.one || query.SELECT.from.ref?.[0].cardinality?.max === 1 ? rows[0] : rows
+  }
+
+  async onINSERT({ query, data }) {
+    const { sql, entries, cqn } = this.cqn2sql(query, data)
+    if (!sql) return // Do nothing when there is nothing to be done
+    const ps = await this.prepare(sql)
+    const results = entries ? await Promise.all(entries.map(e => ps.run(e))) : await ps.run()
+    return new this.class.InsertResults(cqn, results)
+  }
+
+  async onUPSERT({ query, data }) {
+    const { sql, entries } = this.cqn2sql(query, data)
+    if (!sql) return // Do nothing when there is nothing to be done
+    const ps = await this.prepare(sql)
+    const results = entries ? await Promise.all(entries.map(e => ps.run(e))) : await ps.run()
+    return results.reduce((lastValue, currentValue) => (lastValue += currentValue.changes), 0)
+  }
+
+  /** Handler for UPDATE */
+  async onUPDATE(req) {
+    if (!req.query.UPDATE.data && !req.query.UPDATE.with) return 0
+    return this.onSIMPLE(req)
+  }
+
+  /** Handler for Stream */
+  async onSTREAM(req) {
+    const { sql, values, entries } = this.cqn2sql(req.query)
+    // writing stream
+    if (req.query.STREAM.into) {
+      const stream = entries[0]
+      stream.on('error', () => stream.removeAllListeners('error'))
+      values.unshift(stream)
+      const ps = await this.prepare(sql)
+      return (await ps.run(values)).changes
+    }
+    // reading stream
+    const ps = await this.prepare(sql)
+    let result = await ps.all(values)
+    if (result.length === 0) return
+
+    return Object.values(result[0])[0]
+  }
+
+  /** Handler for CREATE, DROP, UPDATE, DELETE, with simple CQN */
+  async onSIMPLE({ query, data }) {
+    const { sql, values } = this.cqn2sql(query, data)
+    let ps = await this.prepare(sql)
+    return (await ps.run(values)).changes
+  }
+
+  /** Handler for BEGIN, COMMIT, ROLLBACK, which don't have any CQN */
+  async onEVENT({ event }) {
+    DEBUG?.(event) // in the other cases above DEBUG happens in cqn2sql
+    return await this.exec(event)
+  }
+
+  /** Handler for SQL statements which don't have any CQN */
+  async onPlainSQL({ query, data }, next) {
+    if (typeof query === 'string') {
+      DEBUG?.(query)
+      const ps = await this.prepare(query)
+      const exec = this.hasResults(query) ? d => ps.all(d) : d => ps.run(d)
+      if (Array.isArray(data) && typeof data[0] === 'object') return await Promise.all(data.map(exec))
+      else return exec(data)
+    } else return next()
+  }
+
+  /** Override in subclasses to detect more statements to be called with ps.all() */
+  hasResults(sql) {
+    return /^(SELECT|WITH|CALL|PRAGMA table_info)/.test(sql)
+  }
+
+  /** Derives and executes a query to fill in `$count` for given query */
+  async count(query, ret) {
+    if (ret) {
+      const { one, limit: _ } = query.SELECT,
+        n = ret.length
+      const [max, offset = 0] = one ? [1] : _ ? [_.rows?.val, _.offset?.val] : []
+      if (max === undefined || (n < max && (n || !offset))) return n + offset
+    }
+    const cq = cds.ql.clone(query, {
+      columns: [{ func: 'count' }],
+      localized: false,
+      expand: false,
+      limit: 0,
+      orderBy: 0,
+    })
+    const { sql, values } = this.cqn2sql(cq)
+    const ps = await this.prepare(sql)
+    const { count } = await ps.get(values)
+    return count
+  }
+
+  static InsertResults = require('./InsertResults')
+
+  /**
+   * Helper class implementing {@link SQLService#cqn2sql}.
+   * Subclasses commonly override this.
+   */
+  static CQN2SQL = require('./cqn2sql').class
+  constructor() {
+    super(...arguments)
+    this.class = new.target // for IntelliSense
+  }
+  cqn2sql(q, values) {
+    const cqn = this.cqn4sql(q)
+
+    const cmd = cqn.cmd || Object.keys(cqn)[0]
+    if (cmd in { INSERT: 1, DELETE: 1, UPSERT: 1, UPDATE: 1 }) {
+      let resolvedCqn = resolveView(cqn, this.model, this)
+      if (resolvedCqn && resolvedCqn[cmd]._transitions?.[0].target) {
+        resolvedCqn = resolvedCqn || cqn
+        resolvedCqn.target = resolvedCqn?.[cmd]._transitions[0].target || cqn.target
+      }
+      return new this.class.CQN2SQL(this.context).render(resolvedCqn, values)
+    }
+    return new this.class.CQN2SQL(this.context).render(cqn, values)
+  }
+  cqn4sql(q) {
+    // REVISIT: move this check to cqn4sql?
+    if (!q.SELECT?.from?.join && !this.model?.definitions[_target_name4(q)]) return _unquirked(q)
+    return cqn4sql(q, this.model)
+  }
+
+  /**
+   * Returns a Promise which resolves to a prepared statement object with
+   * `{run,get,all}` signature as specified in {@link PreparedStatement}.
+   * @returns {PreparedStatement}
+   */
+  // eslint-disable-next-line no-unused-vars
+  async prepare(/*sql*/) {
+    throw '2b overridden by subclass'
+  }
+
+  /**
+   * Used to execute simple SQL statement like BEGIN, COMMIT, ROLLBACK
+   */
+  // eslint-disable-next-line no-unused-vars
+  async exec(sql) {
+    throw '2b overridden by subclass'
+  }
+}
+
+/** Interface of prepared statement objects as returned by {@link SQLService#prepare} */
+class PreparedStatement {
+  // eslint-disable-line no-unused-vars
+  /**
+   * Executes a prepared DML query, i.e., INSERT, UPDATE, DELETE, CREATE, DROP
+   * @param {[]|{}} binding_params
+   */
+  async run(/*binding_params*/) {} // eslint-disable-line no-unused-vars
+  /**
+   * Executes a prepared SELECT query and returns a single/first row only
+   * @param {[]|{}} binding_params
+   */
+  async get(/*binding_params*/) {
+    return {}
+  } // eslint-disable-line no-unused-vars
+  /**
+   * Executes a prepared SELECT query and returns an array of all rows
+   * @param {[]|{}} binding_params
+   */
+  async all(/*binding_params*/) {
+    return [{}]
+  } // eslint-disable-line no-unused-vars
+}
+SQLService.prototype.PreparedStatement = PreparedStatement
+
+const _target_name4 = q => {
+  const target =
+    q.SELECT?.from ||
+    q.INSERT?.into ||
+    q.UPSERT?.into ||
+    q.UPDATE?.entity ||
+    q.DELETE?.from ||
+    q.CREATE?.entity ||
+    q.DROP?.entity ||
+    q.STREAM?.from ||
+    q.STREAM?.into ||
+    undefined
+  if (target?.SET?.op === 'union') throw new cds.error('”UNION” based queries are not supported')
+  if (!target?.ref) return target
+  const [first] = target.ref
+  return first.id || first
+}
+
+const _unquirked = q => {
+  if (typeof q.INSERT?.into === 'string') q.INSERT.into = { ref: [q.INSERT.into] }
+  if (typeof q.UPSERT?.into === 'string') q.UPSERT.into = { ref: [q.UPSERT.into] }
+  if (typeof q.UPDATE?.entity === 'string') q.UPDATE.entity = { ref: [q.UPDATE.entity] }
+  if (typeof q.DELETE?.from === 'string') q.DELETE.from = { ref: [q.DELETE.from] }
+  if (typeof q.CREATE?.entity === 'string') q.CREATE.entity = { ref: [q.CREATE.entity] }
+  if (typeof q.DROP?.entity === 'string') q.DROP.entity = { ref: [q.DROP.entity] }
+  return q
+}
+
+const sqls = new (class extends SQLService {
+  get factory() {
+    return null
+  }
+})()
+cds.extend(cds.ql.Query).with(
+  class {
+    forSQL() {
+      let cqn = (cds.db || sqls).cqn4sql(this)
+      return this.flat(cqn)
+    }
+    toSQL() {
+      let { sql, values } = (cds.db || sqls).cqn2sql(this)
+      return { sql, values } // skipping .cqn property
+    }
+    toSql() {
+      return this.toSQL().sql
+    }
+  },
+)
+
+module.exports = Object.assign(SQLService, { _target_name4 })