{ order_by => 'title' }
);
- my $millenium_cds_rs = $ds->resultset('CD')->search(
+ my $millennium_cds_rs = $ds->resultset('CD')->search(
{ year => 2000 },
{ prefetch => 'artist' }
);
- my $cd = $millenium_cds_rs->next; # SELECT ... FROM cds JOIN artists ...
+ my $cd = $millennium_cds_rs->next; # SELECT ... FROM cds JOIN artists ...
my $cd_artist_name = $cd->artist->name; # Already has the data so no query
my $new_cd = $ds->resultset('CD')->new({ title => 'Spoon' });
$ds->txn_do(sub { $new_cd->update }); # Runs the update in a transaction
- $millenium_cds_rs->update({ year => 2002 }); # Single-query bulk update
+ $millennium_cds_rs->update({ year => 2002 }); # Single-query bulk update
=head1 DESCRIPTION
=head1 NAME
-DBIx::Class::CDBICompat - Class::DBI Compatability layer.
+DBIx::Class::CDBICompat - Class::DBI Compatibility layer.
=head1 SYNOPSIS
=head1 DESCRIPTION
-DBIx::Class features a fully featured compability layer with L<Class::DBI>
+DBIx::Class features a fully featured compatibility layer with L<Class::DBI>
to ease transition for existing CDBI users. In fact, this class is just a
receipe containing all the features emulated. If you like, you can choose
which features to emulate by building your own class and loading it like
=item LiveObjectIndex
The live object index tries to ensure there is only one version of a object
-in the perl interprenter.
+in the perl interpreter.
=item MightHave
These components provide extra functionality beyond
basic functionality that you can't live without.
-L<DBIx::Class::CDBICompat> - Class::DBI Compatability layer.
+L<DBIx::Class::CDBICompat> - Class::DBI Compatibility layer.
L<DBIx::Class::FormTools> - Build forms with multiple interconnected objects.
print join ', ' => Class::C3::calculateMRO('YourClass::Name');
-Check out the L<Class::C3> docs for more information about inhertance.
+Check out the L<Class::C3> docs for more information about inheritance.
=head1 SEE ALSO
$genus->add_to_species({ name => 'troglodyte' });
$genus->wings(2);
$genus->update;
- $schema->txn_do($code, $genus); # Can have a nested transation
+ $schema->txn_do($code, $genus); # Can have a nested transaction
return $genus->species;
};
print $output;
You could use L<Module::Find> to search for all subclasses in the MyDB::*
-namespace, which is currently left as an excercise for the reader.
+namespace, which is currently left as an exercise for the reader.
=head2 Schema versioning
__PACKAGE__->storage->sql_maker->quote_char('"');
-is enough. If the left qoute differs form the right quote, the first
+is enough. If the left quote differs form the right quote, the first
notation should be used. name_sep needs to be set to allow the
SQL generator to put the quotes the correct place.
=head1 DESCRIPTION
-This tutorial will guide you through the proeccess of setting up and
+This tutorial will guide you through the process of setting up and
testing a very basic CD database using SQLite, with DBIx::Class::Schema
as the database frontend.
With these scripts we're relying on @INC looking in the current
working directory. You may want to add the MyDatabase namespaces to
-@INC in a different way when it comes to deployemnt.
+@INC in a different way when it comes to deployment.
The testdb.pl script is an excellent start for testing your database
model.
=head1 NAME
-DBIx::Class::Manual::Glossary - Deconfusion of terms used
+DBIx::Class::Manual::Glossary - Clarification of terms used.
=head1 INTRODUCTION
my $other_schema = My::Schema->connect( $dsn, $user, $password, $attrs );
-Note that L<DBIx::Class::Schema> does not cache connnections for you. If you
+Note that L<DBIx::Class::Schema> does not cache connections for you. If you
use multiple connections, you need to do this manually.
To execute some sql statements on every connect you can pass them to your schema after the connect:
=head2 might_have
- My::DBIC::Schema::Author->might_have(psuedonym => 'Psuedonyms');
- my $pname = $obj->psuedonym; # to get the Psuedonym object
+ My::DBIC::Schema::Author->might_have(pseudonym => 'Pseudonyms');
+ my $pname = $obj->pseudonym; # to get the Pseudonym object
Creates an optional one-to-one relationship with a class, where the foreign
class stores our primary key in one of its columns. Defaults to the primary
The condition needs to be an SQL::Abstract-style representation of the
join between the tables. When resolving the condition for use in a JOIN,
-keys using the psuedo-table I<foreign> are resolved to mean "the Table on the
-other side of the relationship", and values using the psuedo-table I<self>
+keys using the pseudo-table I<foreign> are resolved to mean "the Table on the
+other side of the relationship", and values using the pseudo-table I<self>
are resolved to mean "the Table this class is representing". Other
restrictions, such as by value, sub-select and other tables, may also be
used. Please check your database for JOIN parameter support.
=head2 all
-Returns all elements in the resultset. Called implictly if the resultset
+Returns all elements in the resultset. Called implicitly if the resultset
is returned in list context.
=cut
$obj->delete
-Deletes the object from the database. The object is still perfectly usable
-accessor-wise etc. but ->in_storage will now return 0 and the object must
-be re ->insert'ed before it can be ->update'ed
+Deletes the object from the database. The object is still perfectly usable,
+but ->in_storage() will now return 0 and the object must re inserted using
+->insert() before ->update() can be used on it.
=cut
if (eval{require Data::UUID}) {
return '::Data::UUID';
} elsif ($^O ne 'openbsd' && eval{require APR::UUID}) {
- # APR::UUID on openbsd causes some as yet unfound nastyness for XS
+ # APR::UUID on openbsd causes some as yet unfound nastiness for XS
return '::APR::UUID';
} elsif (eval{require UUID}) {
return '::UUID';
sub as_string {
my $uuid;
- ...magic encantations...
+ ...magic incantations...
return $uuid;
};
# -------------------------------------------------------------------
# parse($tr, $data)
#
-# Note that $data, in the case of this parser, is unuseful.
+# Note that $data, in the case of this parser, is not useful.
# We're working with DBIx::Class Schemas, not data streams.
# -------------------------------------------------------------------
sub parse {
next if(!exists $rel_info->{attrs}{accessor} ||
$rel_info->{attrs}{accessor} eq 'multi');
# Going by the accessor type isn't such a good idea (yes, I know
- # I suggested it). I think the best way to tell if something's a
+ # I suggested it). I think the best way to tell if something is a
# foreign key constraint is to assume if it doesn't include our
# primaries then it is (dumb but it'll do). Ignore any rel cond
# that isn't a straight hash, but get both sets of keys in full
projects / dbsrgits/DBIx-Class.git / commitdiff