Dave Rolsky

NAME

Alzabo::Create::Schema - Schema objects for schema creation

SYNOPSIS

  use Alzabo::Create::Schema;

DESCRIPTION

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.

Instantiation

Every schema keeps track of whether it has been instantiated or not. A schema that is instantiated is one that exists in an RDBMS backend. This can be done explicitly by calling the schema's create() method. It is also implicitly set when a schema is created as the result of reverse engineering.

The most important effect of instantiation is that once a schema is instantiated, the way it generates SQL for itself changes. Before it is instantiated, if you ask it to generate SQL via the make_sql() the method, it will generate the set of SQL statements that are needed to create the schema from scratch.

After it is instantiated, the schema will instead generate the SQL necessary to convert the version in the RDBMS backend to match the object's current state. This can be thought of as a SQL 'diff'.

While this feature is quite useful, it can be confusing too. The most surprising aspect of this is that if you create a schema via reverse engineering and then call the make_sql() method, you will not get any SQL. This is because the schema knows that it is instantiated and it also knows that it is the same as the version in the RDBMS, so no SQL is necessary.

You can use the set_instantiated() method method to change whether or not the schem thinks it is instantiated.

INHERITS FROM

Alzabo::Schema

METHODS

Constructors

new

This constructor takes the following parameters:

  • name => $name

    This is the name of the schema, and will be the name of the database in the RDBMS.

  • rdbms => $rdbms

    This is a string identifying the RDBMS. The allowed values are returned from the Alzabo::RDBMSRules->available method. These are values such as 'MySQL', 'PostgreSQL', etc.

It returns a new Alzabo::Create::Schema object.

Throws: Alzabo::Exception::Params, Alzabo::Exception::System

load_from_file

This constructor takes the following parameters:

  • name => $schema_name

Returns a schema object previously saved to disk, as specified by the "name" parameters.

Throws: Alzabo::Exception::Params, Alzabo::Exception::System

reverse_engineer

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.

It takes the following parameters:

  • name => $name

    The name of the database with which to connect.

  • rdbms => $rdbms

    See the new method documentation for an explanation of this parameter.

In addition, this method takes any parameters that can be used when connecting to the RDBMS, including "user", "password", "host", and "port".

Returns a new Alzabo::Create::Schema object.

Other Methods

set_name ($name)

Changes 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.

Throws: Alzabo::Exception::Params, Alzabo::Exception::RDBMSRules, Alzabo::Exception::System

make_table

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.

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.

Returns a new Alzabo::Create::Table object.

Throws: Alzabo::Exception::Params, Alzabo::Exception::RDBMSRules

delete_table (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.

Throws: Alzabo::Exception::Params

add_table

Add a table to the schema.

This methods takes the following parameters:

  • table => Alzabo::Create::Table object

  • after => Alzabo::Create::Table object (optional)

    ... or ...

  • before => Alzabo::Create::Table object (optional)

Returns a new Alzabo::Create::Table object.

Throws: Alzabo::Exception::Params

move_table

Allows you to change the order of the tables as they are stored in the schema.

This method takes the following parameters:

  • table => Alzabo::Create::Table object

    The table to move.

    and either ...

  • before => Alzabo::Create::Table object

    Move the table before this table

    ... or ...

  • after => Alzabo::Create::Table object

    Move the table after this table.

Throws: Alzabo::Exception::Params

add_relationship

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.

To do this, Alzabo attempts to determine the dependencies of the tables. If you have specified a cardinality of 1..1, or n..1, in cases where both tables are independent, or where they are both dependent then the "table_from" is treated as being the dependent table for the purposes of determining

If no columns with the same names exist in the other table, then columns with those names will be created. Otherwise, add_relationship() changes the dependent columns so that their Alzabo::Create::ColumnDefinition objects are the same as the columns in the table upon which they are dependent, meaning that changes to the type of one column affects both at the same time.

If you want to make a multi-column relationship, the assumption is that the order of the columns is significant. In other words, the first column in the "columns_from" parameter should 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 creating a many to many relationship.

If the cardinality is many to many 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.

This method takes the following parameters:

  • table_from => Alzabo::Create::Table object (optional if columns_from is provided)

  • table_to => Alzabo::Create::Table object (optional if columns_to is provided)

  • columns_from => Alzabo::Create::Column object (optional if table_from is provided)

  • columns_to => Alzabo::Create::Column object (optional if table_to is provided)

  • cardinality => [1, 1], [1, 'n'], ['n', 1], or ['n', 'n']

  • name => $name

    If provided, and if the specified cardinality requires the creation of a linking table, this string will be used to name that linking table. Otherwise, the new table's name will be synthesized from the names of those it's linking.

  • from_is_dependent => $boolean

  • to_is_dependent => $boolean

  • comment => $comment

Throws: Alzabo::Exception::Params

create

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.

This method takes any parameters that can be used when connecting to the RDBMS, including "schema_name", "user", "password", "host", and "port".

If a "schema_name" parameter is given, then this will be the name given to the schema in the RDBMS.

Warning: Every time you call create() or sync_backend(), the schema will consider itself to have been instantiated. This will affect how schema diffs are generated. After this, you will almost certainly need to use sync_backend() to sync the RDBMS schema, since the schema's internal notion of it's state may be incorrect.

instantiated

Returns a boolean value indicating whether the schema has been created in an RDBMS backend, otherwise it is false.

set_instantiated ($bool)

Set the schema's instantiated attribute as true or false.

Throws: Alzabo::Exception::Params

make_sql

Returns 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.

drop

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.

This method takes any parameters that can be used when connecting to the RDBMS, including "schema_name", "user", "password", "host", and "port".

Throws: Alzabo::Exception::Driver

sync_backend

This method will look at the schema as it exists in the RDBMS backend, and make any changes that are necessary in order to make this backend schema match the Alzabo schema object. If there is no corresponding schema in the RDBMS backend, then this method is equivalent to the create() method.

After this method is called, the schema will be considered to be instantiated.

This method will never be perfect because some RDBMS backends alter table definitions as they are created. For example, MySQL has default column "lengths" for all of its integer columns. Alzabo tries to account for these.

In the end, this means that Alzabo may never think that a schema in the RDBMS exactly matches the state of the Alzabo schema object. Even immediately after running this method, running it again may still cause it to execute SQL commands. Fortunately, the SQL it generates will not cause anything to break.

This method takes any parameters that can be used when connecting to the RDBMS, including "schema_name", "user", "password", "host", and "port".

Throws: Alzabo::Exception::Driver

sync_backend_sql

If there is no corresponding schema in the RDBMS backend, then this method returns the SQL necessary to create the schema from scratch.

This method takes any parameters that can be used when connecting to the RDBMS, including "schema_name", "user", "password", "host", and "port".

Throws: Alzabo::Exception::Driver

delete

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.

Throws: Alzabo::Exception::System

clone

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 takes the following parameters:

  • name => $name

This method returns a new Alzabo::Create::Schema object.

Throws: Alzabo::Exception::Params, Alzabo::Exception::RDBMSRules

save_to_file

Saves the schema to a file on disk.

Throws: Alzabo::Exception::System

runtime_clone

Returns a new Alzabo::Runtime::Schema object based on the current schema.

is_saved

Returns true if the schema has been saved to disk.

AUTHOR

Dave Rolsky, <autarch@urth.org>




Hosting generously
sponsored by Bytemark