src/modules/rlm_sql/drivers/rlm_sql_sqlite/rlm_sql_sqlite.c

   1 /*
   2  *   This program is is free software; you can redistribute it and/or modify
   3  *   it under the terms of the GNU General Public License as published by
   4  *   the Free Software Foundation; either version 2 of the License, or (at
   5  *   your option) any later version.
   6  *
   7  *   This program is distributed in the hope that it will be useful,
   8  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *   GNU General Public License for more details.
  11  *
  12  *   You should have received a copy of the GNU General Public License
  13  *   along with this program; if not, write to the Free Software
  14  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  15  */
  16
  17 /**
  18  * $Id$
  19  * @file rlm_sql_sqlite.c
  20  * @brief SQLite driver.
  21  *
  22  * @copyright 2013 Network RADIUS SARL <info@networkradius.com>
  23  * @copyright 2007 Apple Inc.
  24  */
  25 RCSID("$Id$")
  26
  27 #include <freeradius-devel/radiusd.h>
  28 #include <freeradius-devel/rad_assert.h>
  29
  30 #include <fcntl.h>
  31 #include <sys/stat.h>
  32
  33 #include <sqlite3.h>
  34
  35 #include "rlm_sql.h"
  36 #include "config.h"
  37
  38 #define BOOTSTRAP_MAX (1048576 * 10)
  39
  40 /*
  41  *      Allow us to use versions < 3.6.0 beta0
  42  */
  43 #ifndef SQLITE_OPEN_NOMUTEX
  44 #  define SQLITE_OPEN_NOMUTEX 0
  45 #endif
  46
  47 #ifndef HAVE_SQLITE3_INT64
  48 typedef sqlite3_int64 sqlite_int64
  49 #endif
  50
  51 typedef struct rlm_sql_sqlite_conn {
  52         sqlite3 *db;
  53         sqlite3_stmt *statement;
  54         int col_count;
  55 } rlm_sql_sqlite_conn_t;
  56
  57 typedef struct rlm_sql_sqlite_config {
  58         char const *filename;
  59 } rlm_sql_sqlite_config_t;
  60
  61 static const CONF_PARSER driver_config[] = {
  62         { "filename", FR_CONF_OFFSET(PW_TYPE_FILE_OUTPUT | PW_TYPE_REQUIRED, rlm_sql_sqlite_config_t, filename), NULL },
  63
  64         {NULL, -1, 0, NULL, NULL}
  65 };
  66
  67 static sql_rcode_t sql_check_error(sqlite3 *db)
  68 {
  69         int error = sqlite3_errcode(db);
  70
  71         /*
  72          *      Lowest byte is error category, other byte may contain
  73          *      the extended error, depending on version.
  74          */
  75         switch (error & 0xff) {
  76         /*
  77          *      Not errors
  78          */
  79         case SQLITE_OK:
  80         case SQLITE_DONE:
  81         case SQLITE_ROW:
  82                 return RLM_SQL_OK;
  83         /*
  84          *      User/transient errors
  85          */
  86         case SQLITE_ERROR:      /* SQL error or missing database */
  87         case SQLITE_FULL:
  88         case SQLITE_MISMATCH:
  89                 return RLM_SQL_ERROR;
  90
  91         /*
  92          *      Constraints violations
  93          */
  94         case SQLITE_CONSTRAINT:
  95                 return RLM_SQL_ALT_QUERY;
  96
  97         /*
  98          *      Errors with the handle, that probably require reinitialisation
  99          */
 100         default:
 101                 ERROR("rlm_sql_sqlite: Handle is unusable, error (%d): %s", error, sqlite3_errmsg(db));
 102                 return RLM_SQL_RECONNECT;
 103         }
 104 }
 105
 106 #ifdef HAVE_SQLITE3_OPEN_V2
 107 static int sql_loadfile(TALLOC_CTX *ctx, sqlite3 *db, char const *filename)
 108 {
 109         ssize_t len;
 110         char *buffer;
 111         char *p, *q, *s;
 112         int cl;
 113         FILE *f;
 114         struct stat finfo;
 115
 116         int status;
 117         sqlite3_stmt *statement;
 118         char const *z_tail;
 119
 120         INFO("rlm_sql_sqlite: Executing SQL statements from file \"%s\"", filename);
 121
 122         f = fopen(filename, "r");
 123         if (!f) {
 124                 ERROR("rlm_sql_sqlite: Failed opening SQL file \"%s\": %s", filename,
 125                        fr_syserror(errno));
 126
 127                 return -1;
 128         }
 129
 130         if (fstat(fileno(f), &finfo) < 0) {
 131                 ERROR("rlm_sql_sqlite: Failed stating SQL file \"%s\": %s", filename,
 132                        fr_syserror(errno));
 133
 134                 fclose(f);
 135
 136                 return -1;
 137         }
 138
 139         if (finfo.st_size > BOOTSTRAP_MAX) {
 140                 too_big:
 141                 ERROR("rlm_sql_sqlite: Size of SQL (%zu) file exceeds limit (%uk)",
 142                        (size_t) finfo.st_size / 1024, BOOTSTRAP_MAX / 1024);
 143
 144                 fclose(f);
 145
 146                 return -1;
 147         }
 148
 149         MEM(buffer = talloc_array(ctx, char, finfo.st_size + 1));
 150         len = fread(buffer, sizeof(char), finfo.st_size + 1, f);
 151         if (len > finfo.st_size) {
 152                 talloc_free(buffer);
 153                 goto too_big;
 154         }
 155
 156         if (!len) {
 157                 if (ferror(f)) {
 158                         ERROR("rlm_sql_sqlite: Error reading SQL file: %s", fr_syserror(errno));
 159
 160                         fclose(f);
 161                         talloc_free(buffer);
 162
 163                         return -1;
 164                 }
 165
 166                 DEBUG("rlm_sql_sqlite: Ignoring empty SQL file");
 167
 168                 fclose(f);
 169                 talloc_free(buffer);
 170
 171                 return 0;
 172         }
 173
 174         buffer[len] = '\0';
 175         fclose(f);
 176
 177         /*
 178          *      Check if input data is UTF-8.  Allow CR/LF \t, too.
 179          */
 180         for (p = buffer; p < (buffer + len); p += cl) {
 181                 if (*p < ' ') {
 182                         if ((*p != 0x0a) && (*p != 0x0d) && (*p != '\t')) break;
 183                         cl = 1;
 184                 } else {
 185                         cl = fr_utf8_char((uint8_t *) p);
 186                         if (!cl) break;
 187                 }
 188         }
 189
 190         if ((p - buffer) != len) {
 191                 ERROR("rlm_sql_sqlite: Bootstrap file contains non-UTF8 char at offset %zu", p - buffer);
 192                 talloc_free(buffer);
 193                 return -1;
 194         }
 195
 196         /*
 197          *      Statement delimiter is ;\n
 198          */
 199         s = p = buffer;
 200         while ((q = strchr(p, ';'))) {
 201                 if (q[1] != '\n') {
 202                         p = q + 1;
 203                         continue;
 204                 }
 205
 206                 *q = '\0';
 207
 208 #ifdef HAVE_SQLITE3_PREPARE_V2
 209                 (void) sqlite3_prepare_v2(db, s, len, &statement, &z_tail);
 210 #else
 211                 (void) sqlite3_prepare(db, s, len, &>statement, &z_tail);
 212 #endif
 213                 if (sql_check_error(db) != RLM_SQL_OK) {
 214                         talloc_free(buffer);
 215                         return -1;
 216                 }
 217
 218                 (void) sqlite3_step(statement);
 219                 status = sql_check_error(db);
 220
 221                 (void) sqlite3_finalize(statement);
 222                 if ((status != RLM_SQL_OK) || sql_check_error(db)) {
 223                         talloc_free(buffer);
 224                         return -1;
 225                 }
 226
 227                 p = s = q + 1;
 228         }
 229
 230         talloc_free(buffer);
 231         return 0;
 232 }
 233 #endif
 234
 235 static int mod_instantiate(CONF_SECTION *conf, rlm_sql_config_t *config)
 236 {
 237         static bool version_done;
 238
 239         bool exists;
 240         rlm_sql_sqlite_config_t *driver;
 241         struct stat buf;
 242
 243         if (!version_done) {
 244                 version_done = true;
 245
 246                 if (sqlite3_libversion_number() != SQLITE_VERSION_NUMBER) {
 247                         WARN("rlm_sql_sqlite: libsqlite version changed since the server was built");
 248                         WARN("rlm_sql_sqlite: linked: %s built: %s", sqlite3_libversion(), SQLITE_VERSION);
 249                 }
 250                 INFO("rlm_sql_sqlite: libsqlite version: %s", sqlite3_libversion());
 251         }
 252
 253         MEM(driver = config->driver = talloc_zero(config, rlm_sql_sqlite_config_t));
 254         if (cf_section_parse(conf, driver, driver_config) < 0) {
 255                 return -1;
 256         }
 257         if (!driver->filename) {
 258                 MEM(driver->filename = talloc_typed_asprintf(driver, "%s/%s", get_radius_dir(), config->sql_db));
 259         }
 260
 261         if (stat(driver->filename, &buf) == 0) {
 262                 exists = true;
 263         } else if (errno == ENOENT) {
 264                 exists = false;
 265         } else {
 266                 ERROR("rlm_sql_sqlite: Database exists, but couldn't be opened: %s", fr_syserror(errno));
 267                 return -1;
 268         }
 269
 270         if (cf_pair_find(conf, "bootstrap") && !exists) {
 271 #  ifdef HAVE_SQLITE3_OPEN_V2
 272                 int status;
 273                 int ret;
 274                 char const *p;
 275                 char *buff;
 276                 sqlite3 *db = NULL;
 277                 CONF_PAIR *cp;
 278
 279                 INFO("rlm_sql_sqlite: Database doesn't exist, creating it and loading schema");
 280
 281                 p = strrchr(driver->filename, '/');
 282                 if (p) {
 283                         size_t len = (p - driver->filename) + 1;
 284
 285                         buff = talloc_array(conf, char, len);
 286                         strlcpy(buff, driver->filename, len);
 287                 } else {
 288                         MEM(buff = talloc_typed_strdup(conf, driver->filename));
 289                 }
 290
 291                 ret = rad_mkdir(buff, 0700, -1, -1);
 292                 talloc_free(buff);
 293                 if (ret < 0) {
 294                         ERROR("rlm_sql_sqlite: Failed creating directory for SQLite database: %s", fr_syserror(errno));
 295
 296                         return -1;
 297                 };
 298
 299                 status = sqlite3_open_v2(driver->filename, &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
 300                 if (!db) {
 301 #    ifdef HAVE_SQLITE3_ERRSTR
 302                         ERROR("rlm_sql_sqlite: Failed creating opening/creating SQLite database: %s",
 303                               sqlite3_errstr(status));
 304 #    else
 305                         ERROR("rlm_sql_sqlite: Failed creating opening/creating SQLite database, got code (%i)",
 306                               status);
 307 #    endif
 308
 309                         goto unlink;
 310                 }
 311
 312                 if (sql_check_error(db) != RLM_SQL_OK) {
 313                         (void) sqlite3_close(db);
 314
 315                         goto unlink;
 316                 }
 317
 318                 /*
 319                  *      Execute multiple bootstrap SQL files in order
 320                  */
 321                 for (cp = cf_pair_find(conf, "bootstrap");
 322                      cp;
 323                      cp = cf_pair_find_next(conf, cp, "bootstrap")) {
 324                         p = cf_pair_value(cp);
 325                         if (!p) continue;
 326
 327                         ret = sql_loadfile(conf, db, p);
 328                         if (ret < 0) goto unlink;
 329                 }
 330
 331                 status = sqlite3_close(db);
 332                 if (status != SQLITE_OK) {
 333                 /*
 334                  *      Safer to use sqlite3_errstr here, just in case the handle is in a weird state
 335                  */
 336 #  ifdef HAVE_SQLITE3_ERRSTR
 337                         ERROR("rlm_sql_sqlite: Error closing SQLite handle: %s", sqlite3_errstr(status));
 338 #  else
 339                         ERROR("rlm_sql_sqlite: Error closing SQLite handle, got code (%i)", status);
 340 #  endif
 341
 342                         goto unlink;
 343                 }
 344
 345                 if (ret < 0) {
 346                 unlink:
 347                         if ((unlink(driver->filename) < 0) && (errno != ENOENT)) {
 348                                 ERROR("rlm_sql_sqlite: Error removing partially initialised database: %s",
 349                                       fr_syserror(errno));
 350                         }
 351                         return -1;
 352                 }
 353 #else
 354                 WARN("rlm_sql_sqlite: sqlite3_open_v2() not available, cannot bootstrap database. "
 355                        "Upgrade to SQLite >= 3.5.1 if you need this functionality");
 356 #endif
 357         }
 358
 359         return 0;
 360 }
 361
 362 static int _sql_socket_destructor(rlm_sql_sqlite_conn_t *conn)
 363 {
 364         int status = 0;
 365
 366         DEBUG2("rlm_sql_sqlite: Socket destructor called, closing socket");
 367
 368         if (conn->db) {
 369                 status = sqlite3_close(conn->db);
 370                 if (status != SQLITE_OK) {
 371                         WARN("rlm_sql_sqlite: Got SQLite error code (%u) when closing socket", status);
 372                 }
 373         }
 374
 375         return 0;
 376 }
 377
 378 static void _sql_greatest(sqlite3_context *ctx, int num_values, sqlite3_value **values)
 379 {
 380         int i;
 381         sqlite3_int64 value, max = 0;
 382
 383         for (i = 0; i < num_values; i++) {
 384                 value = sqlite3_value_int64(values[i]);
 385                 if (value > max) {
 386                         max = value;
 387                 }
 388         }
 389
 390         sqlite3_result_int64(ctx, max);
 391 }
 392
 393 static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
 394 {
 395         rlm_sql_sqlite_conn_t *conn;
 396         rlm_sql_sqlite_config_t *driver = config->driver;
 397
 398         int status;
 399
 400         MEM(conn = handle->conn = talloc_zero(handle, rlm_sql_sqlite_conn_t));
 401         talloc_set_destructor(conn, _sql_socket_destructor);
 402
 403         INFO("rlm_sql_sqlite: Opening SQLite database \"%s\"", driver->filename);
 404 #ifdef HAVE_SQLITE3_OPEN_V2
 405         status = sqlite3_open_v2(driver->filename, &(conn->db), SQLITE_OPEN_READWRITE | SQLITE_OPEN_NOMUTEX, NULL);
 406 #else
 407         status = sqlite3_open(driver->filename, &(conn->db));
 408 #endif
 409         if (!conn->db) {
 410 #ifdef HAVE_SQLITE3_ERRSTR
 411                 ERROR("rlm_sql_sqlite: Failed creating opening/creating SQLite: %s", sqlite3_errstr(status));
 412 #else
 413                 ERROR("rlm_sql_sqlite: Failed creating opening/creating SQLite database error code (%i)",
 414                       status);
 415 #endif
 416
 417                 return RLM_SQL_ERROR;
 418         }
 419
 420         if (sql_check_error(conn->db) != RLM_SQL_OK) return RLM_SQL_ERROR;
 421
 422         /*
 423          *      Enable extended return codes for extra debugging info.
 424          */
 425 #ifdef HAVE_SQLITE3_EXTENDED_RESULT_CODES
 426         (void) sqlite3_extended_result_codes(conn->db, 1);
 427 #endif
 428         if (sql_check_error(conn->db) != RLM_SQL_OK) return RLM_SQL_ERROR;
 429
 430 #ifdef HAVE_SQLITE3_CREATE_FUNCTION_V2
 431         status = sqlite3_create_function_v2(conn->db, "GREATEST", -1, SQLITE_ANY, NULL,
 432                                             _sql_greatest, NULL, NULL, NULL);
 433 #else
 434         status = sqlite3_create_function(conn->db, "GREATEST", -1, SQLITE_ANY, NULL,
 435                                          _sql_greatest, NULL, NULL);
 436 #endif
 437         if (status != SQLITE_OK) {
 438                 ERROR("rlm_sql_sqlite: Failed registering 'GREATEST' sql function: %s", sqlite3_errmsg(conn->db));
 439         }
 440
 441         return RLM_SQL_OK;
 442 }
 443
 444 static sql_rcode_t sql_select_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config, char const *query)
 445 {
 446         rlm_sql_sqlite_conn_t *conn = handle->conn;
 447         char const *z_tail;
 448
 449 #ifdef HAVE_SQLITE3_PREPARE_V2
 450         (void) sqlite3_prepare_v2(conn->db, query, strlen(query), &conn->statement, &z_tail);
 451 #else
 452         (void) sqlite3_prepare(conn->db, query, strlen(query), &conn->statement, &z_tail);
 453 #endif
 454
 455         conn->col_count = 0;
 456
 457         return sql_check_error(conn->db);
 458 }
 459
 460
 461 static sql_rcode_t sql_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config, char const *query)
 462 {
 463         int status;
 464         rlm_sql_sqlite_conn_t *conn = handle->conn;
 465         char const *z_tail;
 466
 467 #ifdef HAVE_SQLITE3_PREPARE_V2
 468         status = sqlite3_prepare_v2(conn->db, query, strlen(query), &conn->statement, &z_tail);
 469 #else
 470         status = sqlite3_prepare(conn->db, query, strlen(query), &conn->statement, &z_tail);
 471 #endif
 472         if (status != SQLITE_OK) return sql_check_error(conn->db);
 473
 474         (void) sqlite3_step(conn->statement);
 475
 476         return sql_check_error(conn->db);
 477 }
 478
 479 static sql_rcode_t sql_store_result(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
 480 {
 481         return 0;
 482 }
 483
 484 static int sql_num_fields(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
 485 {
 486         rlm_sql_sqlite_conn_t *conn = handle->conn;
 487
 488         if (conn->statement) {
 489                 return sqlite3_column_count(conn->statement);
 490         }
 491
 492         return 0;
 493 }
 494
 495 static int sql_num_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
 496 {
 497         rlm_sql_sqlite_conn_t *conn = handle->conn;
 498
 499         if (conn->statement) {
 500                 return sqlite3_data_count(conn->statement);
 501         }
 502
 503         return 0;
 504 }
 505
 506 static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
 507 {
 508         int status;
 509         rlm_sql_sqlite_conn_t *conn = handle->conn;
 510
 511         int i = 0;
 512
 513         char **row;
 514
 515         /*
 516          *      Executes the SQLite query and interates over the results
 517          */
 518         status = sqlite3_step(conn->statement);
 519
 520         /*
 521          *      Error getting next row
 522          */
 523         if (sql_check_error(conn->db) != RLM_SQL_OK) return RLM_SQL_ERROR;
 524
 525         /*
 526          *      No more rows to process (were done)
 527          */
 528         if (status == SQLITE_DONE) {
 529                 return 1;
 530         }
 531
 532         /*
 533          *      We only need to do this once per result set, because
 534          *      the number of columns won't change.
 535          */
 536         if (conn->col_count == 0) {
 537                 conn->col_count = sql_num_fields(handle, config);
 538                 if (conn->col_count == 0) return RLM_SQL_ERROR;
 539         }
 540
 541         /*
 542          *      Free the previous result (also gets called on finish_query)
 543          */
 544         talloc_free(handle->row);
 545
 546         MEM(row = handle->row = talloc_zero_array(handle->conn, char *, conn->col_count + 1));
 547
 548         for (i = 0; i < conn->col_count; i++) {
 549                 switch (sqlite3_column_type(conn->statement, i)) {
 550                 case SQLITE_INTEGER:
 551                         MEM(row[i] = talloc_typed_asprintf(row, "%d", sqlite3_column_int(conn->statement, i)));
 552                         break;
 553
 554                 case SQLITE_FLOAT:
 555                         MEM(row[i] = talloc_typed_asprintf(row, "%f", sqlite3_column_double(conn->statement, i)));
 556                         break;
 557
 558                 case SQLITE_TEXT:
 559                         {
 560                                 char const *p;
 561                                 p = (char const *) sqlite3_column_text(conn->statement, i);
 562
 563                                 if (p) {
 564                                         MEM(row[i] = talloc_typed_strdup(row, p));
 565                                 }
 566                         }
 567                         break;
 568
 569                 case SQLITE_BLOB:
 570                         {
 571                                 uint8_t const *p;
 572                                 size_t len;
 573
 574                                 p = sqlite3_column_blob(conn->statement, i);
 575                                 if (p) {
 576                                         len = sqlite3_column_bytes(conn->statement, i);
 577
 578                                         MEM(row[i] = talloc_zero_array(row, char, len + 1));
 579                                         memcpy(row[i], p, len);
 580                                 }
 581                         }
 582                         break;
 583
 584                 default:
 585                         break;
 586                 }
 587         }
 588
 589         return 0;
 590 }
 591
 592 static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle,
 593                            UNUSED rlm_sql_config_t *config)
 594 {
 595         rlm_sql_sqlite_conn_t *conn = handle->conn;
 596
 597         if (conn->statement) {
 598                 TALLOC_FREE(handle->row);
 599
 600                 (void) sqlite3_finalize(conn->statement);
 601                 conn->statement = NULL;
 602                 conn->col_count = 0;
 603         }
 604
 605         /*
 606          *      There's no point in checking the code returned by finalize
 607          *      as it'll have already been encountered elsewhere in the code.
 608          *
 609          *      It's just the last error that occurred processing the
 610          *      statement.
 611          */
 612         return 0;
 613 }
 614
 615 /** Retrieves any errors associated with the connection handle
 616  *
 617  * @note Caller will free any memory allocated in ctx.
 618  *
 619  * @param ctx to allocate temporary error buffers in.
 620  * @param out Array of sql_log_entrys to fill.
 621  * @param outlen Length of out array.
 622  * @param handle rlm_sql connection handle.
 623  * @param config rlm_sql config.
 624  * @return number of errors written to the sql_log_entry array.
 625  */
 626 static size_t sql_error(UNUSED TALLOC_CTX *ctx, sql_log_entry_t out[], size_t outlen,
 627                         rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
 628 {
 629         rlm_sql_sqlite_conn_t *conn = handle->conn;
 630         char const *error;
 631
 632         rad_assert(outlen > 0);
 633
 634         error = sqlite3_errmsg(conn->db);
 635         if (!error) return 0;
 636
 637         out[0].type = L_ERR;
 638         out[0].msg = error;
 639
 640         return 1;
 641 }
 642
 643 static sql_rcode_t sql_finish_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
 644 {
 645         return sql_free_result(handle, config);
 646 }
 647
 648 static int sql_affected_rows(rlm_sql_handle_t *handle,
 649                              UNUSED rlm_sql_config_t *config)
 650 {
 651         rlm_sql_sqlite_conn_t *conn = handle->conn;
 652
 653         if (conn->db) {
 654                 return sqlite3_changes(conn->db);
 655         }
 656
 657         return -1;
 658 }
 659
 660
 661 /* Exported to rlm_sql */
 662 extern rlm_sql_module_t rlm_sql_sqlite;
 663 rlm_sql_module_t rlm_sql_sqlite = {
 664         .name                           = "rlm_sql_sqlite",
 665         .flags                          = RLM_SQL_RCODE_FLAGS_ALT_QUERY,
 666         .mod_instantiate                = mod_instantiate,
 667         .sql_socket_init                = sql_socket_init,
 668         .sql_query                      = sql_query,
 669         .sql_select_query               = sql_select_query,
 670         .sql_store_result               = sql_store_result,
 671         .sql_num_fields                 = sql_num_fields,
 672         .sql_num_rows                   = sql_num_rows,
 673         .sql_affected_rows              = sql_affected_rows,
 674         .sql_fetch_row                  = sql_fetch_row,
 675         .sql_free_result                = sql_free_result,
 676         .sql_error                      = sql_error,
 677         .sql_finish_query               = sql_finish_query,
 678         .sql_finish_select_query        = sql_finish_query
 679 };