NAME

       DBIx::Class::Manual::Glossary - Clarification of terms used.

INTRODUCTION

       This document lists various terms used in DBIx::Class and attempts to explain them.

DBIx::Class TERMS

   DB schema
       Refers to a single physical schema within an RDBMS. Synonymous with the terms 'database',
       for MySQL; and 'schema', for most other RDBMS(s).

       In other words, it's the 'xyz' _thing_ you're connecting to when using any of the
       following DSN(s):

         dbi:DriverName:xyz@hostname:port
         dbi:DriverName:database=xyz;host=hostname;port=port

   Inflation
       The act of turning database row data into objects in language-space. DBIx::Class result
       classes can be set up to inflate your data into perl objects which more usefully represent
       their contents. For example: DBIx::Class::InflateColumn::DateTime for datetime or
       timestamp column data.

       See also DBIx::Class::InflateColumn.

   Deflation
       The opposite of "Inflation". Existing perl objects that represent column values can be
       passed to DBIx::Class methods to store into the database. For example a DateTime object
       can be automatically deflated into a datetime string for insertion.

       See DBIx::Class::InflateColumn and other modules in that namespace.

   ORM
       Object-relational mapping, or Object-relationship modelling. Either way it's a method of
       mapping the contents of database tables (rows), to objects in programming-language-space.
       DBIx::Class is an ORM.

   Relationship
       In DBIx::Class a relationship defines the connection between exactly two tables. The
       relationship condition lists the columns in each table that contain the same values. It is
       used to output an SQL JOIN condition between the tables.

   Relationship bridge
       A relationship bridge, such as "many_to_many" defines an accessor to retrieve row contents
       across multiple relationships.

       The difference between a bridge and a relationship is, that the bridge cannot be used to
       "join" tables in a "search", instead its component relationships must be used.

   Schema
       A Schema object represents your entire table collection, plus the connection to the
       database. You can create one or more schema objects, connected to various databases, with
       various users, using the same set of table "Result class" definitions.

       At least one DBIx::Class::Schema class is needed per database.

   Result class
       A Result class defines both a source of data (usually one per table), and the methods that
       will be available in the "Result" objects created using that source.

       One Result class is needed per data source (table, view, query) used in your application,
       they should inherit from DBIx::Class::Core.

       See also: DBIx::Class::Manual::ResultClass

   ResultSource
       ResultSource objects represent the source of your data, these are sometimes (incorrectly)
       called table objects.

       ResultSources do not need to be directly created, a ResultSource instance is created for
       each "Result class" in your "Schema", by the proxied methods "table" and "add_columns".

       See also: "METHODS" in DBIx::Class::ResultSource

   ResultSet
       This is an object representing a set of conditions to filter data. It can either be an
       entire table, or the results of a query. The actual data is not held in the ResultSet, it
       is only a description of how to fetch the data.

       See also: "METHODS" in DBIx::Class::ResultSet

   Record
       See Result.

   Row
       See Result.

   Result
       Result objects contain your actual data. They are returned from ResultSet objects.  These
       are sometimes (incorrectly) called row objects, including older versions of the DBIC
       documentation.

       See also: DBIx::Class::Manual::ResultClass

   Object
       See Result.

   join
       See Join.

   prefetch
       Similar to a join, except the related result objects are fetched and cached for future
       use, instead of used directly from the ResultSet.  This allows you to jump to different
       relationships within a Result without worrying about generating a ton of extra SELECT
       statements.

SQL TERMS

   CRUD
       Create, Read, Update, Delete.  A general concept of something that can do all four
       operations (INSERT, SELECT, UPDATE, DELETE), usually at a row-level.

   Join
       This is an SQL keyword, it is used to link multiple tables in one SQL statement. This
       enables us to fetch data from more than one table at once, or filter data based on content
       in another table, without having to issue multiple SQL queries.

   Normalisation
       A normalised database is a sane database. Each table contains only data belonging to one
       concept, related tables refer to the key field or fields of each other. Some links to
       webpages about normalisation can be found in DBIx::Class::Manual::FAQ.

   Related data
       In SQL, related data actually refers to data that are normalised into the same table.
       (Yes. DBIC does mis-use this term.)

AUTHOR AND CONTRIBUTORS

       See AUTHOR and CONTRIBUTORS in DBIx::Class

LICENSE

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