Short term:

- Expand regression tests for core API - SQLMaker, RDBMSRules.

- Make it possible to do multiple outer joins in a single query.
  restructure join methods to be more flexible.  Something like:

   $schema->join( join => [ [ $table1, $table2 ],
                            [ $table2, $table3, $foreign_key ] ],
                  left_outer => [ $table4, $table1 ],
                  right_outer => [ $table5, $table4, $foreign_key ] );

- Give the options to save objects to disk in something a bit more
  robust than a serialized object form.  Eventually, Alzabo will spit
  out some sort of XML.

- Support transactions in the caching system.  this eventually means
  real transactions at the middleware layer.  argh!

- Make local $table->{prefetch} work (tied scalar).  I'm no longer
  sure this is possible.  My most recent attempt caused inexplicable
  test failures.

Medium term:

- Output Dia XML.

- Support for table attributes (constraints, MySQL table types)

- Add constraints to output SQL for Postgres and MySQL (InnoDB tables
  will actually use them).

- Make sense of foreign key definitions in Postgres and for InnoDB
  tables in MySQL.

- Make a tool to convert schemas from one RDBMS to another.  This will
  probably require user prompting because some things are unresolvable
  without a loss of information.

- Add an Alzabo::Database class between the schema and table.  This
  will allow multiple databases in a schema (on multiple platforms
  ideally) and allow you to do joins between these databases.  This
  probably raises all sorts of horrid caching and transactional issues
  I haven't yet thought of.

- Attempt to guess relationships when reverse engineering a schema
  without foreign key information.

- Rewrite data browser to not suck so much

- Expand data browser to be configurable between sessions (for
  example, to use textarea fields for certain things)

- Help text for all interfaces (some of it should be shared since the
  basic ideas are the same)

- More drivers & rules (Oracle, Sybase, Interbase, Solid, and so on)

- Non-Mason interface(s) (curses, plain CGI)

- Integrate data validation into the code and schema creator in such a
  way that Alzabo::MethodMaker can automatically create pre_insert and
  pre_update methods.

Long term:

- Overhaul foreign key objects so that one relation has one such
  object, shared by two tables.

- GUI (preferably both UNIX & Win32 so Tk?)

Ongoing:

- Support 'feature probing' via the rules for user interface and to
  determine whether to try to do things (like use transactions).  This
  is a broad idea and includes things such as returning a list of
  possible column types to the user interface or having a flag for
  supporting transactions.

- Robin Berjon suggested a single documentation 'page' that contains a
  list of all the method and what objects they apply to.  This exists
  as Alzabo::QuickRef.

- Support any and all SQL, of arbitrary complexity.  This is fairly
  far along, but there's probably more bits to handle (like outer
  joins of >2 tables).

