dql.models module

Data containers

class dql.models.GlobalIndexMeta(index: dynamo3.fields.GlobalIndex)

Bases: object

Container for global index data

includes

Getter for includes

index_type

Getter for index_type

item_count

Getter for item_count

name

Getter for name

pformat(consumed_capacity=None)

Pretty format for insertion into table pformat

schema

The DQL fragment for constructing this index

size

Getter for size

status

Getter for status

throughput

Getter for throughput

class dql.models.IndexField(name, data_type, index_type, index_name, includes=None)

Bases: dql.models.TableField

A TableField that is also part of a Local Secondary Index

schema

The DQL syntax for creating this item

class dql.models.QueryIndex(name: str, is_global: bool, hash_key: dynamo3.fields.DynamoKey, range_key: Optional[dynamo3.fields.DynamoKey], attributes: Optional[Set[str]] = None)

Bases: object

A representation of global/local indexes that used during query building.

When building queries, we need to detect if the constraints are sufficient to perform a query or if they can only do a scan. This simple container class was specifically create to make that logic simpler.

classmethod from_table_index(table: dynamo3.fields.Table, index: dynamo3.fields.BaseIndex) → dql.models.QueryIndex

Factory method

projects_all_attributes(attrs: Iterable[str]) → bool

Return True if the index projects all the attributes

scannable

Only global indexes can be scanned

class dql.models.TableField(name, data_type, key_type=None)

Bases: object

A DynamoDB table attribute

Parameters:

name : str

data_type : str

The type of object (e.g. ‘STRING’, ‘NUMBER’, etc)

key_type : str, optional

The type of key (e.g. ‘RANGE’, ‘HASH’, ‘INDEX’)

schema

The DQL syntax for creating this item

to_index(index_type, index_name, includes=None)

Create an index field from this field

class dql.models.TableMeta(table: dynamo3.fields.Table, attrs: Dict[str, dql.models.TableField], global_indexes: Dict[str, dql.models.GlobalIndexMeta])

Bases: object

Container for table metadata

Parameters:

table : Table

attrs : dict

Mapping of attribute name to TableField

global_indexes : dict

Mapping of hash key to GlobalIndexMeta

decreases_today

Getter for decreases_today

classmethod from_description(table: dynamo3.fields.Table) → dql.models.TableMeta

Factory method that uses the dynamo3 ‘describe’ return value

get_index(index_name: str) → dql.models.QueryIndex

Get a specific index by name

get_indexes() → Dict[str, dql.models.QueryIndex]

Get a dict of index names to index

get_matching_indexes(possible_hash: Set[str], possible_range: Set[str]) → List[dql.models.QueryIndex]

Get all indexes that could be queried on using a set of keys.

If any indexes match both hash AND range keys, indexes that only match the hash key will be excluded from the result.

Parameters:

possible_hash : set

The names of fields that could be used as the hash key

possible_range : set

The names of fields that could be used as the range key

is_on_demand

Getter for is_on_demand

item_count

Getter for item_count

iter_query_indexes() → Iterator[dql.models.QueryIndex]

Iterator that constructs QueryIndex for all global and local indexes, and a special one for the default table hash & range key with the name ‘TABLE’

name

Getter for name

pformat() → str

Pretty string format

primary_key(hkey, rkey=None)

Construct a primary key dictionary

You can either pass in a (hash_key[, range_key]) as the arguments, or you may pass in an Item itself

primary_key_attributes

Get the names of the primary key attributes as a tuple

primary_key_tuple(item: Dict[KT, VT]) → Union[Tuple[str], Tuple[str, str]]

Get the primary key tuple from an item

schema

The DQL query that will construct this table’s schema

size

Getter for size

status

Getter for status

throughput

Getter for throughput

total_read_throughput

Combined read throughput of table and global indexes

total_write_throughput

Combined write throughput of table and global indexes

dql.models.format_throughput(available: float, used: Optional[float] = None) → str

Format the read/write throughput for display