@@ -199,7 +199,9 @@ export class KnexAdapter<
     const data = filters.$limit === 0 ? [] : await builder.catch(errorHandler)
 
     if (paginate && paginate.default) {
-      const total = await countBuilder.then((count) => parseInt(count[0] ? count[0].total : 0))
+      const total = await countBuilder
+        .then((count) => parseInt(count[0] ? count[0].total : 0))
+        .catch(errorHandler)
 
       return {
         total,
@@ -302,7 +304,7 @@ export class KnexAdapter<
     }
     const builder = this.createQuery(updateParams)
 
-    await builder.update(data, [], { includeTriggerModifications: true })
+    await builder.update(data, [], { includeTriggerModifications: true }).catch(errorHandler)
 
     const items = await this._findOrGet(null, updateParams)
 
 
@@ -3,17 +3,39 @@ import { errors } from '@feathersjs/errors'
 export const ERROR = Symbol.for('@feathersjs/knex/error')
 
 /**
- * Knex prefixes driver errors with the query and its bound values as "<sql> - <message>",
- * so keep only the text after the last " - " to not send them to the client.
+ * Knex adds the query and its bound values to errors, as "<sql> - <message>" for driver
+ * errors and "<message> query: <sql>" for compile errors. Keep only the message so the
+ * query is not sent to the client.
  */
-const omitQuery = (message: string) => {
-  const index = message.lastIndexOf(' - ')
+const omitQuery = (error: any) => {
+  const { message, code, sqlMessage } = error
+
+  if (typeof message !== 'string') {
+    return message
+  }
+
+  // MySQL drivers keep the original message
+  if (typeof sqlMessage === 'string' && message.endsWith(sqlMessage)) {
+    const withCode = `${code}: ${sqlMessage}`
+
+    return message.endsWith(withCode) ? withCode : sqlMessage
+  }
+
+  if (message.startsWith('Undefined binding(s) detected')) {
+    const index = message.indexOf(' query: ')
+
+    return index === -1 ? message : message.slice(0, index)
+  }
+
+  // SQLite messages start with the error code
+  const codeIndex = typeof code === 'string' ? message.lastIndexOf(` - ${code}: `) : -1
+  const index = codeIndex !== -1 ? codeIndex : message.lastIndexOf(' - ')
 
   return index === -1 ? message : message.slice(index + 3)
 }
 
-export function errorHandler(error: any) {
-  const message = omitQuery(error.message || '')
+export function errorHandler(error: any): never {
+  const message = omitQuery(error)
   let feathersError = error
 
   if (error.sqlState && error.sqlState.length) {
 
@@ -164,6 +164,65 @@ describe('Knex Error handler', () => {
     )
   })
 
+  it('MySQL errors keep the driver message when values contain " - "', () => {
+    assert.throws(
+      () =>
+        errorHandler({
+          code: 'ER_DUP_ENTRY',
+          errno: 1062,
+          sqlState: '23000',
+          sqlMessage: "Duplicate entry 'foo - bar' for key 'name'",
+          message:
+            "insert into `t` (`name`) values ('foo - bar') - ER_DUP_ENTRY: Duplicate entry 'foo - bar' for key 'name'"
+        }),
+      { name: 'BadRequest', message: "ER_DUP_ENTRY: Duplicate entry 'foo - bar' for key 'name'" }
+    )
+    assert.throws(
+      () =>
+        errorHandler({
+          code: 'ER_DUP_ENTRY',
+          errno: 1062,
+          sqlState: '23000',
+          sqlMessage: "Duplicate entry 'foo - bar' for key 'name'",
+          message:
+            "insert into `t` (`name`) values ('foo - bar') - Duplicate entry 'foo - bar' for key 'name'"
+        }),
+      { name: 'BadRequest', message: "Duplicate entry 'foo - bar' for key 'name'" }
+    )
+  })
+
+  it('SQLite errors keep the driver message when values contain " - "', () => {
+    assert.throws(
+      () =>
+        errorHandler({
+          code: 'SQLITE_CONSTRAINT',
+          errno: 19,
+          message:
+            "insert into `t` (`name`) values ('a - b') - SQLITE_CONSTRAINT: UNIQUE constraint failed: t.name - x"
+        }),
+      { name: 'GeneralError', message: 'SQLITE_CONSTRAINT: UNIQUE constraint failed: t.name - x' }
+    )
+  })
+
+  it('knex compile errors omit the query', () => {
+    assert.throws(
+      () =>
+        errorHandler(
+          new Error(
+            'Undefined binding(s) detected when compiling SELECT. Undefined column(s): [users.id] query: select "users".* from "users" where "users"."id" = ?'
+          )
+        ),
+      {
+        name: 'GeneralError',
+        message: 'Undefined binding(s) detected when compiling SELECT. Undefined column(s): [users.id]'
+      }
+    )
+  })
+
+  it('errors without a message keep the default message', () => {
+    assert.throws(() => errorHandler({ code: 'ECONNRESET' }), { name: 'GeneralError', message: 'Error' })
+  })
+
   it('does not leak queries or bound values from a real database', async () => {
     const db = knex({ client: 'sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true })
 
@@ -187,6 +246,16 @@ describe('Knex Error handler', () => {
           return true
         }
       )
+      const other = await service.create({ email: 'b@example.com', password: 'hash-3' })
+
+      await assert.rejects(
+        () => service.patch(other.id, { email: 'a@example.com', password: 'secret-hash-4' }),
+        (error: any) => {
+          assert.ok(!error.message.includes('update'))
+          assert.ok(!error.message.includes('secret-hash-4'))
+          return true
+        }
+      )
       await assert.rejects(
         () => service.find({ query: { nope: 'x' } } as any),
         (error: any) => {