DBIx-QuickORM

 view release on metacpan or  search on metacpan

lib/DBIx/QuickORM.pm  view on Meta::CPAN

        my $class = delete($spec->{column_class}) || $params{column_class} || ($state->{SCHEMA} ? $state->{SCHEMA}->{column_class} : undef ) || 'DBIx::QuickORM::Table::Column';
        eval { require(mod2file($class)); 1 } or die "Could not load column class '$class': $@";
        $params{columns}{$cname} = $class->new(%$spec);
    }

    my $class = delete($params{table_class}) // 'DBIx::QuickORM::Table';
    eval { require(mod2file($class)); 1 } or croak "Could not load class $class: $@";
    return $class->new(%params);
}

# sub update_table {
build_top_builder update_table => sub {
    my %params = @_;

    my $args   = $params{args};
    my $state  = $params{state};
    my $caller = $params{caller};

    my ($name, $cb) = @$args;

    my $schema = _get_schema() or croak "table() can only be used inside a schema builder";

lib/DBIx/QuickORM/DB.pm  view on Meta::CPAN

sub supports_json { () }
sub supports_datetime { 'DATETIME' }

sub supports_async  { 0 }
sub async_query_arg { croak "$_[0]->async_query_arg() is not implemented" }
sub async_ready     { croak "$_[0]->async_ready() is not implemented" }
sub async_result    { croak "$_[0]->async_result() is not implemented" }
sub async_cancel    { croak "$_[0]->async_cancel() is not implemented" }

sub insert_returning_supported { 0 }
sub update_returning_supported { 0 }

sub ping { $_[1]->ping }

sub driver_name {
    my $self_or_class = shift;
    my $class = blessed($self_or_class) || $self_or_class;
    $class =~ s/^DBIx::QuickORM::DB:://;
    return $class;
}

lib/DBIx/QuickORM/DB/MariaDB.pm  view on Meta::CPAN

use DBD::MariaDB;

use parent 'DBIx::QuickORM::DB::MySQL';
use DBIx::QuickORM::Util::HashBase;

sub sql_spec_keys { qw/mariadb mysql/ }
sub dsn_socket_field { 'mariadb_socket' };

sub insert_returning_supported { 1 }
sub update_returning_supported { 0 }

sub supports_datetime { 'DATETIME(6)' }

sub supports_uuid {
    my $self = shift;
    my ($dbh) = @_;

    return 'UUID' unless $dbh;

    my $ver = $self->db_version($dbh);

lib/DBIx/QuickORM/DB/PostgreSQL.pm  view on Meta::CPAN

sub quote_index_columns  { 0 }

sub start_txn    { $_[1]->begin_work }
sub commit_txn   { $_[1]->commit }
sub rollback_txn { $_[1]->rollback }

sub create_savepoint   { $_[1]->pg_savepoint($_[2]) }
sub commit_savepoint   { $_[1]->pg_release($_[2]) }
sub rollback_savepoint { $_[1]->pg_rollback_to($_[2]) }

sub update_returning_supported { 1 }
sub insert_returning_supported { 1 }

sub supports_datetime { 'TIMESTAMPTZ(6)' }

sub supports_uuid {
    my $self = shift;
    my ($dbh) = @_;

    return 'UUID' unless $dbh;

lib/DBIx/QuickORM/DB/SQLite.pm  view on Meta::CPAN

sub dbi_driver { 'DBD::SQLite' }
sub datetime_formatter { 'DateTime::Format::SQLite' }

sub sql_spec_keys { 'sqlite' }

sub temp_table_supported { 1 }
sub temp_view_supported  { 1 }
sub quote_index_columns  { 1 }

sub update_returning_supported { 1 }
sub insert_returning_supported { 1 }

sub start_txn    { $_[1]->begin_work }
sub commit_txn   { $_[1]->commit }
sub rollback_txn { $_[1]->rollback }

sub create_savepoint   { $_[1]->do("SAVEPOINT $_[2]") }
sub commit_savepoint   { $_[1]->do("RELEASE SAVEPOINT $_[2]") }
sub rollback_savepoint { $_[1]->do("ROLLBACK TO SAVEPOINT $_[2]") }

lib/DBIx/QuickORM/ORM.pm  view on Meta::CPAN

sub count            { my ($self, $source, @args) = @_; $self->source($source)->count(@args) }
sub find             { my ($self, $source, @args) = @_; $self->source($source)->find(@args) }
sub find_or_insert   { my ($self, $source, @args) = @_; $self->source($source)->find_or_insert(@args) }
sub first            { my ($self, $source, @args) = @_; $self->source($source)->first(@args) }
sub forked           { my ($self, $source, @args) = @_; $self->source($source)->forked(@args) }
sub insert           { my ($self, $source, @args) = @_; $self->source($source)->insert(@args) }
sub insert_row       { my ($self, $source, @args) = @_; $self->source($source)->insert_row(@args) }
sub last             { my ($self, $source, @args) = @_; $self->source($source)->last(@args) }
sub relations        { my ($self, $source, @args) = @_; $self->source($source)->relations(@args) }
sub select           { my ($self, $source, @args) = @_; $self->source($source)->select(@args) }
sub update           { my ($self, $source, @args) = @_; $self->source($source)->update(@args) }
sub update_or_insert { my ($self, $source, @args) = @_; $self->source($source)->update_or_insert(@args) }

sub shotgun { die "FIXME" }

sub source {
    my $self = shift;
    my ($name) = @_;

    croak "source() requires a table/view name" unless $name;

    return $self->{+TEMP_SOURCES}->{$name} if $self->{+TEMP_SOURCES}->{$name};

lib/DBIx/QuickORM/Row.pm  view on Meta::CPAN

sub save {
    my $self = shift;

    $self->verify_row;

    return $self->update if $self->{+STORED};
    return $self->insert;
}

sub update {
    my $self = shift;
    my $row_data = $self->parse_hash_arg(@_);

    $self->verify_row;

    croak "Object is not yet in the database, use insert or save" unless $self->{+STORED};

    my $source = $self->real_source;
    my $orm = $source->orm;
    my $cache = $orm->cache;

lib/DBIx/QuickORM/Select.pm  view on Meta::CPAN

        *$clear_meth   = set_subname($clear_meth   => $clear);
        *$with_meth    = set_subname($with_meth    => $with);
        *$without_meth = set_subname($without_meth => $without);
    }
}

sub orm              { $_[0]->{+SOURCE}->orm }
sub find_or_insert   { shift->{+SOURCE}->find_or_insert(@_) }
sub insert           { shift->{+SOURCE}->insert(@_) }
sub insert_row       { shift->{+SOURCE}->insert_row(@_) }
sub update_or_insert { shift->{+SOURCE}->update_or_insert(@_) }
sub table            { shift->{+SOURCE}->table(@_) }
sub select           { shift->{+SOURCE}->select(@_) }

sub update { die "FIXME" }

sub params {
    my $self = shift;

    return $self->{+PARAMS} if $self->{+PARAMS};

    my %out = (
        WHERE() => $self->{+WHERE} // {},
    );

lib/DBIx/QuickORM/Source.pm  view on Meta::CPAN

    <locator
    <created
};

use Role::Tiny::With qw/with/;
with 'DBIx::QuickORM::Role::SelectLike';
with 'DBIx::QuickORM::Role::HasORM';

sub source  { $_[0] }
sub count   { shift->select()->count(@_) }
sub update  { shift->select()->update(@_) }
sub shotgun { shift->select()->shotgun(@_) }

sub table_name { $_[0]->{+TABLE_NAME} //= $_[0]->{+TABLE}->name }

sub relations { die "Fixme" }

sub init {
    my $self = shift;

    my $table = $self->{+TABLE} or croak "The 'table' attribute must be provided";

 view all matches for this distribution
 view release on metacpan -  search on metacpan