/ 
DBIx-Class-0.08099_05
River stage three • 349 direct dependents • 459 total dependents
/ DBIx::Class::ResultSource

NAME

DBIx::Class::ResultSource - Result source object

SYNOPSIS

DESCRIPTION

A ResultSource is a component of a schema from which results can be directly retrieved, most usually a table (see DBIx::Class::ResultSource::Table)

METHODS

new

$class->new();

$class->new({attribute_name => value});

Creates a new ResultSource object. Not normally called directly by end users.

source_info

Stores a hashref of per-source metadata. No specific key names have yet been standardized, the examples below are purely hypothetical and don't actually accomplish anything on their own:

__PACKAGE__->source_info({
  "_tablespace" => 'fast_disk_array_3',
  "_engine" => 'InnoDB',
});

add_columns

$table->add_columns(qw/col1 col2 col3/);

$table->add_columns('col1' => \%col1_info, 'col2' => \%col2_info, ...);

Adds columns to the result source. If supplied key => hashref pairs, uses the hashref as the column_info for that column. Repeated calls of this method will add more columns, not replace them.

The column names given will be created as accessor methods on your DBIx::Class::Row objects, you can change the name of the accessor by supplying an "accessor" in the column_info hash.

The contents of the column_info are not set in stone. The following keys are currently recognised/used by DBIx::Class:

accessor

Use this to set the name of the accessor method for this column. If unset, the name of the column will be used.

data_type

This contains the column type. It is automatically filled by the SQL::Translator::Producer::DBIx::Class::File producer, and the DBIx::Class::Schema::Loader module. If you do not enter a data_type, DBIx::Class will attempt to retrieve it from the database for you, using DBI's column_info method. The values of this key are typically upper-cased.

Currently there is no standard set of values for the data_type. Use whatever your database supports.

size

The length of your column, if it is a column type that can have a size restriction. This is currently only used by "deploy" in DBIx::Class::Schema.

is_nullable

Set this to a true value for a columns that is allowed to contain NULL values. This is currently only used by "deploy" in DBIx::Class::Schema.

is_auto_increment

Set this to a true value for a column whose value is somehow automatically set. This is used to determine which columns to empty when cloning objects using copy. It is also used by "deploy" in DBIx::Class::Schema.

is_foreign_key

Set this to a true value for a column that contains a key from a foreign table. This is currently only used by "deploy" in DBIx::Class::Schema.

default_value

Set this to the default value which will be inserted into a column by the database. Can contain either a value or a function. This is currently only used by "deploy" in DBIx::Class::Schema.

sequence

Set this on a primary key column to the name of the sequence used to generate a new key value. If not specified, DBIx::Class::PK::Auto will attempt to retrieve the name of the sequence from the database automatically.

auto_nextval

Set this to a true value for a column whose value is retrieved automatically from an oracle sequence. If you do not use an oracle trigger to get the nextval, you have to set sequence as well.

extra

This is used by "deploy" in DBIx::Class::Schema and SQL::Translator to add extra non-generic data to the column. For example: extra => { unsigned => 1} is used by the MySQL producer to set an integer column to unsigned. For more details, see SQL::Translator::Producer::MySQL.

add_column

$table->add_column('col' => \%info?);

Convenience alias to add_columns.

has_column

if ($obj->has_column($col)) { ... }

Returns true if the source has a column of this name, false otherwise.

column_info

my $info = $obj->column_info($col);

Returns the column metadata hashref for a column. See the description of add_column for information on the contents of the hashref.

column_info_from_storage

Enables the on-demand automatic loading of the above column metadata from storage as neccesary. This is *deprecated*, and should not be used. It will be removed before 1.0.

__PACKAGE__->column_info_from_storage(1);

columns

my @column_names = $obj->columns;

Returns all column names in the order they were declared to add_columns.

remove_columns

$table->remove_columns(qw/col1 col2 col3/);

Removes columns from the result source.

remove_column

$table->remove_column('col');

Convenience alias to remove_columns.

set_primary_key

Arguments: @cols

Defines one or more columns as primary key for this source. Should be called after add_columns.

Additionally, defines a unique constraint named primary.

The primary key columns are used by DBIx::Class::PK::Auto to retrieve automatically created values from the database.

primary_columns

Read-only accessor which returns the list of primary keys.

add_unique_constraint

Declare a unique constraint on this source. Call once for each unique constraint.

# For UNIQUE (column1, column2)
__PACKAGE__->add_unique_constraint(
  constraint_name => [ qw/column1 column2/ ],
);

Alternatively, you can specify only the columns:

__PACKAGE__->add_unique_constraint([ qw/column1 column2/ ]);

This will result in a unique constraint named table_column1_column2, where table is replaced with the table name.

Unique constraints are used, for example, when you call "find" in DBIx::Class::ResultSet. Only columns in the constraint are searched.

name_unique_constraint

Return a name for a unique constraint containing the specified columns. These names consist of the table name and each column name, separated by underscores.

For example, a constraint on a table named cd containing the columns artist and title would result in a constraint name of cd_artist_title.

unique_constraints

Read-only accessor which returns the list of unique constraints on this source.

unique_constraint_names

Returns the list of unique constraint names defined on this source.

unique_constraint_columns

Returns the list of columns that make up the specified unique constraint.

from

Returns an expression of the source to be supplied to storage to specify retrieval from this source. In the case of a database, the required FROM clause contents.

schema

Returns the DBIx::Class::Schema object that this result source belongs too.

storage

Returns the storage handle for the current schema.

See also: DBIx::Class::Storage

add_relationship

$source->add_relationship('relname', 'related_source', $cond, $attrs);

The relationship name can be arbitrary, but must be unique for each relationship attached to this result source. 'related_source' should be the name with which the related result source was registered with the current schema. For example:

$schema->source('Book')->add_relationship('reviews', 'Review', {
  'foreign.book_id' => 'self.id',
});

The condition $cond needs to be an SQL::Abstract-style representation of the join between the tables. For example, if you're creating a rel from Author to Book,

{ 'foreign.author_id' => 'self.id' }

will result in the JOIN clause

author me JOIN book foreign ON foreign.author_id = me.id

You can specify as many foreign => self mappings as necessary.

Valid attributes are as follows:

join_type

Explicitly specifies the type of join to use in the relationship. Any SQL join type is valid, e.g. LEFT or RIGHT. It will be placed in the SQL command immediately before JOIN.

proxy

An arrayref containing a list of accessors in the foreign class to proxy in the main class. If, for example, you do the following:

CD->might_have(liner_notes => 'LinerNotes', undef, {
  proxy => [ qw/notes/ ],
});

Then, assuming LinerNotes has an accessor named notes, you can do:

my $cd = CD->find(1);
# set notes -- LinerNotes object is created if it doesn't exist
$cd->notes('Notes go here');
accessor

Specifies the type of accessor that should be created for the relationship. Valid values are single (for when there is only a single related object), multi (when there can be many), and filter (for when there is a single related object, but you also want the relationship accessor to double as a column accessor). For multi accessors, an add_to_* method is also created, which calls create_related for the relationship.

relationships

Returns all relationship names for this source.

relationship_info

Arguments: $relname

Returns a hash of relationship information for the specified relationship name.

has_relationship

Arguments: $rel

Returns true if the source has a relationship of this name, false otherwise.

reverse_relationship_info

Arguments: $relname

Returns an array of hash references of relationship information for the other side of the specified relationship name.

compare_relationship_keys

Arguments: $keys1, $keys2

Returns true if both sets of keynames are the same, false otherwise.

resolve_join

Arguments: $relation

Returns the join structure required for the related result source.

pk_depends_on

Arguments: $relname, $rel_data

Determines whether a relation is dependent on an object from this source having already been inserted. Takes the name of the relationship and a hashref of columns of the related object.

resolve_condition

Arguments: $cond, $as, $alias|$object

Resolves the passed condition to a concrete query fragment. If given an alias, returns a join condition; if given an object, inverts that object to produce a related conditional from that object.

resolve_prefetch

Arguments: hashref/arrayref/scalar

Accepts one or more relationships for the current source and returns an array of column names for each of those relationships. Column names are prefixed relative to the current source, in accordance with where they appear in the supplied relationships. Examples:

my $source = $schema->resultset('Tag')->source;
@columns = $source->resolve_prefetch( { cd => 'artist' } );

# @columns =
#(
#  'cd.cdid',
#  'cd.artist',
#  'cd.title',
#  'cd.year',
#  'cd.artist.artistid',
#  'cd.artist.name'
#)

@columns = $source->resolve_prefetch( qw[/ cd /] );

# @columns =
#(
#   'cd.cdid',
#   'cd.artist',
#   'cd.title',
#   'cd.year'
#)

$source = $schema->resultset('CD')->source;
@columns = $source->resolve_prefetch( qw[/ artist producer /] );

# @columns =
#(
#  'artist.artistid',
#  'artist.name',
#  'producer.producerid',
#  'producer.name'
#)
Arguments: $relname

Returns the result source object for the given relationship.

Arguments: $relname

Returns the class name for objects in the given relationship.

resultset

Returns a resultset for the given source. This will initially be created on demand by calling

$self->resultset_class->new($self, $self->resultset_attributes)

but is cached from then on unless resultset_class changes.

resultset_class

` package My::ResultSetClass; use base 'DBIx::Class::ResultSet'; ...

$source->resultset_class('My::ResultSet::Class');

Set the class of the resultset, this is useful if you want to create your own resultset methods. Create your own class derived from DBIx::Class::ResultSet, and set it here. If called with no arguments, this method returns the name of the existing resultset class, if one exists.

resultset_attributes

$source->resultset_attributes({ order_by => [ 'id' ] });

Specify here any attributes you wish to pass to your specialised resultset. For a full list of these, please see "ATTRIBUTES" in DBIx::Class::ResultSet.

source_name

Arguments: $source_name

Set the name of the result source when it is loaded into a schema. This is usefull if you want to refer to a result source by a name other than its class name.

package ArchivedBooks;
use base qw/DBIx::Class/;
__PACKAGE__->table('books_archive');
__PACKAGE__->source_name('Books');

# from your schema...
$schema->resultset('Books')->find(1);

handle

Obtain a new handle to this source. Returns an instance of a DBIx::Class::ResultSourceHandle.

throw_exception

See "throw_exception" in DBIx::Class::Schema.

sqlt_deploy_hook($sqlt_table)

An optional sub which you can declare in your own Schema class that will get passed the SQL::Translator::Schema::Table object when you deploy the schema via "create_ddl_dir" or "deploy".

For an example of what you can do with this, see "Adding Indexes And Functions To Your SQL" in DBIx::Class::Manual::Cookbook.

AUTHORS

Matt S. Trout <mst@shadowcatsystems.co.uk>

LICENSE

You may distribute this code under the same terms as Perl itself.