view release on metacpan or search on metacpan
lib/CSS/Tiny/Style.pm view on Meta::CPAN
#$style =~ s/^;//; # why why why?
$element->attr('style', $style)
}
###########################################################################################################
# from CSS spec at http://www.w3.org/TR/CSS21/cascade.html#specificity
###########################################################################################################
# A selector's specificity is calculated as follows:
#
# * count the number of ID attributes in the selector (= a)
# * count the number of other attributes and pseudo-classes in the selector (= b)
lib/CSS/Tiny/Style.pm view on Meta::CPAN
my $style = CSS::Tiny::Style->new('h1.menu li.myclass');
print $style->specificity # prints 22
Returns the selector's specificity as described in
L<http://www.w3.org/TR/CSS21/cascade.html#specificity>. A base 100 is
used.
=head3 count_tags
my $style = CSS::Tiny::Style->new('h1.menu li.myclass #foo');
view release on metacpan or search on metacpan
lib/CWB/CEQL/Parser.pm view on Meta::CPAN
query and scripting languages (such as the B<C>ommon B<E>lementary B<Q>uery
B<L>anguage provided by B<CWB::CEQL>) into low-level code (e.g. B<CQP> syntax).
The DPP architecture was motivated by the observation that simplified queries
are often very similar in structure to the corresponding low-level queries,
and that many authors use cascaded regular expression substitutions to
transform one into the other. While such cascades are very easy to write in
Perl and perform efficiently, there are two important limitations: it would
often be useful (i) to validate and transform recursive structures, and (ii)
to restrict a particular transformation to a certain scope. Because of these
limitations, incorrect user input -- and sometimes even correct input -- leads
to malformed low-level queries. Without an intimate knowledge of the
lib/CWB/CEQL/Parser.pm view on Meta::CPAN
=head2 Stand-alone rules
The simplest DPP rules are stand-alone rules that transform their input string
directly without invoking any subrules. These rules typically make use of regular
expression substitutions and correspond to one part of the substitution cascade
in a traditional implementation of simple query languages. In contrast to such
cascades, DPP rules apply only to relevant parts of the input string and cannot
accidentally modify other parts of the simple query. The example below transforms
a search term with shell-style wildcards (C<?> and C<*>) into a regular expression.
Note how the input string is first checked to make sure it does not contain any
other metacharacters that might have a special meaning in the generated regular
expression, and B<die>s with an informative error message otherwise.
view release on metacpan or search on metacpan
lib/Cache/Cascade.pm view on Meta::CPAN
For example, caching in a FastMmap based storage is much slower than using a
memory based cache, because pages must be locked to ensure that no corruption
will happen. Likewise Memcached is even more overhead than FastMmap because it
is network bound, and uses blocking IO (on the client side).
This module attempts to make a transparent cascade of caches using several
backends.
The idea is to search from the cheapest backend to the most expensive, and
depending on the options also cache results in the cheaper backends.
The benefits of using a cascade are that if the chance of a hit is much higher
in a slow cache, but checking a cheap cache is negligible in comparison, we
may already have the result we want in the cheap cache. Configure your
expiration policy so that there is approximately an order of magnitude better
probability of cache hits (bigger cache) for each level of the cascade.
=head1 FIELDS
=over 4
lib/Cache/Cascade.pm view on Meta::CPAN
=back
=head1 CAVEATS
When you set or remove a key from the cascade and this propagates downwards, for
example from MemoryCache to FastMmap, other cascades will not notice the change
until their own MemoryCache is expired.
Thus, if cache invalidation is important in your algorithm (data changes) do
not use a cascade. If stale hits are permitted, or the cache is for non
changing data then you should use a cascade.
=head1 SEE ALSO
L<Cache>
view release on metacpan or search on metacpan
maint/carton_install_with_configuredeps.pl view on Meta::CPAN
my $mirror = Carton::Mirror->new($ENV{PERL_CARTON_MIRROR} || $Carton::Mirror::DefaultMirror);
my $env = Carton::Environment->build($cpanfile_path, $install_path);
my $builder = Carton::Builder->new(
cascade => 1,
mirror => $mirror,
without => \@without,
cpanfile => $env->cpanfile,
);
maint/carton_install_with_configuredeps.pl view on Meta::CPAN
print "Installing configure dependency:- $requirement\n";
$builder->run_cpanm(
'-L', $env->install_path,
(map { ("--mirror", $_->url) } $builder->effective_mirrors),
( $builder->index ? ("--mirror-index", $builder->index) : () ),
( $builder->cascade ? "--cascade-search" : () ),
( $builder->custom_mirror ? "--mirror-only" : () ),
"--save-dists", $env->install_path."/cache",
$builder->groups,
$requirement,
);
view release on metacpan or search on metacpan
lib/Carmel/Builder.pm view on Meta::CPAN
if ($self->snapshot) {
my $path = Path::Tiny->tempfile;
$self->snapshot->write_index($path);
unshift @cmd,
"--mirror-index", $path,
"--cascade-search",
"--mirror", "http://cpan.metacpan.org";
}
local $ENV{PERL_CPANM_HOME} = $self->tempdir;
local $ENV{PERL_CPANM_OPT};
view release on metacpan or search on metacpan
lib/Carton/Builder.pm view on Meta::CPAN
package Carton::Builder;
use strict;
use Class::Tiny {
mirror => undef,
index => undef,
cascade => sub { 1 },
without => sub { [] },
cpanfile => undef,
};
sub effective_mirrors {
lib/Carton/Builder.pm view on Meta::CPAN
$self->run_install(
"-L", $path,
(map { ("--mirror", $_->url) } $self->effective_mirrors),
( $self->index ? ("--mirror-index", $self->index) : () ),
( $self->cascade ? "--cascade-search" : () ),
( $self->custom_mirror ? "--mirror-only" : () ),
"--save-dists", "$path/cache",
$self->groups,
"--cpanfile", $self->cpanfile,
"--installdeps", $self->cpanfile->dirname,
view release on metacpan or search on metacpan
share/ext/ext-all-debug.js view on Meta::CPAN
onAdded : function(container, pos) {
this.ownerCt = container;
this.initRef();
this.cascade(function(c){
c.initRef();
});
this.fireEvent('added', this, container, pos);
},
share/ext/ext-all-debug.js view on Meta::CPAN
Ext.destroy(this.layout);
Ext.Container.superclass.beforeDestroy.call(this);
},
cascade : function(fn, scope, args){
if(fn.apply(scope || this, args || [this]) !== false){
if(this.items){
var cs = this.items.items;
for(var i = 0, len = cs.length; i < len; i++){
if(cs[i].cascade){
cs[i].cascade(fn, scope, args);
}else{
fn.apply(scope || cs[i], args || [cs[i]]);
}
}
}
share/ext/ext-all-debug.js view on Meta::CPAN
findById : function(id){
var m = null,
ct = this;
this.cascade(function(c){
if(ct != c && c.id === id){
m = c;
return false;
}
});
share/ext/ext-all-debug.js view on Meta::CPAN
},
findBy : function(fn, scope){
var m = [], ct = this;
this.cascade(function(c){
if(ct != c && fn.call(scope || c, c, ct) === true){
m.push(c);
}
});
return m;
share/ext/ext-all-debug.js view on Meta::CPAN
this[this.collapseEl].hide(this.hideMode);
}
this.afterEffect(anim);
this.cascade(function(c) {
if (c.lastSize) {
c.lastSize = { width: undefined, height: undefined };
}
});
this.fireEvent('collapse', this);
share/ext/ext-all-debug.js view on Meta::CPAN
this.el.show();
if(this.maximized){
this.fitContainer();
}
if(Ext.isMac && Ext.isGecko2){
this.cascade(this.setAutoScroll);
}
if(this.monitorResize || this.modal || this.constrain || this.constrainHeader){
Ext.EventManager.onWindowResize(this.onWindowResize, this);
}
share/ext/ext-all-debug.js view on Meta::CPAN
}
if(show !== false){
this.el.show();
this.focus.defer(10, this);
if(Ext.isMac && Ext.isGecko2){
this.cascade(this.setAutoScroll);
}
}
if(matchPosition !== false){
this.setPosition(this.activeGhost.getLeft(true), this.activeGhost.getTop(true));
}
share/ext/ext-all-debug.js view on Meta::CPAN
var f = function(){
if(this.attributes.checked){
r.push(!a ? this : (a == 'id' ? this.id : this.attributes[a]));
}
};
startNode.cascade(f);
return r;
},
getLoader : function(){
share/ext/ext-all-debug.js view on Meta::CPAN
p = p.parentNode;
}
},
cascade : function(fn, scope, args){
if(fn.apply(scope || this, args || [this]) !== false){
var cs = this.childNodes;
for(var i = 0, len = cs.length; i < len; i++) {
cs[i].cascade(fn, scope, args);
}
}
},
share/ext/ext-all-debug.js view on Meta::CPAN
n.ui.hide();
return false;
}
return true;
};
startNode.cascade(f);
if(this.remove){
for(var id in af){
if(typeof id != "function"){
var n = af[id];
if(n && n.parentNode){
view release on metacpan or search on metacpan
lib/Catalyst/Helper/View/TT/Bootstrap/YUI/Manual.pm view on Meta::CPAN
html.tt uses IE conditional comments to decorate the body tag with a class 'IE'
and another class 'IE5', 'IE6', or 'IE7' depending on the version of the browser
requesting the page. Non-IE browsers will no have these classes added.
This allows you to use the cascade in your css to target IE to correct display
issues that may*cough*WILL*cough* arise.
/* Container dimensions */
.container {
width: 276px;
view release on metacpan or search on metacpan
lib/Catalyst/Helper/View/TT/Bootstrap/Manual.pm view on Meta::CPAN
html.tt uses IE conditional comments to decorate the body tag with a class 'IE'
and another class 'IE5', 'IE6', or 'IE7' depending on the version of the browser
requesting the page. Non-IE browsers will no have these classes added.
This allows you to use the cascade in your css to target IE to correct display
issues that may*cough*WILL*cough* arise.
/* Container dimensions */
.container {
width: 276px;
view release on metacpan or search on metacpan
lib/Catalyst/Manual/Tutorial/03_MoreCatalystBasics.pod view on Meta::CPAN
__PACKAGE__->has_many(
"book_authors",
"MyApp::Schema::Result::BookAuthor",
{ "foreign.book_id" => "self.id" },
{ cascade_copy => 0, cascade_delete => 0 },
);
Each C<Book> "has_many" C<book_authors>, where C<BookAuthor> is the
many-to-many table that allows each Book to have multiple Authors, and
each Author to have multiple books. The arguments to C<has_many> are:
view release on metacpan or search on metacpan
t/lib/Schema/Abilities/Result/Action.pm view on Meta::CPAN
__PACKAGE__->has_many(
"role_actions",
"Schema::Abilities::Result::RoleAction",
{ "foreign.action_id" => "self.id" },
{ cascade_copy => 0, cascade_delete => 0 },
);
=head2 user_actions
Type: has_many
t/lib/Schema/Abilities/Result/Action.pm view on Meta::CPAN
__PACKAGE__->has_many(
"user_actions",
"Schema::Abilities::Result::UserAction",
{ "foreign.action_id" => "self.id" },
{ cascade_copy => 0, cascade_delete => 0 },
);
# Created by DBIx::Class::Schema::Loader v0.07010 @ 2011-10-17 10:52:30
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:9MkM7yJUfbHnQ25yYnVfKw
# __PACKAGE__->has_many(map_role_actions => 'Schema::Abilities::Result::RoleAction', 'role_id',
# { cascade_copy => 0, cascade_delete => 0 });
# __PACKAGE__->many_to_many(roles => 'map_role_actions', 'action');
__PACKAGE__->meta->make_immutable;
1;
view release on metacpan or search on metacpan
examples/demo/lib/DemoAppMusicSchema/Result/Album.pm view on Meta::CPAN
__PACKAGE__->has_many(
"album_artists",
"DemoAppMusicSchema::Result::AlbumArtist",
{ "foreign.album_id" => "self.id" },
{ cascade_copy => 0, cascade_delete => 0 },
);
=head2 sleeve_note
Type: might_have
examples/demo/lib/DemoAppMusicSchema/Result/Album.pm view on Meta::CPAN
__PACKAGE__->might_have(
"sleeve_note",
"DemoAppMusicSchema::Result::SleeveNote",
{ "foreign.album_id" => "self.id" },
{ cascade_copy => 0, cascade_delete => 0 },
);
=head2 tracks
Type: has_many
examples/demo/lib/DemoAppMusicSchema/Result/Album.pm view on Meta::CPAN
__PACKAGE__->has_many(
"tracks",
"DemoAppMusicSchema::Result::Track",
{ "foreign.album_id" => "self.id" },
{ cascade_copy => 0, cascade_delete => 0 },
);
# Created by DBIx::Class::Schema::Loader v0.07010 @ 2011-10-09 18:35:04
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:Wx/g9tUF3BQeBJF1TGW+Ow
view release on metacpan or search on metacpan
lib/Catalyst/Helper/Model/CRUD.pm view on Meta::CPAN
my $class_name = sprintf( "%s::Model::ShanonDBI::%s",
$helper->{'app'}, $this->get_class_name( $src_table->{'Tablename'} ) );
$sql->{'references'} = {
class => $class_name,
name => 'id',
onupdate => 'cascade',
ondelete => 'cascade'
};
push @setting,
sprintf( "CONSTRAINT ref_%s REFERENCES %s (id) ON DELETE cascade ON UPDATE cascade",
$column->{'ColName'}, $src_table->{'Tablename'} );
}
# コメント
if ( 'id' eq lc( $column->{'ColName'} ) ) {
view release on metacpan or search on metacpan
t/lib/TestBlogApp/Schema/Result/Discussion.pm view on Meta::CPAN
__PACKAGE__->has_many(
"blog_posts",
"TestBlogApp::Schema::Result::BlogPost",
{ "foreign.discussion" => "self.id" },
{ cascade_copy => 0, cascade_delete => 0 },
);
1;
view release on metacpan or search on metacpan
t/02-complex.t view on Meta::CPAN
'filters'=>'{"groupOp":"AND","rules":[],"groups":[{"groupOp":"OR","rules":[{"field":"a","op":"eq","data":"1"},{"field":"b","op":"eq","data":"2"}],"groups":[]},{"groupOp":"OR","rules":[{"field":"c","op":"eq","data":"3"},{"field":"d","op":"eq","d...
},
result=>{'-and'=>[{'-or'=>[{'a'=>{'='=>'1'}},{'b'=>{'='=>'2'}}]},{'-or'=>[{'c'=>{'='=>'3'}},{'d'=>{'='=>'4'}}]}]},
},
{
name=>'and cascade: (((((((((((a = "1")))))))))))',
search=>{ '_search'=>'true',
'filters'=>'{"groupOp":"AND","rules":[],"groups":[{"groupOp":"AND","rules":[],"groups":[{"groupOp":"AND","rules":[],"groups":[{"groupOp":"AND","rules":[],"groups":[{"groupOp":"AND","rules":[],"groups":[{"groupOp":"AND","rules":[],"groups":[{"gr...
},
result=>{'-and'=>[{'-and'=>[{'-and'=>[{'-and'=>[{'-and'=>[{'-and'=>[{'-and'=>[{'-and'=>[{'-and'=>[{'-and'=>[{'-and'=>[{'a'=>{'='=>'1'}}]}]}]}]}]}]}]}]}]}]}]},
},
view release on metacpan or search on metacpan
lib/Catalyst/View/Xslate.pm view on Meta::CPAN
The suffix used to auto generate the template name from the action name
(when you do not explicitly specify the template filename);
Do not confuse this with the C<suffix> option, which is passed directly to
the Text::Xslate object instance. This option works on the filename used
for the initial request, while C<suffix> controls what C<cascade> and
C<include> directives do inside Text::Xslate.
=head2 content_charset
The charset used to output the response body. The value defaults to 'UTF-8'.
view release on metacpan or search on metacpan
lib/CatalystX/Crudite/Schema/ResultBase.pm view on Meta::CPAN
);
$class->add_unique_constraint([qw(name)]);
$class->has_many(
user_roles => "${prefix}::UserRole",
'user_id',
{ cascade_delete => 1 },
);
$class->many_to_many('roles', 'user_roles', 'role');
}
sub setup_role_class {
view release on metacpan or search on metacpan
t/lib/MyApp/Schema/Result/Role.pm view on Meta::CPAN
__PACKAGE__->has_many(
"user_roles",
"MyApp::Schema::Result::UserRole",
{ "foreign.role_id" => "self.id" },
{ cascade_copy => 0, cascade_delete => 0 },
);
# Created by DBIx::Class::Schema::Loader v0.07036 @ 2013-10-28 10:35:58
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:9RsVVaxRcjUosxeLZI0SfA
view release on metacpan or search on metacpan
example/root/static/silk.css view on Meta::CPAN
.silk-building-go { background-image: url(fam/building_go.png) !important; background-repeat: no-repeat; }
.silk-building { background-image: url(fam/building.png) !important; background-repeat: no-repeat; }
.silk-cancel { background-image: url(fam/cancel.png) !important; background-repeat: no-repeat; }
.silk-application { background-image: url(fam/application.png) !important; background-repeat: no-repeat; }
.silk-application-add { background-image: url(fam/application_add.png) !important; background-repeat: no-repeat; }
.silk-application-cascade { background-image: url(fam/application_cascade.png) !important; background-repeat: no-repeat; }
.silk-application-delete { background-image: url(fam/application_delete.png) !important; background-repeat: no-repeat; }
.silk-application-double { background-image: url(fam/application_double.png) !important; background-repeat: no-repeat; }
.silk-application-edit { background-image: url(fam/application_edit.png) !important; background-repeat: no-repeat; }
.silk-application-error { background-image: url(fam/application_error.png) !important; background-repeat: no-repeat; }
.silk-application-form { background-image: url(fam/application_form.png) !important; background-repeat: no-repeat; }
view release on metacpan or search on metacpan
t/lib/MyApp/Schema/Result/Role.pm view on Meta::CPAN
__PACKAGE__->has_many(
"user_roles",
"MyApp::Schema::Result::UserRole",
{ "foreign.role_id" => "self.id" },
{ cascade_copy => 0, cascade_delete => 1 },
);
__PACKAGE__->meta->make_immutable;
1;
view release on metacpan or search on metacpan
t/live-test.t view on Meta::CPAN
$mech->get_ok('/list/track', 'Get /list/track');
$mech->content_like(qr{TEMPLATE\sOK}xsm, 'Template compiles');
$mech->content_like(qr{\b13\sentries}xsm, 'Right number of records');
$mech->content_like(qr{track\scode.+track\stitle.+album\sreleased.+artist\sname}xism, 'Display column headings cascade');
$mech->content_like(qr{02/03/1989}xsm, 'Date format helper works');
$mech->content_like(qr{Mike\sSmith}xsm, 'Compound name fields work');
$mech->get_ok('/list/track?myprefixsort=fromalbum.artist.acombined_name-asc');
$mech->content_like(qr{\b13\sentries}xsm, 'Right number of records after 2nd call (i.e. $c updated in FB cache)');
view release on metacpan or search on metacpan
lib/CellBIS/SQL/Abstract/Table.pm view on Meta::CPAN
# For Foreign key attribute :
# ------------------------------------------------------------------------
sub fk_attr_validator {
my ($fk_table) = @_;
my $data = '';
my %ondelup = ('cascade' => 'CASCADE', 'null' => 'SET NULL',
'default' => 'SET DEFAULT');
my $ondel = 0;
if (exists $fk_table->{ondelete}) {
if (exists $ondelup{(lc $fk_table->{ondelete})}) {
$ondel = 1;
view release on metacpan or search on metacpan
lib/Changes/Version.pm view on Meta::CPAN
my $frag = shift( @_ );
my $val = shift( @_ );
# We die, because this is an internal method and those cases should not happen unless this were a design bug
if( !defined( $frag ) || !length( $frag ) )
{
die( "No fragment was provided to cascade" );
}
elsif( $frag !~ /^(major|minor|patch|alpha|\d+)$/ )
{
die( "Unsupported version fragment '$frag'. Only use 'major', 'minor', 'patch' or 'alpha' or a number starting from 1 (1 = major, 2 = minor, etc)." );
}
lib/Changes/Version.pm view on Meta::CPAN
$extra->[ $i - 4 ] = $val;
}
last;
}
}
$self->_cascade( $level );
}
sub _cascade
{
my $self = shift( @_ );
my $frag = shift( @_ );
# We die, because this is an internal method and those cases should not happen unless this were a design bug
if( !defined( $frag ) || !length( $frag ) )
{
die( "No fragment was provided to cascade" );
}
elsif( $frag !~ /^(major|minor|patch|alpha|\d+)$/ )
{
die( "Unsupported version fragment '$frag'. Only use 'major', 'minor', 'patch' or 'alpha' or a number starting from 1 (1 = major, 2 = minor, etc)." );
}
lib/Changes/Version.pm view on Meta::CPAN
}
else
{
$extra->[( $frag - 4 )] = $new_val;
}
$new->_cascade( $frag );
}
$new->reset(1);
return( $new );
}
}
lib/Changes/Version.pm view on Meta::CPAN
}
else
{
$extra->[( $frag - 4 )] = $n;
}
$self->_cascade( $frag );
$self->reset(1);
return( $self );
}
sub _noop
view release on metacpan or search on metacpan
lib/Chess/GameClock/GclkSettings.pm view on Meta::CPAN
my $menubar =$top->Menu(-type => 'menubar');
$top->configure(-menu => $menubar);
foreach my $m (@menu) {
# creation des sous-menus en cascade
$sous_menuref{$m} = $menubar->cascade(-label=>$m) ;
# entrées des données des sous-menus
map($soussous_ref{$m}{$_}= $sous_menuref{$m}->cascade(-label=>$_),@{$sous_menu{$m}});
}
foreach my $type (keys %soussous_ref) {
for my $cadence (keys %{$soussous_ref{$type} }) {
lib/Chess/GameClock/GclkSettings.pm view on Meta::CPAN
for (qw/Cadence2 Cadence3 Cadence4/) {
$rb{ReglagesManuels}{$_}[0]->configure (-state=>'disabled') ;
}
#$soussous_ref{Aide}{Bref}= $sous_menuref{Aide}->cascade(-label=>'En Bref') ;
#my $cmd=$soussous_ref{Aide}{Bref}->command(-label=>'voir',-command=>\&voir) ;
$sous_menuref{Aide}->command(-label=>'En Bref',-command=>[\&voir,%aide]) ;
$soussous_ref{ReglagesManuels}{Options}->command(-label=>'Adjust',-command=>\&adjust) ;
view release on metacpan or search on metacpan
lib/Class/DBI/Cascade/Plugin/Nullify.pm view on Meta::CPAN
use base 'Class::DBI::Cascade::None';
our $VERSION = 0.05;
sub cascade {
my ($self, $obj) = @_;
my $foreign_objects = $self->foreign_for($obj); # get all foreign objects
my $foreign_key = $self->{_rel}->args->{foreign_key}; # get the foreign key
while ( my $foreign_object = $foreign_objects->next) {
lib/Class/DBI/Cascade/Plugin/Nullify.pm view on Meta::CPAN
=head1 SYNOPSIS
package Music::Artist;
# define your class here
Music::Artist->has_many(cds => 'Music::CD', {cascade => 'Class::DBI::Cascade::Plugin::Nullify'});
=head1 DESCRIPTION
This is a cascading nullify strategy (i.e. 'on delete set null') that will nullify any related L<Class::DBI> objects.
THIS MODULE IS NOT LONGER DEVELOPED. Please consider L<Rose::DB::Object> as a alternative to L<Class::DBI>.
=head1 METHODS
=head2 C<cascade>
implementation of the cascading nullify strategy.
=head1 AUTHOR
view release on metacpan or search on metacpan
lib/Class/DBI/Frozen/301/Relationship/HasMany.pm view on Meta::CPAN
$self->SUPER::_set_up_class_data;
}
sub triggers {
my $self = shift;
return if $self->args->{no_cascade_delete}; # undocumented and untestsd!
return (
before_delete => sub {
$self->foreign_class->search($self->args->{foreign_key} => shift->id)
->delete_all;
});
view release on metacpan or search on metacpan
lib/Class/DBI/Relationship/HasManyOrdered.pm view on Meta::CPAN
if ($meta->args->{map}) {
my $pk = $self->columns('Primary');
my $sth = $self->db_Main->prepare("delete from ".$meta->args->{map}." where $pk = ?");
my $rv = $sth->execute($self->id);
} else {
return if $self->args->{no_cascade_delete}; # undocumented and untested!
$f_class->search($f_key => $self->id)->delete_all;
}
});
}
view release on metacpan or search on metacpan
t/cdbi-t-ocache/17-data_type.t
t/cdbi-t-ocache/18-has_a.t
t/cdbi-t-ocache/19-set_sql.t
t/cdbi-t-ocache/21-iterator.t
t/cdbi-t-ocache/22-deflate_order.t
t/cdbi-t-ocache/23-cascade.t
t/cdbi-t-ocache/24-meta_info.t
t/cdbi-t-ocache/25-closures_in_meta.t
t/cdbi-t-ocache/97-pod.t
t/cdbi-t-ocache/98-failure.t
t/cdbi-t-ocache/99-misc.t
t/cdbi-t-rescache/17-data_type.t
t/cdbi-t-rescache/18-has_a.t
t/cdbi-t-rescache/19-set_sql.t
t/cdbi-t-rescache/21-iterator.t
t/cdbi-t-rescache/22-deflate_order.t
t/cdbi-t-rescache/23-cascade.t
t/cdbi-t-rescache/24-meta_info.t
t/cdbi-t-rescache/25-closures_in_meta.t
t/cdbi-t-rescache/97-pod.t
t/cdbi-t-rescache/98-failure.t
t/cdbi-t-rescache/99-misc.t
t/cdbi-t/17-data_type.t
t/cdbi-t/18-has_a.t
t/cdbi-t/19-set_sql.t
t/cdbi-t/21-iterator.t
t/cdbi-t/22-deflate_order.t
t/cdbi-t/23-cascade.t
t/cdbi-t/24-meta_info.t
t/cdbi-t/25-closures_in_meta.t
t/cdbi-t/97-pod.t
t/cdbi-t/98-failure.t
t/cdbi-t/99-misc.t
view release on metacpan or search on metacpan
lib/Class/DBI.pm view on Meta::CPAN
Multiple objects can be deleted by calling delete_all on the Iterator
returned from a search. Each object found will be deleted in turn,
so cascading delete and other triggers will be honoured.
The C<before_delete> trigger is when an object instance is about to be
deleted. It is invoked before any cascaded deletes. The C<after_delete>
trigger is invoked after the record has been deleted from the database
and just before the contents in memory are discarded.
=head1 RETRIEVING OBJECTS
lib/Class/DBI.pm view on Meta::CPAN
For an example of where this is useful see L<"MANY TO MANY RELATIONSHIPS">
below.
=head3 Cascading Delete
Music::Artist->has_many(cds => 'Music::CD', { cascade => 'Fail' });
It is also possible to control what happens to the 'child' objects when
the 'parent' object is deleted. By default this is set to 'Delete' - so,
for example, when you delete an artist, you also delete all their CDs,
leaving no orphaned records. However you could also set this to 'None',
lib/Class/DBI.pm view on Meta::CPAN
For example you could write a Class::DBI::Cascade::Plugin::Nullify
which would set all related foreign keys to be NULL, and plug it into
your relationship:
Music::Artist->has_many(cds => 'Music::CD', {
cascade => 'Class::DBI::Cascade::Plugin::Nullify'
});
=head2 might_have
Music::CD->might_have(method_name => Class => (@fields_to_import));
view release on metacpan or search on metacpan
lib/Class/Interface.pm view on Meta::CPAN
# make sure the import is not found through inheritance.
unless ( defined &{ $caller . "::import" } ) {
*{ $caller . "::import" } = sub {
# don't cascade up to the interface.
}
}
makeMagicConstructor($caller);