Peewee comes with numerous extras which I didn’t really feel like including in the main source module, but which might be interesting to implementers or fun to mess around with.
The playhouse includes modules for different database drivers or database specific functionality:
Modules which expose higher-level python constructs:
As well as tools for working with databases and other frameworks:
The apsw_ext module contains a database class suitable for use with the apsw sqlite driver.
APSW Project page: https://github.com/rogerbinns/apsw
APSW is a really neat library that provides a thin wrapper on top of SQLite’s C interface, making it possible to use all of SQLite’s advanced features.
Here are just a few reasons to use APSW, taken from the documentation:
For more information on the differences between apsw and pysqlite, check the apsw docs.
from apsw_ext import *
db = APSWDatabase(':memory:')
class BaseModel(Model):
class Meta:
database = db
class SomeModel(BaseModel):
col1 = CharField()
col2 = DateTimeField()
Parameters: |
|
---|
Functions just like the Database.transaction() context manager, but accepts an additional parameter specifying the type of lock to use.
Parameters: | lock_type (string) – type of lock to use when opening a new transaction |
---|
Provides a way of globally registering a module. For more information, see the documentation on virtual tables.
Parameters: |
|
---|
Unregister a module.
Parameters: | mod_name (string) – name to use for module |
---|
Note
Be sure to use the Field subclasses defined in the apsw_ext module, as they will properly handle adapting the data types for storage.
The postgresql extensions module provides a number of “postgres-only” functions, currently:
In the future I would like to add support for more of postgresql’s features. If there is a particular feature you would like to see added, please open a Github issue.
Warning
In order to start using the features described below, you will need to use the extension PostgresqlExtDatabase class instead of PostgresqlDatabase.
The code below will assume you are using the following database and base model:
from playhouse.postgres_ext import *
ext_db = PostgresqlExtDatabase('peewee_test', user='postgres')
class BaseExtModel(Model):
class Meta:
database = ext_db
Postgresql hstore is an embedded key/value store. With hstore, you can store arbitrary key/value pairs in your database alongside structured relational data.
Currently the postgres_ext module supports the following operations:
To start with, you will need to import the custom database class and the hstore functions from playhouse.postgres_ext (see above code snippet). Then, it is as simple as adding a HStoreField to your model:
class House(BaseExtModel):
address = CharField()
features = HStoreField()
You can now store arbitrary key/value pairs on House instances:
>>> h = House.create(address='123 Main St', features={'garage': '2 cars', 'bath': '2 bath'})
>>> h_from_db = House.get(House.id == h.id)
>>> h_from_db.features
{'bath': '2 bath', 'garage': '2 cars'}
You can filter by keys or partial dictionary:
>>> f = House.features
>>> House.select().where(f.contains('garage')) # <-- all houses w/garage key
>>> House.select().where(f.contains(['garage', 'bath'])) # <-- all houses w/garage & bath
>>> House.select().where(f.contains({'garage': '2 cars'})) # <-- houses w/2-car garage
Suppose you want to do an atomic update to the house:
>>> f = House.features
>>> new_features = House.features.update({'bath': '2.5 bath', 'sqft': '1100'})
>>> query = House.update(features=new_features)
>>> query.where(House.id == h.id).execute()
1
>>> h = House.get(House.id == h.id)
>>> h.features
{'bath': '2.5 bath', 'garage': '2 cars', 'sqft': '1100'}
Or, alternatively an atomic delete:
>>> query = House.update(features=f.delete('bath'))
>>> query.where(House.id == h.id).execute()
1
>>> h = House.get(House.id == h.id)
>>> h.features
{'garage': '2 cars', 'sqft': '1100'}
Multiple keys can be deleted at the same time:
>>> query = House.update(features=f.delete('garage', 'sqft'))
You can select just keys, just values, or zip the two:
>>> f = House.features
>>> for h in House.select(House.address, f.keys().alias('keys')):
... print h.address, h.keys
123 Main St [u'bath', u'garage']
>>> for h in House.select(House.address, f.values().alias('vals')):
... print h.address, h.vals
123 Main St [u'2 bath', u'2 cars']
>>> for h in House.select(House.address, f.items().alias('mtx')):
... print h.address, h.mtx
123 Main St [[u'bath', u'2 bath'], [u'garage', u'2 cars']]
You can retrieve a slice of data, for example, all the garage data:
>>> f = House.features
>>> for h in House.select(House.address, f.slice('garage').alias('garage_data')):
... print h.address, h.garage_data
123 Main St {'garage': '2 cars'}
You can check for the existence of a key and filter rows accordingly:
>>> for h in House.select(House.address, f.exists('garage').alias('has_garage')):
... print h.address, h.has_garage
123 Main St True
>>> for h in House.select().where(f.exists('garage')):
... print h.address, h.features['garage'] # <-- just houses w/garage data
123 Main St 2 cars
peewee has basic support for Postgres’ native JSON data type, in the form of JSONField. As of version 2.4.7, peewee also supports the Postgres 9.4 binary json jsonb type, via BinaryJSONField.
Warning
Postgres supports a JSON data type natively as of 9.2 (full support in 9.3). In order to use this functionality you must be using the correct version of Postgres with psycopg2 version 2.5 or greater.
To use BinaryJSONField, which has many performance and querying advantages, you must have Postgres 9.4 or later.
Note
You must be sure your database is an instance of PostgresqlExtDatabase in order to use the JSONField.
Here is an example of how you might declare a model with a JSON field:
import json
import urllib2
from playhouse.postgres_ext import *
db = PostgresqlExtDatabase('my_database') # note
class APIResponse(Model):
url = CharField()
response = JSONField()
class Meta:
database = db
@classmethod
def request(cls, url):
fh = urllib2.urlopen(url)
return cls.create(url=url, response=json.loads(fh.read()))
APIResponse.create_table()
# Store a JSON response.
offense = APIResponse.request('http://wtf.charlesleifer.com/api/offense/')
booking = APIResponse.request('http://wtf.charlesleifer.com/api/booking/')
# Query a JSON data structure using a nested key lookup:
offense_responses = APIResponse.select().where(
APIResponse.response['meta']['model'] == 'offense')
# Retrieve a sub-key for each APIResponse. By calling .as_json(), the
# data at the sub-key will be returned as Python objects (dicts, lists,
# etc) instead of serialized JSON.
q = (APIResponse
.select(
APIResponse.data['booking']['person'].as_json().alias('person'))
.where(
APIResponse.data['meta']['model'] == 'booking'))
for result in q:
print result.person['name'], result.person['dob']
The BinaryJSONField works the same and supports the same operations as the regular JSONField, but provides several additional operations for testing containment. Using the binary json field, you can test whether your JSON data contains other partial JSON structures (contains(), contains_any(), contains_all()), or whether it is a subset of a larger JSON document (contained_by()).
For more examples, see the JSONField and BinaryJSONField API documents below.
When psycopg2 executes a query, normally all results are fetched and returned to the client by the backend. This can cause your application to use a lot of memory when making large queries. Using server-side cursors, results are returned a little at a time (by default 2000 records). For the definitive reference, please see the psycopg2 documentation.
Note
To use server-side (or named) cursors, you must be using PostgresqlExtDatabase.
To execute a query using a server-side cursor, simply wrap your select query using the ServerSide() helper:
large_query = PageView.select() # Build query normally.
# Iterate over large query inside a transaction.
for page_view in ServerSide(large_query):
# do some interesting analysis here.
pass
# Server-side resources are released.
If you would like all SELECT queries to automatically use a server-side cursor, you can specify this when creating your PostgresqlExtDatabase:
from postgres_ext import PostgresqlExtDatabase
ss_db = PostgresqlExtDatabase('my_db', server_side_cursors=True)
Note
Server-side cursors live only as long as the transaction, so for this reason peewee will not automatically call commit() after executing a SELECT query. If you do not commit after you are done iterating, you will not release the server-side resources until the connection is closed (or the transaction is committed later). Furthermore, since peewee will by default cache rows returned by the cursor, you should always call .iterator() when iterating over a large query.
If you are using the ServerSide() helper, the transaction and call to iterator() will be handled transparently.
Postgresql provides sophisticated full-text search using special data-types (tsvector and tsquery). Documents should be stored or converted to the tsvector type, and search queries should be converted to tsquery.
For simple cases, you can simply use the Match() function, which will automatically perform the appropriate conversions, and requires no schema changes:
def blog_search(query):
return Blog.select().where(
(Blog.status == Blog.STATUS_PUBLISHED) &
Match(Blog.content, query))
The Match() function will automatically convert the left-hand operand to a tsvector, and the right-hand operand to a tsquery. For better performance, it is recommended you create a GIN index on the column you plan to search:
CREATE INDEX blog_full_text_search ON blog USING gin(to_tsvector(content));
Alternatively, you can use the TSVectorField to maintain a dedicated column for storing tsvector data:
class Blog(Model):
content = TextField()
search_content = TSVectorField()
You will need to explicitly convert the incoming text data to tsvector when inserting or updating the search_content field:
content = 'Excellent blog post about peewee ORM.'
blog_entry = Blog.create(
content=content,
search_content=fn.to_tsvector(content))
Note
If you are using the TSVectorField, it will automatically be created with a GIN index.
Identical to PostgresqlDatabase but required in order to support:
Parameters: |
|
---|
If using server_side_cursors, also be sure to wrap your queries with ServerSide().
If you do not wish to use the HStore extension, you can specify register_hstore=False.
Warning
The PostgresqlExtDatabase by default will attempt to register the HSTORE extension. Most distributions and recent versions include this, but in some cases the extension may not be available. If you do not plan to use the HStore features of peewee, you can pass register_hstore=False when initializing your PostgresqlExtDatabase.
Wrap the given select query in a transaction, and call it’s iterator() method to avoid caching row instances. In order for the server-side resources to be released, be sure to exhaust the generator (iterate over all the rows).
Parameters: | select_query – a SelectQuery instance. |
---|---|
Return type: | generator |
Usage:
large_query = PageView.select()
for page_view in ServerSide(large_query):
# Do something interesting.
pass
# At this point server side resources are released.
Field capable of storing arrays of the provided field_class.
Parameters: |
|
---|
You can store and retrieve lists (or lists-of-lists):
class BlogPost(BaseModel):
content = TextField()
tags = ArrayField(CharField)
post = BlogPost(content='awesome', tags=['foo', 'bar', 'baz'])
Additionally, you can use the __getitem__ API to query values or slices in the database:
# Get the first tag on a given blog post.
first_tag = (BlogPost
.select(BlogPost.tags[0].alias('first_tag'))
.where(BlogPost.id == 1)
.dicts()
.get())
# first_tag = {'first_tag': 'foo'}
Get a slice of values:
# Get the first two tags.
two_tags = (BlogPost
.select(BlogPost.tags[:2].alias('two'))
.dicts()
.get())
# two_tags = {'two': ['foo', 'bar']}
Parameters: | items – One or more items that must be in the given array field. |
---|
# Get all blog posts that are tagged with both "python" and "django".
Blog.select().where(Blog.tags.contains('python', 'django'))
Parameters: | items – One or more items to search for in the given array field. |
---|
Like contains(), except will match rows where the array contains any of the given items.
# Get all blog posts that are tagged with "flask" and/or "django".
Blog.select().where(Blog.tags.contains_any('flask', 'django'))
A timezone-aware subclass of DateTimeField.
A field for storing and retrieving arbitrary key/value pairs. For details on usage, see hstore support.
Returns the keys for a given row.
>>> f = House.features
>>> for h in House.select(House.address, f.keys().alias('keys')):
... print h.address, h.keys
123 Main St [u'bath', u'garage']
Return the values for a given row.
>>> for h in House.select(House.address, f.values().alias('vals')):
... print h.address, h.vals
123 Main St [u'2 bath', u'2 cars']
Like python’s dict, return the keys and values in a list-of-lists:
>>> for h in House.select(House.address, f.items().alias('mtx')):
... print h.address, h.mtx
123 Main St [[u'bath', u'2 bath'], [u'garage', u'2 cars']]
Return a slice of data given a list of keys.
>>> f = House.features
>>> for h in House.select(House.address, f.slice('garage').alias('garage_data')):
... print h.address, h.garage_data
123 Main St {'garage': '2 cars'}
Query for whether the given key exists.
>>> for h in House.select(House.address, f.exists('garage').alias('has_garage')):
... print h.address, h.has_garage
123 Main St True
>>> for h in House.select().where(f.exists('garage')):
... print h.address, h.features['garage'] # <-- just houses w/garage data
123 Main St 2 cars
Query for whether the given key has a value associated with it.
Perform an atomic update to the keys/values for a given row or rows.
>>> query = House.update(features=House.features.update(
... sqft=2000,
... year_built=2012))
>>> query.where(House.id == 1).execute()
Delete the provided keys for a given row or rows.
Note
We will use an UPDATE query.
>>> query = House.update(features=House.features.delete(
... 'sqft', 'year_built'))
>>> query.where(House.id == 1).execute()
Parameters: | value – Either a dict, a list of keys, or a single key. |
---|
Query rows for the existence of either:
>>> f = House.features
>>> House.select().where(f.contains('garage')) # <-- all houses w/garage key
>>> House.select().where(f.contains(['garage', 'bath'])) # <-- all houses w/garage & bath
>>> House.select().where(f.contains({'garage': '2 cars'})) # <-- houses w/2-car garage
Parameters: | keys – One or more keys to search for. |
---|
Query rows for the existince of any key.
Field class suitable for storing and querying arbitrary JSON. When using this on a model, set the field’s value to a Python object (either a dict or a list). When you retrieve your value from the database it will be returned as a Python data structure.
Parameters: | dumps – The default is to call json.dumps() or the dumps function. You can override this method to create a customized JSON wrapper. |
---|
Note
You must be using Postgres 9.2 / psycopg2 2.5 or greater.
Note
If you are using Postgres 9.4, strongly consider using the BinaryJSONField instead as it offers better performance and more powerful querying options.
Example model declaration:
db = PostgresqlExtDatabase('my_db')
class APIResponse(Model):
url = CharField()
response = JSONField()
class Meta:
database = db
Example of storing JSON data:
url = 'http://foo.com/api/resource/'
resp = json.loads(urllib2.urlopen(url).read())
APIResponse.create(url=url, response=resp)
APIResponse.create(url='http://foo.com/baz/', response={'key': 'value'})
To query, use Python’s [] operators to specify nested key or array lookups:
APIResponse.select().where(
APIResponse.response['key1']['nested-key'] == 'some-value')
To illustrate the use of the [] operators, imagine we have the following data stored in an APIResponse:
{
"foo": {
"bar": ["i1", "i2", "i3"],
"baz": {
"huey": "mickey",
"peewee": "nugget"
}
}
}
Here are the results of a few queries:
def get_data(expression):
# Helper function to just retrieve the results of a
# particular expression.
query = (APIResponse
.select(expression.alias('my_data'))
.dicts()
.get())
return query['my_data']
# Accessing the foo -> bar subkey will return a JSON
# representation of the list.
get_data(APIResponse.data['foo']['bar'])
# '["i1", "i2", "i3"]'
# In order to retrieve this list as a Python list,
# we will call .as_json() on the expression.
get_data(APIResponse.data['foo']['bar'].as_json())
# ['i1', 'i2', 'i3']
# Similarly, accessing the foo -> baz subkey will
# return a JSON representation of the dictionary.
get_data(APIResponse.data['foo']['baz'])
# '{"huey": "mickey", "peewee": "nugget"}'
# Again, calling .as_json() will return an actual
# python dictionary.
get_data(APIResponse.data['foo']['baz'].as_json())
# {'huey': 'mickey', 'peewee': 'nugget'}
# When dealing with simple values, either way works as
# you expect.
get_data(APIResponse.data['foo']['bar'][0])
# 'i1'
# Calling .as_json() when the result is a simple value
# will return the same thing as the previous example.
get_data(APIResponse.data['foo']['bar'][0].as_json())
# 'i1'
Store and query arbitrary JSON documents. Data should be stored using normal Python dict and list objects, and when data is returned from the database, it will be returned using dict and list as well.
For examples of basic query operations, see the above code samples for JSONField. The example queries below will use the same APIResponse model described above.
Parameters: | dumps – The default is to call json.dumps() or the dumps function. You can override this method to create a customized JSON wrapper. |
---|
Note
You must be using Postgres 9.4 / psycopg2 2.5 or newer. If you are using Postgres 9.2 or 9.3, you can use the regular JSONField instead.
Test whether the given JSON data contains the given JSON fragment or key.
Example:
search_fragment = {
'foo': {'bar': ['i2']}
}
query = (APIResponse
.select()
.where(APIResponse.data.contains(search_fragment)))
# If we're searching for a list, the list items do not need to
# be ordered in a particular way:
query = (APIResponse
.select()
.where(APIResponse.data.contains({
'foo': {'bar': ['i2', 'i1']}})))
We can pass in simple keys as well. To find APIResponses that contain the key foo at the top-level:
APIResponse.select().where(APIResponse.data.contains('foo'))
We can also search sub-keys using square-brackets:
APIResponse.select().where(
APIResponse.data['foo']['bar'].contains(['i2', 'i1']))
Search for the presence of one or more of the given items.
APIResponse.select().where(
APIResponse.data.contains_any('foo', 'baz', 'nugget'))
Like contains(), we can also search sub-keys:
APIResponse.select().where(
APIResponse.data['foo']['bar'].contains_any('i2', 'ix'))
Search for the presence of all of the given items.
APIResponse.select().where(
APIResponse.data.contains_all('foo'))
Like contains_any(), we can also search sub-keys:
APIResponse.select().where(
APIResponse.data['foo']['bar'].contains_all('i1', 'i2', 'i3'))
Test whether the given JSON document is contained by (is a subset of) the given JSON document. This method is the inverse of contains().
big_doc = {
'foo': {
'bar': ['i1', 'i2', 'i3'],
'baz': {
'huey': 'mickey',
'peewee': 'nugget',
}
},
'other_key': ['nugget', 'bear', 'kitten'],
}
APIResponse.select().where(
APIResponse.data.contained_by(big_doc))
Generate a full-text search expression, automatically converting the left-hand operand to a tsvector, and the right-hand operand to a tsquery.
Example:
def blog_search(query):
return Blog.select().where(
(Blog.status == Blog.STATUS_PUBLISHED) &
Match(Blog.content, query))
Field type suitable for storing tsvector data. This field will automatically be created with a GIN index for improved search performance.
Note
Data stored in this field will still need to be manually converted to the tsvector type.
Example usage:
class Blog(Model):
content = TextField()
search_content = TSVectorField()
content = 'this is a sample blog entry.'
blog_entry = Blog.create(
content=content,
search_content=fn.to_tsvector(content)) # Note `to_tsvector()`.
The SQLite extensions module provides support for some interesting sqlite-only features:
Subclass of the SqliteDatabase that provides some advanced features only offered by Sqlite.
Class-decorator for registering custom aggregation functions.
Parameters: |
|
---|
@db.aggregate('product', 1)
class Product(object):
"""Like sum, except calculate the product of a series of numbers."""
def __init__(self):
self.product = 1
def step(self, value):
self.product *= value
def finalize(self):
return self.product
# To use this aggregate:
product = (Score
.select(fn.product(Score.value))
.scalar())
Function decorator for registering a custom collation.
Parameters: | name – string name to use for this collation. |
---|
@db.collation()
def collate_reverse(s1, s2):
return -cmp(s1, s2)
# To use this collation:
Book.select().order_by(collate_reverse.collation(Book.title))
As you might have noticed, the original collate_reverse function has a special attribute called collation attached to it. This extra attribute provides a shorthand way to generate the SQL necessary to use our custom collation.
Function decorator for registering user-defined functions.
Parameters: |
|
---|
@db.func()
def title_case(s):
return s.title()
# Use in the select clause...
titled_books = Book.select(fn.title_case(Book.title))
@db.func()
def sha1(s):
return hashlib.sha1(s).hexdigest()
# Use in the where clause...
user = User.select().where(
(User.username == username) &
(fn.sha1(User.password) == password_hash)).get()
With the granular_transaction helper, you can specify the isolation level for an individual transaction. The valid options are:
Example usage:
with db.granular_transaction('exclusive'):
# no other readers or writers!
(Account
.update(Account.balance=Account.balance - 100)
.where(Account.id == from_acct)
.execute())
(Account
.update(Account.balance=Account.balance + 100)
.where(Account.id == to_acct)
.execute())
Subclass of Model that signifies the model operates using a virtual table provided by a sqlite extension.
Model class that provides support for Sqlite’s full-text search extension. Models should be defined normally, however there are a couple caveats:
Therefore it usually makes sense to index the content you intend to search and a single link back to the original document, since all SQL queries except full-text searches and rowid lookups will be slow.
Example:
class Document(FTSModel):
title = TextField() # type affinities are ignored by FTS, so use TextField
content = TextField()
Document.create_table(tokenize='porter') # use the porter stemmer.
# populate documents using normal operations.
for doc in list_of_docs_to_index:
Document.create(title=doc['title'], content=doc['content'])
# use the "match" operation for FTS queries.
matching_docs = (Document
.select()
.where(Document.match('some query')))
# to sort by best match, use the custom "rank" function.
best = (Document
.select(Document, Rank(Document).alias('score'))
.where(Document.match('some query'))
.order_by(SQL('score').desc()))
# or use the shortcut method:
best = Document.search('some phrase')
# you can also use the BM25 algorithm to rank documents:
best = (Document
.select(
Document,
Document.bm25(Document.content).alias('score'))
.where(Document.match('some query'))
.order_by(SQL('score').desc()))
# There is a shortcut method for bm25 as well:
best_bm25 = Document.search_bm25('some phrase')
# BM25 allows you to specify a column if your FTS model contains
# multiple fields.
best_bm25 = Document.search_bm25('some phrase', Document.content)
If you have an existing table and would like to add search for a column on that table, you can specify it using the content option:
class Blog(Model):
title = CharField()
pub_date = DateTimeField()
content = TextField() # we want to search this.
class FTSBlog(FTSModel):
content = TextField()
Blog.create_table()
FTSBlog.create_table(content=Blog.content)
# Now, we can manage content in the FTSBlog. To populate it with
# content:
FTSBlog.rebuild()
# Optimize the index.
FTSBlog.optimize()
The content option accepts either a single Field or a Model and can reduce the amount of storage used. However, content will need to be manually moved to/from the associated FTSModel.
Parameters: |
|
---|
Rebuild the search index – this only works when the content option was specified during table creation.
Optimize the search index.
Shorthand for generating a MATCH expression for the given term.
query = Document.select().where(Document.match('search phrase'))
for doc in query:
print 'match: ', doc.title
Calculate the rank based on the quality of the match.
query = (Document
.select(Document, Document.rank().alias('score'))
.where(Document.match('search phrase'))
.order_by(SQL('score').desc()))
for search_result in query:
print search_result.title, search_result.score
Calculate the rank based on the quality of the match using the BM25 algorithm.
Note
If no field is specified, then the first TextField on the model will be used. If no TextField is present, the first CharField will be used. Failing either of those conditions, the last overall field on the model will be used.
query = (Document
.select(
Document,
Document.bm25(Document.content).alias('score'))
.where(Document.match('search phrase'))
.order_by(SQL('score').desc()))
for search_result in query:
print search_result.title, search_result.score
Shorthand way of searching for a term and sorting results by the quality of the match. This is equivalent to the rank() example code presented above.
Parameters: |
|
---|
docs = Document.search('search term')
for result in docs:
print result.title, result.score
Shorthand way of searching for a term and sorting results by the quality of the match, as determined by the BM25 algorithm. This is equivalent to the bm25() example code presented above.
Parameters: |
|
---|
Note
If no field is specified, then the first TextField on the model will be used. If no TextField is present, the first CharField will be used. Failing either of those conditions, the last overall field on the model will be used.
Note
BM25 only works with FTS4 tables.
docs = Document.search_bm25('search term')
for result in docs:
print result.title, result.score
Generate a SQLite MATCH expression for use in full-text searches.
Document.select().where(match(Document.content, 'search term'))
Calculate the rank of the search results, for use with FTSModel queries using the MATCH operator.
# Search for documents and return results ordered by quality
# of match.
docs = (Document
.select(Document, Rank(Document).alias('score'))
.where(Document.match('some search term'))
.order_by(SQL('score').desc()))
Calculate the rank of the search results, for use with FTSModel queries using the MATCH operator.
Parameters: |
|
---|
# Assuming the `content` field has index=2 (0=pk, 1=title, 2=content),
# calculate the BM25 score for each result.
docs = (Document
.select(Document, BM25(Document, 2).alias('score'))
.where(Document.match('search term'))
.order_by(SQL('score').desc()))
Note
BM25 only works with FTS4 tables.
Factory function for creating a model class suitable for working with a transitive closure table. Closure tables are VirtualModel subclasses that work with the transitive closure SQLite extension. These special tables are designed to make it easy to efficiently query heirarchical data. The SQLite extension manages an AVL tree behind-the-scenes, transparently updating the tree when your table changes and making it easy to perform common queries on heirarchical data.
To use the closure table extension in your project, you need:
A copy of the SQLite extension. The source code can be found in the SQLite code repository or by cloning this gist:
$ git clone https://gist.github.com/coleifer/7f3593c5c2a645913b92 closure
$ cd closure/
Compile the extension as a shared library, e.g.
$ gcc -g -fPIC -shared closure.c -o closure.so
Create a model for your heirarchical data. The only requirement here is that the model have an integer primary key and a self-referential foreign key. Any additional fields are fine.
class Category(Model):
name = CharField()
metadata = TextField()
parent = ForeignKeyField('self', index=True, null=True) # Required.
# Generate a model for the closure virtual table.
CategoryClosure = ClosureTable(Category)
In your application code, make sure you load the extension when you instantiate your Database object. This is done by passing the path to the shared library to the load_extension() method.
db = SqliteExtDatabase('my_database.db')
db.load_extension('/path/to/closure')
Parameters: |
|
---|---|
Returns: | Returns a VirtualModel for working with a closure table. |
Warning
There are two caveats you should be aware of when using the transitive_closure extension. First, it requires that your source model have an integer primary key. Second, it is strongly recommended that you create an index on the self-referential foreign key.
Example code:
db = SqliteExtDatabase('my_database.db')
db.load_extension('/path/to/closure')
class Category(Model):
name = CharField()
parent = ForiegnKeyField('self', index=True, null=True) # Required.
class Meta:
database = db
CategoryClosure = ClosureTable(Category)
# Create the tables if they do not exist.
db.create_tables([Category, CategoryClosure], True)
It is now possible to perform interesting queries using the data from the closure table:
# Get all ancestors for a particular node.
laptops = Category.get(Category.name == 'Laptops')
for parent in Closure.ancestors(laptops):
print parent.name
# Computer Hardware
# Computers
# Electronics
# All products
# Get all descendants for a particular node.
hardware = Category.get(Category.name == 'Computer Hardware')
for node in Closure.descendants(hardware):
print node.name
# Laptops
# Desktops
# Hard-drives
# Monitors
# LCD Monitors
# LED Monitors
The VirtualTable returned by this function contains a handful of interesting methods. The model will be a subclass of BaseClosureTable.
A field for the primary key of the given node.
A field representing the relative depth of the given node.
A field representing the relative root node.
Retrieve all descendants of the given node. If a depth is specified, only nodes at that depth (relative to the given node) will be returned.
node = Category.get(Category.name == 'Electronics')
# Direct child categories.
children = CategoryClosure.descendants(node, depth=1)
# Grand-child categories.
children = CategoryClosure.descendants(node, depth=2)
# Descendants at all depths.
all_descendants = CategoryClosure.descendants(node)
Retrieve all ancestors of the given node. If a depth is specified, only nodes at that depth (relative to the given node) will be returned.
node = Category.get(Category.name == 'Laptops')
# All ancestors.
all_ancestors = CategoryClosure.ancestors(node)
# Grand-parent category.
grandparent = CategoryClosure.ancestores(node, depth=2)
Retrieve all nodes that are children of the specified node’s parent.
Note
For an in-depth discussion of the SQLite transitive closure extension, check out this blog post, Querying Tree Structures in SQLite using Python and the Transitive Closure Extension.
BerkeleyDB provides a SQLite-compatible API. BerkeleyDB’s SQL API has many advantages over SQLite:
For more details, Oracle has published a short technical overview.
In order to use peewee with BerkeleyDB, you need to compile BerkeleyDB with the SQL API enabled. Then compile the Python SQLite driver against BerkeleyDB’s sqlite replacement.
Begin by downloading and compiling BerkeleyDB:
wget http://download.oracle.com/berkeley-db/db-6.0.30.tar.gz
tar xzf db-6.0.30.tar.gz
cd db-6.0.30/build_unix
export CFLAGS='-DSQLITE_ENABLE_FTS3=1 -DSQLITE_ENABLE_RTREE=1 -fPIC'
../dist/configure --enable-static --disable-shared --enable-sql --enable-sql-compat
make
sudo make prefix=/usr/local/ install
Then get a copy of the standard library SQLite driver and build it against BerkeleyDB:
git clone https://github.com/ghaering/pysqlite
cd pysqlite
sed -i "s|#||g" setup.cfg
python setup.py build
sudo python setup.py install
You can also find up-to-date step by step instructions on my blog.
Subclass of the SqliteExtDatabase that supports connecting to BerkeleyDB-backed version of SQLite.
Also note that this code relies on pysqlcipher and sqlcipher, and the code there might have vulnerabilities as well, but since these are widely used crypto modules, we can expect “short zero days” there.
Subclass of SqliteDatabase that stores the database encrypted. Instead of the standard sqlite3 backend, it uses pysqlcipher: a python wrapper for sqlcipher, which – in turn – is an encrypted wrapper around sqlite3, so the API is identical to SqliteDatabase‘s, except for object construction parameters:
Parameters: |
|
---|
Notes:
[Hopefully] there’s no way to tell whether the passphrase is wrong or the file is corrupt. In both cases – the first time we try to acces the database – a DatabaseError error is raised, with the exact message: "file is encrypted or is not a database".
As mentioned above, this only happens when you access the databse, so if you need to know right away whether the passphrase was correct, you can trigger this check by calling [e.g.] get_tables() (see example below).
Most applications can expect failed attempts to open the database (common case: prompting the user for passphrase), so the database can’t be hardwired into the Meta of model classes, and a Proxy should be used instead.
Example:
db_proxy = peewee.Proxy()
class BaseModel(Model):
"""Parent for all app's models"""
class Meta:
# We won't have a valid db until user enters passhrase,
# so we use a Proxy() instead.
database = db_proxy
# Derive our model subclasses
class Person(BaseModel):
name = CharField(primary_key=True)
right_passphrase = False
while not right_passphrase:
passphrase = None
db = SqlCipherDatabase('testsqlcipher.db',
get_passphrase_from_user())
try: # Error only gets triggered when we access the db
db.get_tables()
right_passphrase = True
except DatabaseError as exc:
# We only allow a specific [somewhat cryptic] error message.
if exc.message != 'file is encrypted or is not a database':
raise exc
tell_user_the_passphrase_was_wrong()
# If we're here, db is ok, we can connect it to Model subclasses
db_proxy.initialize(db)
See also: a slightly more elaborate example.
The dataset module contains a high-level API for working with databases modeled after the popular project of the same name. The aims of the dataset module are to provide:
A minimal data-loading script might look like this:
from playhouse.dataset import DataSet
db = DataSet('sqlite:///:memory:')
table = db['sometable']
table.insert(name='Huey', age=3)
table.insert(name='Mickey', age=5, gender='male')
huey = table.find_one(name='Huey')
print huey
# {'age': 3, 'gender': None, 'id': 1, 'name': 'Huey'}
for obj in table:
print obj
# {'age': 3, 'gender': None, 'id': 1, 'name': 'Huey'}
# {'age': 5, 'gender': 'male', 'id': 2, 'name': 'Mickey'}
You can export or import data using freeze() and thaw():
# Export table content to the `users.json` file.
db.freeze(table.all(), format='json', filename='users.json')
# Import data from a CSV file into a new table. Columns will be automatically
# created for each field in the CSV file.
new_table = db['stats']
new_table.thaw(format='csv', filename='monthly_stats.csv')
DataSet objects are initialized by passing in a database URL of the format dialect://user:password@host/dbname. See the Database URL section for examples of connecting to various databases.
# Create an in-memory SQLite database.
db = DataSet('sqlite:///:memory:')
To store data, we must first obtain a reference to a table. If the table does not exist, it will be created automatically:
# Get a table reference, creating the table if it does not exist.
table = db['users']
We can now insert() new rows into the table. If the columns do not exist, they will be created automatically:
table.insert(name='Huey', age=3, color='white')
table.insert(name='Mickey', age=5, gender='male')
To update existing entries in the table, pass in a dictionary containing the new values and filter conditions. The list of columns to use as filters is specified in the columns argument. If no filter columns are specified, then all rows will be updated.
# Update the gender for "Huey".
table.update(name='Huey', gender='male', columns=['name'])
# Update all records. If the column does not exist, it will be created.
table.update(favorite_orm='peewee')
To import data from an external source, such as a JSON or CSV file, you can use the thaw() method. By default, new columns will be created for any attributes encountered. If you wish to only populate columns that are already defined on a table, you can pass in strict=True.
# Load data from a JSON file containing a list of objects.
table = dataset['stock_prices']
table.thaw(filename='stocks.json', format='json')
table.all()[:3]
# Might print...
[{'id': 1, 'ticker': 'GOOG', 'price': 703},
{'id': 2, 'ticker': 'AAPL', 'price': 109},
{'id': 3, 'ticker': 'AMZN', 'price': 300}]
DataSet supports nesting transactions using a simple context manager.
table = db['users']
with db.transaction() as txn:
table.insert(name='Charlie')
with db.transaction() as nested_txn:
# Set Charlie's favorite ORM to Django.
table.update(name='Charlie', favorite_orm='django', columns=['name'])
# jk/lol
nested_txn.rollback()
You can use the tables() method to list the tables in the current database:
>>> print db.tables
['sometable', 'user']
And for a given table, you can print the columns:
>>> table = db['user']
>>> print table.columns
['id', 'age', 'name', 'gender', 'favorite_orm']
We can also find out how many rows are in a table:
>>> print len(db['user'])
3
To retrieve all rows, you can use the all() method:
# Retrieve all the users.
users = db['user'].all()
# We can iterate over all rows without calling `.all()`
for user in db['user']:
print user['name']
Specific objects can be retrieved using find() and find_one().
# Find all the users who like peewee.
peewee_users = db['user'].find(favorite_orm='peewee')
# Find Huey.
huey = db['user'].find_one(name='Huey')
To export data, use the freeze() method, passing in the query you wish to export:
peewee_users = db['user'].find(favorite_orm='peewee')
db.freeze(peewee_users, format='json', filename='peewee_users.json')
The DataSet class provides a high-level API for working with relational databases.
Parameters: | url (str) – A database URL. See Database URL for examples. |
---|
Return a list of tables stored in the database. This list is computed dynamically each time it is accessed.
Provide a Table reference to the specified table. If the table does not exist, it will be created.
Parameters: |
|
---|---|
Returns: | A database cursor. |
Execute the provided query against the database.
Create a context manager representing a new transaction (or savepoint).
Parameters: |
|
---|
Parameters: |
|
---|
Open a connection to the underlying database. If a connection is not opened explicitly, one will be opened the first time a query is executed.
Close the connection to the underlying database.
The Table class provides a high-level API for working with rows in a given table.
Return a list of columns in the given table.
Create an index on the given columns:
# Create a unique index on the `username` column.
db['users'].create_index(['username'], unique=True)
Insert the given data dictionary into the table, creating new columns as needed.
Update the table using the provided data. If one or more columns are specified in the columns parameter, then those columns’ values in the data dictionary will be used to determine which rows to update.
# Update all rows.
db['users'].update(favorite_orm='peewee')
# Only update Huey's record, setting his age to 3.
db['users'].update(name='Huey', age=3, columns=['name'])
Query the table for rows matching the specified equality conditions. If no query is specified, then all rows are returned.
peewee_users = db['users'].find(favorite_orm='peewee')
Return a single row matching the specified equality conditions. If no matching row is found then None will be returned.
huey = db['users'].find_one(name='Huey')
Return all rows in the given table.
Delete all rows matching the given equality conditions. If no query is provided, then all rows will be deleted.
# Adios, Django!
db['users'].delete(favorite_orm='Django')
# Delete all the secret messages.
db['secret_messages'].delete()
Parameters: |
|
---|
Parameters: |
|
---|
The Django ORM provides a very high-level abstraction over SQL and as a consequence is in some ways limited in terms of flexibility or expressiveness. I wrote a blog post describing my search for a “missing link” between Django’s ORM and the SQL it generates, concluding that no such layer exists. The djpeewee module attempts to provide an easy-to-use, structured layer for generating SQL queries for use with Django’s ORM.
A couple use-cases might be:
Below is an example of how you might use this:
# Django model.
class Event(models.Model):
start_time = models.DateTimeField()
end_time = models.DateTimeField()
title = models.CharField(max_length=255)
# Suppose we want to find all events that are longer than an hour. Django
# does not support this, but we can use peewee.
from playhouse.djpeewee import translate
P = translate(Event)
query = (P.Event
.select()
.where(
(P.Event.end_time - P.Event.start_time) > timedelta(hours=1)))
# Now feed our peewee query into Django's `raw()` method:
sql, params = query.sql()
Event.objects.raw(sql, params)
The translate() function will recursively traverse the graph of models and return a dictionary populated with everything it finds. Back-references are not searched by default, but can be included by specifying backrefs=True.
Example:
>>> from django.contrib.auth.models import User, Group
>>> from playhouse.djpeewee import translate
>>> translate(User, Group)
{'ContentType': peewee.ContentType,
'Group': peewee.Group,
'Group_permissions': peewee.Group_permissions,
'Permission': peewee.Permission,
'User': peewee.User,
'User_groups': peewee.User_groups,
'User_user_permissions': peewee.User_user_permissions}
As you can see in the example above, although only User and Group were passed in to translate(), several other models which are related by foreign key were also created. Additionally, the many-to-many “through” tables were created as separate models since peewee does not abstract away these types of relationships.
Using the above models it is possible to construct joins. The following example will get all users who belong to a group that starts with the letter “A”:
>>> P = translate(User, Group)
>>> query = P.User.select().join(P.User_groups).join(P.Group).where(
... fn.Lower(fn.Substr(P.Group.name, 1, 1)) == 'a')
>>> sql, params = query.sql()
>>> print sql # formatted for legibility
SELECT t1."id", t1."password", ...
FROM "auth_user" AS t1
INNER JOIN "auth_user_groups" AS t2 ON (t1."id" = t2."user_id")
INNER JOIN "auth_group" AS t3 ON (t2."group_id" = t3."id")
WHERE (Lower(Substr(t3."name", %s, %s)) = %s)
Translate the given Django models into roughly equivalent peewee models suitable for use constructing queries. Foreign keys and many-to-many relationships will be followed and models generated, although back references are not traversed.
Parameters: |
|
---|---|
Returns: | A dict-like object containing the generated models, but which supports dotted-name style lookups. |
The following are valid options:
This module also contains several field classes that implement additional logic like encryption and compression. There is also a ManyToManyField that makes it easy to work with simple many-to-many relationships.
Parameters: |
---|
The ManyToManyField provides a simple interface for working with many-to-many relationships, inspired by Django. A many-to-many relationship is typically implemented by creating a junction table with foreign keys to the two models being related. For instance, if you were building a syllabus manager for college students, the relationship between students and courses would be many-to-many. Here is the schema using standard APIs:
class Student(Model):
name = CharField()
class Course(Model):
name = CharField()
class StudentCourse(Model):
student = ForeignKeyField(Student)
course = ForeignKeyField(Course)
To query the courses for a particular student, you would join through the junction table:
# List the courses that "Huey" is enrolled in:
courses = (Course
.select()
.join(StudentCourse)
.join(Student)
.where(Student.name == 'Huey'))
for course in courses:
print course.name
The ManyToManyField is designed to simplify this use-case by providing a field-like API for querying and modifying data in the junction table. Here is how our code looks using ManyToManyField:
class Student(Model):
name = CharField()
class Course(Model):
name = CharField()
students = ManyToManyField(Student, related_name='courses')
Note
It does not matter from Peewee’s perspective which model the ManyToManyField goes on, since the back-reference is just the mirror image. In order to write valid Python, though, you will need to add the ManyToManyField on the second model so that the name of the first model is in the scope.
We still need a junction table to store the relationships between students and courses. This model can be accessed by calling the get_through_model() method. This is useful when creating tables.
# Create tables for the students, courses, and relationships between
# the two.
db.create_tables([
Student,
Course,
Course.students.get_through_model()])
When accessed from a model instance, the ManyToManyField exposes a SelectQuery representing the set of related objects. Let’s use the interactive shell to see how all this works:
>>> huey = Student.get(Student.name == 'huey')
>>> [course.name for course in huey.courses]
['English 101', 'CS 101']
>>> engl_101 = Course.get(Course.name == 'English 101')
>>> [student.name for student in engl_101.students]
['Huey', 'Mickey', 'Zaizee']
To add new relationships between objects, you can either assign the objects directly to the ManyToManyField attribute, or call the add() method. The difference between the two is that simply assigning will clear out any existing relationships, whereas add() can preserve existing relationships.
>>> huey.courses = Course.select().where(Course.name.contains('english'))
>>> for course in huey.courses.order_by(Course.name):
... print course.name
English 101
English 151
English 201
English 221
>>> cs_101 = Course.get(Course.name == 'CS 101')
>>> cs_151 = Course.get(Course.name == 'CS 151')
>>> huey.courses.add([cs_101, cs_151])
>>> [course.name for course in huey.courses.order_by(Course.name)]
['CS 101', 'CS151', 'English 101', 'English 151', 'English 201',
'English 221']
This is quite a few courses, so let’s remove the 200-level english courses. To remove objects, use the remove() method.
>>> huey.courses.remove(Course.select().where(Course.name.contains('2'))
2
>>> [course.name for course in huey.courses.order_by(Course.name)]
['CS 101', 'CS151', 'English 101', 'English 151']
To remove all relationships from a collection, you can use the clear() method. Let’s say that English 101 is canceled, so we need to remove all the students from it:
>>> engl_101 = Course.get(Course.name == 'English 101')
>>> engl_101.students.clear()
Note
For an overview of implementing many-to-many relationships using standard Peewee APIs, check out the Implementing Many to Many section. For all but the most simple cases, you will be better off implementing many-to-many using the standard APIs.
Parameters: |
|
---|
Associate value with the current instance. You can pass in a single model instance, a list of model instances, or even a SelectQuery.
Example code:
# Huey needs to enroll in a bunch of courses, including all
# the English classes, and a couple Comp-Sci classes.
huey = Student.get(Student.name == 'Huey')
# We can add all the objects represented by a query.
english_courses = Course.select().where(
Course.name.contains('english'))
huey.courses.add(english_courses)
# We can also add lists of individual objects.
cs101 = Course.get(Course.name == 'CS 101')
cs151 = Course.get(Course.name == 'CS 151')
huey.courses.add([cs101, cs151])
Parameters: | value – Either a Model instance, a list of model instances, or a SelectQuery. |
---|
Disassociate value from the current instance. Like add(), you can pass in a model instance, a list of model instances, or even a SelectQuery.
Example code:
# Huey is currently enrolled in a lot of english classes
# as well as some Comp-Sci. He is changing majors, so we
# will remove all his courses.
english_courses = Course.select().where(
Course.name.contains('english'))
huey.courses.remove(english_courses)
# Remove the two Comp-Sci classes Huey is enrolled in.
cs101 = Course.get(Course.name == 'CS 101')
cs151 = Course.get(Course.name == 'CS 151')
huey.courses.remove([cs101, cs151])
Remove all associated objects.
Example code:
# English 101 is canceled this semester, so remove all
# the enrollments.
english_101 = Course.get(Course.name == 'English 101')
english_101.students.clear()
Return the Model representing the many-to-many junction table. This can be specified manually when the field is being instantiated using the through_model parameter. If a through_model is not specified, one will automatically be created.
When creating tables for an application that uses ManyToManyField, you must create the through table expicitly.
# Get a reference to the automatically-created through table.
StudentCourseThrough = Course.students.get_through_model()
# Create tables for our two models as well as the through model.
db.create_tables([
Student,
Course,
StudentCourseThrough])
CompressedField stores compressed data using the specified algorithm. This field extends BlobField, transparently storing a compressed representation of the data in the database.
Parameters: |
|
---|
The gfk module provides a Generic ForeignKey (GFK), similar to Django. A GFK is composed of two columns: an object ID and an object type identifier. The object types are collected in a global registry (all_models).
How a GFKField is resolved:
Note
In order to use Generic ForeignKeys, your application’s models must subclass playhouse.gfk.Model. This ensures that the model class will be added to the global registry.
Note
GFKs themselves are not actually a field and will not add a column to your table.
Like regular ForeignKeys, GFKs support a “back-reference” via the ReverseGFK descriptor.
Example:
from playhouse.gfk import *
class Tag(Model):
tag = CharField()
object_type = CharField(null=True)
object_id = IntegerField(null=True)
object = GFKField('object_type', 'object_id')
class Blog(Model):
tags = ReverseGFK(Tag, 'object_type', 'object_id')
class Photo(Model):
tags = ReverseGFK(Tag, 'object_type', 'object_id')
How you use these is pretty straightforward hopefully:
>>> b = Blog.create(name='awesome post')
>>> Tag.create(tag='awesome', object=b)
>>> b2 = Blog.create(name='whiny post')
>>> Tag.create(tag='whiny', object=b2)
>>> b.tags # <-- a select query
<class '__main__.Tag'> SELECT t1."id", t1."tag", t1."object_type", t1."object_id" FROM "tag" AS t1 WHERE ((t1."object_type" = ?) AND (t1."object_id" = ?)) [u'blog', 1]
>>> [x.tag for x in b.tags]
[u'awesome']
>>> [x.tag for x in b2.tags]
[u'whiny']
>>> p = Photo.create(name='picture of cat')
>>> Tag.create(object=p, tag='kitties')
>>> Tag.create(object=p, tag='cats')
>>> [x.tag for x in p.tags]
[u'kitties', u'cats']
>>> [x.tag for x in Blog.tags]
[u'awesome', u'whiny']
>>> t = Tag.get(Tag.tag == 'awesome')
>>> t.object
<__main__.Blog at 0x268f450>
>>> t.object.name
u'awesome post'
Provide a clean API for storing “generic” foreign keys. Generic foreign keys are comprised of an object type, which maps to a model class, and an object id, which maps to the primary key of the related model class.
Setting the GFKField on a model will automatically populate the model_type_field and model_id_field. Similarly, getting the GFKField on a model instance will “resolve” the two fields, first looking up the model class, then looking up the instance by ID.
Hybrid attributes encapsulate functionality that operates at both the Python and SQL levels. The idea for hybrid attributes comes from a feature of the same name in SQLAlchemy. Consider the following example:
class Interval(Model):
start = IntegerField()
end = IntegerField()
@hybrid_property
def length(self):
return self.end - self.start
@hybrid_method
def contains(self, point):
return (self.start <= point) & (point < self.end)
The hybrid attribute gets its name from the fact that the length attribute will behave differently depending on whether it is accessed via the Interval class or an Interval instance.
If accessed via an instance, then it behaves just as you would expect.
If accessed via the Interval.length class attribute, however, the length calculation will be expressed as a SQL expression. For example:
query = Interval.select().where(Interval.length > 5)
This query will be equivalent to the following SQL:
SELECT "t1"."id", "t1"."start", "t1"."end"
FROM "interval" AS t1
WHERE (("t1"."end" - "t1"."start") > 5)
The hybrid module also contains a decorator for implementing hybrid methods which can accept parameters. As with hybrid properties, when accessed via a model instance, then the function executes normally as-written. When the hybrid method is called on the class, however, it will generate a SQL expression.
Example:
query = Interval.select().where(Interval.contains(2))
This query is equivalent to the following SQL:
SELECT "t1"."id", "t1"."start", "t1"."end"
FROM "interval" AS t1
WHERE (("t1"."start" <= 2) AND (2 < "t1"."end"))
There is an additional API for situations where the python implementation differs slightly from the SQL implementation. Let’s add a radius method to the Interval model. Because this method calculates an absolute value, we will use the Python abs() function for the instance portion and the fn.ABS() SQL function for the class portion.
class Interval(Model):
start = IntegerField()
end = IntegerField()
@hybrid_property
def length(self):
return self.end - self.start
@hybrid_property
def radius(self):
return abs(self.length) / 2
@radius.expression
def radius(cls):
return fn.ABS(cls.length) / 2
What is neat is that both the radius implementations refer to the length hybrid attribute! When accessed via an Interval instance, the radius calculation will be executed in Python. When invoked via an Interval class, we will get the appropriate SQL.
Example:
query = Interval.select().where(Interval.radius < 3)
This query is equivalent to the following SQL:
SELECT "t1"."id", "t1"."start", "t1"."end"
FROM "interval" AS t1
WHERE ((abs("t1"."end" - "t1"."start") / 2) < 3)
Pretty neat, right? Thanks for the cool idea, SQLAlchemy!
Method decorator that allows the definition of a Python object method with both instance-level and class-level behavior.
Example:
class Interval(Model):
start = IntegerField()
end = IntegerField()
@hybrid_method
def contains(self, point):
return (self.start <= point) & (point < self.end)
When called with an Interval instance, the contains method will behave as you would expect. When called as a classmethod, though, a SQL expression will be generated:
query = Interval.select().where(Interval.contains(2))
Would generate the following SQL:
SELECT "t1"."id", "t1"."start", "t1"."end"
FROM "interval" AS t1
WHERE (("t1"."start" <= 2) AND (2 < "t1"."end"))
Method decorator for specifying the SQL-expression producing method.
Method decorator that allows the definition of a Python object property with both instance-level and class-level behavior.
Examples:
class Interval(Model):
start = IntegerField()
end = IntegerField()
@hybrid_property
def length(self):
return self.end - self.start
@hybrid_property
def radius(self):
return abs(self.length) / 2
@radius.expression
def radius(cls):
return fn.ABS(cls.length) / 2
When accessed on an Interval instance, the length and radius properties will behave as you would expect. When accessed as class attributes, though, a SQL expression will be generated instead:
query = (Interval
.select()
.where(
(Interval.length > 6) &
(Interval.radius >= 3)))
Would generate the following SQL:
SELECT "t1"."id", "t1"."start", "t1"."end"
FROM "interval" AS t1
WHERE (
(("t1"."end" - "t1"."start") > 6) AND
((abs("t1"."end" - "t1"."start") / 2) >= 3)
)
Provides a simple key/value store, using a dictionary API. By default the the KeyStore will use an in-memory sqlite database, but any database will work.
To start using the key-store, create an instance and pass it a field to use for the values.
>>> kv = KeyStore(TextField())
>>> kv['a'] = 'A'
>>> kv['a']
'A'
Note
To store arbitrary python objects, use the PickledKeyStore, which stores values in a pickled BlobField.
If your objects are JSON-serializable, you can also use the JSONKeyStore, which stores the values as JSON-encoded strings.
Using the KeyStore it is possible to use “expressions” to retrieve values from the dictionary. For instance, imagine you want to get all keys which contain a certain substring:
>>> keys_matching_substr = kv[kv.key % '%substr%']
>>> keys_start_with_a = kv[fn.Lower(fn.Substr(kv.key, 1, 1)) == 'a']
Lightweight dictionary interface to a model containing a key and value. Implements common dictionary methods, such as __getitem__, __setitem__, get, pop, items, keys, and values.
Parameters: |
---|
Example:
>>> from playhouse.kv import KeyStore
>>> kv = KeyStore(TextField())
>>> kv['a'] = 'foo'
>>> for k, v in kv:
... print k, v
a foo
>>> 'a' in kv
True
>>> 'b' in kv
False
Identical to the KeyStore except the values are stored as JSON-encoded strings, so you can store complex data-types like dictionaries and lists.
Example:
>>> from playhouse.kv import JSONKeyStore
>>> jkv = JSONKeyStore()
>>> jkv['a'] = 'A'
>>> jkv['b'] = [1, 2, 3]
>>> list(jkv.items())
[(u'a', 'A'), (u'b', [1, 2, 3])]
Identical to the KeyStore except anything can be stored as a value in the dictionary. The storage for the value will be a pickled BlobField.
Example:
>>> from playhouse.kv import PickledKeyStore
>>> pkv = PickledKeyStore()
>>> pkv['a'] = 'A'
>>> pkv['b'] = 1.0
>>> list(pkv.items())
[(u'a', 'A'), (u'b', 1.0)]
This module contains helper functions for expressing things that would otherwise be somewhat verbose or cumbersome using peewee’s APIs. There are also helpers for serializing models to dictionaries and vice-versa.
Parameters: |
|
---|
Example SQL case statements:
-- case with predicate --
SELECT "username",
CASE "user_id"
WHEN 1 THEN "one"
WHEN 2 THEN "two"
ELSE "?"
END
FROM "users";
-- case with no predicate (inline expressions) --
SELECT "username",
CASE
WHEN "user_id" = 1 THEN "one"
WHEN "user_id" = 2 THEN "two"
ELSE "?"
END
FROM "users";
Equivalent function invocations:
User.select(User.username, case(User.user_id, (
(1, "one"),
(2, "two")), "?"))
User.select(User.username, case(None, (
(User.user_id == 1, "one"), # note the double equals
(User.user_id == 2, "two")), "?"))
You can specify a value for the CASE expression using the alias() method:
User.select(User.username, case(User.user_id, (
(1, "one"),
(2, "two")), "?").alias("id_string"))
Parameters: |
|
---|---|
Returns: | a function call to cast the node as the given type. |
Example:
# Find all data points whose numbers are palindromes. We do this by
# casting the number to string, reversing it, then casting the reversed
# string back to an integer.
reverse_val = cast(fn.REVERSE(cast(DataPoint.value, 'str')), 'int')
query = (DataPoint
.select()
.where(DataPoint.value == reverse_val))
Convert a model instance (and optionally any related instances) to a dictionary.
Parameters: |
|
---|
Examples:
>>> user = User.create(username='charlie')
>>> model_to_dict(user)
{'id': 1, 'username': 'charlie'}
>>> model_to_dict(user, backrefs=True)
{'id': 1, 'tweets': [], 'username': 'charlie'}
>>> t1 = Tweet.create(user=user, message='tweet-1')
>>> t2 = Tweet.create(user=user, message='tweet-2')
>>> model_to_dict(user, backrefs=True)
{
'id': 1,
'tweets': [
{'id': 1, 'message': 'tweet-1'},
{'id': 2, 'message': 'tweet-2'},
],
'username': 'charlie'
}
>>> model_to_dict(t1)
{
'id': 1,
'message': 'tweet-1',
'user': {
'id': 1,
'username': 'charlie'
}
}
>>> model_to_dict(t2, recurse=False)
{'id': 1, 'message': 'tweet-2', 'user': 1}
Convert a dictionary of data to a model instance, creating related instances where appropriate.
Parameters: |
|
---|
Examples:
>>> user_data = {'id': 1, 'username': 'charlie'}
>>> user = dict_to_model(User, user_data)
>>> user
<__main__.User at 0x7fea8fa4d490>
>>> user.username
'charlie'
>>> note_data = {'id': 2, 'text': 'note text', 'user': user_data}
>>> note = dict_to_model(Note, note_data)
>>> note.text
'note text'
>>> note.user.username
'charlie'
>>> user_with_notes = {
... 'id': 1,
... 'username': 'charlie',
... 'notes': [{'id': 1, 'text': 'note-1'}, {'id': 2, 'text': 'note-2'}]}
>>> user = dict_to_model(User, user_with_notes)
>>> user.notes[0].text
'note-1'
>>> user.notes[0].user.username
'charlie'
Models with hooks for signals (a-la django) are provided in playhouse.signals. To use the signals, you will need all of your project’s models to be a subclass of playhouse.signals.Model, which overrides the necessary methods to provide support for the various signals.
from playhouse.signals import Model, post_save
class MyModel(Model):
data = IntegerField()
@post_save(sender=MyModel)
def on_save_handler(model_class, instance, created):
put_data_in_cache(instance.data)
The following signals are provided:
Whenever a signal is dispatched, it will call any handlers that have been registered. This allows totally separate code to respond to events like model save and delete.
The Signal class provides a connect() method, which takes a callback function and two optional parameters for “sender” and “name”. If specified, the “sender” parameter should be a single model class and allows your callback to only receive signals from that one model class. The “name” parameter is used as a convenient alias in the event you wish to unregister your signal handler.
Example usage:
from playhouse.signals import *
def post_save_handler(sender, instance, created):
print '%s was just saved' % instance
# our handler will only be called when we save instances of SomeModel
post_save.connect(post_save_handler, sender=SomeModel)
All signal handlers accept as their first two arguments sender and instance, where sender is the model class and instance is the actual model being acted upon.
If you’d like, you can also use a decorator to connect signal handlers. This is functionally equivalent to the above example:
@post_save(sender=SomeModel)
def post_save_handler(sender, instance, created):
print '%s was just saved' % instance
Stores a list of receivers (callbacks) and calls them when the “send” method is invoked.
Add the receiver to the internal list of receivers, which will be called whenever the signal is sent.
Parameters: |
|
---|
from playhouse.signals import post_save
from project.handlers import cache_buster
post_save.connect(cache_buster, name='project.cache_buster')
Disconnect the given receiver (or the receiver with the given name alias) so that it no longer is called. Either the receiver or the name must be provided.
Parameters: |
|
---|
post_save.disconnect(name='project.cache_buster')
Iterates over the receivers and will call them in the order in which they were connected. If the receiver specified a sender, it will only be called if the instance is an instance of the sender.
Parameters: | instance – a model instance |
---|
pwiz is a little script that ships with peewee and is capable of introspecting an existing database and generating model code suitable for interacting with the underlying data. If you have a database already, pwiz can give you a nice boost by generating skeleton code with correct column affinities and foreign keys.
If you install peewee using setup.py install, pwiz will be installed as a “script” and you can just run:
python -m pwiz -e postgresql -u postgres my_postgres_db
This will print a bunch of models to standard output. So you can do this:
python -m pwiz -e postgresql my_postgres_db > mymodels.py
python # <-- fire up an interactive shell
>>> from mymodels import Blog, Entry, Tag, Whatever
>>> print [blog.name for blog in Blog.select()]
Option | Meaning | Example |
---|---|---|
-h | show help | |
-e | database backend | -e mysql |
-H | host to connect to | -H remote.db.server |
-p | port to connect on | -p 9001 |
-u | database user | -u postgres |
-P | database password | -P secret |
-s | postgres schema | -s public |
The following are valid parameters for the engine:
Peewee now supports schema migrations, with well-tested support for Postgresql, SQLite and MySQL. Unlike other schema migration tools, peewee’s migrations do not handle introspection and database “versioning”. Rather, peewee provides a number of helper functions for generating and running schema-altering statements. This engine provides the basis on which a more sophisticated tool could some day be built.
Migrations can be written as simple python scripts and executed from the command-line. Since the migrations only depend on your applications Database object, it should be easy to manage changing your model definitions and maintaining a set of migration scripts without introducing dependencies.
Begin by importing the helpers from the migrate module:
from playhouse.migrate import *
Instantiate a migrator. The SchemaMigrator class is responsible for generating schema altering operations, which can then be run sequentially by the migrate() helper.
# Postgres example:
my_db = PostgresqlDatabase(...)
migrator = PostgresqlMigrator(my_db)
# SQLite example:
my_db = SqliteDatabase('my_database.db')
migrator = SqliteMigrator(my_db)
Use migrate() to execute one or more operations:
title_field = CharField(default='')
status_field = IntegerField(null=True)
migrate(
migrator.add_column('some_table', 'title', title_field),
migrator.add_column('some_table', 'status', status_field),
migrator.drop_column('some_table', 'old_column'),
)
Warning
Migrations are not run inside a transaction. If you wish the migration to run in a transaction you will need to wrap the call to migrate in a transaction block, e.g.
with my_db.transaction():
migrate(...)
Add new field(s) to an existing model:
# Create your field instances. For non-null fields you must specify a
# default value.
pubdate_field = DateTimeField(null=True)
comment_field = TextField(default='')
# Run the migration, specifying the database table, field name and field.
migrate(
migrator.add_column('comment_tbl', 'pub_date', pubdate_field),
migrator.add_column('comment_tbl', 'comment', comment_field),
)
Renaming a field:
# Specify the table, original name of the column, and its new name.
migrate(
migrator.rename_column('story', 'pub_date', 'publish_date'),
migrator.rename_column('story', 'mod_date', 'modified_date'),
)
Dropping a field:
migrate(
migrator.drop_column('story', 'some_old_field'),
)
Making a field nullable or not nullable:
# Note that when making a field not null that field must not have any
# NULL values present.
migrate(
# Make `pub_date` allow NULL values.
migrator.drop_not_null('story', 'pub_date'),
# Prevent `modified_date` from containing NULL values.
migrator.add_not_null('story', 'modified_date'),
)
Renaming a table:
migrate(
migrator.rename_table('story', 'stories_tbl'),
)
Adding an index:
# Specify the table, column names, and whether the index should be
# UNIQUE or not.
migrate(
# Create an index on the `pub_date` column.
migrator.add_index('story', ('pub_date',), False),
# Create a multi-column index on the `pub_date` and `status` fields.
migrator.add_index('story', ('pub_date', 'status'), False),
# Create a unique index on the category and title fields.
migrator.add_index('story', ('category_id', 'title'), True),
)
Dropping an index:
# Specify the index name.
migrate(migrator.drop_index('story', 'story_pub_date_status'))
Execute one or more schema altering operations.
Usage:
migrate(
migrator.add_column('some_table', 'new_column', CharField(default='')),
migrator.create_index('some_table', ('new_column',)),
)
Parameters: | database – a Database instance. |
---|
The SchemaMigrator is responsible for generating schema-altering statements.
Parameters: |
|
---|
Add a new column to the provided table. The field provided will be used to generate the appropriate column definition.
Note
If the field is not nullable it must specify a default value.
Note
For non-null fields, the field will initially be added as a null field, then an UPDATE statement will be executed to populate the column with the default value. Finally, the column will be marked as not null.
Parameters: |
|
---|
Parameters: |
|
---|
Parameters: |
|
---|
Parameters: |
|
---|
Parameters: |
|
---|
Parameters: |
|
---|
:param str table Name of the table containing the index to be dropped. :param str index_name: Name of the index to be dropped.
Generate migrations for Postgresql databases.
Generate migrations for SQLite databases.
Generate migrations for MySQL databases.
The reflection module contains helpers for introspecting existing databases. This module is used internally by several other modules in the playhouse, including DataSet and pwiz, a model generator.
Metadata can be extracted from a database by instantiating an Introspector. Rather than instantiating this class directly, it is recommended to use the factory method from_database().
Creates an Introspector instance suitable for use with the given database.
Parameters: |
|
---|
Usage:
db = SqliteDatabase('my_app.db')
introspector = Introspector.from_database(db)
models = introspector.generate_models()
# User and Tweet (assumed to exist in the database) are
# peewee Model classes generated from the database schema.
User = models['user']
Tweet = models['tweet']
This module contains a helper function to generate a database connection from a URL connection string.
Create a Database instance from the given connection URL.
Examples:
Supported schemes:
Usage:
import os
from playhouse.db_url import connect
# Connect to the database URL defined in the environment, falling
# back to a local Sqlite database if no database URL is specified.
db = connect(os.environ.get('DATABASE') or 'sqlite:///default.db')
Parse the information in the given URL into a dictionary containing database, host, port, user and/or password.
If you are using a custom database class, you can use the parse() function to extract information from a URL which can then be passed in to your database object.
This module contains helpers for dumping queries into CSV, and for loading CSV data into a database. CSV files can be introspected to generate an appropriate model class for working with the data. This makes it really easy to explore the data in a CSV file using Peewee and SQL.
Here is how you would load a CSV file into an in-memory SQLite database. The call to load_csv() returns a Model instance suitable for working with the CSV data:
from peewee import *
from playhouse.csv_loader import load_csv
db = SqliteDatabase(':memory:')
ZipToTZ = load_csv(db, 'zip_to_tz.csv')
Now we can run queries using the new model.
# Get the timezone for a zipcode.
>>> ZipToTZ.get(ZipToTZ.zip == 66047).timezone
'US/Central'
# Get all the zipcodes for my town.
>>> [row.zip for row in ZipToTZ.select().where(
... (ZipToTZ.city == 'Lawrence') && (ZipToTZ.state == 'KS'))]
[66044, 66045, 66046, 66047, 66049]
For more information and examples check out this blog post.
Load a CSV file into the provided database or model class, returning a Model suitable for working with the CSV data.
Parameters: |
|
---|---|
Return type: | A Model suitable for querying the CSV data. |
Basic example – field names and types will be introspected:
from peewee import *
from playhouse.csv_loader import *
db = SqliteDatabase(':memory:')
User = load_csv(db, 'users.csv')
Using a pre-defined model:
class ZipToTZ(Model):
zip = IntegerField()
timezone = CharField()
load_csv(ZipToTZ, 'zip_to_tz.csv')
Specifying fields:
fields = [DecimalField(), IntegerField(), IntegerField(), DateField()]
field_names = ['amount', 'from_acct', 'to_acct', 'timestamp']
Payments = load_csv(db, 'payments.csv', fields=fields, field_names=field_names, has_header=False)
Parameters: |
|
---|
Example usage:
with open('account-export.csv', 'w') as fh:
query = Account.select().order_by(Account.id)
dump_csv(query, fh)
The pool module contains a number of Database classes that provide connection pooling for PostgreSQL and MySQL databases. The pool works by overriding the methods on the Database class that open and close connections to the backend. The pool can specify a timeout after which connections are recycled, as well as an upper bound on the number of open connections.
In a multi-threaded application, up to max_connections will be opened. Each thread (or, if using gevent, greenlet) will have it’s own connection.
In a single-threaded application, only one connection will be created. It will be continually recycled until either it exceeds the stale timeout or is closed explicitly (using .manual_close()).
By default, all your application needs to do is ensure that connections are closed when you are finished with them, and they will be returned to the pool. For web applications, this typically means that at the beginning of a request, you will open a connection, and when you return a response, you will close the connection.
Simple Postgres pool example code:
# Use the special postgresql extensions.
from playhouse.pool import PooledPostgresqlExtDatabase
db = PooledPostgresqlExtDatabase(
'my_app',
max_connections=32,
stale_timeout=300, # 5 minutes.
user='postgres')
class BaseModel(Model):
class Meta:
database = db
That’s it! If you would like finer-grained control over the pool of connections, check out the Advanced Connection Management section.
Mixin class intended to be used with a subclass of Database.
Parameters: |
|
---|
Note
Connections will not be closed exactly when they exceed their stale_timeout. Instead, stale connections are only closed when a new connection is requested.
Note
If the number of open connections exceeds max_connections, a ValueError will be raised.
Request a connection from the pool. If there are no available connections a new one will be opened.
By default conn will not be closed and instead will be returned to the pool of available connections. If close_conn=True, then conn will be closed and not be returned to the pool.
Close the currently-open connection without returning it to the pool.
Subclass of PostgresqlDatabase that mixes in the PooledDatabase helper.
Subclass of PostgresqlExtDatabase that mixes in the PooledDatabase helper. The PostgresqlExtDatabase is a part of the Postgresql Extensions module and provides support for many Postgres-specific features.
Subclass of MySQLDatabase that mixes in the PooledDatabase helper.
The read_slave module contains a Model subclass that can be used to automatically execute SELECT queries against different database(s). This might be useful if you have your databases in a master / slave configuration.
Model subclass that will route SELECT queries to a different database.
Master and read-slaves are specified using Model.Meta:
# Declare a master and two read-replicas.
master = PostgresqlDatabase('master')
replica_1 = PostgresqlDatabase('replica_1')
replica_2 = PostgresqlDatabase('replica_2')
# Declare a BaseModel, the normal best-practice.
class BaseModel(ReadSlaveModel):
class Meta:
database = master
read_slaves = (replica_1, replica_2)
# Declare your models.
class User(BaseModel):
username = CharField()
When you execute writes (or deletes), they will be executed against the master database:
User.create(username='Peewee') # Executed against master.
When you execute a read query, it will run against one of the replicas:
users = User.select().where(User.username == 'Peewee')
Note
To force a SELECT query against the master database, manually create the SelectQuery.
SelectQuery(User) # master database.
Note
Queries will be dispatched among the read_slaves in round-robin fashion.
Contains utilities helpful when testing peewee projects.
Context manager that lets you use a different database with a set of models. Models can also be automatically created and dropped.
This context manager helps make it possible to test your peewee models using a “test-only” database.
Parameters: |
---|
Example:
from unittest import TestCase
from playhouse.test_utils import test_database
from peewee import *
from my_app.models import User, Tweet
test_db = SqliteDatabase(':memory:')
class TestUsersTweets(TestCase):
def create_test_data(self):
# ... create a bunch of users and tweets
for i in range(10):
User.create(username='user-%d' % i)
def test_timeline(self):
with test_database(test_db, (User, Tweet)):
# This data will be created in `test_db`
self.create_test_data()
# Perform assertions on test data inside ctx manager.
self.assertEqual(Tweet.timeline('user-0') [...])
# once we exit the context manager, we're back to using the normal database
Context manager that will count the number of queries executed within the context.
Parameters: | only_select (bool) – Only count SELECT queries. |
---|
with count_queries() as counter:
huey = User.get(User.username == 'huey')
huey_tweets = [tweet.message for tweet in huey.tweets]
assert counter.count == 2
The number of queries executed.
Return a list of 2-tuples consisting of the SQL query and a list of parameters.
Function or method decorator that will raise an AssertionError if the number of queries executed in the decorated function does not equal the expected number.
class TestMyApp(unittest.TestCase):
@assert_query_count(1)
def test_get_popular_blogs(self):
popular_blogs = Blog.get_popular()
self.assertEqual(
[blog.title for blog in popular_blogs],
["Peewee's Playhouse!", "All About Huey", "Mickey's Adventures"])
This function can also be used as a context manager:
class TestMyApp(unittest.TestCase):
def test_expensive_operation(self):
with assert_query_count(1):
perform_expensive_operation()
I often find myself writing very small scripts with peewee. pskel will generate the boilerplate code for a basic peewee script.
Usage:
pskel [options] model1 model2 ...
pskel accepts the following options:
Option | Default | Description |
---|---|---|
-l,--logging | False | Log all queries to stdout. |
-e,--engine | sqlite | Database driver to use. |
-d,--database | :memory: | Database to connect to. |
Example:
$ pskel -e postgres -d my_database User Tweet
This will print the following code to stdout (which you can redirect into a file using >):
#!/usr/bin/env python
import logging
from peewee import *
from peewee import create_model_tables
db = PostgresqlDatabase('my_database')
class BaseModel(Model):
class Meta:
database = db
class User(BaseModel):
pass
class Tweet(BaseModel):
pass
def main():
create_model_tables([User, Tweet], fail_silently=True)
if __name__ == '__main__':
main()
The playhouse.flask_utils module contains several helpers for integrating peewee with the Flask web framework.
The FlaskDB class provides a convenient way to configure a peewee Database instance using Flask app configuration. The FlaskDB wrapper will also automatically set up request setup and teardown handlers to ensure your connections are managed correctly.
Basic usage:
import datetime
from flask import Flask
from peewee import *
from playhouse.flask_utils import FlaskDB
DATABASE = 'postgresql://postgres:password@localhost:5432/my_database'
app = Flask(__name__)
app.config.from_object(__name__)
database = FlaskDB(app)
class User(database.Model):
username = CharField(unique=True)
class Tweet(database.Model):
user = ForeignKeyField(User, related_name='tweets')
content = TextField()
timestamp = DateTimeField(default=datetime.datetime.now)
The above code example will create and instantiate a peewee PostgresqlDatabase specified by the given database URL. Request hooks will be configured to establish a connection when a request is received, and automatically close the connection when the response is sent. Lastly, the FlaskDB class exposes a FlaskDB.Model property which can be used as a base for your application’s models.
Note
The underlying peewee database can be accessed using the FlaskDB.database attribute.
While the above example shows using a database URL, for more advanced usages you can specify a dictionary of configuration options:
DATABASE = {
'name': 'my_app_db',
'engine': 'playhouse.pool.PooledPostgresqlDatabase',
'user': 'postgres',
'max_connections': 32,
'stale_timeout': 600,
}
app = Flask(__name__)
app.config.from_object(__name__)
database = FlaskDB(app)
If you prefer to use the application factory pattern, the FlaskDB class implements an init_app() method.
Using as a factory:
database = FlaskDB()
# Even though the database is not yet initialized, you can still use the
# `Model` property to create model classes.
class User(database.Model):
username = CharField(unique=True)
def create_app():
app = Flask(__name__)
app.config['DATABASE'] = 'sqlite:////home/code/apps/my-database.db'
database.init_app(app)
return app
The flask_utils module provides several helpers for managing queries in your web app. Some common patterns include:
Retrieve the object matching the given query, or return a 404 not found response. A common use-case might be a detail page for a weblog. You want to either retrieve the post matching the given URL, or return a 404.
Parameters: |
|
---|
Example:
@app.route('/blog/<slug>/')
def post_detail(slug):
public_posts = Post.select().where(Post.published == True)
post = get_object_or_404(public_posts, (Post.slug == slug))
return render_template('post_detail.html', post=post)
Retrieve a paginated list of objects specified by the given query. The paginated object list will be dropped into the context using the given context_variable, as well as metadata about the current page and total number of pages, and finally any arbitrary context data passed as keyword-arguments.
The page is specified using the page GET argument, e.g. /my-object-list/?page=3 would return the third page of objects.
Parameters: |
|
---|
Example:
@app.route('/blog/')
def post_index():
public_posts = (Post
.select()
.where(Post.published == True)
.order_by(Post.timestamp.desc()))
return object_list(
'post_index.html',
query=public_posts,
context_variable='post_list',
paginate_by=10)
The template will have the following context:
Helper class to perform pagination based on GET arguments.
Parameters: |
|
---|
Return the currently selected page, as indicated by the value of the page_var GET parameter. If no page is explicitly selected, then this method will return 1, indicating the first page.
Return the total number of possible pages.
Using the value of get_page(), return the page of objects requested by the user. The return value is a SelectQuery with the appropriate LIMIT and OFFSET clauses.
If check_bounds was set to True and the requested page contains no objects, then a 404 will be raised.