view release on metacpan or  search on metacpan

lib/DB/Object/Tables.pm  view on Meta::CPAN

        $self->reset;
        return( $val );
    }
}

sub limit { return( shift->_method_to_query( 'limit', @_ ) ); }

sub local { return( shift->_method_to_query( 'local', @_ ) ); }

sub lock
{
    my $self = shift( @_ );
    my $class = ref( $self );
    return( $self->error( "lock() is not implemented by $class." ) );
}

sub name
{
    # Read-only
    return( shift->{table} );
}

sub new_check
{
    my $self = shift( @_ );
    my $args = $self->_get_args_as_hash( @_ );
    $self->_load_class( 'DB::Object::Constraint::Check' ) ||
        return( $self->pass_error );
    $args->{debug} = $self->debug if( !CORE::exists( $args->{debug} ) || !defined( $args->{debug} ) );
    my $this = DB::Object::Constraint::Check->new( %$args ) ||
        return( $self->pass_error( DB::Object::Constraint::Check->error ) );
    return( $this );
}

sub new_foreign
{
    my $self = shift( @_ );
    my $args = $self->_get_args_as_hash( @_ );
    $self->_load_class( 'DB::Object::Constraint::Foreign' ) ||
        return( $self->pass_error );
    $args->{debug} = $self->debug if( !CORE::exists( $args->{debug} ) || !defined( $args->{debug} ) );
    my $this = DB::Object::Constraint::Foreign->new( %$args ) ||
        return( $self->pass_error( DB::Object::Constraint::Foreign->error ) );
    return( $this );
}

sub new_index
{
    my $self = shift( @_ );
    my $args = $self->_get_args_as_hash( @_ );
    $self->_load_class( 'DB::Object::Constraint::Index' ) ||
        return( $self->pass_error );
    $args->{debug} = $self->debug if( !CORE::exists( $args->{debug} ) || !defined( $args->{debug} ) );
    my $this = DB::Object::Constraint::Index->new( %$args ) ||
        return( $self->pass_error( DB::Object::Constraint::Index->error ) );
    return( $this );
}

sub no_bind { return( shift->_set_get_boolean({
    field => 'no_bind',
    callbacks =>
    {
        set => sub
        {
            my $self = shift( @_ );
            my $val = shift( @_ );
            return if( !defined( $val ) );
            return( $val ) if( !$val );
            my $q = $self->_reset_query;
            my $where = $q->where();
            my $group = $q->group();
            my $order = $q->order();
            my $limit = $q->limit();
            my $binded_where = $q->binded_where;
            my $binded_group = $q->binded_group;
            my $binded_order = $q->binded_order;
            my $binded_limit = $q->binded_limit;
            # Replace the placeholders by their corresponding value
            # and have them re-processed by their corresponding method
            if( $where && @$binded_where )
            {
                $where =~ s/(=\s*\?)/"='" . quotemeta( $binded_where->[ $#+ ] ) . "'"/ge;
                $self->where( $where );
            }
            if( $group && @$binded_group )
            {
                $group =~ s/(=\s*\?)/"='" . quotemeta( $binded_group->[ $#+ ] ) . "'"/ge;
                $self->group( $group );
            }
            if( $order && @$binded_order )
            {
                $order =~ s/(=\s*\?)/"='" . quotemeta( $binded_order->[ $#+ ] ) . "'"/ge;
                $self->order( $order );
            }
            if( $limit && @$binded_limit )
            {
                # $limit =~ s/(=\s*\?)/"='" . quotemeta( $binded_limit[ $#+ ] ) . "'"/ge;
                $self->limit( @$binded_limit );
            }
            $q->reset_bind;
            return( $val );
        },
    }
}, @_ ) ); }

sub null
{
    my $self = shift( @_ );
    $self->structure || return( $self->pass_error );
    my $fields = $self->fields;
    # my $null = $self->{null};
    my $null = +{ map{ $_ => ( $fields->{ $_ }->is_nullable ? 1 : 0 ) } keys( %$fields ) };
    return( $self->_clone( $null ) );
}

sub on_conflict { return( shift->error( "The on conflict clause is not supported by this driver." ) ); }

sub optimize
{
    my $self = shift( @_ );
    my $class = ref( $self );