++++ News ++++ .. contents:: Contents: :backlinks: none .. _start: SQLObject 0.9.1 =============== Released 25 July 2007. Bug Fixes --------- * Fixed misspelled methods in col.py. * A number of bugfixes ported from `SQLObject 0.7.8`_ and `SQLObject 0.8.5`_. SQLObject 0.9.0 =============== Released 10 May 2007. Features & Interface -------------------- * Support for Python 2.2 has been declared obsolete. * Removed actively deprecated attributes; lowered deprecation level for other attributes to be removed after 0.9. * SQLite connection got columnsFromSchema(). Now all connections fully support fromDatabase. There are two version of columnsFromSchema() for SQLite - one parses the result of "SELECT sql FROM sqlite_master" and the other uses "PRAGMA table_info"; the user can choose one over the other by using "use_table_info" parameter in DB URI; default is False as the pragma is available only in the later versions of SQLite. * Changed connection.delColumn(): the first argument is sqlmeta, not tableName (required for SQLite). * SQLite connection got delColumn(). Now all connections fully support delColumn(). As SQLite backend doesn't implement "ALTER TABLE DROP COLUMN" delColumn() is implemented by creating a new table without the column, copying all data, dropping the original table and renaming the new table. * Versioning_. .. _Versioning: Versioning.html * MySQLConnection got new keyword "conv" - a list of custom converters. * Use logging if it's available and is configured via DB URI. * New columns: TimestampCol to support MySQL TIMESTAMP type; SetCol to support MySQL SET type; TinyIntCol for TINYINT; SmallIntCol for SMALLINT; MediumIntCol for MEDIUMINT; BigIntCol for BIGINT. Small Features -------------- * Support for MySQL INT type attributes: UNSIGNED, ZEROFILL. * Support for DEFAULT SQL attribute via defaultSQL keyword argument. * cls.tableExists() as a shortcut for conn.tableExists(cls.sqlmeta.table). * cls.deleteMany(), cls.deleteBy(). Bug Fixes --------- * idName can be inherited from the parent sqlmeta class. SQLObject 0.8.5 =============== Released 25 July 2007. Bug Fixes --------- * Run post_funcs after sending RowCreatedSignal. * Suppress the second RowUpdateSignal in .set() called from ._SO_setValue(). * A number of bugfixes ported from `SQLObject 0.7.8`_. SQLObject 0.8.4 =============== Released 10 May 2007. Bug Fixes --------- * A number of bugfixes forward-ported from 0.7.7. SQLObject 0.8.3 =============== Released 3 May 2007. Bug Fixes --------- * A number of bugfixes forward-ported from 0.7.6. SQLObject 0.8.2 =============== Released 11 Apr 2007. Bug Fixes --------- * Fixed ConnectionHub.doInTransaction() - if the original connection was processConnection - reset processConnection, not threadConnection. SQLObject 0.8.1 =============== Released 19 Mar 2007. Bug Fixes --------- * ID columns are reverted back from INT UNSIGNED to INT for MySQL to be in accord with FOREIGN KEYs. * Fixed return value from Firebird/MaxdbConnection.createTable(). * Fixed and simplified DatabaseIndex.get(). * Fixed ConnectionHub.doInTransaction() - close low-level connection on commit() to prevent connections leaking. SQLObject 0.8.0 =============== Released 12 Feb 2007. Features & Interface -------------------- * It is now possible to create tables that reference each other. Constraints (in the DBMSes that support constraints) are added after the tables have been created. * Added ``createSQL`` as an option for sqlmeta. Here you can add related SQL you want executed by sqlobject-admin create after table creation. createSQL expects a string, list, or dictionary. If using a dictionary the key should be a dbName value (ex. 'postgres') and the value should be a string or list. Examples in sqlobject/tests/test_sqlobject_admin.py or at * Added method ``sqlhub.doInTransaction(callable, *args, **kwargs)``, to be used like:: sqlhub.doInTransaction(process_request, os.environ) This will run ``process_request(os.environ)``. The return value will be preserved. * Added method ``.getOne([default])`` to ``SelectResults`` (these are the objects returned by ``.select()`` and ``.selectBy()``). This returns a single object, when the query is expected to return only one object. The single argument is the value to return when zero results are found (more than one result is always an error). If no default is given, it is an error if no such object exists. * Added a WSGI middleware (in ``sqlobject.wsgi_middleware``) for configuring the database for the request. Also handles transactions. Available as ``egg:SQLObject`` in Paste Deploy configuration files. * New joins! ManyToMany and OneToMany; not fully documented yet, but still more sensible and smarter. * SELECT FOR UPDATE * New module dberrors.py - a hierarchy of exceptions. Translation of DB API module's exceptions to the new hierarchy is performed for SQLite and MySQL. * SQLiteConnection got a new keyword "factory" - a name or a reference to a factory function that returns a connection class; useful for implementing functions or aggregates. See test_select.py and test_sqlite_factory.py for examples. * SQLObject now disallows columns with names that collide with existing variables and methods, such as "_init", "expire", "set" and so on. Small Features -------------- * Configurable client character set (encoding) for MySQL. * Added a close option to .commit(), so you can close the transaction as you commit it. * DecimalValidator. * Added .expireAll() methods to sqlmeta and connection objects, to expire all instances in those cases. * String IDs. * FOREIGN KEY for MySQL. * Support for sqlite3 (a builtin module in Python 2.5). * SelectResults cannot be queried for truth value; in any case it was meaningless - the result was always True; now __nonzero__() raises NotImplementedError in case one tries bool(MyTable.select()) or "if MyTable.select():..." * With empty parameters AND() and OR() returns None. * Allows to use set/frozenset sets/Set/ImmutableSet sets as sequences passed to the IN operator. * ID columns are now INT UNSIGNED for MySQL. Bug Fixes --------- * Fixed problem with sqlite and threads; connections are no longer shared between threads for sqlite (except for :memory:). * The reference loop between SQLObject and SQLObjectState eliminated using weak references. * Another round of bugfixes for MySQL errors 2006 and 2013 (SERVER_GONE, SERVER_LOST). * Fixed a bug in MSSQLConnection caused by column names being unicode. * Fixed a bug in FirebirdConnection caused by column names having trailing spaces. * Order by several columns with inheritance. * Fixed aggregators and accumulators with inheritance. SQLObject 0.7.8 =============== Released 25 July 2007. Bug Fixes --------- * Replaced calls to style.dbColumnToPythonAttr() in joins.py by name/dbName lookup in case the user named columns differently using dbName. * Minor correction in the tests: we fully support EnumCol in Postgres. * MySQLConnection now recognizes Enum, Double and Time columns when drawing the database scheme from DB. * Minor fix in FirebirdConnection.fromDatabase. * Fixed a bug with default field values for columns for Firebird connection. * Prevent a deadlock in declarative.threadSafeMethod() by not reacquiring the class lock. * Fixed a bug in col.createSQL(). * Fixed a bug in converting date/time for years < 1000 (time.strptime() requires exactly 4 digits for %Y, hence a year < 1000 must be 0-padded). Other Changes ------------- * Changed string quoting style for PostgreSQL and MySQL from \' to ''. SQLObject 0.7.7 =============== Released 10 May 2007. Bug Fixes --------- * Fixed a bug in SQLRelatedJoin that ignored per-instance connection. * Fixed a bug in MySQL connection in case there is no charset in the DB URI. SQLObject 0.7.6 =============== Released 3 May 2007. Bug Fixes --------- * Fixed a longstanding bug with .select() ignoring 'limit' parameter. * Fixed a bug with absent comma in JOINs. * Fixed sqlbuilder - .startswith(), .endswith() and .contains() assumed their parameter must be a string; now you can pass an SQLExpression: Table.q.name.contains(func.upper('a')), for example. * Fixed a longstanding bug in sqlbuilder.Select() with groupBy being a sequence. * Fixed a bug with Aliases in JOINs. * Yet another patch to properly initialize MySQL connection encoding. * Fixed a minor comparison problem in test_decimal.py. * More documentation about orderBy. SQLObject 0.7.5 =============== Released 11 Apr 2007. Bug Fixes --------- * Fixed test_deep_inheritance.py - setup classes in the correct order (required for Postgres 8.0+ which is strict about referential integrity). * Fixed a bug in DateValidator caused by datetime being a subclass of date. SQLObject 0.7.4 =============== Released 19 Mar 2007. Small Features -------------- * For MySQLdb 1.2.2+ call ping(True) on the connection to allow autoreconnect after a timeout. Bug Fixes --------- * Another round of changes to create/drop the tables in the right order in the command-line client `sqlobject-admin`. * Fixed a bug in UnicodeField - allow comparison with None. SQLObject 0.7.3 =============== Released 30 Jan 2007. Bug Fixes --------- * Allow multiple MSSQL connections. * Psycopg1 requires port to be a string; psycopg2 requires port to be an int. * Fixed a bug in MSSQLConnection caused by column names being unicode. * Fixed a bug in FirebirdConnection caused by column names having trailing spaces. * Fixed a missed import in firebirdconnection.py. * Remove a leading slash in FirebirdConnection. * Fixed a bug in deep Inheritance tree. SQLObject 0.7.2 =============== Released 20 Nov 2006. Features & Interface -------------------- * sqlbuilder.Select now supports JOINs exactly like SQLObject.select. * destroySelf() removes the object from related joins. Bug Fixes --------- * Fixed a number of unicode-related problems with newer MySQLdb. * If the DB API driver returns timedelta instead of time (MySQLdb does this) it is converted to time; but if the timedelta has days an exception is raised. * Fixed a number of bugs in InheritableSQLObject related to foreign keys. * Fixed a bug in InheritableSQLObject related to the order of tableRegistry dictionary. * A bug fix that allows to use SQLObject with DateTime from Zope. Documentation Added ------------------- * Added "How can I define my own intermediate table in my Many-to-Many relationship?" to FAQ. SQLObject 0.7.1 =============== Released 25 Sep 2006. Features & Interface -------------------- * Added support for psycopg2_ .. _psycopg2: http://initd.org/projects/psycopg2 * Added support for MSSQL. * Added ``TimeCol``. * ``RelatedJoin`` and ``SQLRelatedJoin`` objects have a ``createRelatedTable`` keyword argument (default ``True``). If ``False``, then the related table won't be automatically created; instead you must manually create it (e.g., with explicit SQLObject classes for the joins). * Implemented ``RLIKE`` (regular expression LIKE). * Moved _idSequence to sqlmeta.idSequence. Small Features -------------- * Select over RelatedJoin. * SQLite foreign keys. * Postgres DB URIs with a non-default path to unix socket. * Allow the use of foreign keys in selects. * Implemented addColumn() for SQLite. * With PySQLite2 use encode()/decode() from PySQLite1 for BLOBCol if available; else use base64. Bug Fixes --------- * Fixed a longstanding problem with UnicodeCol - at last you can use unicode strings in .select() and .selectBy() queries. There are some limitations, though; see the description of the UnicodeCol_. .. _UnicodeCol: SQLObject.html#column-types * Cull patch (clear cache). * .destroySelf() inside a transaction. * Synchronize main connection cache during transaction commit. * Ordering joins with NULLs. * Fixed bugs with plain/non-plain setters. * Lots of other bug fixes. SQLObject 0.7.0 =============== Features & Interface -------------------- * Inheritance. See Inheritance.html_ .. _Inheritance.html: Inheritance.html * Date/time validators, converters, tests. * Both `mxDateTime `_ and `datetime `_ supported for ``DateTimeCol``. * Added ``BLOBCol``, for binary data. * Added ``PickleCol``, to transparently pickle and unpickle data from column. * New `documented reflection interface `_, using the new ``.sqlmeta`` class/instance. Most special attributes that started with ``_`` were moved into ``sqlmeta`` (with leading underscore removed). * New aggregate functions for select results, like ``cls.select().max(columnName)``: ``.max()``, ``.min()``, ``.avg()``. * ``ConnectionHub`` aka ``sqlhub`` (@@: Needs documentation) * Command-line client `sqlobject-admin `_. * ``StringCol`` has ``char_binary`` attribute, for explicit case handling in MySQL. * Various joins now supported (LEFT, RIGHT, STRAIGHT, INNER, OUTER, CROSS): see `documentation `_. Aliases for joining a table with itself. * Subqueries/subselects (`see docs `_). * Select results support ``.filter(extra_query)`` * ``SQLMultipleJoin`` and ``SQLRelatedJoin``, like ``MultipleJoin`` and ``RelatedJoin``, except return select results (@@: Document). * `SingleJoin `_. * Columns retain their order from the class definition to table creation. * SQLObject now depends on the `FormEncode `_ library, and internal conversion/validation is done through FormEncode (was previously using old fork of FormEncode). * Column instances can have attributes set on them (generally for annotating columns with extra data). Other Changes ------------- * When iterating over select results, a list is now immediately created with the full list of instances being selected. Before instances were created on demand, as select results were pulled out row-by-row. The previous lazy behavior is available with the method ``lazyIter``, used like ``for obj in MyClass.select().lazyIter(): ...``. * Test framework now uses `py.test `_. * SQLObject now uses a simpler metaclass (``sqlobject.declarative.DeclarativeMeta``). * autoCommit and queryIns ?? (@@: expand) * Deprecation (@@: document) * Use `setuptools `_ for packaging and installation. Small Features -------------- * ``IntValidator`` for testing ``IntCol`` inputs. * Base style (``sqlobject.styles.Style``) is now a usable no-op style. * SQLite in-memory databases allowed with ``sqlite:/:memory:`` * Keyword parameters allowed to ``connectionForURI`` (like ``debug=True``). * More parameters passed to MySQL connections (unix_socket, named_pipe, init_command, read_default_file, read_default_group, connect_time, compress, named_pipe, use_unicode, client_flag, local_infile). * ``DateTimeCol.now`` is a function for producing the current date, using whatever date/time module you are using (good for use as a default). * Inherited classes fetched more efficiently (fewer queries). * Decimal converter to create `decimal objects `_. * Repository rearranged (now in ``http://svn.colorstudy.com/SQLObject/trunk``). Bug Fixes --------- * Tables with no columns can work. Why would you have a table without a column? We do not know, we try only to serve. * Sybase ``_fromDatabase`` fixed. * Various fixes to support most recent ``MySQLdb`` adapter, and ``pysqlite`` adapters. * URI parsing improved, including Windows paths (for use with SQLite). * ``selectBy(column=None)`` creates ``IS NULL`` query. * ``selectBy(foreignKey=value)`` now supported (not just selecting by foreign key ID). * ``cascade='null'`` wasn't working properly (was cascading all deletes, not nullifying!). * Lots of other bug fixes. SQLObject 0.6.1 =============== Interface Changes ----------------- * The long broken and unused ``DBMConnection`` has been removed. * Added a connection parameter to all class methods (patch 974755) * Connection objects have a ``.module`` attribute, which points to the DB-API module. This is useful for getting access to the exception objects. Features -------- * New ``UnicodeCol()`` that converts to and from Unicode in the database. See docs_. .. _docs: SQLObject.html#subclasses-of-col * Added indexing (from Jeremy Fitzhardinge). See `the documentation`__ for more. .. __: SQLObject.html#indexes * All connections are explicitly closed, not just garbage collected. Many database drivers don't close database connections properly when the connection object is garbage collected. * New ``distinct`` option to selects, like ``MyClass.select(..., distinct=True)`` * You can now do ``MyClass.selectBy(joinedTable=joinedTableInstance)``, where before you had to do ``MyClass.selectBy(joinedTableID=joinedTableInstance.id)``. (From Dave Cook) SQLObject 0.6 ============= Interface Changes ----------------- * Lazy updates. Add ``_lazyUpdate=True`` to your class, and updates will only be written when you call ``obj.syncUpdate()`` or ``obj.sync()`` (``sync`` also refetches the data from the database, which ``syncUpdate`` does not do). When enabled, instances have a property ``dirty``, which indicates if they have pending updates. Inserts are still done immediately. * Separated database drivers (PostgresConnection, MySQLConnection, etc.) into separate packages. You can access the driver through URIs, like ``mysql://user:pass@host/dbname`` -- to set drivers after class creation you should use `sqlobject.connectionForURI()`. * The ``SQLObject`` package has been renamed to ``sqlobject``. This makes it similar to several other packages, and emphasizes the distinction between the ``sqlobject`` package and the ``SQLObject`` class. * Class instantiation now creates new rows (like `.new()` used to do), and the `.get()` method now retrieves objects that already have rows (like class instantiation used to do). * We're now using a Subversion repository instead of CVS. It is located at http://svn.colorstudy.com/trunk/SQLObject * If you pass ``forceDBName=True`` to the ``*Col`` constructors, then your column name doesn't have to be restricted to a-z, 0-9, and _. * ``*Col`` constructors now support cascade: ``cascade=None`` (default) means no constraint; ``cascade=True`` means that if the foreign key is deleted, the object will be deleted; ``cascade=False`` means that the delete will fail; ``cascade="null"`` means that the column will be set to NULL. The constraints are only implemented in the DBMS, not in SQLObject (i.e., they will not work in databases like MySQL and SQLite). * New ``_create(id, **kw)`` method that can be overridden to intercept and modify attempts to insert rows in the database. * You can specify ``_idType`` in your class, like ``_idType = str``. The default type is ``int``; i.e., IDs are coerced to integers. This is a temporary interface; a more general specifier for primary keys will be added later. * New classmethod ``createTableSQL()`` method for SQLObject classes, which returns the SQL that can be used to create the table. Analog to ``createTable()``. Bugs ---- * SQLite booleans fixed. * You can now use ``sqlite:/:memory:`` to store the database in memory. * Some bugs resolved when caching is turned off (SF 956847) SQLObject 0.5.3 =============== Bugs ---- * Python 2.2 booleans fixed (SF: 903488) * Longs (e.g., ``1L``) get converted properly (SF: 939965) SQLObject 0.5.2 =============== We're now using Subversion instead of CVS. The repository is located at svn://colorstudy.com/trunk/SQLObject Interface Changes ----------------- * If you commit or rollback a transaction, you must call ``trans.begin()`` to restart the transaction. Any database access on the transaction inbetween commit/rollback and being will result in an AssertionError. (It's also acceptable to create a new transaction object instead of reusing the old one, but objects in that transaction will be invalid) Bugs ---- * Using .select() would hold on to a connection, and also release it back to the connection pool. Very un-threadsafe and all-around bad. * Fixed bug which did not release connections after database (query) error. * When setting columns that use validators, the Pythonic (vs. database) representation wasn't being stored in the column. Now we roundtrip (through toPython and fromPython) the values when they get set. * PostgreConnection is back to using sequences for ID generation, instead of oids. Long explanation -- oids can be unindexed in some versions of Postgres, or not even exist. * When turning caching off and using transactions, got an attribute error on rollback. * Rollback or commit didn't find objects that were expired from the cache but still in memory. * Rollback or commit didn't free the connection object, so as you created more transactions it stole connections and didn't put them back in the pool. SQLObject 0.5.1 =============== Released: 12-Nov-2003 Interface Changes ----------------- * Select results no longer have a __len__ method (i.e., you can't do ``len(Person.select(Person.q.firstName=='Bob'))``). There is now a ``.count()`` method instead. ``__len__`` gets called implicitly in several circumstances, like ``list()``, which causes potentially expensive queries to ``COUNT(*)``. Bugs ---- * Objects retrieved from a join now respect the transaction context of the original instance. * ``.select().reversed()`` works. SQLObject 0.5 ============= Released: 1-Nov-2003 Features -------- * Firebird_ support. * Database-specific literal quoting (motivation: MySQL and Postgres use backslashes, Firebird and SQLite do not). * Generic conversion/validation can be added to columns. * BoolCol for portable boolean columns (BOOL on Postgres, INT on MySQL, etc.) * Non-integer IDs. (Automatic table creation is not supported for non-integer IDs) * Explicit IDs for new instances/rows (required for non-integer IDs). * Instances can be synced with the database (in case there have been updates to the object since it was first fetched). * Instances can be expired, so that they will be synced when they are next accessed. .. _Firebird: http://firebird.sourceforge.net/ Interface Changes ----------------- * `SQLBuilder.sqlRepr` renamed to `SQLBuilder.sqlrepr`, signature changed to ``sqlrepr(value, databaseName)`` to quote ``value``, where ``databaseName`` is one of ``"mysql"``, ``"postgres"``, ``"sqlite"``, ``"firebird"``. * ``sqlRepr`` magic method renamed to ``__sqlrepr__``, and takes new ``databaseName`` argument. * When using explicit booleans, use ``Col.TRUE`` and ``Col.FALSE`` for backward compatibility with Python 2.2. This is not required for ``BoolCol``, however (which converts all true values to TRUE and false values to FALSE) * SQLObject has a ``sqlrepr`` method, so you can construct queries with something like ``"WHERE last_name = %s" % Person.sqlrepr('Bob')`` Bugs ---- * Released all locks with ``finally:``, so that bugs won't cause frozen locks. * Tons of transaction fixes. Transactions pretty much work. * A class can have multiple foreign keys pointing to the same table (e.g., ``spouse = ForeignKey("Person"); supervisor = ForeignKey("Person")``) SQLObject 0.4 ============= Features -------- * You can specify columns in a new, preferred manner:: class SomeObject(SQLObject): someColumn = Col() Equivalent to:: class SomeObject(SQLObject): _columns = [Col('someColumn')] Ditto joins. * Cache objects have a clear method, which empties all objects. However, weak references to objects *are* maintained, so the integrity of the cache can be ensured. * SQLObject subclasses can be further subclassed, adding or removing column definitions (as well as changing settings like connection, style, etc). Each class still refers to a single concrete table in the database -- the class hierarchy is not represented in the database. * Each SQLObject subclass can have an associated style, as given in the `_style` attribute. This object is used to map between Python and database names (e.g., the column name for a Python attribute). Some samples are available in the `Style` module. * Postgres support for `_fromDatabase` (reading a table definition from the database, and creating a class from that). * Postgres id columns more permissive, you don't have to create a specially named sequence (or implicitly create that sequence through ``SERIAL``). lastoid is used instead. * MySQL uses ``localhost`` as the default host, and the empty string as the default password. * Added functions for use with queries: `ISNULL`, `ISNOTNULL`. ``==`` and ``!=`` can be used with None, and is translated into `ISNULL`, `ISNOTNULL`. * Classes can be part of a specific registry. Since classes are referred to by name in several places, the names have to be unique. This can be problematic, so you can add a class variable `_registry`, the value of which should be a string. Classes references are assumed to be inside that registry, and class names need only be unique among classes in that registry. * ``SomeClass.select()`` selects all, instead of using ``SomeClass.select('all')``. You can also use None instead of ``'all'``. * Trying to fetch non-existent objects raises `SQLObjectNotFound`, which is a subclass of the builtin exception `LookupError`. This may not be raised if `_cacheValues` is False and you use the ID to fetch an object (but alternateID fetches will raise the exception in either case). * Can order by descending order, with the `reversed` option to the `select` method, or by prefixing the column with a ``"-"``. * Ordering with joins works better -- you can order with multiple columns, as well as descending ordering. Col and Join ~~~~~~~~~~~~ * `Join` constructors have an argument `orderBy`, which is the name of a Python attribute to sort results by. If not given, the appropriate class's `_defaultOrder` will be used. None implies no sorting (and ``orderBy=None`` will override `_defaultOrder`). * `ForeignKey` class (subclass of `Col`), for somewhat easier/clearer declaration of foreign keys. * `Col` (and subclasses) can take a `sqlType` argument, which is used in table definitions. E.g., ``Col(sqlType="BOOLEAN")`` can be used to create a ``BOOLEAN`` column, even though no `BooleanCol` exists. * `alternateID` (a specifier for columns) implies ``NOT NULL``. Also implies ``UNIQUE``. * `unique` (a specifier for columns) added. * `DecimalCol` and `CurrencyCol` added. * `EnumCol` uses constraints on Postgres (if you use `createTable`). Bugs ---- * `DateTimeCol` uses ``TIMESTAMP`` for Postgres. Note that the Python type name is used for column names, not necessarily the SQL standard name. * Foreign key column names are slightly more permissive. They still need to end in ``id``, but it's case insensitive. * _defaultOrder should be the python attribute's name, not the database name. * SomeClass.q.colName uses proper Python attributes for colName, and proper database names when executed in the database. * SQLite select results back to being proper iterator. * SomeClass.q.colName now does proper translation to database names, using dbName, etc., instead of being entirely algorithm-driven. * Raise `TypeError` if you pass an unknown argument to the `new` method. * You can override the _get_* or _set_* version of a property without overriding the other. * Python 2.3 compatible. * Trying to use ``Col('id')`` or ``id = Col()`` will raise an exception, instead of just acting funky. * ``ForeignKey`` columns return None if the associated column is NULL in the database (used to just act weird). * Instantiating an object with an id of None will give an error, instead of just acting weird. Internal -------- * `Col` class separated into `Col` and `SOCol` (and same for all other `*Col` classes). `Col` defines a column, `SOCol` is that definition bound to a particular SQLObject class. * Instance variable ``_SO_columns`` holds the `SOCol` instances. SQLObject 0.3 ============= Features -------- * Table creation (SQL schema generation) via new class method `createTable`. And of course a `dropTable` method to go with. * Add and remove columns at runtime, optionally modifying the schema in the database (via ``ALTER``). (Does not work in SQLite) * New column classes (see `Col` module), indicates type * Classes can be created by parsing an already existant table (MySQL only). * Objects are not cached indefinitely. Cached objects are expired into a weak dictionary (it allows objects to be garbage collected if nowhere else in the program is using the object, but until it is collected it's still available to the cache). Some cache control, pass ``nocache=True`` to your connection object to eliminate as much caching as possible. See `Cache` module for a bit more. * New DBMConnection, implements a database-like backend without any database to speak of, including queries (so long as you use `SQLBuilder` and don't generate your where clauses manually). Actual SQL generation is done entirely by the database connection, allowing portability across very different backends. * Postgres table IDs should be created with type ``SERIAL`` (which implicitly creates a sequence). * New `_defaultOrder` class variable gives a default for the `orderBy` parameter to `select` queries. Bugs ---- * LIMIT/OFFSET (select result slicing) works in Postgres and SQLite. * ``tableExists`` method from DBConnection works in same. * mxDateTime not required (never should have been, always just an option). SQLObject 0.2.1 =============== Bugs ---- * Fixed caching of new objects Features -------- * SQLite_ support * Select statements are lazily generated, retrieve full rows for speed, and are slicable (`select docs`_). * `alternateID` option for `Col` objects -- select individual objects via UNIQUE columns, e.g., a username (`Col docs`_). .. _SQLite: http://sqlite.org/ .. _select docs: SQLObject.html#selecting-multiple-objects .. _Col docs: SQLObject.html#col-class-specifying-columns