doctable.DocTableLegacy = class DocTableLegacy(builtins.object)
    This is a base class for working with text documents. 
It is to be inhereted by a class actually defining the table schema for documents.
 
  Methods defined here:
__del__(self)
Closes connection upon deletion.
__init__(self, colschema=None, fname='doctable.db', tabname='documents', constraints=(), verbose=False, persistent_conn=True, make_new_db=True, check_schema=True)
Args:
    fname (str): filename of database
    tabname (str): name of sqlite table to manipulate.
    colschema (tuple of 2-tuples): list of colname, coltype columns
    constraints (tuple of str): constraints to put on columns
    verbose (bool): print querys before executing
    persistent_conn (bool): keep a persistent sqlite3 connection to 
        the db.
    new_db (bool): create a new database file if one does not already 
        exist. Prevents creation of new db if filename is mis-specified.
__str__(self)
Outputs string specifying number of documents in the table.
 
Output: string of doc info
add(self, datadict, ifnotunique=None, **queryargs)
Adds a single entry where each column is identified by a key-value pair. 
    Will automatically convert python types to sqlite storage blobs using pickle.
 
Inputs:
    datadict: dictionary of column name -> value mappings
    ifnotunique: choose what happens when an existing entry matches
        any UNIQUE criteria specified in the schema.
        Choose from ('REPLACE', 'IGNORE').
Output:
    query response
addmany(self, data, keys=None, ifnotunique=None, **queryargs)
Adds multiple entries to the database, where column names are specified by "keys".
    If "keys" is not specified, will use all columns (including autoincrement columns).
    Will automatically convert python types to sqlite storage blobs using pickle.
    
Inputs:
    data: lists of tuples representing data for each row
    keys: column names corresponding to each tuple entry
    ifnotunique: choose what happens when an existing entry matches
        any UNIQUE criteria specified in the schema.
        Choose from ('REPLACE', 'IGNORE').
Output:
    sqlite executemany query response
commit(self)
Commits database changes to file.
delete(self, where=None, **queryargs)
Deletes all rows matching the where criteria.
    
Inputs:
    where: if "*" is specified, will drop all rows. Otherwise
        is fed directly into the query statement.
 
Output:
    query response
get(self, sel=None, where=None, orderby=None, limit=None, table=None, verbose=False, asdict=True, **queryargs)
Query rows from database as generator.
    
Inputs:
    sel: list of fields to retrieve with the query
    where: literal SQLite "where" string corresponding to criteria for 
        value replacement.
    orderby: literal sqlite order by command value. Can be "column_1 ASC",
        or order by multiple columns using, for instance, "column_1 ASC, column_2 DESC"
    limit: number of rows to retrieve before stopping query. Can be used for quick testing.
    table: table name to retrieve for. Default is object table name, but can query from 
        others here.
    verbose: True/False flag indicating whether or not output should appear.
    asdict: True/False flag indicating whether rows should be returned as 
        lists (False) or as dicts with field names (True & default).
    kwargs: to be sent to self.query().
getdf(self, *args, **kwargs)
Query rows from database, return as Pandas DataFrame.
    
Inputs:
    See inputs for self.get().
query(self, qstr, payload=None, many=False, verbose=False)
Executes raw query using database connection.
 
Output: sqlite query conn.execute() output.
update(self, values, where, **queryargs)
Updates rows matching the "where" string with specified values.
    
Inputs:
    values: dictionary of field->values. all rows which meet the where criteria 
        will have these values assigned
    where: literal SQLite "where" string corresponding to column criteria for 
        value replacement.
        The value "*" will match all rows by omitting WHERE statement.
Output:
    query response

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)