NAME

       Tangram::Type - mapping individual fields

DESCRIPTION

       Tangram's persistent type system is extensible, allowing you to mount your own types and
       make them persistent. All you have to do is to register your type and provide mapping
       code. See Tangram::Type::Extending.

       Tangram comes with built-in support for the following types:

       Simple Scalar types
           Supported are strings, integers, real numbers and dates.  More types of this ilk are
           easily added.

           "string", "int", "real": see Tangram::Type::Scalar

           "date", "time", "datetime", "dmdatetime": see "Date/Type/Date/DateTime" in
           Tangram::Type

       Compound Structure types
           "perl_dump": see Tangram::Type::Dump::Perl.  A "perl_dump" structure may contain any
           structure which Data::Dumper can dump successfully.

           "storable": see Tangram::Type::Dump::Storable.  Very much like "perl_dump", but
           implemented via the `Storable' serialisation engine.

           "yaml": see Tangram::Type::Dump::YAML.  Very much like "perl_dump", but implemented
           via the `YAML' serialisation engine.  Doesn't currently work, due to inadequacies in
           the current Perl YAML implementation.

           NEW in Tangram 2.08:

           "idbif": see Tangram::Type::Dump::Any.  Like the above, but can combine multiple
           object properties into a single database column.

       `Flat' Array & Hash types
           Note: these are only actually required if you need to be able to query on individual
           fields inside the array/hash - otherwise, the "perl_dump" or "idbif" mapping is a lot
           faster and more flexible.

           "flat_array": see "Array/Scalar" in Tangram::Type

           "flat_hash": see "Hash/Scalar" in Tangram::Type

       References to other objects
           "ref": see Tangram::Type::Ref::FromMany (implementing an N to 1 relationship, in which
           any object can be the referant)

       Sets of other objects
           Set relationships are closest to the main type of relationship used in an RDBMS.  Avid
           CompSci students will know that the relational database model is based heavily on `Set
           Theory', which is a subset of a more general concept of `Categories' - generic
           couplings of a number of classes.

           In Perl space, these collections are represented via the Set::Object module.  Sets may
           not have duplicate elements, and cannot contain undef values.

           "set": see Tangram::Type::Set::FromMany (implementing an unordered N to N
           relationship, with all objects sharing a common base class)

           "iset": see Tangram::Type::Set::FromOne (implementing an unordered 1 to N
           relationship, with all objects sharing a common base class)

       Arrays of other objects
           The addition to Sets, you can have `Arrays' of objects, represented by a standard Perl
           array in memory.  Arrays may contain undef values (in the middle of the list), and the
           "array" type may contain duplicates (ie, the same element present in separate places
           in the list).

           "array" : see Tangram::Type::Array::FromMany (implementing an ordered N to N
           relationship, with all objects sharing a common base class)

           "iarray": see Tangram::Type::Array::FromOne (implementing an ordered 1 to N
           relationship, with all objects sharing a common base class)

       Hashes of other objects
           Much like the Array types, the Hash types are indexed via a string value, and
           represented as a Perl hash in memory.  These hashes may not contain undef values
           (those are dropped).  The "hash" type may contain duplicate elements.

           "hash" : see Tangram::Type::Hash::FromMany (implementing a keyed N to N relationship,
           with all objects sharing a common base class)

           "ihash": see Tangram::Type::Hash::FromOne (implementing a keyed 1 to N relationship,
           with all objects sharing a common base class)