diff --git a/mx_mysql.c b/mx_mysql.c
index c7d66759..a047ead2 100644
--- a/mx_mysql.c
+++ b/mx_mysql.c
@@ -15,6 +15,7 @@
 #include <errno.h>
 
 #include <time.h>
+#include <limits.h>
 
 #include "mx_mysql.h"
 #include "mx_util.h"
@@ -60,8 +61,8 @@ char *mx_mysql_error(void) {
 
 static const char *mx__mysql_error(struct mx_mysql *mysql)
 {
-    mx_assert_return_NULL(mysql, EINVAL);
-    mx_assert_return_NULL(mysql->mysql, EBADF);
+    assert(mysql);
+    assert(mysql->mysql);
 
     /* no mysql errors possible */
     return mysql_error(mysql->mysql);
@@ -69,8 +70,8 @@ static const char *mx__mysql_error(struct mx_mysql *mysql)
 
 static int mx__mysql_init(struct mx_mysql *mysql)
 {
-    mx_assert_return_minus_errno(mysql, EINVAL);
-    mx_assert_return_minus_errno(!mysql->mysql, EUCLEAN);
+    assert(mysql);
+    assert(!mysql->mysql);
 
     mysql->mysql = mysql_init(NULL);
     if (mysql->mysql)
@@ -83,8 +84,8 @@ static int mx__mysql_options(struct mx_mysql *mysql, enum mysql_option option, c
 {
     int res;
 
-    mx_assert_return_minus_errno(mysql, EINVAL);
-    mx_assert_return_minus_errno(mysql->mysql, EBADF);
+    assert(mysql);
+    assert(mysql->mysql);
 
     res = mysql_options(mysql->mysql, option, arg);
     if (res == 0)
@@ -97,8 +98,8 @@ static int mx__mysql_real_connect(struct mx_mysql *mysql, const char *host, cons
 {
     MYSQL *m;
 
-    mx_assert_return_minus_errno(mysql, EINVAL);
-    mx_assert_return_minus_errno(mysql->mysql, EBADF);
+    assert(mysql);
+    assert(mysql->mysql);
 
     m = mysql_real_connect(mysql->mysql, host, user, passwd, db, port, unix_socket, client_flag);
     if (m && m == mysql->mysql)
@@ -128,8 +129,8 @@ static int mx__mysql_real_connect(struct mx_mysql *mysql, const char *host, cons
 
 static int mx__mysql_ping(struct mx_mysql *mysql)
 {
-    mx_assert_return_minus_errno(mysql, EINVAL);
-    mx_assert_return_minus_errno(mysql->mysql, EBADF);
+    assert(mysql);
+    assert(mysql->mysql);
 
     int res;
 
@@ -164,9 +165,9 @@ static int mx__mysql_ping(struct mx_mysql *mysql)
 
 static int mx__mysql_stmt_init(struct mx_mysql_stmt *stmt)
 {
-    mx_assert_return_minus_errno(stmt, EINVAL);
-    mx_assert_return_minus_errno(!stmt->stmt, EUCLEAN);
-    mx_assert_return_minus_errno(stmt->mysql, EBADF);
+    assert(stmt);
+    assert(!stmt->stmt);
+    assert(stmt->mysql);
 
     stmt->stmt = mysql_stmt_init(stmt->mysql->mysql);
     if (stmt->stmt)
@@ -179,14 +180,14 @@ static int mx__mysql_stmt_prepare(struct mx_mysql_stmt *stmt, char *statement)
 {
     int res;
 
-    mx_assert_return_minus_errno(stmt,       EINVAL);
-    mx_assert_return_minus_errno(statement,  EINVAL);
-    mx_assert_return_minus_errno(*statement, EINVAL);
+    assert(stmt);
+    assert(statement);
+    assert(*statement);
 
-    mx_assert_return_minus_errno(!stmt->statement, EUCLEAN);
+    assert(!stmt->statement);
 
-    mx_assert_return_minus_errno(stmt->mysql, EBADF);
-    mx_assert_return_minus_errno(stmt->stmt,  EBADF);
+    assert(stmt->mysql);
+    assert(stmt->stmt);
 
     res = mysql_stmt_prepare(stmt->stmt, statement, strlen(statement));
     if (res == 0) {
@@ -220,8 +221,8 @@ static int mx__mysql_stmt_bind_param(struct mx_mysql_stmt *stmt)
 {
     int res;
 
-    mx_assert_return_minus_errno(stmt, EINVAL);
-    mx_assert_return_minus_errno(stmt->stmt, EBADF);
+    assert(stmt);
+    assert(stmt->stmt);
 
     res = (int)mysql_stmt_bind_param(stmt->stmt, stmt->param.bind);
     if (res == 0)
@@ -246,8 +247,8 @@ static int mx__mysql_stmt_bind_result(struct mx_mysql_stmt *stmt)
 {
     int res;
 
-    mx_assert_return_minus_errno(stmt, EINVAL);
-    mx_assert_return_minus_errno(stmt->stmt, EBADF);
+    assert(stmt);
+    assert(stmt->stmt);
 
     res = (int)mysql_stmt_bind_result(stmt->stmt, stmt->result.bind);
     if (res == 0)
@@ -272,8 +273,8 @@ static int mx__mysql_stmt_execute(struct mx_mysql_stmt *stmt)
 {
     int res;
 
-    mx_assert_return_minus_errno(stmt, EINVAL);
-    mx_assert_return_minus_errno(stmt->stmt, EBADF);
+    assert(stmt);
+    assert(stmt->stmt);
 
     res = mysql_stmt_execute(stmt->stmt);
     if (res == 0)
@@ -302,8 +303,8 @@ static int mx__mysql_stmt_store_result(struct mx_mysql_stmt *stmt)
 {
     int res;
 
-    mx_assert_return_minus_errno(stmt, EINVAL);
-    mx_assert_return_minus_errno(stmt->stmt, EBADF);
+    assert(stmt);
+    assert(stmt->stmt);
 
     res = mysql_stmt_store_result(stmt->stmt);
     if (res == 0)
@@ -332,8 +333,8 @@ static int mx__mysql_stmt_free_result(struct mx_mysql_stmt *stmt)
 {
     int res;
 
-    mx_assert_return_minus_errno(stmt, EINVAL);
-    mx_assert_return_minus_errno(stmt->stmt, EBADF);
+    assert(stmt);
+    assert(stmt->stmt);
 
     res = (int)mysql_stmt_free_result(stmt->stmt);
     if (res == 0)
@@ -347,8 +348,8 @@ static int mx__mysql_stmt_fetch(struct mx_mysql_stmt *stmt)
 {
     int res;
 
-    mx_assert_return_minus_errno(stmt, EINVAL);
-    mx_assert_return_minus_errno(stmt->stmt, EBADF);
+    assert(stmt);
+    assert(stmt->stmt);
 
     res = mysql_stmt_fetch(stmt->stmt);
     if (res == 0)
@@ -389,8 +390,8 @@ static int mx__mysql_stmt_fetch_column(struct mx_mysql_stmt *stmt, unsigned int
 {
     int res;
 
-    mx_assert_return_minus_errno(stmt, EINVAL);
-    mx_assert_return_minus_errno(stmt->stmt, EBADF);
+    assert(stmt);
+    assert(stmt->stmt);
 
     res = mysql_stmt_fetch_column(stmt->stmt, &(stmt->result.bind[column]), column, offset);
     if (res == 0)
@@ -411,11 +412,11 @@ static int mx__mysql_stmt_param_count(struct mx_mysql_stmt *stmt)
 {
     unsigned long count;
 
-    mx_assert_return_minus_errno(stmt,       EINVAL);
-    mx_assert_return_minus_errno(stmt->stmt, EBADF);
+    assert(stmt);
+    assert(stmt->stmt);
 
     count = mysql_stmt_param_count(stmt->stmt);
-    mx_assert_return_minus_errno((unsigned long)(int)count == count, ERANGE);
+    assert(count <= INT_MAX);
 
     /* no mysql errors possible */
     return (int)count;
@@ -425,11 +426,11 @@ static int mx__mysql_stmt_field_count(struct mx_mysql_stmt *stmt)
 {
     unsigned long count;
 
-    mx_assert_return_minus_errno(stmt,       EINVAL);
-    mx_assert_return_minus_errno(stmt->stmt, EBADF);
+    assert(stmt);
+    assert(stmt->stmt);
 
     count = mysql_stmt_field_count(stmt->stmt);
-    mx_assert_return_minus_errno((unsigned long)(int)count == count, ERANGE);
+    assert(count <= INT_MAX);
 
     /* no mysql errors possible */
     return (int)count;
@@ -439,8 +440,8 @@ static int mx__mysql_stmt_affected_rows(struct mx_mysql_stmt *stmt, unsigned lon
 {
     my_ulonglong c;
 
-    mx_assert_return_minus_errno(stmt,       EINVAL);
-    mx_assert_return_minus_errno(stmt->stmt, EBADF);
+    assert(stmt);
+    assert(stmt->stmt);
 
     c = mysql_stmt_affected_rows(stmt->stmt);
 
@@ -454,8 +455,8 @@ static int mx__mysql_stmt_insert_id(struct mx_mysql_stmt *stmt, unsigned long lo
 {
     my_ulonglong c;
 
-    mx_assert_return_minus_errno(stmt,       EINVAL);
-    mx_assert_return_minus_errno(stmt->stmt, EBADF);
+    assert(stmt);
+    assert(stmt->stmt);
 
     c = mysql_stmt_insert_id(stmt->stmt);
 
@@ -469,7 +470,7 @@ static int mx__mysql_stmt_close(struct mx_mysql_stmt *stmt)
 {
     bool res;
 
-    mx_assert_return_minus_errno(stmt, EINVAL);
+    assert(stmt);
 
     res = mysql_stmt_close(stmt->stmt);
     if (res == 0) {
@@ -489,7 +490,7 @@ static int mx__mysql_stmt_close(struct mx_mysql_stmt *stmt)
 }
 
 static int mx__mysql_close(struct mx_mysql *mysql) {
-    mx_assert_return_minus_errno(mysql, EINVAL);
+    assert(mysql);
 
     if (mysql->mysql) {
         mysql_close(mysql->mysql);
@@ -510,12 +511,12 @@ static int mx__mysql_library_end(void) {
 
 static int _mx_mysql_bind_integer(struct mx_mysql_bind *b, unsigned int index, void *value, int type, int is_unsigned)
 {
-    mx_assert_return_minus_errno(b,     EINVAL);
-    mx_assert_return_minus_errno(value, EINVAL);
+    assert(b);
+    assert(value);
 
-    mx_assert_return_minus_errno(index < b->count, ERANGE);
+    assert(index < b->count);
 
-    mx_assert_return_minus_errno(!(b->data[index].flags), EUCLEAN);
+    assert(!(b->data[index].flags));
 
     memset(&(b->bind[index]), 0, sizeof(b->bind[index]));
 
@@ -533,14 +534,14 @@ static int _mx_mysql_bind_integer(struct mx_mysql_bind *b, unsigned int index, v
 
 static int _mx_mysql_bind_string(struct mx_mysql_bind *b, unsigned int index, char **value)
 {
-    mx_assert_return_minus_errno(b,     EINVAL);
-    mx_assert_return_minus_errno(value, EINVAL);
+    assert(b);
+    assert(value);
 
-    mx_assert_return_minus_errno(index < b->count, ERANGE);
+    assert(index < b->count);
 
-    mx_assert_return_minus_errno(!(b->data[index].flags), EUCLEAN);
+    assert(!(b->data[index].flags));
 
-    mx_assert_return_minus_errno((*value && b->type == MX_MYSQL_BIND_TYPE_PARAM) || (!*value && b->type == MX_MYSQL_BIND_TYPE_RESULT), EBADF);
+    assert((*value && b->type == MX_MYSQL_BIND_TYPE_PARAM) || (!*value && b->type == MX_MYSQL_BIND_TYPE_RESULT));
 
     memset(&(b->bind[index]), 0, sizeof(b->bind[index]));
 
@@ -572,7 +573,7 @@ static int _mx_mysql_bind_string(struct mx_mysql_bind *b, unsigned int index, ch
 
 static int _mx_mysql_bind_validate(struct mx_mysql_bind *b)
 {
-    mx_assert_return_minus_errno(b, EINVAL);
+    assert(b);
 
     for (unsigned long i=0; i < b->count; i++) {
         if (!(b->data[i].flags)) {
@@ -590,8 +591,8 @@ int mx_mysql_initialize(struct mx_mysql **mysql)
 {
     struct mx_mysql *m;
 
-    mx_assert_return_minus_errno(mysql, EINVAL);
-    mx_assert_return_minus_errno(!(*mysql), EUCLEAN);
+    assert(mysql);
+    assert(!(*mysql));
 
     m = mx_calloc_forever(1, sizeof(*m));
 
@@ -604,7 +605,7 @@ static int mx_mysql_init(struct mx_mysql *mysql)
 {
     int res;
 
-    mx_assert_return_minus_errno(mysql, EINVAL);
+    assert(mysql);
 
     do {
         res = mx__mysql_init(mysql);
@@ -624,7 +625,7 @@ static int mx_mysql_init(struct mx_mysql *mysql)
 
 int mx_mysql_option_set_default_file(struct mx_mysql *mysql, char *fname)
 {
-    mx_assert_return_minus_errno(mysql, EINVAL);
+    assert(mysql);
 
     if (fname && (*fname == '/') && (euidaccess(fname, R_OK) != 0)) {
         mx_mysql_save_error_va("%s: %m - falling back to mysql default config search path", fname);
@@ -641,7 +642,7 @@ int mx_mysql_option_set_default_file(struct mx_mysql *mysql, char *fname)
 
 int mx_mysql_option_set_default_group(struct mx_mysql *mysql, char *group)
 {
-    mx_assert_return_minus_errno(mysql, EINVAL);
+    assert(mysql);
 
     if (group && !(*group))
         group = NULL;
@@ -653,7 +654,7 @@ int mx_mysql_option_set_default_group(struct mx_mysql *mysql, char *group)
 
 int mx_mysql_option_set_reconnect(struct mx_mysql *mysql, int reconnect)
 {
-    mx_assert_return_minus_errno(mysql, EINVAL);
+    assert(mysql);
 
     mysql->reconnect = (bool)!!reconnect;
     return 0;
@@ -663,8 +664,8 @@ static int mx_mysql_real_connect(struct mx_mysql *mysql, const char *host, const
 {
     int res;
 
-    mx_assert_return_minus_errno(mysql, EINVAL);
-    mx_assert_return_minus_errno(mysql->mysql, EBADF);
+    assert(mysql);
+    assert(mysql->mysql);
 
     if (mysql->default_file) {
         res = mx__mysql_options(mysql, MYSQL_READ_DEFAULT_FILE, mysql->default_file);
@@ -699,7 +700,7 @@ int mx_mysql_connect(struct mx_mysql **mysql)
 {
     int res;
 
-    mx_assert_return_minus_errno(mysql, EINVAL);
+    assert(mysql);
 
     if (!(*mysql)) {
         res = mx_mysql_initialize(mysql);
@@ -730,7 +731,7 @@ int mx_mysql_connect_forever_sec(struct mx_mysql **mysql, unsigned int seconds)
 }
 
 int mx_mysql_disconnect(struct mx_mysql *mysql) {
-    mx_assert_return_minus_errno(mysql, EINVAL);
+    assert(mysql);
 
     return mx__mysql_close(mysql);
 }
@@ -741,9 +742,9 @@ static int mx_mysql_end(void) {
 
 static int mx_mysql_free(struct mx_mysql **mysql)
 {
-    mx_assert_return_minus_errno(mysql, EINVAL);
-    mx_assert_return_minus_errno(*mysql, EBADF);
-    mx_assert_return_minus_errno(!((*mysql)->mysql), EUCLEAN);
+    assert(mysql);
+    assert(*mysql);
+    assert(!((*mysql)->mysql));
 
     mx_free_null(*mysql);
 
@@ -774,7 +775,7 @@ int mx_mysql_finish(struct mx_mysql **mysql)
 
 static int mx_mysql_ping(struct mx_mysql *mysql)
 {
-    mx_assert_return_minus_errno(mysql, EINVAL);
+    assert(mysql);
 
     return mx__mysql_ping(mysql);
 }
@@ -784,7 +785,7 @@ static int mx_mysql_ping_forever(struct mx_mysql *mysql)
     int res;
     int fail = 0;
 
-    mx_assert_return_minus_errno(mysql, EINVAL);
+    assert(mysql);
 
     while (1) {
         res = mx_mysql_ping(mysql);
@@ -809,9 +810,9 @@ static int mx_mysql_statement_init(struct mx_mysql *mysql, struct mx_mysql_stmt
     struct mx_mysql_stmt *s;
     int res;
 
-    mx_assert_return_minus_errno(stmt, EINVAL);
-    mx_assert_return_minus_errno(mysql, EINVAL);
-    mx_assert_return_minus_errno(!(*stmt), EUCLEAN);
+    assert(stmt);
+    assert(mysql);
+    assert(!(*stmt));
 
     s = mx_calloc_forever(1, sizeof(*s));
 
@@ -838,8 +839,8 @@ int mx_mysql_statement_execute(struct mx_mysql_stmt *stmt, unsigned long long *c
 {
     int res;
 
-    mx_assert_return_minus_errno(stmt, EINVAL);
-    mx_assert_return_minus_errno(stmt->stmt, EBADF);
+    assert(stmt);
+    assert(stmt->stmt);
 
     res = _mx_mysql_bind_validate(&stmt->param);
     if (res < 0) {
@@ -886,8 +887,8 @@ int mx_mysql_statement_fetch(struct mx_mysql_stmt *stmt)
     char *str;
     int no_error = 1;
 
-    mx_assert_return_minus_errno(stmt, EINVAL);
-    mx_assert_return_minus_errno(stmt->stmt, EBADF);
+    assert(stmt);
+    assert(stmt->stmt);
 
     res = _mx_mysql_bind_validate(&stmt->result);
     if (res < 0) {
@@ -943,21 +944,21 @@ int mx_mysql_statement_fetch(struct mx_mysql_stmt *stmt)
 
 int mx_mysql_statement_param_count(struct mx_mysql_stmt *stmt)
 {
-    mx_assert_return_minus_errno(stmt, EINVAL);
+    assert(stmt);
 
     return mx__mysql_stmt_param_count(stmt);
 }
 
 int mx_mysql_statement_field_count(struct mx_mysql_stmt *stmt)
 {
-    mx_assert_return_minus_errno(stmt, EINVAL);
+    assert(stmt);
     return mx__mysql_stmt_field_count(stmt);
 }
 
 static int mx_mysql_stmt_field_count_set(struct mx_mysql_stmt *stmt)
 {
-    mx_assert_return_minus_errno(stmt,       EINVAL);
-    mx_assert_return_minus_errno(stmt->stmt, EBADF);
+    assert(stmt);
+    assert(stmt->stmt);
 
     stmt->field_count = mysql_stmt_field_count(stmt->stmt);
 
@@ -966,8 +967,8 @@ static int mx_mysql_stmt_field_count_set(struct mx_mysql_stmt *stmt)
 
 static int mx_mysql_stmt_param_count_set(struct mx_mysql_stmt *stmt)
 {
-    mx_assert_return_minus_errno(stmt,       EINVAL);
-    mx_assert_return_minus_errno(stmt->stmt, EBADF);
+    assert(stmt);
+    assert(stmt->stmt);
 
     stmt->param_count = mysql_stmt_param_count(stmt->stmt);
 
@@ -989,11 +990,11 @@ static int mx_mysql_bind_cleanup(struct mx_mysql_bind *bind)
 
 static int mx_mysql_bind_init_from(struct mx_mysql_bind *bind, unsigned long count, enum mx_mysql_bind_type type, struct mx_mysql_bind *from)
 {
-    mx_assert_return_minus_errno(bind, EINVAL);
+    assert(bind);
 
-    mx_assert_return_minus_errno(!bind->count,  EUCLEAN);
-    mx_assert_return_minus_errno(!bind->bind,   EUCLEAN);
-    mx_assert_return_minus_errno(!bind->data,   EUCLEAN);
+    assert(!bind->count);
+    assert(!bind->bind);
+    assert(!bind->data);
 
     if (from) {
         assert(count == from->count);
@@ -1009,11 +1010,11 @@ static int mx_mysql_bind_init_from(struct mx_mysql_bind *bind, unsigned long cou
 
 int mx_mysql_bind_init(struct mx_mysql_bind *bind, unsigned long count, enum mx_mysql_bind_type type)
 {
-    mx_assert_return_minus_errno(bind, EINVAL);
+    assert(bind);
 
-    mx_assert_return_minus_errno(!bind->count,  EUCLEAN);
-    mx_assert_return_minus_errno(!bind->bind,   EUCLEAN);
-    mx_assert_return_minus_errno(!bind->data,   EUCLEAN);
+    assert(!bind->count);
+    assert(!bind->bind);
+    assert(!bind->data);
 
     bind->type  = type;
     bind->count = count;
@@ -1122,9 +1123,9 @@ static struct mx_mysql_stmt *mx_mysql_statement_prepare_with_bindings(struct mx_
     int res;
     struct mx_mysql_stmt *stmt = NULL;
 
-    mx_assert_return_NULL(mysql, EINVAL);
-    mx_assert_return_NULL(statement, EINVAL);
-    mx_assert_return_NULL(*statement, EINVAL);
+    assert(mysql);
+    assert(statement);
+    assert(*statement);
 
     res = mx_mysql_statement_init(mysql, &stmt);
     if (res < 0)
@@ -1161,17 +1162,17 @@ static struct mx_mysql_stmt *mx_mysql_statement_prepare_with_bindings(struct mx_
 
 struct mx_mysql_stmt *mx_mysql_statement_prepare(struct mx_mysql *mysql, char *statement)
 {
-    mx_assert_return_NULL(mysql, EINVAL);
-    mx_assert_return_NULL(statement, EINVAL);
-    mx_assert_return_NULL(*statement, EINVAL);
+    assert(mysql);
+    assert(statement);
+    assert(*statement);
 
     return mx_mysql_statement_prepare_with_bindings(mysql, statement, NULL, NULL);
 }
 
 int mx_mysql_statement_close(struct mx_mysql_stmt **stmt)
 {
-    mx_assert_return_minus_errno(stmt, EINVAL);
-    mx_assert_return_minus_errno(*stmt, EINVAL);
+    assert(stmt);
+    assert(*stmt);
 
     mx__mysql_stmt_free_result(*stmt);
     mx__mysql_stmt_close(*stmt);
@@ -1185,8 +1186,8 @@ int mx_mysql_statement_close(struct mx_mysql_stmt **stmt)
 
 int mx_mysql_statement_close_no_bind_cleanup(struct mx_mysql_stmt **stmt)
 {
-    mx_assert_return_minus_errno(stmt, EINVAL);
-    mx_assert_return_minus_errno(*stmt, EINVAL);
+    assert(stmt);
+    assert(*stmt);
 
     mx__mysql_stmt_free_result(*stmt);
     mx__mysql_stmt_close(*stmt);
diff --git a/mx_mysql.h b/mx_mysql.h
index c09c3bb7..fd9c5a8a 100644
--- a/mx_mysql.h
+++ b/mx_mysql.h
@@ -6,19 +6,6 @@
 
 #include "mx_util.h"
 
-#ifdef MX_NDEBUG_MYSQL
-#   include <assert.h>
-#   define mx_mysql_assert_return_minus_errno(test, eno) \
-           assert(test)
-#   define mx_mysql_assert_return_NULL(test, eno) \
-           assert(test)
-#else
-#   define mx_mysql_assert_return_minus_errno(test, eno) \
-           mx_assert_return_minus_errno(test, eno)
-#   define mx_mysql_assert_return_NULL(test, eno) \
-           mx_assert_return_NULL(test, eno)
-#endif
-
 #define mx_mysql_assert_usage_ok(res)  \
     do { \
         if ((res) < 0) { \