g'day. This is dbcook, a framework to cook databases from recipes, written as python declarations. Eventually the result may be edible (;-) If u're interested, have a look, dbcook/usage/example1.py might be a start. The directory-structure is still in flux - u need to get the internal dbcook/ accessible somehow (PYTHONPATH or else). Licensed as MIT-license. svn co https://dbcook.svn.sf.net/svnroot/dbcook/trunk http://dbcook.sf.net Here a short description what it probably is, and can do: A framework for declarative mapping of object hierarchies/relations into a (relational or not) database. The "language" itself is made with independence in mind, although currently all available builder stuff is over SQLAlchemy as backend (so it looks like wrapping declarative translator). It completely hides/automates the table/key/column/mapper/whatever creation. The user can only control certain characteristics of the way the mapping happens, mostly related to hierarchy and relations between objects (subclasses, instances, leafs, uniqueness etc). it's about 10 months old now. It can handle: - data column types - reference columns -> foreign keys - class inheritance, and class inclusion (inheritance without database mapping of the base), and virtual classes (those never have instances). More in mapcontext._Base - polymorphism, giving 3 kinds of queries for each mapped class: ALL, base-only, subclasses only - any combination of table-inheritance-types within the tree (concrete/joined/no-single-yet; beware that sql-polymorphism only works with joined-table for now) - automatic solving of cyclical references/dependencies (and putting proper alter_table / post_update) - associations (many2many) - implicit and explicit - more? maybe Example declarations: import dbcook.usage.plainwrap as o2r class Text( o2r.Type): pass class Address( Base): place = Text() class Person( o2r.Base): name = Text() address = o2r.Type4SubStruct( Address) friend = o2r.Type4SubStruct( 'Person') class Employee( Person): job = Text() ..... and no mentioning of tables, columns etc whatsoever ..... Once the mapping is built, any of these can be done: - use it as plain SA - session.query( class).. and similar - query-clause expressions can be automatically created from plain python functions over objects' attributes, e.g.: lambda self: (self.friend.manager.age < 40) & self.name.endswith('a') - generate a source of the equivalent plain SA-calls to build it So far it is just a library. There is no single way to use it. The directory usage/ has 2 possible reflectors (things that walk the declared classes and gather info from them), one is just plain python (plainwrap.py), another is for my static_type/ framework. You can make your own for your own taste. The usage/samanager thing tries to (correctly - context like) keep all related things in one place - mappings, dbs, engines, sessions, etc. If destroy() is requested, it'll try hard to clear all side-effects of its existence. Certain pieces are (almost) independent and are usable as is without all the rest: expression.py, usage/hack*py, sa_generator.py - all SQLAlchemy related. The tests/ directory contains 2 types of tests - sa/ which proves that the way SA is used in dbcook is correct/working, and mapper/other which check whether the cooker does right thing as result. It still uses makefile to run all stuff. external dependencies: - needs kjbuckets (from gadfly) for graph-arithmetics - needs sqlalchemy, 0.3.6+? - optional static_type/ framework - makes staticly-declared structs (a-la java/C semantics) in python - do mail if interested. Some todo's, long- or short- term: - nicer/some way of declaring collections (SA: relation(.. use_list=True)) - some documentation, translate all in both languages. - tests for all the stuff, in most of combinations, instead of just trying this/that - generate sql-server-side functions, triggers etc - autoload / reverse-engineering - single-table inheritance - other reflectors/"syntaxes" - e.g. elixir-like - concrete-polymorphism: polymunion of (type,id) key have fun svil svilen_dobrev at users point sourceforge point net Might be easier to reach me at sqlalchemy's newsgroup. -------------- <P><A HREF="http://dbcook.sf.net">dbcook 0.1</A> - A framework for declarative mapping of object hierarchies/relations into a (relational or not) database. (19-jul-2007)