Author image Matthew Lawrence
and 1 contributors


Class::DBI::ViewLoader - Load views from existing databases as Class::DBI classes


    use Class::DBI::ViewLoader;

    # set up loader object
    $loader = new Class::DBI::ViewLoader (
            dsn => 'dbi:Pg:dbname=mydb',
            username => 'me',
            password => 'mypasswd',
            options => {
                RaiseError => 1,
                AutoCommit => 1
            namespace => 'MyClass::View',
            exclude => qr(^te(?:st|mp)_)i,
            include => qr(_foo$),
            import_classes => [qw(
            base_classes => [qw(
            accessor_prefix => 'get_',
            mutator_prefix => 'set_',

    # create classes
    @classes = $loader->load_views;

    # retrieve all rows from view live_foo

    # Get the class name from the view name
    $class = $loader->view_to_class('live_foo');

    # Works for views that weren't loaded too
    $unloaded_class = $loader->view_to_class('test_foo');


This class loads views from databases as Class::DBI classes. It follows roughly the same interface employed by Class::DBI::Loader.

This class behaves as a base class for the database-dependent driver classes, which are loaded by Module::Pluggable. Objects are reblessed into the relevant subclass as soon as the driver is discovered, see set_dsn(). Driver classes should always be named Class::DBI::ViewLoader::<driver_name>.



    $obj = $class->new(%args)

Instantiates a new object. The values of %args are passed to the relevant set_* accessors, detailed below. The following 2 statements should be equivalent:

    new Class::DBI::ViewLoader ( dsn => $dsn, username => $user );

    new Class::DBI::ViewLoader->set_dsn($dsn)->set_username($user);

For compatibilty with Class::DBI::Loader, the following aliases are provided for use in the arguments to new() only.

  • user -> username

  • additional_classes -> import_classes

  • additional_base_classes -> base_classes

  • constraint -> include

the debug and relationships options are not supported but are silently ignored.


    new Class::DBI::ViewLoader user => 'me', constraint => '^foo', debug => 1;

Is equivalent to:

    new Class::DBI::ViewLoader username => 'me', include => '^foo';

Unrecognised options will cause a fatal error to be raised, see DIAGNOSTICS.



    $obj = $obj->set_dsn($dsn_string)

Sets the datasource for the object. This should be in the form understood by DBI e.g. "dbi:Pg:dbname=mydb"

Calling this method will rebless the object into a handler class for the given driver. If no such handler is installed, "No handler for driver" will be raised via croak(). See DIAGNOSTICS for other fatal errors raised by this method.


    $dsn = $obj->get_dsn

Returns the dsn string, as passed in by set_dsn.


    $obj = $obj->set_username($username)

Sets the username to use when connecting to the database.


    $username = $obj->get_username

Returns the username.


    $obj = $obj->set_password

Sets the password to use when connecting to the database.


    $password = $obj->get_password

Returns the password


    $obj = $obj->set_dbi_options(%opts)

Accepts a hash or a hash reference.

Sets the additional configuration options to pass to DBI.

The hash will be copied internally, to guard against any accidental modification after assignment.

Options specified affect how the database that is used by the loader is built. This is not always the same handle that is used by generated classes.


    \%opts = $obj->get_dbi_options

Returns the DBI options hash. The return value should always be a hash reference, even if there are no dbi options set.

The reference returned by this function is live, so modification of it directly affects the object.


    $obj = $obj->set_namespace($namespace)

Sets the namespace to load views into. This should be a valid perl package name, with or without a trailing '::'.


    $namespace = $obj->get_namespace

Returns the target namespace. If not set, returns an empty list.


    $obj = $obj->set_include($regexp)

Sets a regexp that matches the views to load. Only views that match this expression will be loaded, unless they also match the exclude expression.

Accepts strings or Regexps, croaks if any other reference is passed.

The value is stored as a Regexp, even if a string was passed in.


    $regexp = $obj->get_include

Returns the include regular expression.

Note that this may not be identical to what was passed in.


    $obj = $obj->set_exclude($regexp)

Sets a regexp to use to rule out views. Any view that matches this regex will not be loaded by load_views(), even if it is explicitly included by the include rule.

Accepts strings or Regexps, croaks if any other reference is passed.

The value is stored as a Regexp, even if a string was passed in.


    $regexp = $obj->get_exclude

Returns the exclude regular expression.

Note that this may not be identical to what was passed in.


    $obj = $obj->set_base_classes(@classes)

Sets classes for all generated classes to inherit from.

This is in addition to the class specified by the driver's base_class method, which will always be the first item in the generated @ISA.

Note that these classes are not loaded for you, be sure to use or require them yourself.


    $obj = $obj->add_base_classes(@classes)

Appends to the list of base classes.


    @classes = $obj->get_base_classes

Returns the list of base classes, as supplied by set_base_classes.


Sets base classes like set_base_classes, except that the added classes will go before the driver's base_class.


    @classes = $obj->get_left_base_classes

Returns the list of left base classes, as supplied by set_base_classes.


    $obj = $obj->add_base_classes(@classes)

Appends to the list of left base classes.


    $obj = $obj->set_import_classes(@classes)

Sets a list of classes to import from. Note that these classes are not loaded by the generated class itself.

    # Load the module first
    require Class::DBI::Plugin::RetrieveAll;
    # Make generated classes import symbols

Any classes that inherit from Exporter will be loaded via Exporter's export function. Any other classes are loaded by a use call in a string eval.


    $obj = $obj->add_import_classes(@classes)

Appends to the list of import classes.


    @classes = $obj->get_import_classes

Returns the list of classes that will be imported into you generated classes.


    $obj = $obj->set_accessor_prefix

Sets the accessor prefix for generated classes. See Class::DBI for details of how this works.


    $prefix = $obj->get_accessor_prefix

Returns the object's accessor prefix.


    $obj = $obj->set_mutator_prefix

Sets the mutator prefix for generated classes. See Class::DBI for details of how this works.


    $prefix = $obj->get_mutator_prefix

Returns the object's mutator prefix.



    @classes = $obj->load_views

The main method for the class, loads all relevant views from the database and generates classes for those views.

The generated classes will be read-only and have a multi-column primary key containing every column. This is because it is not guaranteed that the view will have a real primary key and Class::DBI insists that there should be a unique identifier for every row.

If the newly generated class inherits a "Main" Class::DBI handle (via connection or set_db calls in base classes) that handle will be used by the class. Otherwise, a new connection is set up for the classes based on the loader's connection.

Usually, any row containing an undef (NULL) primary key column is considered false in boolean context, in this particular case however that doesn't make much sense. So only all-null rows are considered false in classes generated by this class.

Each class is only ever generated once, no matter how many times load_views() is called. If you want to load the same view twice for some reason, you can achieve this by changing the namespace.

Returns class names for all created classes.


    $class = $obj->view_to_class($view)

Returns the class for the given view name. This depends on the object's current namespace, see set_namespace(). It doesn't matter if the class has been loaded, or if the view exists in the database.

If this method is called without arguments, or with an empty string, it returns an empty string.


    $dbh = $obj->_get_dbi_handle

Returns a DBI handle based on the object's dsn, username and password. This generally shouldn't be called externally (hence the leading underscore).

Making multiple calls to this method won't cause multiple connections to be made. A single handle is cached by the object from the first call to _get_dbi_handle until such time as the object goes out of scope or set_dsn is called again, at which time the handle is disconnected and the cache is cleared.

If the connection fails, a fatal error is raised.



This is the cleanup method for the object's DBI handle. It is called whenever the DBI handle needs to be closed down. i.e. when a new handle is used or the object goes out of scope. Subclasses should override this method if they need to clean up any state data that relies on the current database connection, like statement handles for example. If you don't want the handle that the object is using to be disconnected, use the _set_keepalive method.

    sub _clear_dbi_handle {
        my $self = shift;

        delete $self->{statement_handle};



    $obj = $obj->_set_dbi_handle($dbh)

This method is used to attach a DBI handle to the object. It might prove useful to use this method in order to use an existing database connection in the loader object. Note that unlike set_dsn, calling this method directly will not cause an appropriate driver to be loaded. See _load_driver for that.


    $obj = $obj->_set_keepalive($bool)

When set to true, the database handle used by the object won't be disconnected automatically.


    $obj = $obj->_load_driver($driver_name)

This method is used internally by set_dsn to load a driver to handle database-specific functionality. It can be called directly in conjunction with _set_dbi_handle to load views from an existing database connection.


The following methods are provided by the relevant driver classes. If they are called on a native Class::DBI::ViewLoader object (one without a dsn set), they will cause fatal errors. They are documented here for the benefit of driver writers but they may prove useful for users also.

  • base_class

        $class = $driver->base_class

    Should return the name of the base class to be used by generated classes. This will generally be a Class::DBI driver class.

        package Class::DBI::ViewLoader::Pg;
        # Generate postgres classes
        sub base_class { "Class::DBI::Pg" }
  • get_views

        @views = $driver->get_views;

    Should return the names of all the views in the current database.

  • get_view_cols

        @columns = $driver->get_view_cols($view);

    Should return the names of all the columns in the given view.

A list of these methods is provided by this class, in @Class::DBI::ViewLoader::driver_methods, so that each driver can be sure that it is implementing all required methods. The provided t/04..plugin.t is a self-contained test script that checks a driver for compatibility with the current version of Class::DBI::ViewLoader, driver writers should be able to copy the test into their distribution and edit the driver name to provide basic compliance tests.


The following fatal errors are raised by this class:

  • No dsn

    set_dsn was called without an argument

  • Invalid dsn %s

    the dsn passed to set_dsn couldn't be parsed by DBI->parse_dsn

  • No handler for driver %s, from dsn %s

    set_dsn couldn't find a driver handler for the given dsn. You may need to install a plugin to handle your database.

  • No handler loaded

    load_views() or some other driver-dependent method was called on an object which hadn't loaded a driver.

  • %s not overridden

    A driver did not override the given method. You may need to upgrade the driver class.

  • Couldn't connect to database

    Self-explanatory. The DBI error string is appended to the error message.

  • Regexp or string required

    set_include or set_exclude called with a ref other than 'Regexp'.

  • Unrecognised arguments in new

    new() encountered unsupported arguments. The offending arguments are listed after the error message.

The following warnings are generated:

  • No columns found in %s, skipping

    The given view didn't seem to have any columns, it won't be loaded.

  • %s has no import function

    The given module from the object's import_classes list couldn't be imported because it had no import() function.


With later versions of Class::DBI, columns names that clash with methods (such as 'id') can cause exceptions. Using accessor_prefix and mutator_prefix can help avoid this problem.


DBI, Class::DBI, Class::DBI::Loader


Matt Lawrence <>


Copyright 2005 Matt Lawrence, All Rights Reserved.

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.