Class DBTable

source code

                        object --+            
                                 |            
base.sqlsupport.PostgresQueryMixin --+        
                                     |        
                        object --+   |        
                                 |   |        
base.sqlsupport.StandardQueryMixin --+        
                                     |        
          base.sqlsupport.QuerierMixin --+    
                                         |    
                            DBMethodsMixin --+
                                             |
                            object --+       |
                                     |       |
                   base.meta.MetaMixin --+   |
                                         |   |
                            object --+   |   |
                                     |   |   |
                     common.ParamMixin --+   |
                                         |   |
                           table.BaseTable --+
                                             |
                                object --+   |
                                         |   |
                            MetaTableMixin --+
                                             |
                                            DBTable

Known Subclasses:

• View

An interface to a table in the database.

These are usually created using ``api.TableForDef(tableDef)`` with a
table definition obtained, e.g., from an RD, saying ``onDisk=True``.

When constructing a DBTable, it will be created if necessary (unless
``create=False`` is passed), but indices or primary keys keys will only be
created on a call to ``importFinished``.

The constructor does not check if the schema of the table on disk matches 
the tableDef.  If the two diverge, all kinds of failures are conceivable;
use ``dachs val -c``  to make sure on-disk structure match the RDs.

You can pass a ``nometa`` boolean kw argument to suppress entering the table
into the ``dc_tables`` table.

You can pass an exclusive boolean kw argument; if you do, the
``iterQuery`` (and possibly similar methods in the future) method
will block concurrent writes to the selected rows ("FOR UPDATE")
as long as the transaction is active.

The main attributes (with API guarantees) include:

* tableDef -- the defining tableDef
* getFeeder() -- returns a function you can call with rowdicts to 
  insert them into the table.
* importFinished() -- must be called after you've fed all rows when
  importing data.
* drop() -- drops the table in the database
* recreate() -- drops the table and generates a new empty one.
* getTableForQuery(...) -- returns a Table instance built from a query
  over this table (you probably to use ``conn.query*`` and 
  ``td.getSimpleQuery`` instead).