|
Alzabo::Create::Schema - Schema objects for schema creation |
load_from_file($name)Alzabo::Create::Table object)
Alzabo::Create::Schema - Schema objects for schema creation
use Alzabo::Create::Schema;
This class represents the whole schema. It contains table objects, which in turn contain columns, indexes, etc. It contains methods that act globally on the schema, including methods to save it to disk, create itself in an RDBMS, create relationships between tables, etc.
Alzabo::Schema
Note: all relevant documentation from the superclass has been merged into this document.
Alzabo::RDBMSRules->available
method. These are values such as 'MySQL', 'PostgreSQL', etc.
A new Alzabo::Create::Schema object.
Alzabo::Exception::Params
Alzabo::Exception::System
load_from_file($name)Returns a schema object previously saved to disk.
The Alzabo::Create::Schema object specified by the name parameter.
Attempts to connect to a database and instantiate a new schema object based on information in the specified database. The returned object will have its instantiated value set to true so that subsequent changes will lead to SQL diffs, as opposed to SQL to create the database from scratch.
The schema object returned by this method will have its instantiated
attribute set as true. This means that calling the make_sql method
on the object won't generate any SQL. To do this you'd have to first
call
$schema->set_instantiated(0) and then $schema->make_sql.
new method documentation for an explanation of this
parameter.
A new Alzabo::Create::Schema object.
A string containing the name of the schema.
Change the schema name. Since schemas are saved on disk with
filenames based on the schema name, this deletes the files for the old
name. Call save_to_file immediately afterwards if
you want to make sure you have a copy of the schema saved.
An Alzabo::Create::Table object representing the specified
table.
A list of Alzabo::Create::Table object named in the list
given. If no list is provided, then it returns all table objects in
the schema.
This method makes a new table and adds it to the schema, the
parameters given are passed directly to the
Alzabo::Create::Table->new method.
The schema parameter is filled in automatically.
The Alzabo::Create::Table object created.
Alzabo::Create::Table object)Removes the given table from the schema. This method will also delete all foreign keys in other tables that point at the given table.
Add a table to the schema. If a before or after parameter is given
then the move_table method will be called to move the
new table to the appropriate position.
Alzabo::Create::Table objectAlzabo::Create::Table object (optional)Alzabo::Create::Table object (optional)
The Alzabo::Create::Table object created.
Allows you to change the order of the tables as they are stored in the schema.
Alzabo::Create::Table objectand either ...
Alzabo::Create::Table object... or ...
Alzabo::Create::Table object
Creates a relationship between two tables. This involves creating
Alzabo::Create::ForeignKey objects in
both tables. If the columns_from and columns_to parameters are
not specified then the schema object attempts to calculate the proper
values for these attributes.
This is determined as follows: If the min_max_from value is 1..1 or
1..n, it assumes that the table specified as table_from is dependent
on the other table, and use the other table's primary key as the
linking table. If the min_max_from and min_max_to are both 0..(1
or n) then it also assumes that the table_from table is dependent.
In all other cases, it uses the primary key from the table_from.
If no columns with the same names exist in the other table, then
columns with that name will be created. Otherwise, it changes the
dependent columns so that their
Alzabo::Create::ColumnDefinition
objects are the same as the columns in the table upon which it is
dependent, meaning that changes to the type of one column affects both
at the same time.
If you want to make multi-column relation, the assumption is that the
order of the columns is significant. In other words, the first column
in the columns_from parameter is assumed to correspond to the first
column in hte columns_to parameter and so on.
The number of columns given in columns_from and columns_to must
be the same except when both min_max_... parameters have are (0 or
1)..n.
If both the min_max_from and min_max_to parameters are (0 or
1)..n then a new table will be created to link the two tables
together. This table will contain the primary keys of both the tables
passed into this function. It will contain foreign keys to both of
these tables as well and these tables will be linked to this new
table.
Alzabo::Create::Table object (optional if columns_from is provided)Alzabo::Create::Table object (optional if columns_to is provided)Alzabo::Create::Column object (optional if table_from is provided)Alzabo::Create::Column object (optional if table_to is provided)The first of these scalars can be the value '0' or '1' while the second can be '1' or 'n'.
This method causes the schema to connect to the RDBMS, create a new database if necessary, and then execute whatever SQL is necessary to make that database match the current state of the schema object. If the schema has been instantiated previously, then it will generate the SQL necessary to change the database. This may be destructive (dropping tables, columns, etc) so be careful. This will cause the schema to be marked as instantiated.
Wherever possible, existing data will be preserved.
The value of the schema's instantiated attribute. It is true if the schema has been created in an RDBMS backend, otherwise it is false.
Set the schema's instantiated attribute as true or false.
The Alzabo::Driver subclass object for the
schema.
The schema's Alzabo::RDBMSRules object.
An array containing the SQL statements necessary to either create the
database from scratch or update the database to match the schema
object. See the create method for
more details.
Drops the database/schema from the RDBMS. This will cause the schema
to be marked as not instantiated. This method does not delete the
Alzabo files from disk. To do this, call the delete method.
Removes the schema object from disk. It does not delete the database
from the RDBMS. To do this you must call the drop method
first.
This method creates a new object identical to the one that the method was called on, except that this new schema has a different name, it does not yet exist on disk, its instantiation attribute is set to false.
It is also worth noting that if you set the instantiation attribute to true immediately, then the new schema be able to generate 'diffs' against the last version of the schema instantiated in an RDBMS backend. This is useful in the case where you have already copied the data from the old database to the new database in the RDBMS backend.
A new Alzabo::Create::Schema object.
Saves the schema to a file on disk.
Dave Rolsky, <autarch@urth.org>
|
Alzabo::Create::Schema - Schema objects for schema creation |