DB-Object

 view release on metacpan or  search on metacpan

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

        if( $cache_file->exists &&
            $cache_file->is_file &&
            !$cache_file->is_empty )
        {
            return( $sth );
        }
        $self->Module::Generic::serialise( $sth,
            file       => $cache_file,
            lock       => 1,
            serialiser => $serialiser,
            ( $serialiser eq 'Sereal' ? ( freeze_callbacks => 1 ) : () ),
        ) || return( $self->pass_error );
    }
    elsif( $cache_query )
    {
        $repo->set( $sth );
        $repo->unlock;
    }
    return( $sth );
}

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

            return( $self->error( "No table name associated with this table object." ) );
        if( $name !~ /^\w+[\w\-\.]*$/ )
        {
            return( $self->error( "The table name '$name' contains illegal characters." ) );
        }
        my $file = $cache_dir->child( "${prefix}-${name}.bin" );
        my $tbl  = $self->Module::Generic::serialise( $table,
            file => $file,
            lock => 1,
            serialiser => $serialiser,
            ( $serialiser eq 'Sereal' ? ( freeze_callbacks => 1 ) : () ),
        ) || return( $self->pass_error );
        return(1);
    }
    # The user has provided a table name, and thus expects the related cloned table object from the cache table repository.
    # This is accessor mode.
    elsif( !ref( $table ) || ( ref( $table ) && $self->_can_overload( $table => '""' ) ) )
    {
        $table = "$table";
        if( $table !~ /^\w+[\w\-\.]*$/ )
        {

lib/DB/Object/Query/Element.pm  view on Meta::CPAN

    if( $placeholder =~ /^$placeholder_re$/ && defined( $+{index} ) )
    {
        return(1);
    }
    return(0);
}

# The placeholder, such as ?, $2, ?2, or others supported by the driver
sub placeholder { return( shift->_set_get_scalar_as_object({
    field => 'placeholder',
    callbacks => 
    {
        set => sub
        {
            # $val is a scalar object (Module::Generic::Scalar)
            my( $self, $val ) = @_;
            my $placeholder_re = $self->query_object->database_object->_placeholder_regexp;
            return( $val ) if( $self->_is_scalar( $val ) && $self->_can( $val => 'defined' ) && !$val->defined );
            if( defined( $val ) && "$val" =~ /^(?:$placeholder_re)$/ )
            {
                # Could be undef

lib/DB/Object/Query/Element.pm  view on Meta::CPAN

            }
            return( $val );
        }
    }
}, @_ ) ); }

sub query_object { return( shift->_set_get_object( 'query_object', 'DB::Object::Query', @_ ) ); }

# The field data type to be used when binding parameters
# sub type { return( shift->_set_get_scalar_as_object( 'type', @_ ) ); }
sub type { return( shift->_set_get_scalar_as_object( { field => 'type', callbacks => 
{
    get => sub
    {
        my( $self, $val ) = @_;
        my $field = $self->field;
        if( ( !defined( $val ) || !$val->defined || !CORE::length( $val // '' ) ) &&
            $self->_is_a( $field => 'DB::Object::Fields::Field' ) )
        {
            $val = $field->datatype->constant;
        }

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

    $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();