DBIO

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

        - Add as_subselect_rs to DBIC::ResultSet from
          DBIC::Helper::ResultSet::VirtualView::as_virtual_view
        - Refactor dbicadmin adding DDL manipulation capabilities
        - New optional dependency manager to aid extension writers
        - Depend on newest bugfixed Moose
        - Make resultset chaining consistent wrt selection specification
        - Storage::DBI::Replicated cleanup
        - Fix autoinc PKs without an autoinc flag on Sybase ASA

0.08118 2010-02-08 11:53:00 (UTC)
        - Fix a bug causing UTF8 columns not to be decoded (RT#54395)
        - Fix bug in One->Many->One prefetch-collapse handling (RT#54039)
        - Cleanup handling of relationship accessor types

0.08117 2010-02-05 17:10:00 (UTC)
        - Perl 5.8.1 is now the minimum supported version
        - Massive optimization of the join resolution code - now joins
          will be removed from the resulting SQL if DBIC can prove they
          are not referenced by anything
        - Subqueries no longer marked experimental
        - Support for Informix RDBMS (limit/offset and auto-inc columns)

bin/dbiogen  view on Meta::CPAN

=over 4

=item B<--style=STYLE>

Generated code style. One of C<vanilla> (default), C<cake>, C<candy>, or
C<moose>. See L</DESCRIPTION> above for a description of each style.

=item B<-o key=value>

Pass an option directly to L<DBIO::Generate>. May be given multiple
times. Values that look like JSON objects or arrays are decoded automatically.
Numeric values are coerced to numbers. Examples:

    -o dump_directory=./lib
    -o debug=1
    -o components=["DBIO::InflateColumn::DateTime"]

Any option accepted by L<DBIO::Generate> may be set this way.

=back

t/serialize/01-inflatecolumn.t  view on Meta::CPAN

# (no real DB) per the core "mock only" rule.
sub backend_pair {
    my ($backend_class, %info) = @_;
    $info{serializer_class} = $backend_class; # kept for parity; not used by backends
    my $freezer   = $backend_class->get_freezer('col', \%info, {});
    my $unfreezer = $backend_class->get_unfreezer('col', \%info, {});
    return ($freezer, $unfreezer);
}

# Round-trip helper: encode $value with the freezer, decode with the
# unfreezer, return ($encoded, $decoded). For binary backends (MessagePack)
# the encoded payload is bytes, not text.
sub round_trip {
    my ($freezer, $unfreezer, $value) = @_;
    my $encoded = $freezer->($value);
    my $decoded = $unfreezer->($encoded);
    return ($encoded, $decoded);
}

# Shared fixtures
my $simple   = { name => 'Caterwauler McCrae', rank => 13 };
my $nested   = { a => 1, b => [1, 2, 3], c => { d => 'e' } };
my $arrayref = [1, 2, 3];

# ---------------------------------------------------------------------------
# JSON backend
# ---------------------------------------------------------------------------

t/serialize/01-inflatecolumn.t  view on Meta::CPAN

    # 2. Nested round-trip
    {
        my ($enc, $dec) = round_trip($freezer, $unfreezer, $nested);
        is_deeply($dec, $nested, 'JSON nested: round-trip yields equivalent nested structure');
    }

    # 3. Arrayref round-trip
    {
        my ($enc, $dec) = round_trip($freezer, $unfreezer, $arrayref);
        is(reftype($dec), 'ARRAY', 'JSON arrayref: decoded value is an arrayref');
        is_deeply($dec, $arrayref, 'JSON arrayref: round-trip yields equivalent arrayref');
    }

    # 4. Undef round-trip — JSON::MaybeXS rejects non-refs by default;
    #    build a dedicated freezer with allow_nonref => 1. The standard
    #    freezer (no options) would die with "hash- or arrayref expected".
    {
        my ($anon_freezer, $anon_unfreezer) = backend_pair(
            'DBIO::InflateColumn::Serializer::JSON',
            serializer_options => { allow_nonref => 1 },

t/serialize/01-inflatecolumn.t  view on Meta::CPAN

        # 2. Nested round-trip
        {
            my ($enc, $dec) = round_trip($freezer, $unfreezer, $nested);
            is_deeply($dec, $nested, 'YAML nested: round-trip yields equivalent nested structure');
        }

        # 3. Arrayref round-trip
        {
            my ($enc, $dec) = round_trip($freezer, $unfreezer, $arrayref);
            is(reftype($dec), 'ARRAY', 'YAML arrayref: decoded value is an arrayref');
            is_deeply($dec, $arrayref, 'YAML arrayref: round-trip yields equivalent arrayref');
        }

        # 4. Undef round-trip — YAML::Dump(undef) yields the empty string;
        #    YAML::Load("") yields undef. Document the actual behaviour.
        {
            my ($enc, $dec) = round_trip($freezer, $unfreezer, undef);
            ok(!defined($dec), 'YAML undef: decode round-trips to undef');
        }

        # 5. YAML safety: decode result is a plain (unblessed) hashref, and
        #    the source file uses YAML::Load (not LoadFile or similar).
        {
            my $dec = $unfreezer->("name: foo\nrank: 13\n");
            is(ref($dec), 'HASH', 'YAML safety: decoded scalar doc is a hashref');
            ok(!blessed($dec),
                'YAML safety: decoded value is not blessed (F04 risk-surface: LoadBlessed off)');

            my $src = _read_source(
                'DBIO::InflateColumn::Serializer::YAML',
                '/storage/raid/home/getty/dev/perl/dbio-dev/dbio/lib/DBIO/InflateColumn/Serializer/YAML.pm',
            );
            like($src, qr/\bYAML::Load\b/,
                'YAML safety: source uses YAML::Load (not LoadFile / LoadString)');
            unlike($src, qr/\bYAML::LoadFile\b/,
                'YAML safety: source does NOT use YAML::LoadFile');
        }

t/serialize/01-inflatecolumn.t  view on Meta::CPAN

        # 2. Nested round-trip
        {
            my ($enc, $dec) = round_trip($freezer, $unfreezer, $nested);
            is_deeply($dec, $nested, 'MessagePack nested: round-trip yields equivalent nested structure');
        }

        # 3. Arrayref round-trip
        {
            my ($enc, $dec) = round_trip($freezer, $unfreezer, $arrayref);
            is(reftype($dec), 'ARRAY', 'MessagePack arrayref: decoded value is an arrayref');
            is_deeply($dec, $arrayref, 'MessagePack arrayref: round-trip yields equivalent arrayref');
        }

        # 4. Undef round-trip — Data::MessagePack encodes undef as the
        #    nil marker and decodes it back to Perl undef.
        {
            my ($enc, $dec) = round_trip($freezer, $unfreezer, undef);
            ok(!defined($dec), 'MessagePack undef: decode round-trips to undef');
        }