File Coverage

blib/lib/DBIx/QuickDB/Driver/DuckDB.pm

Criterion	Covered	Total	%
statement	31	69	44.9
branch	4	18	22.2
condition	0	6	0.0
subroutine	9	18	50.0
pod	9	9	100.0
total	53	120	44.1

package DBIx::QuickDB::Driver::DuckDB;
use strict;
use warnings;

use IPC::Cmd qw/can_run/;
use Scalar::Util qw/reftype/;

our $VERSION = '0.000042';

use parent 'DBIx::QuickDB::Driver';

use DBIx::QuickDB::Util::HashBase qw{-duckdb -started};

my ($DUCKDB, $DBDDUCKDB);

BEGIN {
    local $@;

    $DUCKDB = can_run('duckdb');
    $DBDDUCKDB = eval { require DBD::DuckDB; 'DBD::DuckDB' };
}

sub version_string {
    my $binary;

    # Go in reverse order assuming the last param hash provided is most important
    for my $arg (reverse @_) {
        my $type = reftype($arg) or next;    # skip if not a ref
        next unless $type eq 'HASH';         # We have a hashref, possibly blessed

        # If we find a launcher we are done looping, we want to use this binary.
        $binary = $arg->{+DUCKDB} and last;
    }

    # If no args provided one to use we fallback to the default from $PATH
    $binary ||= $DUCKDB;

    return 'unknown' unless $binary;

    # Call the binary with '--version', capturing and returning the output using backticks.
    return `$binary --version`;
}

sub _default_paths { return (duckdb => $DUCKDB) }

sub viable {
    my $this = shift;
    my ($spec) = @_;

    my %check = (ref($this) ? %$this : (), $this->_default_paths, %$spec);

    my @bad;
    push @bad => "'DBD::DuckDB' module could not be loaded, needed for connecting" unless $DBDDUCKDB;
    push @bad => "'duckdb' command is missing, needed for loading SQL"              unless $check{+DUCKDB};

    return (1, undef) unless @bad;
    return (0, join "\n" => @bad);
}

sub init {
    my $self = shift;
    $self->SUPER::init();

    my %defaults = $self->_default_paths;
    $self->{$_} ||= $defaults{$_} for keys %defaults;

    $self->{+STARTED} = 1;

    return;
}

sub bootstrap { return }
sub start     { return }
sub stop      { return }

sub clone {
    my $self = shift;

    local $self->{+STARTED} = 0;

    return $self->SUPER::clone(@_);
}

sub connect_string {
    my $self = shift;
    my ($db_name) = @_;
    $db_name = 'quickdb' unless defined $db_name;

    my $dir = $self->{+DIR};
    my $path = "$dir/$db_name";

    require DBD::DuckDB;
    return "dbi:DuckDB:dbname=$path";
}

sub load_sql {
    my $self = shift;
    my ($db_name, $file) = @_;

    my $dir = $self->{+DIR};
    my $path = "$dir/$db_name";

    # DBD::DuckDB cannot prepare multiple statements in one do(); the CLI reads
    # statements from STDIN, so pipe the file through it.
    $self->run_command([$self->{+DUCKDB}, $path], {stdin => $file});
}

sub shell_command {
    my $self = shift;
    my ($db_name) = @_;

    my $dir = $self->{+DIR};
    my $path = "$dir/$db_name";

    return ($self->{+DUCKDB}, $path);
}

1;

__END__