doctable.DocTable = class DocTable(builtins.object)
     Methods defined here:
__delete__(self)
Closes database connection to prevent locking db.
__getitem__(self, colname)
Accesses a column object by calling .col().
__init__(self, target=None, tabname=None, schema=None, dialect='sqlite', engine=None, readonly=False, new_db=False, new_table=True, persistent_conn=True, verbose=False, **engine_kwargs)
Create new database.
Args:
    schema (list<list>): schema from which to create db. Includes a
        list of columns (including contraints and indexes) as tuples
        defined according to information needed to execute the sqlalchemy
        commands.
    tabname (str): table name for this specific doctable.
    target (str): filename for database to connect to. ":memory:" is a 
        special value indicating to the python db engine that the db
        should be created in memory. Will create new empty database file
        if it does not exist and new_db is True.
    dialect (str): database engine through which to construct db.
        For more info, see sqlalchemy dialect info:
        https://docs.sqlalchemy.org/en/13/dialects/
    persistent_conn (bool): whether or not to create a persistent conn 
        to database. Set to True to lock db from other process access 
        while instance exists, esp if calling .update() in a .select()
        loop. Set to False to access from separate processes.
    verbose (bool): Print every sql command before executing.
    readonly (bool): Prevents user from calling insert(), delete(), or 
        update(). Will not block other sql commands.
    new_db (bool): Indicate if new db file should be created given 
        that a schema is provided and the db file doesn't exist.
    new_table (bool): Allow doctable to create a new table if one 
        doesn't exist already.
    engine_kwargs (**kwargs): Pass directly to the sqlalchemy
        .create_engine(). Args typically vary by dialect.
        Example: connect_args={'timeout': 15} for sqlite
        or connect_args={'connect_timeout': 15} for PostgreSQL.
__repr__(self)
Return repr(self).
__str__(self)
Return str(self).
bootstrap(self, *args, n=None, **kwargs)
Generates a DocBootstrapper object to sample from.
Notes:
    The DocBootstrap object keeps all selected docs in
        memory, and yields samples with .sample().
Args:
    *args: passed to .select()
    n (int): number of samples to bs. If left unset, can
        specify when drawing sample from DocBootstrap obj.
    **kwargs: passed to .select()
Returns:
    DocBootstrap object for bootstrapping.
clean_col_files(self, col, check_missing=True, delete_extraneous=True)
Make sure there is a 1-1 mapping between files listed in db and files in folder.
Args:
    col (str or Column object): column to clean picklefiles for.
    ignore_missing (bool): if False, throw an error when a db file doesn't exist.
close_conn(self)
Closes connection to db (if one exists).
col(self, name)
Accesses a column object.
Args:
    Name of column to access. Applied as subscript to 
        sqlalchemy columns object.
colnames(self)
count(self, where=None, wherestr=None, **kwargs)
Count number of rows which match where condition.
Notes:
    Calls select_first under the hood.
Args:
    where (sqlalchemy condition): filter rows before counting.
    wherestr (str): filter rows before counting.
Returns:
    int: number of rows that match "where" and "wherestr" criteria.
delete(self, where=None, wherestr=None, vacuum=False, **kwargs)
Delete rows from the table that meet the where criteria.
Args:
    where (sqlalchemy condition): criteria for deletion.
    wherestr (sql string): addtnl criteria for deletion.
    vacuum (bool): will execute vacuum sql command to reduce
        storage space needed by SQL table. Use when deleting
        significant ammounts of data.
Returns:
    SQLAlchemy result proxy object.
execute(self, query, verbose=None, **kwargs)
Execute an sql command. Called by most higher-level functions.
Args:
    query (sqlalchemy condition or str): query to execute;
        can be provided as sqlalchemy condition object or
        plain sql text.
    verbose (bool or None): Print SQL command issued before
        execution.
head(self, n=5)
Return first n rows as dataframe for quick viewing.
Args:
    n (int): number of rows to return in dataframe.
Returns:
    Dataframe of the first n rows of the table.
insert(self, rowdat, ifnotunique='fail', **kwargs)
Insert a row or rows into the database.
Args:
    rowdat (list<dict> or dict): row data to insert.
    ifnotunique (str): way to handle inserted data if it breaks
        a table constraint. Choose from FAIL, IGNORE, REPLACE.
Returns:
    sqlalchemy query result object.
list_tables(self)
open_conn(self)
Opens connection to db (if one does not exist).
reopen_engine(self, open_conn=None)
Opens connection engine. 
Args:
    open_conn (bool): create a new db connection.
schema_info(self)
Get info about each column as a dictionary.
Returns:
    dict<dict>: info about each column.
schema_table(self)
Get info about each column as a dictionary.
Returns:
    DataFrame: info about each column.
select(self, cols=None, where=None, orderby=None, groupby=None, limit=None, wherestr=None, offset=None, **kwargs)
Perform select query, yield result for each row.
 
Description: Because output must be iterable, returns special column results 
    by performing one query per row. Can be inefficient for many smaller 
    special data information.
 
Args:
    cols: list of sqlalchemy datatypes created from calling .col() method.
    where (sqlachemy BinaryExpression): sqlalchemy "where" object to parse
    orderby: sqlalchemy orderby directive
    groupby: sqlalchemy gropuby directive
    limit (int): number of entries to return before stopping
    wherestr (str): raw sql "where" conditionals to add to where input
Yields:
    sqlalchemy result object: row data
select_chunks(self, cols=None, chunksize=100, limit=None, **kwargs)
Performs select while querying only a subset of the results at a time.
Args:
    cols (col name(s) or sqlalchemy object(s)): columns to query
    chunksize (int): size of individual queries to be made. Will
        load this number of rows into memory before yielding.
    limit (int): maximum number of rows to retrieve. Because 
        the limit argument is being used internally to limit data
        to smaller chunks, use this argument instead. Internally,
        this function will load a maximum of limit + chunksize 
        - 1 rows into memory, but yields only limit.
Yields:
    sqlalchemy result: row data - same as .select() method.
select_df(self, cols=None, *args, **kwargs)
Select returning dataframe.
Args:
    cols: sequence of columns to query. Must be sequence,
        passed directly to .select() method.
    *args: args to regular .select() method.
    **kwargs: args to regular .select() method.
Returns:
    pandas dataframe: Each row is a database row,
        and output is not indexed according to primary 
        key or otherwise. Call .set_index('id') on the
        dataframe to envoke this behavior.
select_first(self, *args, **kwargs)
Perform regular select query returning only the first result.
Args:
    *args: args to regular .select() method.
    **kwargs: args to regular .select() method.
Returns:
    sqlalchemy results obect: First result from select query.
Raises:
    LookupError: where no items are returned with the select 
        statement. Couldn't return None or other object because
        those could be valid objects in a single-row select query.
        In cases where uncertain if row match exists, use regular 
        .select() and count num results, or use try/catch.
select_iter(self, cols=None, chunksize=1, limit=None, **kwargs)
Same as .select except results retrieved from db in chunks.
Args:
    cols (col name(s) or sqlalchemy object(s)): columns to query
    chunksize (int): size of individual queries to be made. Will
        load this number of rows into memory before yielding.
    limit (int): maximum number of rows to retrieve. Because 
        the limit argument is being used internally to limit data
        to smaller chunks, use this argument instead. Internally,
        this function will load a maximum of limit + chunksize 
        - 1 rows into memory, but yields only limit.
Yields:
    sqlalchemy result: row data - same as .select() method.
select_series(self, col, *args, **kwargs)
Select returning pandas Series.
Args:
    col: column to query. Passed directly to .select() 
        method.
    *args: args to regular .select() method.
    **kwargs: args to regular .select() method.
Returns:
    pandas series: enters rows as values.
update(self, values, where=None, wherestr=None, **kwargs)
Update row(s) assigning the provided values.
Args:
    values (dict<colname->value> or list<dict> or list<(col,value)>)): 
        values to populate rows with. If dict, will insert those values
        into all rows that match conditions. If list of dicts, assigns
        expression in value (i.e. id['year']+1) to column. If list of 
        (col,value) 2-tuples, will assign value to col in the order 
        provided. For example given row values x=1 and y=2, the input
        [(x,y+10),(y,20)], new values will be x=12, y=20. If opposite
        order [(y,20),(x,y+10)] is provided new values would be y=20,
        x=30. In cases where list<dict> is provided, this behavior is 
        undefined.
    where (sqlalchemy condition): used to match rows where
        update will be applied.
    wherestr (sql string condition): matches same as where arg.
Returns:
    SQLAlchemy result proxy object

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)
columns
Exposes SQLAlchemy core table columns object.
Notes:
    some info here: 
    https://docs.sqlalchemy.org/en/13/core/metadata.html
    
    c = db.columns['id']
    c.type, c.name, c.
Returns:
    sqlalchemy columns: access to underlying columns
        object.
engine
table
Returns underlying sqlalchemy table object for manual manipulation.
tabname
Gets name of table for this connection.

Data and other attributes defined here:
__default_tabname__ = '_documents_'