Alzabo::Runtime::Schema - Schema objects
use Alzabo::Runtime::Schema qw(some_schema); my $schema = Alzabo::Runtime::Schema->load_from_file( name => 'foo' ); $schema->set_user( $username ); $schema->set_password( $password ); $schema->connect;
This object can only be loaded from a file. The file is created whenever a corresponding Alzabo::Create::Schema object is saved.
Alzabo::Schema
Loads a schema from a file. This is the only constructor for this class.
name => $schema_name
An Alzabo::Runtime::Schema object.
Alzabo::Runtime::Schema
Alzabo::Exception::Params
The username used by the schema when connecting to the database.
Set the username to use when connecting to the database.
The password used by the schema when connecting to the database.
Set the password to use when connecting to the database.
The host used by the schema when connecting to the database.
Set the host to use when connecting to the database.
A boolean value indicating whether this schema will attempt to maintain referential integrity.
Sets the value returned by the referential_integrity method. If true, then when Alzabo::Runtime::Row objects are deleted, updated, or inserted, they will report this activity to any relevant Alzabo::Runtime::ForeignKey objects for the row, so that the foreign key objects can take appropriate action.
referential_integrity
Alzabo::Runtime::Row
Alzabo::Runtime::ForeignKey
Defaults to false.
Calls the Alzabo::Driver->connect method for the driver owned by the schema. The username, password, and host set for the schema will be passed to the driver, as will any additional parameters given to this method. See the Alzabo::Driver->connect method for more details.
Alzabo::Driver->connect
Joins are done by taking the tables provided in order, and finding a relation between them. If any given table pair has more than one relation, then this method will fail. The relations, along with the values given in the optional where clause will then be used to generate the necessary SQL. See Alzabo::Runtime::JoinCursor for more information.
Alzabo::Runtime::JoinCursor
tables => <see below>
This parameter can either be a simple array reference of tables or a reference to an array containing more arrays, each of which contain two tables.
If a simple array reference is given, then the order of these tables is significant when there are more than 2 tables. Alzabo expects to find relationships between tables 1 & 2, 2 & 3, 3 & 4, etc.
For example, given:
tables => [ $table_A, $table_B, $table_C ]
Alzabo would expect that table A has a relationship to table B, which in turn has a relationship to table C.
If you need to specify a more complicated set of relationships, this can be done with a slightly more complicated data structure, which looks like this:
tables => [ [ $table_A, $table_B ], [ $table_A, $table_C ], [ $table_C, $table_D ], [ $table_C, $table_E ] ]
This is fairly self explanatory in that each pair of tables describes a pair of tables between which Alzabo should expect to find a relationship. This allows for the construction of arbitrarily complex join clauses.
If the latter method of specifying tables is used and no select parameter is provided, then order of the rows returned from calling next on the cursor is not guaranteed. In other words, the array that the cursor returns will contain a row from each table involved in the join, but the which row belongs to which table cannot be determined except by examining each row in turn. The order will be the same every time next is called, however.
select
next
select => Alzabo::Runtime::Table object or objects (optional)
Alzabo::Runtime::Table
This parameter specifies from which tables you would like rows returned. If this parameter is not given, then the tables parameter will be used instead.
This can be either a single table or an array reference of table objects.
distinct => Alzabo::Runtime::Table object (optional)
If this parameter is given, it indicates that results from the join should never repeat rows for the given table. This is useful if your join contains multiple tables but you are only interested in rows from some of them.
If you are expecting rows from multiple tables, then it is important that this parameter be set to the table that would have the least repeated rows. Otherwise, you will lose information. For example, if a join would return the following rows:
A B --- --- 1 1 1 1 1 2 2 2 2 3 2 3 3 4 3 4 3 5
etc.
If you set A as distinct, it is possible that you could entirely miss certain relevant rows from B.
where
See the documentation on where clauses for the Alzabo::Runtime::Table class.
order_by
See the documentation on order by clauses for the Alzabo::Runtime::Table class.
limit
See the documentation on limit clauses for the Alzabo::Runtime::Table class.
If the select parameter (or tables parameter) specified that more than one table is desired, then this method will return an Alzabo::Runtime::JoinCursor object representing the results of the join. Otherwise, the method returns an Alzabo::Runtime::RowCursor object.
tables
Alzabo::Runtime::RowCursor
Alzabo::Exception::Logic
Joins are done by taking the tables provided, in order, and finding a relation between them, excluding the last table given. If any given table pair has more than one relation, then this method will fail. The relations, along with the values given in the optional where clause will then be used to generate the necessary SQL. See Alzabo::Runtime::OuterJoinCursor for more information.
Alzabo::Runtime::OuterJoinCursor
See the documentation on the table parameter for the join method.
If you pass a simple array reference of tables for this parameter, then the outer join is done between the first and last table given.
If you pass a reference to an array of array references, then the outer join will be between the first pair of tables.
An Alzabo::Runtime::OuterJoinCursor object. representing the results of the join.
This method takes the exact same parameters as the join method but instead of returning a cursor, it returns a single array of row object. These will be the rows representing the first ids that are returned by the database.
join
These two methods differ only in their return values.
select => $function or [ SQL functions and/or Alzabo::Column objects ]
Alzabo::Column
If you pass an array reference for this parameter, it may contain either SQL functions or column objects. For example:
$schema->function( select => [ $table->column('name'), LENGTH( $table->column('name') ) ] );
See the documentation on the tables parameter for the join method.
group_by
See the documentation on group by clauses for the Alzabo::Runtime::Table class.
This method is used to call arbitrary SQL functions such as 'AVG' or 'MAX'. The function (or functions) should be the return values from the functions exported by the SQLMaker subclass that you are using. Please see Using SQL functions for more details.
The return value of this method is highly context sensitive.
If you only requested a single function ( DISTINCT(foo) ), then it returns the first value in scalar context and all the values in list context.
If you requested multiple functions ( AVG(foo), MAX(foo) ) then it returns a single array reference (the first row of values) in scalar context and a list of array references in list context.
This method always returns a new Alzabo::DriverStatement object containing the results of the query.
Alzabo::DriverStatement
This information is never saved to disk. This means that if you're operating in an environment where the schema object is reloaded from disk every time it is used, such as a CGI program spanning multiple requests, then you will have to make a new connection every time. In a persistent environment, this is not a problem. In a mod_perl environment, you could load the schema and call the set_user and set_password methods in the server startup file. Then all the mod_perl children will inherit the schema with the user and password already set. Otherwise you will have to provide it for each request.
set_user
set_password
You may ask why you have to go to all this trouble to deal with the user and password information. The basic reason was that I did not feel I could come up with a solution to this problem that was secure, easy to configure and use, and cross-platform compatible. Rather, I think it is best to let each user decide on a security practice with which they feel comfortable. If anybody does come up with such a scheme, then code submissions are more than welcome.
If Alzabo is attempting to maintain referential integrity and you are not using either the Alzabo::ObjectCache or Alzabo::ObjectCacheIPC module, then situations can arise where objects you are holding onto in memory can get out of sync with the database and you will not know this. If you are using one of the cache modules then attempts to access data from an expired or deleted object will throw an exception, allowing you to try again (if it is expired) or give up (if it is deleted). Please see Alzabo::ObjectCache for more details.
Alzabo::ObjectCache
Alzabo::ObjectCacheIPC
Dave Rolsky, <autarch@urth.org>
To install Alzabo, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Alzabo
CPAN shell
perl -MCPAN -e shell install Alzabo
For more information on module installation, please visit the detailed CPAN module installation guide.