view release on metacpan or  search on metacpan

t/14_new_features.t  view on Meta::CPAN

        });
    });
});

# stmt wrappers freed on reset (no close_stmt needed)
with_mariadb(cb => sub {
    $m->prepare("select 1", sub {
        my ($stmt, $err) = @_;
        ok(!$err, 'stmt cleanup on reset: prepare ok');
        $m->execute($stmt, undef, sub {
            my ($r, $e) = @_;
            ok(!$e && $r->[0][0] == 1, 'stmt cleanup on reset: execute ok');
            # reset without close_stmt — stmt wrapper should be freed internally
            $m->reset;
        });
    });
    # after reset, on_connect fires again
    $m->on_connect(sub {
        $m->q("select 42", sub {
            my ($r, $e) = @_;
            ok(!$e && $r->[0][0] == 42, 'stmt cleanup on reset: works after reset');
            EV::break;
        });
    });
});

# stale stmt handle after reset: croaks instead of crashing
with_mariadb(cb => sub {
    $m->prepare("select 1", sub {
        my ($stmt, $err) = @_;
        ok(!$err, 'stale stmt: prepare ok');
        $m->reset;
    });
    $m->on_connect(sub {
        # now $stmt from the old connection is invalidated
        # close_stmt should succeed (no-op) on an already-closed handle
        # but execute should croak
        # we don't have $stmt here, so test via a fresh prepare + reset cycle
        $m->prepare("select 1", sub {
            my ($stmt2, $err2) = @_;
            ok(!$err2, 'stale stmt: prepare on new connection ok');
            $m->close_stmt($stmt2, sub { EV::break });
        });
    });
});

# fork safety: child DESTROY must not kill parent connection
with_mariadb(cb => sub {
    my $pid = fork;
    if (!defined $pid) {
        fail("fork safety: fork failed: $!");
        EV::break;
        return;
    }
    if ($pid == 0) {
        # child: just exit — DESTROY should skip mysql_close
        exit 0;
    }
    # parent: wait for child, then verify connection still works
    waitpid($pid, 0);
    $m->q("select 'alive'", sub {
        my ($r, $e) = @_;
        ok(!$e && $r->[0][0] eq 'alive', 'fork safety: parent connection survives child exit');
        EV::break;
    });
});

# utf8 option: text query results get UTF-8 flag
with_mariadb(utf8 => 1, charset => 'utf8mb4', cb => sub {
    $m->q("select 'hello', _binary'raw'", sub {
        my ($r, $e, $f) = @_;
        ok(!$e, 'utf8 option: query ok');
        ok(utf8::is_utf8($r->[0][0]), 'utf8 option: text column has UTF-8 flag');
        ok(!utf8::is_utf8($r->[0][1]), 'utf8 option: binary column has no UTF-8 flag');
        # prepared statement
        $m->prepare("select ?", sub {
            my ($stmt, $pe) = @_;
            ok(!$pe, 'utf8 option: prepare ok');
            $m->execute($stmt, ["test"], sub {
                my ($pr, $pe2) = @_;
                ok(utf8::is_utf8($pr->[0][0]), 'utf8 option: prepared stmt result has UTF-8 flag');
                $m->close_stmt($stmt, sub { EV::break });
            });
        });
    });
});

# utf8 round-trip: insert and read back Unicode via text query and prepared stmt
with_mariadb(utf8 => 1, charset => 'utf8mb4', cb => sub {
    my $uni = "\x{263A}\x{2603}\x{1F600}";  # smiley, snowman, grinning face (4-byte)
    $m->q("create temporary table _utf8rt (val varchar(100)) character set utf8mb4", sub {
        die $_[1] if $_[1];
        # insert via text query using escape
        my $escaped = $m->escape($uni);
        $m->q("insert into _utf8rt values ('$escaped')", sub {
            die $_[1] if $_[1];
            # read back via text query
            $m->q("select val from _utf8rt", sub {
                my ($r, $e) = @_;
                ok(!$e, 'utf8 round-trip: text query select ok');
                ok(utf8::is_utf8($r->[0][0]), 'utf8 round-trip: text result has UTF-8 flag');
                is($r->[0][0], $uni, 'utf8 round-trip: text query data intact');
                # insert + read via prepared stmt
                $m->prepare("insert into _utf8rt values (?)", sub {
                    my ($istmt, $ie) = @_;
                    ok(!$ie, 'utf8 round-trip: prepare insert ok');
                    $m->execute($istmt, [$uni], sub {
                        die $_[1] if $_[1];
                        $m->close_stmt($istmt, sub {
                            $m->prepare("select val from _utf8rt order by val limit 1", sub {
                                my ($sstmt, $se) = @_;
                                ok(!$se, 'utf8 round-trip: prepare select ok');
                                $m->execute($sstmt, [], sub {
                                    my ($pr, $pe) = @_;
                                    ok(utf8::is_utf8($pr->[0][0]), 'utf8 round-trip: prepared result has UTF-8 flag');
                                    is($pr->[0][0], $uni, 'utf8 round-trip: prepared stmt data intact');
                                    $m->close_stmt($sstmt, sub { EV::break });
                                });
                            });
                        });
                    });
                });
            });