view release on metacpan or  search on metacpan

MariaDB.xs  view on Meta::CPAN

    }

    if (mysql_stmt_bind_param(ctx->stmt, bp)) {
        char errbuf[512];
        COPY_ERROR(errbuf, mysql_stmt_error(ctx->stmt));
        free_stmt_bind_params(ctx);
        croak("%s", errbuf);
    }
}

static void start_connect(ev_mariadb_t *self) {
    int status;

    self->conn = mysql_init(NULL);
    if (NULL == self->conn) {
        croak("mysql_init failed");
    }

    self->connect_pid = getpid();
    mysql_options(self->conn, MYSQL_OPT_NONBLOCK, 0);
    apply_options(self);

    self->state = STATE_CONNECTING;
    status = mysql_real_connect_start(&self->op_conn_ret, self->conn,
        self->host, self->user, self->password, self->database,
        self->port, self->unix_socket, self->client_flags);

    if (status == 0) {
        on_connect_done(self);
    } else {
        self->fd = mysql_get_socket(self->conn);
        if (self->fd < 0) {
            mysql_close(self->conn);
            self->conn = NULL;
            self->state = STATE_IDLE;
            croak("mysql_get_socket returned invalid fd");
        }

        init_io_watchers(self);

        update_watchers(self, status);
    }
}

MODULE = EV::MariaDB  PACKAGE = EV::MariaDB

BOOT:
{
    I_EV_API("EV::MariaDB");
    call_atexit(drain_freelists, NULL);
}

EV::MariaDB
_new(char *class, EV::Loop loop)
CODE:
{
    PERL_UNUSED_VAR(class);
    Newxz(RETVAL, 1, ev_mariadb_t);
    RETVAL->magic = EV_MARIADB_MAGIC;
    RETVAL->loop = loop;
    RETVAL->loop_sv = SvREFCNT_inc(ST(1));   /* keep the EV::Loop object alive */
    RETVAL->fd = -1;
    RETVAL->state = STATE_IDLE;
    ngx_queue_init(&RETVAL->cb_queue);
    ngx_queue_init(&RETVAL->send_queue);

    ev_init(&RETVAL->timer, timer_cb);
    RETVAL->timer.data = (void *)RETVAL;
}
OUTPUT:
    RETVAL

void
DESTROY(EV::MariaDB self)
CODE:
{
    if (self->magic != EV_MARIADB_MAGIC)
        return;

    self->magic = EV_MARIADB_FREED;

    stop_reading(self);
    stop_writing(self);
    stop_timer(self);

    if (PL_dirty) {
        /* global destruction — free C resources only; skip SvREFCNT_dec
           to avoid cascading destructors in torn-down interpreter */
        int is_fork = IS_FORKED(self);
        while (!ngx_queue_empty(&self->send_queue)) {
            ngx_queue_t *q = ngx_queue_head(&self->send_queue);
            ev_mariadb_send_t *s = ngx_queue_data(q, ev_mariadb_send_t, queue);
            ngx_queue_remove(q);
            Safefree(s->sql);
            Safefree(s);
        }
        while (!ngx_queue_empty(&self->cb_queue)) {
            ngx_queue_t *q = ngx_queue_head(&self->cb_queue);
            ev_mariadb_cb_t *cbt = ngx_queue_data(q, ev_mariadb_cb_t, queue);
            ngx_queue_remove(q);
            Safefree(cbt);
        }
        if (self->op_data_ptr) Safefree(self->op_data_ptr);
        Safefree(self->pending_user);
        Safefree(self->pending_password);
        Safefree(self->pending_database);
        Safefree(self->pending_charset);
        self->stream_cb = NULL;
        /* skip loop_sv dec: global destruction, like the other SVs here */
        {
            ev_mariadb_stmt_t *ctx = self->stmt_list;
            while (ctx) {
                ev_mariadb_stmt_t *next = ctx->next;
                free_stmt_bind_params(ctx);
                if (!is_fork && ctx->stmt) {
                    if (ctx->stmt == self->op_stmt) self->op_stmt = NULL;
                    mysql_stmt_close(ctx->stmt);
                }
                Safefree(ctx);
                ctx = next;
            }