Cppcheck report - GATE C/C++ Framework: gate/data/mysql_adapter.c

/* GATE PROJECT LICENSE:
+----------------------------------------------------------------------------+
| Copyright(c) 2018-2025, Stefan Meislinger                                  |
| All rights reserved.                                                       |
|                                                                            |
| Redistribution and use in source and binary forms, with or without         |
| modification, are permitted provided that the following conditions are met:|
|                                                                            |
| 1. Redistributions of source code must retain the above copyright notice,  |
|    this list of conditions and the following disclaimer.                   |
| 2. Redistributions in binary form must reproduce the above copyright       |
|    notice, this list of conditions and the following disclaimer in the     |
|    documentation and/or other materials provided with the distribution.    |
|                                                                            |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE  |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE    |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR        |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF       |
| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS   |
| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN    |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)    |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF     |
| THE POSSIBILITY OF SUCH DAMAGE.                                            |
+----------------------------------------------------------------------------+
*/

#include "gate/data/mysql_adapter.h"
#include "gate/data/adapter_base.h"

#include "gate/libraries.h"
#include "gate/results.h"
#include "gate/uris.h"

#if defined(GATE_SYS_WIN)
#define MYSQL_API	__stdcall
#else
#define MYSQL_API
#endif

typedef struct MYSQL_struct MYSQL;
typedef struct MYSQL_RES_struct MYSQL_RES;
typedef struct MYSQL_STMT_struct MYSQL_STMT;
typedef struct NET_struct NET;

enum enum_field_types
{
    MYSQL_TYPE_DECIMAL = 0,
    MYSQL_TYPE_TINY = 1,
    MYSQL_TYPE_SHORT = 2,
    MYSQL_TYPE_LONG = 3,
    MYSQL_TYPE_FLOAT = 4,
    MYSQL_TYPE_DOUBLE = 5,
    MYSQL_TYPE_NULL = 6,
    MYSQL_TYPE_TIMESTAMP = 7,
    MYSQL_TYPE_LONGLONG = 8,
    MYSQL_TYPE_INT24 = 9,
    MYSQL_TYPE_DATE = 10,
    MYSQL_TYPE_TIME = 11,
    MYSQL_TYPE_DATETIME = 12,
    MYSQL_TYPE_YEAR = 13,
    MYSQL_TYPE_NEWDATE = 14,
    MYSQL_TYPE_VARCHAR = 15,
    MYSQL_TYPE_BIT = 16,
    MYSQL_TYPE_TIMESTAMP2 = 17,
    MYSQL_TYPE_DATETIME2 = 18,
    MYSQL_TYPE_TIME2 = 19,
    MYSQL_TYPE_TYPED_ARRAY = 20,

    MYSQL_TYPE_INVALID = 243,
    MYSQL_TYPE_BOOL = 244,
    MYSQL_TYPE_JSON = 245,
    MYSQL_TYPE_NEWDECIMAL = 246,
    MYSQL_TYPE_ENUM = 247,
    MYSQL_TYPE_SET = 248,
    MYSQL_TYPE_TINY_BLOB = 249,
    MYSQL_TYPE_MEDIUM_BLOB = 250,
    MYSQL_TYPE_LONG_BLOB = 251,
    MYSQL_TYPE_BLOB = 252,
    MYSQL_TYPE_VAR_STRING = 253,
    MYSQL_TYPE_STRING = 254,
    MYSQL_TYPE_GEOMETRY = 255
};

typedef struct MYSQL_FIELD
{
    char* name;
    char* org_name;
    char* table;
    char* org_table;
    char* db;
    char* catalog;
    char* def;
    unsigned long length;
    unsigned long max_length;
    unsigned int name_length;
    unsigned int org_name_length;
    unsigned int table_length;
    unsigned int org_table_length;
    unsigned int db_length;
    unsigned int catalog_length;
    unsigned int def_length;
    unsigned int flags;
    unsigned int decimals;
    unsigned int charsetnr;
    enum enum_field_types type;
    void* extension;
} MYSQL_FIELD;

typedef struct MYSQL_BIND
{
    unsigned long* length;<--- struct member 'MYSQL_BIND::length' is never used.
    bool* is_null;<--- struct member 'MYSQL_BIND::is_null' is never used.
    void* buffer;<--- struct member 'MYSQL_BIND::buffer' is never used.
    bool* error;<--- struct member 'MYSQL_BIND::error' is never used.
    unsigned char* row_ptr;<--- struct member 'MYSQL_BIND::row_ptr' is never used.
    void (*store_param_func)(NET* net, struct MYSQL_BIND* param);<--- struct member 'MYSQL_BIND::store_param_func' is never used.
    void (*fetch_result)(struct MYSQL_BIND*, MYSQL_FIELD*, unsigned char** row);<--- struct member 'MYSQL_BIND::fetch_result' is never used.
    void (*skip_result)(struct MYSQL_BIND*, MYSQL_FIELD*, unsigned char** row);<--- struct member 'MYSQL_BIND::skip_result' is never used.
    unsigned long			buffer_length;<--- struct member 'MYSQL_BIND::buffer_length' is never used.
    unsigned long			offset;<--- struct member 'MYSQL_BIND::offset' is never used.
    unsigned long			length_value;<--- struct member 'MYSQL_BIND::length_value' is never used.
    unsigned int			param_number;<--- struct member 'MYSQL_BIND::param_number' is never used.
    unsigned int			pack_length;<--- struct member 'MYSQL_BIND::pack_length' is never used.
    enum enum_field_types	buffer_type;
    bool					error_value;<--- struct member 'MYSQL_BIND::error_value' is never used.
    bool					is_unsigned;<--- struct member 'MYSQL_BIND::is_unsigned' is never used.
    bool					long_data_used;<--- struct member 'MYSQL_BIND::long_data_used' is never used.
    bool					is_null_value;<--- struct member 'MYSQL_BIND::is_null_value' is never used.
    void* extension;<--- struct member 'MYSQL_BIND::extension' is never used.
} MYSQL_BIND;

typedef char** MYSQL_ROW;                /* return data as array of strings */

typedef struct gate_mysql_api_class
{
    MYSQL* (MYSQL_API* init)			(MYSQL* mysql);
    void			(MYSQL_API* close)			(MYSQL* mysql);
    MYSQL* (MYSQL_API* real_connect)	(MYSQL* mysql, const char* host,
        const char* user, const char* passwd,
        const char* db, unsigned int port,
        const char* unix_socket,
        unsigned long clientflag);
    int				(MYSQL_API* query)			(MYSQL* mysql, const char* q);
    MYSQL_RES* (MYSQL_API* use_result)		(MYSQL* mysql);
    MYSQL_ROW(MYSQL_API* fetch_row)		(MYSQL_RES* result);
    void			(MYSQL_API* free_result)	(MYSQL_RES* result);
    unsigned int	(MYSQL_API* num_fields)		(MYSQL_RES* res);
    unsigned long* (MYSQL_API* fetch_lengths)	(MYSQL_RES* result);
    unsigned int	(MYSQL_API* field_count)	(MYSQL* mysql);
    gate_uint64_t(MYSQL_API* affected_rows)	(MYSQL* mysql);
    MYSQL_FIELD* (MYSQL_API* fetch_field)	(MYSQL_RES* result);

    MYSQL_STMT* (MYSQL_API* stmt_init)(MYSQL* mysql);
    gate_bool_t(MYSQL_API* stmt_close)(MYSQL_STMT* stmt);
    int				(MYSQL_API* stmt_prepare)(MYSQL_STMT* stmt, const char* query, unsigned long length);
    int				(MYSQL_API* stmt_execute)(MYSQL_STMT* stmt);
    gate_bool_t(MYSQL_API* stmt_bind_result)(MYSQL_STMT* stmt, MYSQL_BIND* bnd);
    int				(MYSQL_API* stmt_fetch)(MYSQL_STMT* stmt);
    int				(MYSQL_API* stmt_fetch_column)(MYSQL_STMT* stmt, MYSQL_BIND* bind_arg, unsigned int column, unsigned long offset);
    int				(MYSQL_API* stmt_store_result)(MYSQL_STMT* stmt);
    MYSQL_RES* (MYSQL_API* stmt_result_metadata)(MYSQL_STMT* stmt);
    unsigned long	(MYSQL_API* stmt_param_count)(MYSQL_STMT* stmt);
    unsigned int	(MYSQL_API* stmt_field_count)(MYSQL_STMT* stmt);
    gate_uint64_t(MYSQL_API* stmt_affected_rows)(MYSQL_STMT* stmt);
    gate_bool_t(MYSQL_API* stmt_bind_param)(MYSQL_STMT* stmt, MYSQL_BIND* bnd);

} gate_mysql_api_t;

static gate_mysql_api_t mysql;

static gate_string_t const mysql_library_names[] =
{
    GATE_STRING_INIT_STATIC("libmysql"),
};
static gate_size_t const mysql_library_names_count = sizeof(mysql_library_names) / sizeof(mysql_library_names[0]);

static gate_result_t gate_mysql_load_api()
{
    static gate_library_t mysql_lib = NULL;
    static gate_atomic_int_t mysql_lib_loaded = 0;
    gate_result_t result;
    gate_int32_t state;
    gate_size_t ndx;

    do
    {
        state = gate_atomic_int_xchg_if(&mysql_lib_loaded, 0, 1);
        if (state != 0)
        {
            break;
        }

        state = 1;<--- Variable 'state' is reassigned a value before the old one has been used.

        result = GATE_RESULT_FAILED;
        for (ndx = 0; (ndx != mysql_library_names_count) && GATE_FAILED(result); ++ndx)
        {
            result = gate_library_open(&mysql_library_names[ndx], &mysql_lib, 0);
        }
        GATE_BREAK_IF_FAILED(result);

        result |= gate_library_get_function_name(mysql_lib, "mysql_init", &mysql.init);
        result |= gate_library_get_function_name(mysql_lib, "mysql_close", &mysql.close);
        result |= gate_library_get_function_name(mysql_lib, "mysql_real_connect", &mysql.real_connect);
        result |= gate_library_get_function_name(mysql_lib, "mysql_query", &mysql.query);
        result |= gate_library_get_function_name(mysql_lib, "mysql_use_result", &mysql.use_result);
        result |= gate_library_get_function_name(mysql_lib, "mysql_fetch_row", &mysql.fetch_row);
        result |= gate_library_get_function_name(mysql_lib, "mysql_free_result", &mysql.free_result);
        result |= gate_library_get_function_name(mysql_lib, "mysql_num_fields", &mysql.num_fields);
        result |= gate_library_get_function_name(mysql_lib, "mysql_fetch_lengths", &mysql.fetch_lengths);
        result |= gate_library_get_function_name(mysql_lib, "mysql_field_count", &mysql.field_count);
        result |= gate_library_get_function_name(mysql_lib, "mysql_affected_rows", &mysql.affected_rows);
        result |= gate_library_get_function_name(mysql_lib, "mysql_fetch_field", &mysql.fetch_field);

        result |= gate_library_get_function_name(mysql_lib, "mysql_stmt_init", &mysql.stmt_init);
        result |= gate_library_get_function_name(mysql_lib, "mysql_stmt_close", &mysql.stmt_close);
        result |= gate_library_get_function_name(mysql_lib, "mysql_stmt_prepare", &mysql.stmt_prepare);
        result |= gate_library_get_function_name(mysql_lib, "mysql_stmt_execute", &mysql.stmt_execute);
        result |= gate_library_get_function_name(mysql_lib, "mysql_stmt_bind_result", &mysql.stmt_bind_result);
        result |= gate_library_get_function_name(mysql_lib, "mysql_stmt_fetch", &mysql.stmt_fetch);
        result |= gate_library_get_function_name(mysql_lib, "mysql_stmt_fetch_column", &mysql.stmt_fetch_column);
        result |= gate_library_get_function_name(mysql_lib, "mysql_stmt_store_result", &mysql.stmt_store_result);
        result |= gate_library_get_function_name(mysql_lib, "mysql_stmt_result_metadata", &mysql.stmt_result_metadata);
        result |= gate_library_get_function_name(mysql_lib, "mysql_stmt_param_count", &mysql.stmt_param_count);
        result |= gate_library_get_function_name(mysql_lib, "mysql_stmt_field_count", &mysql.stmt_field_count);
        result |= gate_library_get_function_name(mysql_lib, "mysql_stmt_affected_rows", &mysql.stmt_affected_rows);
        result |= gate_library_get_function_name(mysql_lib, "mysql_stmt_bind_param", &mysql.stmt_bind_param);



        GATE_BREAK_IF_FAILED(result);

        gate_atomic_int_set(&mysql_lib_loaded, 2);
    } while (0);

    state = gate_atomic_int_xchg_if(&mysql_lib_loaded, 1, 0);<--- Variable 'state' is reassigned a value before the old one has been used.

    if (state == 2)
    {
        return GATE_RESULT_OK;
    }
    return GATE_RESULT_FAILED;
}



static gate_result_t mysqlconn_init(gate_data_connection_base_t* self)
{
    GATE_UNUSED_ARG(self);
    return GATE_RESULT_OK;
}

static void mysqlconn_close(gate_data_connection_base_t* self)
{
    MYSQL* ptr_mysql = (MYSQL*)self->native_handles[0];
    if (ptr_mysql)
    {
        self->native_handles[0] = NULL;
        mysql.close(ptr_mysql);
    }
}

static gate_result_t mysqlreader_init(gate_data_reader_base_t* reader)
{
    MYSQL_RES* ptr_meta = (MYSQL_RES*)reader->native_handles[2];
    MYSQL_FIELD* ptr_field;
    gate_size_t field_count = 0;
    gate_type_id_t gate_type;

    while ((ptr_field = mysql.fetch_field(ptr_meta)))
    {
        if (field_count >= 64)
        {
            break;
        }
        gate_string_create(&reader->names[field_count], ptr_field->name, ptr_field->name_length);
        switch (ptr_field->type)
        {
        case MYSQL_TYPE_INVALID:
        case MYSQL_TYPE_NULL:		gate_type = GATE_TYPE_EMPTY; break;
        case MYSQL_TYPE_BIT:
        case MYSQL_TYPE_BOOL:		gate_type = GATE_TYPE_BOOL; break;
        case MYSQL_TYPE_TINY:		gate_type = GATE_TYPE_I8; break;
        case MYSQL_TYPE_SHORT:		gate_type = GATE_TYPE_I16; break;
        case MYSQL_TYPE_ENUM:
        case MYSQL_TYPE_INT24:
        case MYSQL_TYPE_LONG:		gate_type = GATE_TYPE_I32; break;
        case MYSQL_TYPE_LONGLONG:	gate_type = GATE_TYPE_I64; break;
        case MYSQL_TYPE_FLOAT:		gate_type = GATE_TYPE_R32; break;
        case MYSQL_TYPE_DECIMAL:
        case MYSQL_TYPE_NEWDECIMAL:
        case MYSQL_TYPE_DOUBLE:		gate_type = GATE_TYPE_R64; break;
        case MYSQL_TYPE_TIME:
        case MYSQL_TYPE_TIME2:
        case MYSQL_TYPE_TIMESTAMP2:
        case MYSQL_TYPE_TIMESTAMP:	gate_type = GATE_TYPE_TIME; break;
        case MYSQL_TYPE_YEAR:
        case MYSQL_TYPE_NEWDATE:
        case MYSQL_TYPE_DATE:		gate_type = GATE_TYPE_DATE; break;
        case MYSQL_TYPE_DATETIME2:
        case MYSQL_TYPE_DATETIME:	gate_type = GATE_TYPE_DATETIME; break;
        case MYSQL_TYPE_JSON:
        case MYSQL_TYPE_SET:
        case MYSQL_TYPE_VARCHAR:
        case MYSQL_TYPE_VAR_STRING:
        case MYSQL_TYPE_STRING:		gate_type = GATE_TYPE_STRING; break;
        case MYSQL_TYPE_TINY_BLOB:
        case MYSQL_TYPE_MEDIUM_BLOB:
        case MYSQL_TYPE_LONG_BLOB:
        case MYSQL_TYPE_BLOB:		gate_type = GATE_TYPE_BLOB; break;
        case MYSQL_TYPE_GEOMETRY:
        case MYSQL_TYPE_TYPED_ARRAY:
        {
            gate_type = GATE_TYPE_ARRAY; break;
        }

        }
        ++field_count;
    }

    return GATE_RESULT_FAILED;
}
static gate_bool_t mysqlreader_is_valid(gate_data_reader_base_t* reader)
{
    MYSQL_STMT* ptr_stmt = (MYSQL_STMT*)reader->native_handles[1];
    return ptr_stmt == NULL;
}
static gate_result_t mysqlreader_next(gate_data_reader_base_t* reader)
{
    MYSQL* ptr_mysql = (MYSQL*)reader->native_handles[0];<--- Variable 'ptr_mysql' is assigned a value that is never used.
    MYSQL_STMT* ptr_stmt = (MYSQL_STMT*)reader->native_handles[1];
    MYSQL_RES* ptr_meta = (MYSQL_RES*)reader->native_handles[2];<--- Variable 'ptr_meta' is assigned a value that is never used.

    MYSQL_BIND fields[64];<--- Variable 'fields' is assigned a value that is never used.
    unsigned int fields_count;<--- Unused variable: fields_count

    if (!ptr_stmt)
    {
        return GATE_RESULT_ENDOFSTREAM;
    }

    /*
    fields_count = mysql.stmt_field_count(ptr_stmt);


    MYSQL_RES* ptr_meta = (MYSQL_RES*)reader->native_handles[2];
    MYSQL_FIELD* ptr_field;
    gate_size_t field_count = 0;

    while((ptr_field = mysql.fetch_field(ptr_meta)))
    {
        gate_string_create(&reader->names[field_count], ptr_field->name, ptr_field->name_length);
        ++field_count;
    }
    */
    return GATE_RESULT_FAILED;
}
static gate_result_t mysqlreader_close(gate_data_reader_base_t* reader)
{
    MYSQL_STMT* ptr_stmt = (MYSQL_STMT*)reader->native_handles[1];
    MYSQL_RES* ptr_meta = (MYSQL_RES*)reader->native_handles[2];
    if (ptr_meta)
    {
        mysql.free_result(ptr_meta);
    }
    if (ptr_stmt)
    {
        mysql.stmt_close(ptr_stmt);
    }
    reader->native_handles[0] = NULL;
    reader->native_handles[1] = NULL;
    reader->native_handles[2] = NULL;
    return GATE_RESULT_OK;
}

/*
static gate_result_t gate_mysql_execute(gate_data_connection_base_t* self, gate_string_t const* command, gate_int32_t* affected_rows)
{
    MYSQL* ptr_mysql = (MYSQL*)self->native_handles[0];
    if(!ptr_mysql)
    {
        return GATE_RESULT_INVALIDSTATE;

    }
    return GATE_RESULT_FAILED;
}

static gate_result_t gate_mysql_query(gate_data_connection_base_t* self, gate_string_t const* query, gate_data_reader_t** ptr_reader)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    int result;
    gate_cstrbuffer_t sql = GATE_INIT_EMPTY;
    gate_data_handles_t reader_handles;
    MYSQL_STMT* ptr_stmt = NULL;
    MYSQL* ptr_mysql = (MYSQL*)self->native_handles[0];
    MYSQL_RES* ptr_meta_result = NULL;
    gate_data_reader_t* data_reader = NULL;

    do
    {
        if(!ptr_mysql || gate_string_is_empty(query))
        {
            ret = GATE_RESULT_INVALIDSTATE;
            break;
        }

        if(NULL == gate_cstrbuffer_create_string(&sql, query, false))
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        ptr_stmt = mysql.stmt_init(ptr_mysql);
        if(!ptr_stmt)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        result = mysql.stmt_prepare(ptr_stmt, gate_cstrbuffer_get(&sql), gate_cstrbuffer_length(&sql));
        if(0 != result)
        {
            ret = GATE_RESULT_INVALIDINPUT;
            break;
        }

        result = mysql.stmt_execute(ptr_stmt);
        if(0 != result)
        {
            ret = GATE_RESULT_FAILED;
            break;
        }

        ptr_meta_result = mysql.stmt_result_metadata(ptr_stmt);
        if(!ptr_meta_result)
        {
            ret = GATE_RESULT_INVALIDOUTPUT;
            break;
        }

        gate_mem_clear(reader_handles, sizeof(reader_handles));
        reader_handles[0] = ptr_mysql;
        reader_handles[1] = ptr_stmt;
        reader_handles[2] = ptr_meta_result;

        data_reader = gate_data_reader_base_create(reader_handles, &gate_mysql_reader_init, gate_mysql_reader_is_valid, gate_mysql_reader_next, gate_mysql_reader_close);
        if(data_reader == NULL)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
        }

        ptr_stmt = NULL;
        ptr_meta_result = NULL;

        if(ptr_reader)
        {
            *ptr_reader = data_reader;
            data_reader = NULL;
        }
        ret = GATE_RESULT_OK;

    } while(0);

    if(data_reader)
    {
        gate_object_release(data_reader);
    }

    gate_cstrbuffer_destroy(&sql);
    if(ptr_meta_result)
    {
        mysql.free_result(ptr_meta_result);
    }

    if(ptr_stmt)
    {
        mysql.stmt_close(ptr_stmt);
    }

    return ret;
}
*/

static gate_result_t mysqlstmt_init(gate_data_statement_base_t* self)
{
    GATE_UNUSED_ARG(self);
    return GATE_RESULT_OK;
}

static void mysqlstmt_close(gate_data_statement_base_t* self)
{
    GATE_UNUSED_ARG(self);
}
static gate_result_t mysqlstmt_set_param(gate_data_statement_base_t* self, gate_size_t index, gate_value_t const* value)
{
    /* TODO implementation */
    return GATE_RESULT_NOTSUPPORTED;
}
static gate_result_t mysqlstmt_set_named_param(gate_data_statement_base_t* self, gate_string_t const* name, gate_value_t const* value)
{
    /* TODO implementation */
    return GATE_RESULT_NOTSUPPORTED;
}
static gate_result_t mysqlstmt_reset(gate_data_statement_base_t* self)
{
    /* TODO implementation */
    return GATE_RESULT_NOTSUPPORTED;
}
static gate_result_t mysqlstmt_execute(gate_data_statement_base_t* self, gate_int32_t* affected_rows)
{
    /* TODO implementation */
    return GATE_RESULT_NOTSUPPORTED;
}
static gate_result_t mysqlstmt_query(gate_data_statement_base_t* self, gate_data_reader_t** ptr_reader)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    MYSQL* const ptr_mysql = (MYSQL*)self->native_handles[0];
    MYSQL_STMT* const ptr_stmt = (MYSQL_STMT*)self->native_handles[1];
    MYSQL_RES* ptr_meta_result = NULL;
    int my_result;
<--- The scope of the variable 'my_result' can be reduced. [+]
The scope of the variable 'my_result' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_data_handles_t reader_handles;

    do
    {
        my_result = mysql.stmt_execute(ptr_stmt);
        if (0 != my_result)
        {
            ret = GATE_RESULT_FAILED;
            break;
        }

        ptr_meta_result = mysql.stmt_result_metadata(ptr_stmt);
        if (!ptr_meta_result)
        {
            ret = GATE_RESULT_INVALIDOUTPUT;
            break;
        }

        ret = GATE_RESULT_OK;
        if (ptr_reader)
        {
            gate_mem_clear(&reader_handles[0], sizeof(reader_handles));
            reader_handles[0] = ptr_mysql;
            reader_handles[1] = ptr_stmt;
            reader_handles[2] = ptr_meta_result;

            *ptr_reader = gate_data_reader_base_create(
                (gate_data_statement_t*)self, reader_handles,
                &mysqlreader_init,
                &mysqlreader_is_valid,
                &mysqlreader_next,
                &mysqlreader_close);
            if (*ptr_reader == NULL)
            {
                ret = GATE_RESULT_OUTOFMEMORY;
                break;
            }
            ptr_meta_result = NULL;
        }
    } while (0);

    if (ptr_meta_result != NULL)
    {
        mysql.free_result(ptr_meta_result);
    }

    return ret;
}





static gate_result_t mysqlconn_create_statement(gate_data_connection_base_t* self, gate_string_t const* sql, gate_data_statement_t** ptr_statement)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    int result;
<--- The scope of the variable 'result' can be reduced. [+]
The scope of the variable 'result' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_cstrbuffer_t sql_cmd = GATE_INIT_EMPTY;
    gate_data_handles_t reader_handles;
    MYSQL* const ptr_mysql = (MYSQL*)self->native_handles[0];
    MYSQL_STMT* ptr_stmt = NULL;
    gate_data_statement_base_t* ptr_statement_base = NULL;

    do
    {
        if (!ptr_mysql || gate_string_is_empty(sql))
        {
            ret = GATE_RESULT_INVALIDSTATE;
            break;
        }

        if (NULL == gate_cstrbuffer_create_string(&sql_cmd, sql, false))
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        ptr_stmt = mysql.stmt_init(ptr_mysql);
        if (!ptr_stmt)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        result = mysql.stmt_prepare(ptr_stmt,
            gate_cstrbuffer_get(&sql_cmd),
            (unsigned long)gate_cstrbuffer_length(&sql_cmd));
        if (0 != result)
        {
            ret = GATE_RESULT_INVALIDINPUT;
            break;
        }

        gate_mem_clear(&reader_handles[0], sizeof(reader_handles));
        reader_handles[0] = ptr_mysql;
        reader_handles[1] = ptr_stmt;

        ret = gate_data_statement_base_create(
            self, reader_handles, sql,
            &mysqlstmt_init,
            &mysqlstmt_close,
            &mysqlstmt_set_param,
            &mysqlstmt_set_named_param,
            &mysqlstmt_reset,
            &mysqlstmt_execute,
            &mysqlstmt_query,
            &ptr_statement_base);

        if (GATE_FAILED(ret))
        {
            mysql.stmt_close(ptr_stmt);
            break;
        }

        ret = GATE_RESULT_OK;
        ptr_stmt = NULL;


    } while (0);

    if (ptr_statement_base != NULL)
    {
        gate_object_release(ptr_statement_base);
    }

    gate_cstrbuffer_destroy(&sql_cmd);
    if (ptr_stmt != NULL)
    {
        mysql.stmt_close(ptr_stmt);
    }
    return ret;
}




static gate_string_t const mysql_uri_scheme = GATE_STRING_INIT_STATIC("mysql");

gate_result_t gate_data_adapter_mysql_create(gate_string_t const* path, gate_enumint_t flags,
    gate_data_connection_t** ptr_connection)
{
    gate_result_t result;
    gate_data_handles_t data_handles = GATE_INIT_EMPTY;
    gate_uri_t uri = GATE_INIT_EMPTY;
    gate_uint16_t mysql_port = 0;
    gate_string_t username = GATE_STRING_INIT_EMPTY;
    gate_string_t password = GATE_STRING_INIT_EMPTY;
    gate_cstrbuffer_t mysql_host = GATE_INIT_EMPTY;
    gate_cstrbuffer_t mysql_user = GATE_INIT_EMPTY;
    gate_cstrbuffer_t mysql_pass = GATE_INIT_EMPTY;
    gate_cstrbuffer_t mysql_db = GATE_INIT_EMPTY;
    char const* mysql_db_ptr = NULL;
    MYSQL* ptr_mysql = NULL;

    do
    {
        result = gate_uri_parse(&uri, path);
        GATE_BREAK_IF_FAILED(result);

        if (!gate_string_equals(&uri.scheme, &mysql_uri_scheme))
        {
            result = GATE_RESULT_INVALIDINPUT;
            break;
        }
        gate_cstrbuffer_create_string(&mysql_host, &uri.host, false);
        mysql_port = uri.port ? uri.port : 3306;
        gate_uri_parse_user_info(&uri.user_info, &username, &password);
        gate_cstrbuffer_create_string(&mysql_user, &username, false);
        gate_cstrbuffer_create_string(&mysql_pass, &password, false);
        gate_cstrbuffer_create_string(&mysql_db, &uri.absolute_path, false);

        mysql_db_ptr = gate_cstrbuffer_get(&mysql_db);
        if (mysql_db_ptr && mysql_db_ptr[0] == '/')
        {
            mysql_db_ptr = &mysql_db_ptr[1];
            if (gate_str_length(mysql_db_ptr) == 0)
            {
                mysql_db_ptr = NULL;
            }
        }

        result = gate_mysql_load_api();
        GATE_BREAK_IF_FAILED(result);

        ptr_mysql = mysql.init(NULL);
        if (NULL == ptr_mysql)
        {
            result = GATE_RESULT_FAILED;
            break;
        }

        if (NULL == mysql.real_connect(ptr_mysql,
            gate_cstrbuffer_get(&mysql_host),
            gate_cstrbuffer_get(&mysql_user),
            gate_cstrbuffer_get(&mysql_pass),
            mysql_db_ptr, mysql_port, NULL, 0))
        {
            result = GATE_RESULT_FAILED;
            break;
        }

        data_handles[0] = (void*)ptr_mysql;

        result = gate_data_connection_base_create(data_handles,
            &mysqlconn_init,
            &mysqlconn_close,
            &mysqlconn_create_statement,
            ptr_connection);
        GATE_BREAK_IF_FAILED(result);

        /* success, handles transfered to ptr_connection! */
        ptr_mysql = NULL;
    } while (0);

    if (ptr_mysql)
    {
        mysql.close(ptr_mysql);
    }

    gate_string_release(&username);
    gate_string_release(&password);
    gate_cstrbuffer_destroy(&mysql_host);
    gate_cstrbuffer_destroy(&mysql_user);
    gate_cstrbuffer_destroy(&mysql_pass);
    gate_cstrbuffer_destroy(&mysql_db);
    gate_uri_destroy(&uri);

    return result;
}