sqlobject-discuss Mailing List for SQLObject (Page 3)

On Tue, Apr 16, 2019 at 01:10:54PM +0200, Markus Elfring <Mar...@we...> wrote:
> > Ic SQLObject one has classes that correspond to tables:
> 
> Can the class hierarchy grow?

   SQLObject supports 2 kinds of inheritance: see

http://sqlobject.org/FAQ.html#how-does-inheritance-work and

http://sqlobject.org/Inheritance.html

   And of course classes can be simply inherited without creating SQL
tables.

> Regards,
> Markus

Oleg.
-- 
    Oleg Broytman            https://phdru.name/            ph...@ph...
           Programmers don't die, they just GOSUB without RETURN.

>> I would prefer then that corresponding classes will be loaded (or imported)
>> only if the code for such functionality will be used at all finally.
>
>    That's not how SQLObject is structured and intended to be used.

Thanks for this information.


> Ic SQLObject one has classes that correspond to tables:

Can the class hierarchy grow?


>    It'd be best if a pull request or a patch will be accompanied with
> tests and docs.

I tend to check the general change acceptance for some software extensions
before more concrete adjustments.

Regards,
Markus

On Tue, Apr 16, 2019 at 12:50:27PM +0200, Markus Elfring <Mar...@we...> wrote:
> > No, I don't see a reason for a new class. New class could override
> > existing methods but we're talking about new method(s) so
> > why not add them just to SQLObject's main class?
> 
> A command like ???CREATE TABLE??? belongs to the category ???data definition language???
> within SQL.
> I would prefer then that corresponding classes will be loaded (or imported)
> only if the code for such functionality will be used at all finally.

   That's not how SQLObject is structured and intended to be used. In
SQLObject one has classes that correspond to tables:

    class MyTable(SQLObject):
        name = StringCol()

and the classes and their instances are used to query database. One can
create the table with ``MyTable.createTable()`` and query it with
``MyTable.select()``. You cannot split ``SQLObject`` class into plugins
that could be loaded only when needed.

> >>>    SQLObject does some limited introspection.
> >>
> >> Would you like to improve the software situation in this area?
> 
> Will the software documentation be extended also?

   It'd be best if a pull request or a patch will be accompanied with
tests and docs.

> Regards,
> Markus

Oleg.
-- 
    Oleg Broytman            https://phdru.name/            ph...@ph...
           Programmers don't die, they just GOSUB without RETURN.

> No, I don't see a reason for a new class. New class could override
> existing methods but we're talking about new method(s) so
> why not add them just to SQLObject's main class?

A command like “CREATE TABLE” belongs to the category “data definition language”
within SQL.
I would prefer then that corresponding classes will be loaded (or imported)
only if the code for such functionality will be used at all finally.


>>>    SQLObject does some limited introspection.
>>
>> Would you like to improve the software situation in this area?

Will the software documentation be extended also?

Regards,
Markus

> No, I don't see a reason for a new class. New class could override
> existing methods but we're talking about new method(s) so
> why not add them just to SQLObject's main class?

A command like “CREATE TABLE” belongs to the category “data definition language”
within SQL.
I would prefer then that corresponding classes will be loaded (or imported)
only if the code for such functionality will be used at all finally.


>>>    SQLObject does some limited introspection.
>>
>> Would you like to improve the software situation in this area?

Will the software documentation be extended also?

Regards,
Markus

On Tue, Apr 16, 2019 at 11:40:37AM +0200, Markus Elfring <Mar...@we...> wrote:
> >> How do you think about the clarification for additional classes?
> >
> >    Sorry, I don't understand.
> 
> You indicated the possibility to add two methods directly
> to the class ???SQLObject??? (as a design sketch).
> Will it become more helpful to extend the corresponding class hierarchy?

   Ah, I see, tnx. No, I don't see a reason for a new class. New class
could override existing methods but we're talking about new method(s) so
why not add them just to SQLObject's main class?

> >    SQLObject does some limited introspection.
> 
> Would you like to improve the software situation in this area?

   I'll be glad to accept pull requests or patches in any area in
SQLObject.

> > It can determine if a table exists[1] and get the list[2][3] of columns and joins.
> 
> Such functionality might be sufficient for my data analysis needs
> while I can get more concerned also about other software limitations
> (or requirements).
> 
> Can the name be automatically determined for a dynamically generated
> database table?

   No. In SQLObject you have to have a name. You can generate the name
dynamically or you can list tables[1] and filter the list.

1. https://github.com/sqlobject/sqlobject/blob/ed64be0ed032055b0a6613fe3051d83a74ded566/sqlobject/postgres/pgconnection.py#L525

> Regards,
> Markus

Oleg.
-- 
    Oleg Broytman            https://phdru.name/            ph...@ph...
           Programmers don't die, they just GOSUB without RETURN.

>> How do you think about the clarification for additional classes?
>
>    Sorry, I don't understand.

You indicated the possibility to add two methods directly
to the class “SQLObject” (as a design sketch).
Will it become more helpful to extend the corresponding class hierarchy?


>    SQLObject does some limited introspection.

Would you like to improve the software situation in this area?


> It can determine if a table exists[1] and get the list[2][3] of columns and joins.

Such functionality might be sufficient for my data analysis needs
while I can get more concerned also about other software limitations
(or requirements).

Can the name be automatically determined for a dynamically generated
database table?

Regards,
Markus

On Tue, Apr 16, 2019 at 10:35:13AM +0200, Markus Elfring <Mar...@we...> wrote:
> >> Will such software extensions become more feasible?
> >
> > Yes, I think so.
> 
> Thanks for such positive feedback.

   Welcome! :-)

> > The API perhaps would be simple, something like
> >
> >     class SQLObject(...):
> >         @classmethod
> >         def createAsSelectSQL(cls, selectFrom):
> >             ...
> 
> How do you think about the clarification for additional classes?

   Sorry, I don't understand.

> >         @classmethod
> >         def createAsSelect(cls, selectFrom):
> >             conn = connection or cls._connection
> >             query = cls.createAsSelectSQL(selectFrom)
> >             conn.query(query)
> >
> > where ``selectFrom`` is ``SelectResults`` instance. The method shod
> > construct ``CREATE TABLE ... AS SELECT ...`` but it also must construct
> > a list of columns (instances of ``col.Col`` classes) and call
> > ``cls.sqlmeta.addColumn(columnDef)`` for every column in the list.
> 
> Will the determination of involved data structures need any further
> software design considerations?

   That can only be determined during design and implementation.

> > And here I foresee a problem. It's possible to create a table in the
> > database but how to recreate the class with all columns on the second
> > run of the program or in another program that will use the class?
> 
> Are you used to fiddle with database reflection (or introspection)?

   SQLObject does some limited introspection. It can determine if a
table exists[1] and get the list[2][3] of columns and joins.

1. https://github.com/sqlobject/sqlobject/blob/ed64be0ed032055b0a6613fe3051d83a74ded566/sqlobject/main.py#L1471

2. http://sqlobject.org/SQLObject.html#automatic-class-generation

3. https://github.com/sqlobject/sqlobject/blob/ed64be0ed032055b0a6613fe3051d83a74ded566/sqlobject/postgres/pgconnection.py#L346

> Regards,
> Markus

Oleg.
-- 
    Oleg Broytman            https://phdru.name/            ph...@ph...
           Programmers don't die, they just GOSUB without RETURN.

>> Will such software extensions become more feasible?
>
> Yes, I think so.

Thanks for such positive feedback.


> The API perhaps would be simple, something like
>
>     class SQLObject(...):
>         @classmethod
>         def createAsSelectSQL(cls, selectFrom):
>             ...

How do you think about the clarification for additional classes?


>         @classmethod
>         def createAsSelect(cls, selectFrom):
>             conn = connection or cls._connection
>             query = cls.createAsSelectSQL(selectFrom)
>             conn.query(query)
>
> where ``selectFrom`` is ``SelectResults`` instance. The method shod
> construct ``CREATE TABLE ... AS SELECT ...`` but it also must construct
> a list of columns (instances of ``col.Col`` classes) and call
> ``cls.sqlmeta.addColumn(columnDef)`` for every column in the list.

Will the determination of involved data structures need any further
software design considerations?


> And here I foresee a problem. It's possible to create a table in the
> database but how to recreate the class with all columns on the second
> run of the program or in another program that will use the class?

Are you used to fiddle with database reflection (or introspection)?

Regards,
Markus

On Sat, Apr 13, 2019 at 07:12:37PM +0200, Markus Elfring <Mar...@we...> wrote:
> > Do you want to implement it?
> 
> I guess that I am not familiar enough with corresponding software
> design constraints (at the moment).
> 
> Will such software extensions become more feasible?

Yes, I think so. The API perhaps would be simple, something like

    class SQLObject(...):
        @classmethod
        def createAsSelectSQL(cls, selectFrom):
            ...

        @classmethod
        def createAsSelect(cls, selectFrom):
            conn = connection or cls._connection
            query = cls.createAsSelectSQL(selectFrom)
            conn.query(query)

where ``selectFrom`` is ``SelectResults`` instance. The method shod
construct ``CREATE TABLE ... AS SELECT ...`` but it also must construct
a list of columns (instances of ``col.Col`` classes) and call
``cls.sqlmeta.addColumn(columnDef)`` for every column in the list.

And here I foresee a problem. It's possible to create a table in the
database but how to recreate the class with all columns on the second
run of the program or in another program that will use the class? The
code must recreate the list of columns again without executing ``CREATE
TABLE AS SELECT`` query. Perhaps an API to produce a list of columns
from ``selectFrom`` should be a separate API that could be called eve
when the table is already exists.

> Regards,
> Markus

Oleg.
-- 
    Oleg Broytman            https://phdru.name/            ph...@ph...
           Programmers don't die, they just GOSUB without RETURN.

>> Do any of these classes trigger a table creation (CTAS command)
>> which is automatically mapped to another Python object?
>
>    No, not even ``CREATE TABLE``. And ``CREATE TABLE AS SELECT`` is not
> implemented in SQLObject at all.

Thanks for this clarification.


> Do you want to implement it?

I guess that I am not familiar enough with corresponding software
design constraints (at the moment).

Will such software extensions become more feasible?

Regards,
Markus

On Sat, Apr 13, 2019 at 06:38:32PM +0200, Markus Elfring <Mar...@we...> wrote:
> >> This software situation can look different if there are additional
> >> abstractions involved because of object-relational mapping.
> >> Can a query object be passed as a parameter for a corresponding method call?
> >
> >    Certainly. Both SelectResults[1] and SQLBuilder[2]'s objects
> > can be passed, they're just Python objects, no magic.
> >
> > 1. http://sqlobject.org/SelectResults.html
> > 2. http://sqlobject.org/SQLBuilder.html
> 
> Do any of these classes trigger a table creation (CTAS command)
> which is automatically mapped to another Python object?

   No, not even ``CREATE TABLE``. And ``CREATE TABLE AS SELECT`` is not
implemented in SQLObject at all. Do you want to implement it?

> Regards,
> Markus

Oleg.
-- 
    Oleg Broytman            https://phdru.name/            ph...@ph...
           Programmers don't die, they just GOSUB without RETURN.

>> This software situation can look different if there are additional
>> abstractions involved because of object-relational mapping.
>> Can a query object be passed as a parameter for a corresponding method call?
>
>    Certainly. Both SelectResults[1] and SQLBuilder[2]'s objects
> can be passed, they're just Python objects, no magic.
>
> 1. http://sqlobject.org/SelectResults.html
> 2. http://sqlobject.org/SQLBuilder.html

Do any of these classes trigger a table creation (CTAS command)
which is automatically mapped to another Python object?

Regards,
Markus

On Sat, Apr 13, 2019 at 06:19:40PM +0200, Markus Elfring <Mar...@we...> wrote:
> >> Can the support be improved for the command variant ???CREATE TABLE AS SELECT??? (CTAS)
> >> in this software area?
> >
> >    How would you write that in Python?
> 
> It could be written already if such a SQL command would be submitted to
> a direct database programming interface.
> This software situation can look different if there are additional
> abstractions involved because of object-relational mapping.
> Can a query object be passed as a parameter for a corresponding method call?

   Certainly. Both SelectResults[1] and SQLBuilder[2]'s objects
can be passed, they're just Python objects, no magic.

1. http://sqlobject.org/SelectResults.html
2. http://sqlobject.org/SQLBuilder.html

> Regards,
> Markus

Oleg.
-- 
    Oleg Broytman            https://phdru.name/            ph...@ph...
           Programmers don't die, they just GOSUB without RETURN.

>> Can the support be improved for the command variant ???CREATE TABLE AS SELECT??? (CTAS)
>> in this software area?
>
>    How would you write that in Python?

It could be written already if such a SQL command would be submitted to
a direct database programming interface.
This software situation can look different if there are additional
abstractions involved because of object-relational mapping.
Can a query object be passed as a parameter for a corresponding method call?

Regards,
Markus

On Sat, Apr 13, 2019 at 05:08:48PM +0200, Markus Elfring <Mar...@we...> wrote:
> >    You can create a table using high-level API:
> >
> > http://sqlobject.org/SQLObject.html#declaring-the-class
> >
> >    or you can execute ``CREATE TABLE`` directly.
> 
> Can the support be improved for the command variant ???CREATE TABLE AS SELECT??? (CTAS)
> in this software area?

   How would you write that in Python?

> Regards,
> Markus

Oleg.
-- 
    Oleg Broytman            https://phdru.name/            ph...@ph...
           Programmers don't die, they just GOSUB without RETURN.

>    You can create a table using high-level API:
>
> http://sqlobject.org/SQLObject.html#declaring-the-class
>
>    or you can execute ``CREATE TABLE`` directly.

Can the support be improved for the command variant “CREATE TABLE AS SELECT” (CTAS)
in this software area?

Regards,
Markus

Hi!

On Sat, Apr 13, 2019 at 02:46:31PM +0200, Markus Elfring <Mar...@we...> wrote:
> Hello,
> 
> I would like to count value combinations in database records together with
> the software ???SQLObject 3.7.1???.
> The computation result should be stored into a dynamically generated table.
> I am curious how such table creation can be achieved by the programming
> interface ???object-relational mapping??? currently.

   You can create a table using high-level API:

http://sqlobject.org/SQLObject.html#declaring-the-class

   or you can execute ``CREATE TABLE`` directly.

> Regards,
> Markus

Oleg.
-- 
    Oleg Broytman            https://phdru.name/            ph...@ph...
           Programmers don't die, they just GOSUB without RETURN.

Hello,

I would like to count value combinations in database records together with
the software “SQLObject 3.7.1”.
The computation result should be stored into a dynamically generated table.
I am curious how such table creation can be achieved by the programming
interface “object-relational mapping” currently.

Regards,
Markus

Hello!

I'm pleased to announce version 3.7.1, the first bugfix release of branch
3.7 of SQLObject.


What's new in SQLObject
=======================

Contributor for this release is Neil Muller.

Bug fixes
---------

* Fixed a unicode problem in the latest mysqlclient.

Documentation
-------------

* Exclude sqlmeta members from some of the api docs.
  The inclusion of of these sqlmeta members in these files breaks
  reproducible builds.

Development
-----------

* Source code was made flake8-clean using the latest flake8.

CI
--

* Run tests with Python 3.7.

For a more complete list, please see the news:
http://sqlobject.org/News.html


What is SQLObject
=================

SQLObject is an object-relational mapper.  Your database tables are described
as classes, and rows are instances of those classes.  SQLObject is meant to be
easy to use and quick to get started with.

SQLObject supports a number of backends: MySQL, PostgreSQL, SQLite,
Firebird, Sybase, MSSQL and MaxDB (also known as SAPDB).

Python 2.7 or 3.4+ is required.


Where is SQLObject
==================

Site:
http://sqlobject.org

Development:
http://sqlobject.org/devel/

Mailing list:
https://lists.sourceforge.net/mailman/listinfo/sqlobject-discuss

Download:
https://pypi.org/project/SQLObject/3.7.1/

News and changes:
http://sqlobject.org/News.html

StackOverflow:
https://stackoverflow.com/questions/tagged/sqlobject


Example
=======

Create a simple class that wraps a table::

  >>> from sqlobject import *
  >>>
  >>> sqlhub.processConnection = connectionForURI('sqlite:/:memory:')
  >>>
  >>> class Person(SQLObject):
  ...     fname = StringCol()
  ...     mi = StringCol(length=1, default=None)
  ...     lname = StringCol()
  ...
  >>> Person.createTable()

Use the object::

  >>> p = Person(fname="John", lname="Doe")
  >>> p
  <Person 1 fname='John' mi=None lname='Doe'>
  >>> p.fname
  'John'
  >>> p.mi = 'Q'
  >>> p2 = Person.get(1)
  >>> p2
  <Person 1 fname='John' mi='Q' lname='Doe'>
  >>> p is p2
  True

Queries::

  >>> p3 = Person.selectBy(lname="Doe")[0]
  >>> p3
  <Person 1 fname='John' mi='Q' lname='Doe'>
  >>> pc = Person.select(Person.q.lname=="Doe").count()
  >>> pc
  1

Oleg.
-- 
    Oleg Broytman            https://phdru.name/            ph...@ph...
           Programmers don't die, they just GOSUB without RETURN.

Hello!

I'm pleased to announce version 3.7.0, the first stable release of branch
3.7 of SQLObject.


What's new in SQLObject
=======================

Contributors for this release are Scott Stahl and Christophe Popov.

Features
--------

* Add signals on commit and rollback; pull request by Scott Stahl.

Bug fixes
---------

* Fix SSL-related parameters for MySQL-connector (connector uses
  a different param style). Bug reported by Christophe Popov.

Drivers
-------

* Remove psycopg1. Driver ``psycopg`` is now just an alias for ``psycopg2``.

Tests
-----

* Install psycopg2 from `psycopg2-binary`_ package.

.. _`psycopg2-binary`: https://pypi.org/project/psycopg2-binary/

For a more complete list, please see the news:
http://sqlobject.org/News.html


What is SQLObject
=================

SQLObject is an object-relational mapper.  Your database tables are described
as classes, and rows are instances of those classes.  SQLObject is meant to be
easy to use and quick to get started with.

SQLObject supports a number of backends: MySQL, PostgreSQL, SQLite,
Firebird, Sybase, MSSQL and MaxDB (also known as SAPDB).

Python 2.7 or 3.4+ is required.


Where is SQLObject
==================

Site:
http://sqlobject.org

Development:
http://sqlobject.org/devel/

Mailing list:
https://lists.sourceforge.net/mailman/listinfo/sqlobject-discuss

Download:
https://pypi.org/project/SQLObject/3.7.0/

News and changes:
http://sqlobject.org/News.html

StackOverflow:
https://stackoverflow.com/questions/tagged/sqlobject


Example
=======

Create a simple class that wraps a table::

  >>> from sqlobject import *
  >>>
  >>> sqlhub.processConnection = connectionForURI('sqlite:/:memory:')
  >>>
  >>> class Person(SQLObject):
  ...     fname = StringCol()
  ...     mi = StringCol(length=1, default=None)
  ...     lname = StringCol()
  ...
  >>> Person.createTable()

Use the object::

  >>> p = Person(fname="John", lname="Doe")
  >>> p
  <Person 1 fname='John' mi=None lname='Doe'>
  >>> p.fname
  'John'
  >>> p.mi = 'Q'
  >>> p2 = Person.get(1)
  >>> p2
  <Person 1 fname='John' mi='Q' lname='Doe'>
  >>> p is p2
  True

Queries::

  >>> p3 = Person.selectBy(lname="Doe")[0]
  >>> p3
  <Person 1 fname='John' mi='Q' lname='Doe'>
  >>> pc = Person.select(Person.q.lname=="Doe").count()
  >>> pc
  1

Oleg.
-- 
    Oleg Broytman            https://phdru.name/            ph...@ph...
           Programmers don't die, they just GOSUB without RETURN.

Hello!

I'm pleased to announce version 3.6.0, the first stable release of branch
3.6 of SQLObject.


What's new in SQLObject
=======================

Contributor for this release is Michael S. Root.

Minor features
--------------

* Close cursors after using to free resources immediately
  instead of waiting for gc.

Bug fixes
---------

* Fix for TypeError using selectBy on a BLOBCol. PR by Michael S. Root.

Drivers
-------

* Extend support for oursql and Python 3 (requires our fork of the driver).

* Fix cursor.arraysize - pymssql doesn't have arraysize.

* Set timeout for ODBC with MSSQL.

* Fix _setAutoCommit for MSSQL.

Documentation
-------------

* Document extras that are available for installation.

Build
-----

* Use ``python_version`` environment marker in ``setup.py`` to make
  ``install_requires`` and ``extras_require`` declarative. This makes
  the universal wheel truly universal.

* Use ``python_requires`` keyword in ``setup.py``.

For a more complete list, please see the news:
http://sqlobject.org/News.html


What is SQLObject
=================

SQLObject is an object-relational mapper.  Your database tables are described
as classes, and rows are instances of those classes.  SQLObject is meant to be
easy to use and quick to get started with.

SQLObject supports a number of backends: MySQL, PostgreSQL, SQLite,
Firebird, Sybase, MSSQL and MaxDB (also known as SAPDB).

Python 2.7 or 3.4+ is required.


Where is SQLObject
==================

Site:
http://sqlobject.org

Development:
http://sqlobject.org/devel/

Mailing list:
https://lists.sourceforge.net/mailman/listinfo/sqlobject-discuss

Download:
https://pypi.python.org/pypi/SQLObject/3.6.0

News and changes:
http://sqlobject.org/News.html

StackOverflow:
https://stackoverflow.com/questions/tagged/sqlobject


Example
=======

Create a simple class that wraps a table::

  >>> from sqlobject import *
  >>>
  >>> sqlhub.processConnection = connectionForURI('sqlite:/:memory:')
  >>>
  >>> class Person(SQLObject):
  ...     fname = StringCol()
  ...     mi = StringCol(length=1, default=None)
  ...     lname = StringCol()
  ...
  >>> Person.createTable()

Use the object::

  >>> p = Person(fname="John", lname="Doe")
  >>> p
  <Person 1 fname='John' mi=None lname='Doe'>
  >>> p.fname
  'John'
  >>> p.mi = 'Q'
  >>> p2 = Person.get(1)
  >>> p2
  <Person 1 fname='John' mi='Q' lname='Doe'>
  >>> p is p2
  True

Queries::

  >>> p3 = Person.selectBy(lname="Doe")[0]
  >>> p3
  <Person 1 fname='John' mi='Q' lname='Doe'>
  >>> pc = Person.select(Person.q.lname=="Doe").count()
  >>> pc
  1

Oleg.
-- 
     Oleg Broytman            http://phdru.name/            ph...@ph...
           Programmers don't die, they just GOSUB without RETURN.

Yikes!

Get well and thank you for all of your work on SQLObject.

Schiavo
Simon

I'm ill and gonna spend a month in a hospital. Please help each other.

Oleg.
-- 
     Oleg Broytman            http://phdru.name/            ph...@ph...
           Programmers don't die, they just GOSUB without RETURN.

Hello!

I'm pleased to announce version 3.5.0, the first stable release of branch
3.5 of SQLObject.


What's new in SQLObject
=======================

Contributors for this release are Shailesh Mungikar and Michael S. Root.

Minor features
--------------

* Add Python3 special methods for division to SQLExpression.
  Pull request by Michael S. Root.

Drivers
-------

* Add support for `pg8000 <https://pypi.python.org/pypi/pg8000>`_
  PostgreSQL driver.

* Fix autoreconnect with pymysql driver. Contributed by Shailesh Mungikar.

Documentation
-------------

* Remove generated HTML from eggs/wheels (docs are installed into wrong
  place). Generated docs are still included in the source distribution.

Tests
-----

* Add tests for PyGreSQL, py-postgresql and pg8000 at AppVeyor.

* Fixed bugs in py-postgresql at AppVeyor. SQLObject requires
  the latest version of the driver from our fork.

For a more complete list, please see the news:
http://sqlobject.org/News.html


What is SQLObject
=================

SQLObject is an object-relational mapper.  Your database tables are described
as classes, and rows are instances of those classes.  SQLObject is meant to be
easy to use and quick to get started with.

SQLObject supports a number of backends: MySQL, PostgreSQL, SQLite,
Firebird, Sybase, MSSQL and MaxDB (also known as SAPDB).

Python 2.7 or 3.4+ is required.


Where is SQLObject
==================

Site:
http://sqlobject.org

Development:
http://sqlobject.org/devel/

Mailing list:
https://lists.sourceforge.net/mailman/listinfo/sqlobject-discuss

Download:
https://pypi.python.org/pypi/SQLObject/3.5.0

News and changes:
http://sqlobject.org/News.html

StackOverflow:
https://stackoverflow.com/questions/tagged/sqlobject


Example
=======

Create a simple class that wraps a table::

  >>> from sqlobject import *
  >>>
  >>> sqlhub.processConnection = connectionForURI('sqlite:/:memory:')
  >>>
  >>> class Person(SQLObject):
  ...     fname = StringCol()
  ...     mi = StringCol(length=1, default=None)
  ...     lname = StringCol()
  ...
  >>> Person.createTable()

Use the object::

  >>> p = Person(fname="John", lname="Doe")
  >>> p
  <Person 1 fname='John' mi=None lname='Doe'>
  >>> p.fname
  'John'
  >>> p.mi = 'Q'
  >>> p2 = Person.get(1)
  >>> p2
  <Person 1 fname='John' mi='Q' lname='Doe'>
  >>> p is p2
  True

Queries::

  >>> p3 = Person.selectBy(lname="Doe")[0]
  >>> p3
  <Person 1 fname='John' mi='Q' lname='Doe'>
  >>> pc = Person.select(Person.q.lname=="Doe").count()
  >>> pc
  1

Oleg.
-- 
     Oleg Broytman            http://phdru.name/            ph...@ph...
           Programmers don't die, they just GOSUB without RETURN.