package DBD::DuckDB::Constants;

use strict;
use warnings;
use utf8;
use v5.10;

use Exporter 'import';

our @DUCKDB_TYPES = qw(
    DUCKDB_TYPE_INVALID
    DUCKDB_TYPE_BOOLEAN
    DUCKDB_TYPE_TINYINT
    DUCKDB_TYPE_SMALLINT
    DUCKDB_TYPE_INTEGER
    DUCKDB_TYPE_BIGINT
    DUCKDB_TYPE_UTINYINT
    DUCKDB_TYPE_USMALLINT
    DUCKDB_TYPE_UINTEGER
    DUCKDB_TYPE_UBIGINT
    DUCKDB_TYPE_FLOAT
    DUCKDB_TYPE_DOUBLE
    DUCKDB_TYPE_TIMESTAMP
    DUCKDB_TYPE_DATE
    DUCKDB_TYPE_TIME
    DUCKDB_TYPE_INTERVAL
    DUCKDB_TYPE_HUGEINT
    DUCKDB_TYPE_VARCHAR
    DUCKDB_TYPE_BLOB
    DUCKDB_TYPE_DECIMAL
    DUCKDB_TYPE_TIMESTAMP_S
    DUCKDB_TYPE_TIMESTAMP_MS
    DUCKDB_TYPE_TIMESTAMP_NS
    DUCKDB_TYPE_ENUM
    DUCKDB_TYPE_LIST
    DUCKDB_TYPE_STRUCT
    DUCKDB_TYPE_MAP
    DUCKDB_TYPE_UUID
    DUCKDB_TYPE_UNION
    DUCKDB_TYPE_BIT
    DUCKDB_TYPE_TIME_TZ
    DUCKDB_TYPE_TIMESTAMP_TZ
    DUCKDB_TYPE_UHUGEINT
    DUCKDB_TYPE_ARRAY
    DUCKDB_TYPE_ANY
    DUCKDB_TYPE_BIGNUM
    DUCKDB_TYPE_SQLNULL
    DUCKDB_TYPE_STRING_LITERAL
    DUCKDB_TYPE_INTEGER_LITERAL
    DUCKDB_TYPE_TIME_NS
);

our @DUCKDB_STATES = qw(
    DUCKDB_SUCCESS
    DUCKDB_ERROR
);

our @DUCKDB_PENDING_STATES = qw(
    DUCKDB_PENDING_RESULT_READY
    DUCKDB_PENDING_RESULT_NOT_READY
    DUCKDB_PENDING_ERROR
    DUCKDB_PENDING_NO_TASKS_AVAILABLE
);

our @DUCKDB_RESULT_TYPES = qw(
    DUCKDB_RESULT_TYPE_INVALID
    DUCKDB_RESULT_TYPE_CHANGED_ROWS
    DUCKDB_RESULT_TYPE_NOTHING
    DUCKDB_RESULT_TYPE_QUERY_RESULT
);

our @DUCKDB_STATEMENT_TYPES = qw(
    DUCKDB_STATEMENT_TYPE_INVALID
    DUCKDB_STATEMENT_TYPE_SELECT
    DUCKDB_STATEMENT_TYPE_INSERT
    DUCKDB_STATEMENT_TYPE_UPDATE
    DUCKDB_STATEMENT_TYPE_EXPLAIN
    DUCKDB_STATEMENT_TYPE_DELETE
    DUCKDB_STATEMENT_TYPE_PREPARE
    DUCKDB_STATEMENT_TYPE_CREATE
    DUCKDB_STATEMENT_TYPE_EXECUTE
    DUCKDB_STATEMENT_TYPE_ALTER
    DUCKDB_STATEMENT_TYPE_TRANSACTION
    DUCKDB_STATEMENT_TYPE_COPY
    DUCKDB_STATEMENT_TYPE_ANALYZE
    DUCKDB_STATEMENT_TYPE_VARIABLE_SET
    DUCKDB_STATEMENT_TYPE_CREATE_FUNC
    DUCKDB_STATEMENT_TYPE_DROP
    DUCKDB_STATEMENT_TYPE_EXPORT
    DUCKDB_STATEMENT_TYPE_PRAGMA
    DUCKDB_STATEMENT_TYPE_VACUUM
    DUCKDB_STATEMENT_TYPE_CALL
    DUCKDB_STATEMENT_TYPE_SET
    DUCKDB_STATEMENT_TYPE_LOAD
    DUCKDB_STATEMENT_TYPE_RELATION
    DUCKDB_STATEMENT_TYPE_EXTENSION
    DUCKDB_STATEMENT_TYPE_LOGICAL_PLAN
    DUCKDB_STATEMENT_TYPE_ATTACH
    DUCKDB_STATEMENT_TYPE_DETACH
    DUCKDB_STATEMENT_TYPE_MULTI
);

our @DUCKDB_ERROR_TYPES = qw(
    DUCKDB_ERROR_INVALID
    DUCKDB_ERROR_OUT_OF_RANGE
    DUCKDB_ERROR_CONVERSION
    DUCKDB_ERROR_UNKNOWN_TYPE
    DUCKDB_ERROR_DECIMAL
    DUCKDB_ERROR_MISMATCH_TYPE
    DUCKDB_ERROR_DIVIDE_BY_ZERO
    DUCKDB_ERROR_OBJECT_SIZE
    DUCKDB_ERROR_INVALID_TYPE
    DUCKDB_ERROR_SERIALIZATION
    DUCKDB_ERROR_TRANSACTION
    DUCKDB_ERROR_NOT_IMPLEMENTED
    DUCKDB_ERROR_EXPRESSION
    DUCKDB_ERROR_CATALOG
    DUCKDB_ERROR_PARSER
    DUCKDB_ERROR_PLANNER
    DUCKDB_ERROR_SCHEDULER
    DUCKDB_ERROR_EXECUTOR
    DUCKDB_ERROR_CONSTRAINT
    DUCKDB_ERROR_INDEX
    DUCKDB_ERROR_STAT
    DUCKDB_ERROR_CONNECTION
    DUCKDB_ERROR_SYNTAX
    DUCKDB_ERROR_SETTINGS
    DUCKDB_ERROR_BINDER
    DUCKDB_ERROR_NETWORK
    DUCKDB_ERROR_OPTIMIZER
    DUCKDB_ERROR_NULL_POINTER
    DUCKDB_ERROR_IO
    DUCKDB_ERROR_INTERRUPT
    DUCKDB_ERROR_FATAL
    DUCKDB_ERROR_INTERNAL
    DUCKDB_ERROR_INVALID_INPUT
    DUCKDB_ERROR_OUT_OF_MEMORY
    DUCKDB_ERROR_PERMISSION
    DUCKDB_ERROR_PARAMETER_NOT_RESOLVED
    DUCKDB_ERROR_PARAMETER_NOT_ALLOWED
    DUCKDB_ERROR_DEPENDENCY
    DUCKDB_ERROR_HTTP
    DUCKDB_ERROR_MISSING_EXTENSION
    DUCKDB_ERROR_AUTOLOAD
    DUCKDB_ERROR_SEQUENCE
    DUCKDB_INVALID_CONFIGURATION
);

our @DUCKDB_CAST_MODES = qw(
    DUCKDB_CAST_NORMAL
    DUCKDB_CAST_TRY
);

our @EXPORT = (
    @DUCKDB_TYPES,           @DUCKDB_STATES,      @DUCKDB_PENDING_STATES, @DUCKDB_RESULT_TYPES,
    @DUCKDB_STATEMENT_TYPES, @DUCKDB_ERROR_TYPES, @DUCKDB_CAST_MODES
);

our %EXPORT_TAGS = (
    all                    => \@EXPORT,
    duckdb_types           => \@DUCKDB_TYPES,
    duckdb_states          => \@DUCKDB_STATES,
    duckdb_pending_states  => \@DUCKDB_PENDING_STATES,
    duckdb_result_types    => \@DUCKDB_RESULT_TYPES,
    duckdb_statement_types => \@DUCKDB_STATEMENT_TYPES,
    duckdb_error_types     => \@DUCKDB_ERROR_TYPES,
    duckdb_cast_modes      => \@DUCKDB_CAST_MODES,
);

# enum duckdb_type
use constant {
    DUCKDB_TYPE_INVALID         => 0,
    DUCKDB_TYPE_BOOLEAN         => 1,     # bool
    DUCKDB_TYPE_TINYINT         => 2,     # int8_t
    DUCKDB_TYPE_SMALLINT        => 3,     # int16_t
    DUCKDB_TYPE_INTEGER         => 4,     # int32_t
    DUCKDB_TYPE_BIGINT          => 5,     # int64_t
    DUCKDB_TYPE_UTINYINT        => 6,     # uint8_t
    DUCKDB_TYPE_USMALLINT       => 7,     # uint16_t
    DUCKDB_TYPE_UINTEGER        => 8,     # uint32_t
    DUCKDB_TYPE_UBIGINT         => 9,     # uint64_t
    DUCKDB_TYPE_FLOAT           => 10,    # float
    DUCKDB_TYPE_DOUBLE          => 11,    # double
    DUCKDB_TYPE_TIMESTAMP       => 12,    # duckdb_timestamp (microseconds)
    DUCKDB_TYPE_DATE            => 13,    # duckdb_date
    DUCKDB_TYPE_TIME            => 14,    # duckdb_time
    DUCKDB_TYPE_INTERVAL        => 15,    # duckdb_interval
    DUCKDB_TYPE_HUGEINT         => 16,    # duckdb_hugeint
    DUCKDB_TYPE_VARCHAR         => 17,    # const char*
    DUCKDB_TYPE_BLOB            => 18,    # duckdb_blob
    DUCKDB_TYPE_DECIMAL         => 19,    # duckdb_decimal
    DUCKDB_TYPE_TIMESTAMP_S     => 20,    # duckdb_timestamp_s (seconds)
    DUCKDB_TYPE_TIMESTAMP_MS    => 21,    # duckdb_timestamp_ms (milliseconds)
    DUCKDB_TYPE_TIMESTAMP_NS    => 22,    # duckdb_timestamp_ns (nanoseconds)
    DUCKDB_TYPE_ENUM            => 23,    # enum type, only useful as logical type
    DUCKDB_TYPE_LIST            => 24,    # list type, only useful as logical type
    DUCKDB_TYPE_STRUCT          => 25,    # struct type, only useful as logical type
    DUCKDB_TYPE_MAP             => 26,    # map type, only useful as logical type
    DUCKDB_TYPE_UUID            => 27,    # duckdb_hugeint
    DUCKDB_TYPE_UNION           => 28,    # union type, only useful as logical type
    DUCKDB_TYPE_BIT             => 29,    # duckdb_bit
    DUCKDB_TYPE_TIME_TZ         => 30,    # duckdb_time_tz
    DUCKDB_TYPE_TIMESTAMP_TZ    => 31,    # duckdb_timestamp (microseconds)
    DUCKDB_TYPE_UHUGEINT        => 32,    # duckdb_uhugeint
    DUCKDB_TYPE_ARRAY           => 33,    # duckdb_array, only useful as logical type
    DUCKDB_TYPE_ANY             => 34,    # enum type, only useful as logical type
    DUCKDB_TYPE_BIGNUM          => 35,    # duckdb_bignum
    DUCKDB_TYPE_SQLNULL         => 36,    # enum type, only useful as logical type
    DUCKDB_TYPE_STRING_LITERAL  => 37,    # enum type, only useful as logical type
    DUCKDB_TYPE_INTEGER_LITERAL => 38,    # enum type, only useful as logical type
    DUCKDB_TYPE_TIME_NS         => 39,    # duckdb_time_ns (nanoseconds)
};

# enum duckdb_state
use constant {DUCKDB_SUCCESS => 0, DUCKDB_ERROR => 1};

# enum duckdb_pending_state
use constant {
    DUCKDB_PENDING_RESULT_READY       => 0,
    DUCKDB_PENDING_RESULT_NOT_READY   => 1,
    DUCKDB_PENDING_ERROR              => 2,
    DUCKDB_PENDING_NO_TASKS_AVAILABLE => 3
};

# enum duckdb_result_type
use constant {
    DUCKDB_RESULT_TYPE_INVALID      => 0,
    DUCKDB_RESULT_TYPE_CHANGED_ROWS => 1,
    DUCKDB_RESULT_TYPE_NOTHING      => 2,
    DUCKDB_RESULT_TYPE_QUERY_RESULT => 3,
};

# enum duckdb_statement_type
use constant {
    DUCKDB_STATEMENT_TYPE_INVALID      => 0,
    DUCKDB_STATEMENT_TYPE_SELECT       => 1,
    DUCKDB_STATEMENT_TYPE_INSERT       => 2,
    DUCKDB_STATEMENT_TYPE_UPDATE       => 3,
    DUCKDB_STATEMENT_TYPE_EXPLAIN      => 4,
    DUCKDB_STATEMENT_TYPE_DELETE       => 5,
    DUCKDB_STATEMENT_TYPE_PREPARE      => 6,
    DUCKDB_STATEMENT_TYPE_CREATE       => 7,
    DUCKDB_STATEMENT_TYPE_EXECUTE      => 8,
    DUCKDB_STATEMENT_TYPE_ALTER        => 9,
    DUCKDB_STATEMENT_TYPE_TRANSACTION  => 10,
    DUCKDB_STATEMENT_TYPE_COPY         => 11,
    DUCKDB_STATEMENT_TYPE_ANALYZE      => 12,
    DUCKDB_STATEMENT_TYPE_VARIABLE_SET => 13,
    DUCKDB_STATEMENT_TYPE_CREATE_FUNC  => 14,
    DUCKDB_STATEMENT_TYPE_DROP         => 15,
    DUCKDB_STATEMENT_TYPE_EXPORT       => 16,
    DUCKDB_STATEMENT_TYPE_PRAGMA       => 17,
    DUCKDB_STATEMENT_TYPE_VACUUM       => 18,
    DUCKDB_STATEMENT_TYPE_CALL         => 19,
    DUCKDB_STATEMENT_TYPE_SET          => 20,
    DUCKDB_STATEMENT_TYPE_LOAD         => 21,
    DUCKDB_STATEMENT_TYPE_RELATION     => 22,
    DUCKDB_STATEMENT_TYPE_EXTENSION    => 23,
    DUCKDB_STATEMENT_TYPE_LOGICAL_PLAN => 24,
    DUCKDB_STATEMENT_TYPE_ATTACH       => 25,
    DUCKDB_STATEMENT_TYPE_DETACH       => 26,
    DUCKDB_STATEMENT_TYPE_MULTI        => 27,
};

# enum duckdb_error_type
use constant {
    DUCKDB_ERROR_INVALID                => 0,
    DUCKDB_ERROR_OUT_OF_RANGE           => 1,
    DUCKDB_ERROR_CONVERSION             => 2,
    DUCKDB_ERROR_UNKNOWN_TYPE           => 3,
    DUCKDB_ERROR_DECIMAL                => 4,
    DUCKDB_ERROR_MISMATCH_TYPE          => 5,
    DUCKDB_ERROR_DIVIDE_BY_ZERO         => 6,
    DUCKDB_ERROR_OBJECT_SIZE            => 7,
    DUCKDB_ERROR_INVALID_TYPE           => 8,
    DUCKDB_ERROR_SERIALIZATION          => 9,
    DUCKDB_ERROR_TRANSACTION            => 10,
    DUCKDB_ERROR_NOT_IMPLEMENTED        => 11,
    DUCKDB_ERROR_EXPRESSION             => 12,
    DUCKDB_ERROR_CATALOG                => 13,
    DUCKDB_ERROR_PARSER                 => 14,
    DUCKDB_ERROR_PLANNER                => 15,
    DUCKDB_ERROR_SCHEDULER              => 16,
    DUCKDB_ERROR_EXECUTOR               => 17,
    DUCKDB_ERROR_CONSTRAINT             => 18,
    DUCKDB_ERROR_INDEX                  => 19,
    DUCKDB_ERROR_STAT                   => 20,
    DUCKDB_ERROR_CONNECTION             => 21,
    DUCKDB_ERROR_SYNTAX                 => 22,
    DUCKDB_ERROR_SETTINGS               => 23,
    DUCKDB_ERROR_BINDER                 => 24,
    DUCKDB_ERROR_NETWORK                => 25,
    DUCKDB_ERROR_OPTIMIZER              => 26,
    DUCKDB_ERROR_NULL_POINTER           => 27,
    DUCKDB_ERROR_IO                     => 28,
    DUCKDB_ERROR_INTERRUPT              => 29,
    DUCKDB_ERROR_FATAL                  => 30,
    DUCKDB_ERROR_INTERNAL               => 31,
    DUCKDB_ERROR_INVALID_INPUT          => 32,
    DUCKDB_ERROR_OUT_OF_MEMORY          => 33,
    DUCKDB_ERROR_PERMISSION             => 34,
    DUCKDB_ERROR_PARAMETER_NOT_RESOLVED => 35,
    DUCKDB_ERROR_PARAMETER_NOT_ALLOWED  => 36,
    DUCKDB_ERROR_DEPENDENCY             => 37,
    DUCKDB_ERROR_HTTP                   => 38,
    DUCKDB_ERROR_MISSING_EXTENSION      => 39,
    DUCKDB_ERROR_AUTOLOAD               => 40,
    DUCKDB_ERROR_SEQUENCE               => 41,
    DUCKDB_INVALID_CONFIGURATION        => 42
};

# enum
use constant {DUCKDB_CAST_NORMAL => 0, DUCKDB_CAST_TRY => 1};

my $_i = 0;
our %DUCKDB_TYPE_IDS = map { $_i++ => $_ } @DUCKDB_TYPES;

sub DUCKDB_TYPE { $DUCKDB_TYPE_IDS{$_[1]} }

1;

__END__

=pod

=encoding UTF-8

=head1 NAME

DBD::DuckDB::Constants - Constants for DuckDB

    use DBI;
    use DBD::DuckDB::Constants qw(:duckdb_types);

=head1 CONSTANTS

=head2 :duckdb_types

=over

=item * DUCKDB_TYPE_INVALID

=item * DUCKDB_TYPE_BOOLEAN

=item * DUCKDB_TYPE_TINYINT

=item * DUCKDB_TYPE_SMALLINT

=item * DUCKDB_TYPE_INTEGER

=item * DUCKDB_TYPE_BIGINT

=item * DUCKDB_TYPE_UTINYINT

=item * DUCKDB_TYPE_USMALLINT

=item * DUCKDB_TYPE_UINTEGER

=item * DUCKDB_TYPE_UBIGINT

=item * DUCKDB_TYPE_FLOAT

=item * DUCKDB_TYPE_DOUBLE

=item * DUCKDB_TYPE_TIMESTAMP

=item * DUCKDB_TYPE_DATE

=item * DUCKDB_TYPE_TIME

=item * DUCKDB_TYPE_INTERVAL

=item * DUCKDB_TYPE_HUGEINT

=item * DUCKDB_TYPE_UHUGEINT

=item * DUCKDB_TYPE_VARCHAR

=item * DUCKDB_TYPE_BLOB

=item * DUCKDB_TYPE_DECIMAL

=item * DUCKDB_TYPE_TIMESTAMP_S

=item * DUCKDB_TYPE_TIMESTAMP_MS

=item * DUCKDB_TYPE_TIMESTAMP_NS

=item * DUCKDB_TYPE_ENUM

=item * DUCKDB_TYPE_LIST

=item * DUCKDB_TYPE_STRUCT

=item * DUCKDB_TYPE_MAP

=item * DUCKDB_TYPE_ARRAY

=item * DUCKDB_TYPE_UUID

=item * DUCKDB_TYPE_UNION

=item * DUCKDB_TYPE_BIT

=item * DUCKDB_TYPE_TIME_TZ

=item * DUCKDB_TYPE_TIMESTAMP_TZ

=item * DUCKDB_TYPE_ANY

=item * DUCKDB_TYPE_BIGNUM

=item * DUCKDB_TYPE_SQLNULL

=item * DUCKDB_TYPE_STRING_LITERAL

=item * DUCKDB_TYPE_INTEGER_LITERAL

=item * DUCKDB_TYPE_TIME_NS

=back


=head2 :duckdb_states

=over

=item * DUCKDB_SUCCESS

=item * DUCKDB_ERROR

=back


=head2 :duckdb_pending_states

=over

=item * DUCKDB_PENDING_RESULT_READY

=item * DUCKDB_PENDING_RESULT_NOT_READY

=item * DUCKDB_PENDING_ERROR

=item * DUCKDB_PENDING_NO_TASKS_AVAILABLE

=back


=head2 :duckdb_result_types

=over

=item * DUCKDB_RESULT_TYPE_INVALID

=item * DUCKDB_RESULT_TYPE_CHANGED_ROWS

=item * DUCKDB_RESULT_TYPE_NOTHING

=item * DUCKDB_RESULT_TYPE_QUERY_RESULT

=back


=head2 :duckdb_statement_types

=over

=item * DUCKDB_STATEMENT_TYPE_INVALID

=item * DUCKDB_STATEMENT_TYPE_SELECT

=item * DUCKDB_STATEMENT_TYPE_INSERT

=item * DUCKDB_STATEMENT_TYPE_UPDATE

=item * DUCKDB_STATEMENT_TYPE_EXPLAIN

=item * DUCKDB_STATEMENT_TYPE_DELETE

=item * DUCKDB_STATEMENT_TYPE_PREPARE

=item * DUCKDB_STATEMENT_TYPE_CREATE

=item * DUCKDB_STATEMENT_TYPE_EXECUTE

=item * DUCKDB_STATEMENT_TYPE_ALTER

=item * DUCKDB_STATEMENT_TYPE_TRANSACTION

=item * DUCKDB_STATEMENT_TYPE_COPY

=item * DUCKDB_STATEMENT_TYPE_ANALYZE

=item * DUCKDB_STATEMENT_TYPE_VARIABLE_SET

=item * DUCKDB_STATEMENT_TYPE_CREATE_FUNC

=item * DUCKDB_STATEMENT_TYPE_DROP

=item * DUCKDB_STATEMENT_TYPE_EXPORT

=item * DUCKDB_STATEMENT_TYPE_PRAGMA

=item * DUCKDB_STATEMENT_TYPE_VACUUM

=item * DUCKDB_STATEMENT_TYPE_CALL

=item * DUCKDB_STATEMENT_TYPE_SET

=item * DUCKDB_STATEMENT_TYPE_LOAD

=item * DUCKDB_STATEMENT_TYPE_RELATION

=item * DUCKDB_STATEMENT_TYPE_EXTENSION

=item * DUCKDB_STATEMENT_TYPE_LOGICAL_PLAN

=item * DUCKDB_STATEMENT_TYPE_ATTACH

=item * DUCKDB_STATEMENT_TYPE_DETACH

=item * DUCKDB_STATEMENT_TYPE_MULTI

=back


=head2 :duckdb_error_types

=over

=item * DUCKDB_ERROR_INVALID

=item * DUCKDB_ERROR_OUT_OF_RANGE

=item * DUCKDB_ERROR_CONVERSION

=item * DUCKDB_ERROR_UNKNOWN_TYPE

=item * DUCKDB_ERROR_DECIMAL

=item * DUCKDB_ERROR_MISMATCH_TYPE

=item * DUCKDB_ERROR_DIVIDE_BY_ZERO

=item * DUCKDB_ERROR_OBJECT_SIZE

=item * DUCKDB_ERROR_INVALID_TYPE

=item * DUCKDB_ERROR_SERIALIZATION

=item * DUCKDB_ERROR_TRANSACTION

=item * DUCKDB_ERROR_NOT_IMPLEMENTED

=item * DUCKDB_ERROR_EXPRESSION

=item * DUCKDB_ERROR_CATALOG

=item * DUCKDB_ERROR_PARSER

=item * DUCKDB_ERROR_PLANNER

=item * DUCKDB_ERROR_SCHEDULER

=item * DUCKDB_ERROR_EXECUTOR

=item * DUCKDB_ERROR_CONSTRAINT

=item * DUCKDB_ERROR_INDEX

=item * DUCKDB_ERROR_STAT

=item * DUCKDB_ERROR_CONNECTION

=item * DUCKDB_ERROR_SYNTAX

=item * DUCKDB_ERROR_SETTINGS

=item * DUCKDB_ERROR_BINDER

=item * DUCKDB_ERROR_NETWORK

=item * DUCKDB_ERROR_OPTIMIZER

=item * DUCKDB_ERROR_NULL_POINTER

=item * DUCKDB_ERROR_IO

=item * DUCKDB_ERROR_INTERRUPT

=item * DUCKDB_ERROR_FATAL

=item * DUCKDB_ERROR_INTERNAL

=item * DUCKDB_ERROR_INVALID_INPUT

=item * DUCKDB_ERROR_OUT_OF_MEMORY

=item * DUCKDB_ERROR_PERMISSION

=item * DUCKDB_ERROR_PARAMETER_NOT_RESOLVED

=item * DUCKDB_ERROR_PARAMETER_NOT_ALLOWED

=item * DUCKDB_ERROR_DEPENDENCY

=item * DUCKDB_ERROR_HTTP

=item * DUCKDB_ERROR_MISSING_EXTENSION

=item * DUCKDB_ERROR_AUTOLOAD

=item * DUCKDB_ERROR_SEQUENCE

=item * DUCKDB_INVALID_CONFIGURATION

=back


=head1 SUPPORT

=head2 Bugs / Feature Requests

Please report any bugs or feature requests through the issue tracker
at L<https://github.com/giterlizzi/perl-DBD-DuckDB/issues>.
You will be notified automatically of any progress on your issue.

=head2 Source Code

This is open source software.  The code repository is available for
public review and contribution under the terms of the license.

L<https://github.com/giterlizzi/perl-DBD-DuckDB>

    git clone https://github.com/giterlizzi/perl-DBD-DuckDB.git


=head1 AUTHOR

=over 4

=item * Giuseppe Di Terlizzi <gdt@cpan.org>

=back


=head1 LICENSE AND COPYRIGHT

This software is copyright (c) 2024-2025 by Giuseppe Di Terlizzi.

This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.

=cut
