Schema/Description/ViewObjectLayer.txt

Help on module ViewObjectLayer:

NAME
    ViewObjectLayer

FILE
    /Users/gregorygraham/druid/cms_dm_dev/importAgent/Python/ViewObjectLayer.py

CLASSES
    RowInterface
        Row(RowInterface, __builtin__.dict)
    SchemaInterface
        MultiSchema
        SingleSchema
    TableInterface
        Table
    genException.genException(exceptions.Exception)
        AbstractMethodException
        ViewObjectLayerException
    
    class AbstractMethodException(genException.genException)
     |  Exception class for creating interfaces
     |  
     |  Method resolution order:
     |      AbstractMethodException
     |      genException.genException
     |      exceptions.Exception
     |  
     |  Methods defined here:
     |  
     |  __init__(self, **kwargs)
     |      Constructor
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from genException.genException:
     |  
     |  __str__(self)
     |      Generate string representation of error.
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from exceptions.Exception:
     |  
     |  __getitem__(...)
    
    class MultiSchema(SchemaInterface)
     |  This class represents the product of composing together schema 
     |  representing different tables.
     |  
     |  Methods defined here:
     |  
     |  __init__(self, fkExcl=[])
     |      Constructor
     |  
     |  addCondition(self, condition)
     |      Adds a list of conditions to the schema.  Implements 
     |      SchemaInterface::addCondition()
     |  
     |  addSchema(self, schema, nary=0)
     |      Adds a simple schema to the MultiSchema.
     |      Takes an instance of SimpleSchmea, and a flag to indicate if 
     |      many to one is desired.
     |  
     |  addSeq(self, attribute, val=-1)
     |      Declares a sequencer on attribute.  Does not reset existing values.  Implements 
     |      SchemaInterface::addSeq().
     |  
     |  attributes(self)
     |      Returns the attributes in the CompositeTable.
     |      All attributes of components by table name are
     |      included.  Implements SchemaInterface::attributes().
     |  
     |  defaults(self, attribute)
     |      Returns the default value of an attribute. The attribute should be given 
     |      in table.attribute format, but it will attempt to find a match if not.
     |      Implements SchemaInterface::defaults().
     |  
     |  foreignKeys(self, flag=1)
     |      Accessor to foreign key definitions.  Will return a dictionary 
     |      of all foreign key definitions by default.  If the first bit is set, 
     |      then foreign keys that refer to the same table are excluded from 
     |      the list. If the second bit is set, then foreign keys that refer to 
     |      defferent tables but are still within the composite table are excluded.
     |      If the third bit is set then external references are excluded.
     |      If the fourth bit is set, foreign keys that are also in the join 
     |      conditions are excluded. The output format is 
     |      {table1.attr1 : table2:attr2} where the sense is that table1:attr1 
     |      references table2:attr2. Implements SchemaInterface::foreignKeys().
     |  
     |  getConditions(self)
     |      Accessor returns list of view conditions
     |      Implements SchemaInterface::viewConditions
     |  
     |  getNextSeq(self, attribute)
     |      Gets the next integer in sequence for attribute is it
     |      has a sequencer defined. Uses TableName.Attribute name 
     |      for the attribute.  Implements SchemaInterface::getNextSeq().
     |  
     |  info(self, subselect, field)
     |      Returns information about the selected subschema in subselect.
     |      If field is "FKList", a list of foreign keys exported by the
     |      subschema into the existing schema is returned.  If field is 
     |      "Nary", a 0 or 1 is returned is the relationship expected is 
     |      one to one or one to many respectively.  If field is something 
     |      else, None is returned.  Implements SchemaInterface::info().
     |  
     |  matchAttribute(self, attr)
     |      Maps attribute to table.attribute(fkey) format.  For MultiSchema, 
     |      this may not always return a unique attribute.  Implements 
     |      SchemaInterface::matchAttribute().
     |  
     |  names(self)
     |      Returns the list of Component table names.  
     |      This is empty until ComponentTables are added.
     |      Implements SchemaInterface::names()
     |  
     |  notNull(self)
     |      Returns the defined not null constraints, 
     |      format is TableName.AttributeName. Implements
     |      SchemaInterface::notNull.
     |  
     |  primaryKey(self)
     |      Returns the primary key attributes.  Implements 
     |      SchemaInterface::primaryKey().
     |  
     |  sequences(self)
     |      This returns the existing attributes with sequencers defined.
     |      Implements SchemaInterface::sequences().
     |  
     |  setSeq(self, attribute, val)
     |      Sets the value of a sequencer.  Implements SchemaInterface::setSeq().
     |  
     |  subSchema(self, selector)
     |      For MultiSchema, this returns the subschema named by the selector.
     |      If selector equals None, it then returns self.  Implements 
     |      SchemaInterface::subSchema().
     |  
     |  types(self, attribute)
     |      Returns the type of an attribute. The attribute should be given 
     |      in table.attribute format, but it will attempt to find a match if not.
     |      Implements SchemaInterface::types().
     |  
     |  uniqueKeys(self)
     |      This function does not find all of the unique keys.
     |      Rather, we look for tables tht appear in the primary key 
     |      attributes and list direct products of unique keys from 
     |      those tables only on the strength that a unique key is
     |      functionally dependent on the primary key.  Implements
     |      SchemaInterface::uniqueKeys().
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from SchemaInterface:
     |  
     |  expr = r"matchAttribute.__doc__ = '\n   Abstract definition for interf...
     |  
     |  method = 'matchAttribute'
    
    class Row(RowInterface, __builtin__.dict)
     |  Row object for the CompositeTable class. 
     |  In order to satisfy the one to many relationships and 
     |  possible multiple foreign key references to the same table,
     |  the structure is more complicated than a simple one table
     |  row object.
     |  
     |  Method resolution order:
     |      Row
     |      RowInterface
     |      __builtin__.dict
     |      __builtin__.object
     |  
     |  Methods defined here:
     |  
     |  __getitem__(self, key, index=None)
     |      Overrides dict::__getitem__() to restrict domain to 
     |      possibleKeys().  If key points to an n-ary list  
     |      of subrows, the last row only is used to get the value.
     |      Optional index can be given to get data from the ith subrow.
     |  
     |  __init__(self, parSchema)
     |      Constructor takes parent table reference as argument.
     |      An optional list of attributes to ignore when finding 
     |      foreign keys can be given.
     |  
     |  __setitem__(self, key, value, allFlag=0)
     |      Overrides dict::__setitem__() to restrict domain to 
     |      possibleKeys().  If key points to an n-ary list  
     |      of subrows, the last row only is set.  If allFlag is 1, 
     |      then all rows in an n-ary list get set.
     |  
     |  availableSchemas(self)
     |      Returns a list of available schemas.  Each schema in 
     |      this list corresponds to exactly one table.  
     |      Implements RowInterface::availableSchemas().
     |  
     |  fixRow(self, fKeyConditions, joinConditions, reverse=0)
     |      Fixes up a row according to conditions
     |          (a) Foreign key conditions are fixed in the direction 
     |              refered --> referer.  This overwrites any previous 
     |              value in referer.  
     |          (b) Join conditions are fixed in the direction of  
     |              non-None value to None value.  If both sides are None, 
     |              nothing happens.  If both side are not None and unequal,
     |              an exception is thrown.
     |      Implements RowInterface::fixRow()
     |  
     |  getData(self, schemaName, fkey=None)
     |      For the given schemaName in RowInterface::availableSchemas(), 
     |      return data corresponding only to that schema.  Implements
     |      RowInterface::getData().
     |  
     |  keys(self)
     |      Overrides dict::keys() to restrict domain to possibleKeys().
     |  
     |  matchAttribute(self, attr)
     |      Convenience method to access SchemaInterface::matchAttribute().
     |  
     |  newData(self, schemaName)
     |      If schemaInfo(schemaName)['Nary'] > 0, then new data can 
     |      be added to the schema corresponding to schemaName without 
     |      creating a new row.  Implements RowInterface::newData().
     |  
     |  parentSchema(self)
     |      Accessor to the SchemaInterface corresponding
     |      to this row.  Implements RowInterface::parentSchema().
     |  
     |  possibleKeys(self)
     |      Convenience method to access a list of all possible attributes  
     |      of the Row.  Implements RowInterface::possibleKeys().
     |  
     |  schemaInfo(self, selector)
     |      Returns info on one to one/many relationships and foreign 
     |      key target lists.  (See SchemaInterface::info().) 
     |      Implements RowInterface::schemaInfo()
     |  
     |  setSkipOnEmpty(self, schemaName=None)
     |      Adds a schema name to the list of schemas that are allowed 
     |      to have empty data.  Insert algrithms should not throw an 
     |      exception in that case.  Implements RowInterface::skipOnEmpty().
     |  
     |  skipOnEmpty(self, schemaName)
     |      Returns 0 or 1 if the row cannot be skipped (or can) in case 
     |      of empty row.   Insert algrithms should not throw an 
     |      exception in that case.  Implements RowInterface::skipOnEmpty().
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  __dict__ = <dictproxy object at 0x50f6f0>
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__ = <attribute '__weakref__' of 'Row' objects>
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from RowInterface:
     |  
     |  expr = r"fixRow.__doc__ = '\n   Abstract definition for interface meth...
     |  
     |  method = 'fixRow'
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from __builtin__.dict:
     |  
     |  __cmp__(...)
     |      x.__cmp__(y) <==> cmp(x,y)
     |  
     |  __contains__(...)
     |      D.__contains__(k) -> True if D has a key k, else False
     |  
     |  __delitem__(...)
     |      x.__delitem__(y) <==> del x[y]
     |  
     |  __eq__(...)
     |      x.__eq__(y) <==> x==y
     |  
     |  __ge__(...)
     |      x.__ge__(y) <==> x>=y
     |  
     |  __getattribute__(...)
     |      x.__getattribute__('name') <==> x.name
     |  
     |  __gt__(...)
     |      x.__gt__(y) <==> x>y
     |  
     |  __hash__(...)
     |      x.__hash__() <==> hash(x)
     |  
     |  __iter__(...)
     |      x.__iter__() <==> iter(x)
     |  
     |  __le__(...)
     |      x.__le__(y) <==> x<=y
     |  
     |  __len__(...)
     |      x.__len__() <==> len(x)
     |  
     |  __lt__(...)
     |      x.__lt__(y) <==> x<y
     |  
     |  __ne__(...)
     |      x.__ne__(y) <==> x!=y
     |  
     |  __repr__(...)
     |      x.__repr__() <==> repr(x)
     |  
     |  clear(...)
     |      D.clear() -> None.  Remove all items from D.
     |  
     |  copy(...)
     |      D.copy() -> a shallow copy of D
     |  
     |  get(...)
     |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
     |  
     |  has_key(...)
     |      D.has_key(k) -> True if D has a key k, else False
     |  
     |  items(...)
     |      D.items() -> list of D's (key, value) pairs, as 2-tuples
     |  
     |  iteritems(...)
     |      D.iteritems() -> an iterator over the (key, value) items of D
     |  
     |  iterkeys(...)
     |      D.iterkeys() -> an iterator over the keys of D
     |  
     |  itervalues(...)
     |      D.itervalues() -> an iterator over the values of D
     |  
     |  pop(...)
     |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value
     |      If key is not found, d is returned if given, otherwise KeyError is raised
     |  
     |  popitem(...)
     |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
     |      2-tuple; but raise KeyError if D is empty
     |  
     |  setdefault(...)
     |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
     |  
     |  update(...)
     |      D.update(E, **F) -> None.  Update D from E and F: for k in E: D[k] = E[k]
     |      (if E has keys else: for (k, v) in E: D[k] = v) then: for k in F: D[k] = F[k]
     |  
     |  values(...)
     |      D.values() -> list of D's values
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from __builtin__.dict:
     |  
     |  __new__ = <built-in method __new__ of type object at 0x101016f0>
     |      T.__new__(S, ...) -> a new object with type S, a subtype of T
     |  
     |  fromkeys = <built-in method fromkeys of type object at 0x119ee0>
     |      dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
     |      v defaults to None.
    
    class RowInterface
     |  Interface definition for a row class.  The row should be a dict, but 
     |  it should also have methods to handle special cases.
     |  
     |  Methods defined here:
     |  
     |  __init__(self)
     |      Constructor - Abstract class definition
     |      Checks that methods declared in the public interface are actually defined.
     |  
     |  lambdaself, x='ViewObjectLayer', y='RowInterface', z='availableSchemas'
     |      Abstract definition for interface method availableSchemas()
     |  
     |  lambdaself, x='ViewObjectLayer', y='RowInterface', z='fixRow'
     |      Abstract definition for interface method fixRow()
     |  
     |  lambdaself, x='ViewObjectLayer', y='RowInterface', z='getData'
     |      Abstract definition for interface method getData()
     |  
     |  lambdaself, x='ViewObjectLayer', y='RowInterface', z='matchAttribute'
     |      Abstract definition for interface method matchAttribute()
     |  
     |  lambdaself, x='ViewObjectLayer', y='RowInterface', z='newData'
     |      Abstract definition for interface method newData()
     |  
     |  lambdaself, x='ViewObjectLayer', y='RowInterface', z='parentSchema'
     |      Abstract definition for interface method parentSchema()
     |  
     |  lambdaself, x='ViewObjectLayer', y='RowInterface', z='possibleKeys'
     |      Abstract definition for interface method possibleKeys()
     |  
     |  lambdaself, x='ViewObjectLayer', y='RowInterface', z='schemaInfo'
     |      Abstract definition for interface method schemaInfo()
     |  
     |  lambdaself, x='ViewObjectLayer', y='RowInterface', z='setSkipOnEmpty'
     |      Abstract definition for interface method setSkipOnEmpty()
     |  
     |  lambdaself, x='ViewObjectLayer', y='RowInterface', z='skipOnEmpty'
     |      Abstract definition for interface method skipOnEmpty()
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  expr = r"fixRow.__doc__ = '\n   Abstract definition for interface meth...
     |  
     |  method = 'fixRow'
    
    class SchemaInterface
     |  This interface defines methods to access and manipulate relational 
     |  database constraints on a single table or multi-table view.
     |  
     |  Methods defined here:
     |  
     |  __init__(self)
     |      Constructor - Check that method definitions declared in 
     |      the public interface are actually defined.
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='addCondition'
     |      Abstract definition for interface method addCondition()
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='addSeq'
     |      Abstract definition for interface method addSeq()
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='attributes'
     |      Abstract definition for interface method attributes()
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='defaults'
     |      Abstract definition for interface method defaults()
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='foreignKeys'
     |      Abstract definition for interface method foreignKeys()
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='getConditions'
     |      Abstract definition for interface method getConditions()
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='getNextSeq'
     |      Abstract definition for interface method getNextSeq()
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='info'
     |      Abstract definition for interface method info()
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='matchAttribute'
     |      Abstract definition for interface method matchAttribute()
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='names'
     |      Abstract definition for interface method names()
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='notNull'
     |      Abstract definition for interface method notNull()
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='primaryKey'
     |      Abstract definition for interface method primaryKey()
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='sequences'
     |      Abstract definition for interface method sequences()
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='setSeq'
     |      Abstract definition for interface method setSeq()
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='subSchema'
     |      Abstract definition for interface method subSchema()
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='types'
     |      Abstract definition for interface method types()
     |  
     |  lambdaself, x='ViewObjectLayer', y='SchemaInterface', z='uniqueKeys'
     |      Abstract definition for interface method uniqueKeys()
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  expr = r"matchAttribute.__doc__ = '\n   Abstract definition for interf...
     |  
     |  method = 'matchAttribute'
    
    class SingleSchema(SchemaInterface)
     |  Class to represent schema from a single database table.
     |  
     |  Methods defined here:
     |  
     |  __init__(self, name, attributes, types, pk, uk, fk, nn, df, sq, conditions=[])
     |      This implementation of SchemaInterface is for a single table definition.
     |  
     |  addCondition(self, condition)
     |      Adds a list of conditions to the schema.  Implements 
     |      SchemaInterface::addCondition()
     |  
     |  addSeq(self, item, value=-1)
     |      Declares a sequencer on attribute.  Does not reset existing values.  Implements 
     |      SchemaInterface::addSeq().
     |  
     |  attributes(self)
     |      Accessor to table attribtes.  Returns all attrbutes in a list.
     |      Implements SchemaInterface::attributes()
     |  
     |  defaults(self, attribute)
     |      Accessor to attribute defaults. Will return a string describing the 
     |      default value of the given attribute, or None if it was not defined. 
     |      Implements SchemaInterface::types().
     |  
     |  foreignKeys(self, flag=1)
     |      Accessor to foreign key definitions.  Will return a dictionary 
     |      of all foreign key definitions by default.  If the first bit is set, 
     |      then foreign keys that refer to the same table are excluded from 
     |      the list. The output format is {attr1 : table2:attr2} where 
     |      the sense is that attr1 references table2:attr2. (table1 is 
     |      understood to be this table.) Implements SchemaInterface::foreignKeys()
     |  
     |  getConditions(self)
     |      Accessor returns list of view conditions. Implements 
     |      SchemaInterface::getConditions()
     |  
     |  getNextSeq(self, item)
     |      For the given attribute, this increments the associated sequence  
     |      counter and returns its value.  If no counter was defined, then 
     |      it raises an error.  Implements SchemaInterface::getNextSeq().
     |  
     |  info(self, selector, field)
     |      Returns information about the selected subschema in selector.
     |      If field is "FKList", a list of foreign keys exported by the
     |      subschema into the existing schema is returned.  If field is 
     |      "Nary", a 0 or 1 is returned is the relationship expected is 
     |      one to one or one to many respectively.  If field is something 
     |      else, None is returned.  Implements SchemaInterface::info().
     |  
     |  matchAttribute(self, attr)
     |      Maps attribute to table.attribute format.  For SingleSchema, 
     |      this always returns a unique attribute.  Implements 
     |      SchemaInterface::matchAttribute().
     |  
     |  names(self)
     |      Accessor to the table name.  Returns a list of string names.
     |      For a SingleSchema, this list always has one element in it.
     |      Implements SchemaInterface::names().
     |  
     |  notNull(self)
     |      Accessor returns 1 (true) if the given attribute is not nullable
     |      or 0 (false) if it is allowed to be null.  Implements 
     |      SchemaInterface::notNull().
     |  
     |  primaryKey(self)
     |      Accessor to primary key attributes.  This will return a list 
     |      of the attributes. Implements SchemaInterface::primaryKey()
     |  
     |  sequences(self)
     |      This returns the existing attributes with sequencers defined.
     |      Implements SchemaInterface::sequences().
     |  
     |  setSeq(self, item, val=-1)
     |      Sets the value of a sequencer.  Implements SchemaInterface::setSeq().
     |  
     |  subSchema(self, selector)
     |      For SingleSchema, this checks that the subschema asked for 
     |      is the same as self, and then returns self.  Implements 
     |      SchemaInterface::subSchema().
     |  
     |  types(self, attribute)
     |      Accessor to attribute types. Will return a string describing the 
     |      type of the given attribute. Implements SchemaInterface::types().
     |  
     |  uniqueKeys(self)
     |      Accessor to list of unique keys.  Returns a list of all unique 
     |      keys defined on the table, each of which is a list of attributes.
     |      Implements SchemaInterface::uniqueKeys().
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from SchemaInterface:
     |  
     |  expr = r"matchAttribute.__doc__ = '\n   Abstract definition for interf...
     |  
     |  method = 'matchAttribute'
    
    class Table(TableInterface)
     |  This class represents a database view with schema, 
     |  elementary operations, and a physical connection.  The 
     |  schema can be either any object that implements the 
     |  SchemaInterface.  Data is exchanged with the Table in 
     |  objects that implement the RowInterface.
     |  
     |  Methods defined here:
     |  
     |  __init__(self, schema, cParms={})
     |      Constructor for the Table class
     |  
     |  delete(self, conditions)
     |      Delete function not implemented.
     |  
     |  getConnection(self)
     |      Returns the connection object.
     |      Implements TableInterface::getConnections
     |  
     |  initializeSequencers(self)
     |      This function initializes sequencers by appealing to the database table. 
     |      The initial value is set to the max() of the corresponding column.
     |      Implements TableInterface::initializeSequencers().
     |  
     |  insert(self, row, colList=[])
     |      Does an insert on component tables.  At least 
     |      one unique key per comp table is required for insert.
     |      (There should be a test insert function.)
     |  
     |  resetConnection(self, **cParms)
     |      This closes the existing connection and opens a new one using the 
     |      given parameters.  If none are given, then existing parameters are used.
     |      Implements TableInterface::resetConnection.
     |  
     |  resetTransaction(self)
     |      This clears the transaction with implicit rollback.
     |      Implements TableInterface::resetTransaction
     |  
     |  saveTransaction(self)
     |      This clears the transaction with implicit commit.
     |      Implements TableInterface::saveTransaction
     |  
     |  schema(self)
     |      This returns a reference to the schema on which this table is defined.
     |      Implements TableInterface::schema()
     |  
     |  select(self, colList, conditions)
     |      Does a multi table select.  colList should be in 
     |      TableName.AttributeName format.  What gets returned
     |      is more or less just a flat row, and the attributes 
     |      in the column list and conditions are flattened as
     |      well.
     |  
     |  smartInsert(self, row, colList=[])
     |      Does a smartInsert on the multi tables.
     |  
     |  smartSelect(self, colList, conditions)
     |      Does a multi-table select that completely retrieves
     |      the objects.
     |  
     |  update(self, colList, values, conditions)
     |      Update function not implemented.
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  SingleTable = <class ViewObjectLayer.SingleTable at 0x50c8d0>
     |      This class represents a single database table using the 
     |      same interface as Table.  This is meant for internal use
     |      only and is just an implementation mechanism.
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from TableInterface:
     |  
     |  lambdaself, x='ViewObjectLayer', y='TableInterface', z='modify'
     |      Abstract definition for interface method modify()
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from TableInterface:
     |  
     |  expr = r"saveTransaction.__doc__ = '\n   Abstract definition for inter...
     |  
     |  method = 'saveTransaction'
    
    class TableInterface
     |  This interface is a light interface to a database table. It contains simple
     |  commit and rollback methods, a Row class definition and a factory method for
     |  making new Rows, sequencers for tables with artificial integer primary keys, 
     |  and simple SQL manipulation methods insert, update, delete, select, and modify.
     |  
     |  Methods defined here:
     |  
     |  __init__(self, schema, cParms=None)
     |      Constructor - Abstract class definition
     |      Checks that methods declared in the public 
     |      interface are actually defined.
     |  
     |  lambdaself, x='ViewObjectLayer', y='TableInterface', z='delete'
     |      Abstract definition for interface method delete()
     |  
     |  lambdaself, x='ViewObjectLayer', y='TableInterface', z='getConnection'
     |      Abstract definition for interface method getConnection()
     |  
     |  lambdaself, x='ViewObjectLayer', y='TableInterface', z='initializeSequencers'
     |      Abstract definition for interface method initializeSequencers()
     |  
     |  lambdaself, x='ViewObjectLayer', y='TableInterface', z='insert'
     |      Abstract definition for interface method insert()
     |  
     |  lambdaself, x='ViewObjectLayer', y='TableInterface', z='modify'
     |      Abstract definition for interface method modify()
     |  
     |  lambdaself, x='ViewObjectLayer', y='TableInterface', z='resetConnection'
     |      Abstract definition for interface method resetConnection()
     |  
     |  lambdaself, x='ViewObjectLayer', y='TableInterface', z='resetTransaction'
     |      Abstract definition for interface method resetTransaction()
     |  
     |  lambdaself, x='ViewObjectLayer', y='TableInterface', z='saveTransaction'
     |      Abstract definition for interface method saveTransaction()
     |  
     |  lambdaself, x='ViewObjectLayer', y='TableInterface', z='schema'
     |      Abstract definition for interface method schema()
     |  
     |  lambdaself, x='ViewObjectLayer', y='TableInterface', z='select'
     |      Abstract definition for interface method select()
     |  
     |  lambdaself, x='ViewObjectLayer', y='TableInterface', z='smartInsert'
     |      Abstract definition for interface method smartInsert()
     |  
     |  lambdaself, x='ViewObjectLayer', y='TableInterface', z='smartSelect'
     |      Abstract definition for interface method smartSelect()
     |  
     |  lambdaself, x='ViewObjectLayer', y='TableInterface', z='update'
     |      Abstract definition for interface method update()
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  expr = r"saveTransaction.__doc__ = '\n   Abstract definition for inter...
     |  
     |  method = 'saveTransaction'
    
    class ViewObjectLayerException(genException.genException)
     |  Exception class for SQL side of object layer.
     |  
     |  Method resolution order:
     |      ViewObjectLayerException
     |      genException.genException
     |      exceptions.Exception
     |  
     |  Methods defined here:
     |  
     |  __init__(self, msgText, **kwargs)
     |      Constructor
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from genException.genException:
     |  
     |  __str__(self)
     |      Generate string representation of error.
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from exceptions.Exception:
     |  
     |  __getitem__(...)

FUNCTIONS
    raiseAbstractException(module, Class, method)
        General purpose exception raiser for abstract exceptions.
        This will raise the AbstractMethodException with the 
        call parameters.

DATA
    __revision__ = '$Revision: 1.2 $'
    __version__ = '$Id: ViewObjectLayer.py,v 1.8 2005/05/16 07:14:11 ggrah...

VERSION
    $Id: ViewObjectLayer.txt,v 1.2 2005/05/16 08:57:31 ggraham Exp $

Revision:	1.1
Committed:	Fri May 20 04:59:55 2005 UTC (19 years, 11 months ago) by ggraham
Content type:	text/plain
Branch:	MAIN
CVS Tags:	DBS_1_1_2_pre1, DBS_1_1_0, DBS_1_0_9_pre4, DBS_1_0_9_pre3, DBS_1_0_9_pre2, DBS_1_0_8, DBS_1_0_8_pre7, DBS_1_0_8_pre6, DBS_1_0_8_pre5, DBS_1_0_8_pre4, DBS_1_0_8_pre3_b4code_rehash, DBS_1_0_8_pre2, DBS_1_0_8_pre1, DBS_1_0_7, DBS_1_0_7_pre2, DBS_1_0_7_pre1, DBS_1_0_5, DBS_1_0_3, DBS_1_0_3_pre1, DBS_1_0_0, DBS_1_0_0_pre8, DBS_1_0_0_pre6, DBS_1_0_0_pre5, pre5_v01_00_00, pre4_v01_00_00, pre3_v01_00_00, pre2_v01_00_00, pre_v01_00_00, v00_00_14, v00_00_13, v00_00_12, v00_00_11, v00_00_10, v00_00_09, v00_00_08, v00_00_07, v00_00_06, v00_00_05, pre_v00_00_05, v00_00_004, pre_v00_00_02, v00_00_01, DBS_0_0_3a, DBS_0_0_3, DBS_0_0_2, DBS_0_0_1, pre_DBS_0_0_1, post_dict_type_checking_merge, post_MiniPythonAPI_merged_to_trunk, pre_MiniPythonAPI_merge_to_trunk, DBS_0_0_0, vs20060320, AfterJan2006SchemaChanges_v01_00_01, AfterJan2006SchemaChanges_v01_00_00, AfterJan2006SchemaChanges, BeforeJan2006SchemaChanges, before_message_removal, HEAD
Branch point for:	BranchForCPPWebServiceTesting
Log Message:	Import of DBS Prototype 0 publishAgent