The Field class is used to describe the mapping of Model attributes to database columns. Each field type has a corresponding SQL storage class (i.e. varchar, int), and conversion between python data types and underlying storage is handled transparently.
When creating a Model class, fields are defined as class-level attributes. This should look familiar to users of the django framework. Here’s an example:
from peewee import *
class User(Model):
username = CharField()
join_date = DateTimeField()
about_me = TextField()
There is one special type of field, ForeignKeyField, which allows you to expose foreign-key relationships between models in an intuitive way:
class Message(Model):
user = ForeignKeyField(User, related_name='messages')
body = TextField()
send_date = DateTimeField()
This allows you to write code like the following:
>>> print some_message.user.username
Some User
>>> for message in some_user.messages:
... print message.body
some message
another message
yet another message
Parameters accepted by all field types and their default values:
Field Type | Sqlite | Postgresql | MySQL |
---|---|---|---|
CharField | varchar | varchar | varchar |
TextField | text | text | longtext |
DateTimeField | datetime | timestamp | datetime |
IntegerField | integer | integer | integer |
BooleanField | smallint | boolean | bool |
FloatField | real | real | real |
DoubleField | real | double precision | double precision |
BigIntegerField | integer | bigint | bigint |
DecimalField | decimal | numeric | numeric |
PrimaryKeyField | integer | serial | integer |
ForeignKeyField | integer | integer | integer |
DateField | date | date | date |
TimeField | time | time | time |
Field type | Special Parameters |
---|---|
CharField | max_length |
DecimalField | max_digits, decimal_places |
ForeignKeyField | to, related_name, cascade, extra |
Since the class is not available at the time the field is declared, when creating a self-referential foreign key pass in ‘self’ as the “to” relation:
class Category(Model):
name = CharField()
parent = ForeignKeyField('self', related_name='children', null=True)
Peewee does not provide a “field” for many to many relationships the way that django does – this is because the “field” really is hiding an intermediary table. To implement many-to-many with peewee, you will therefore create the intermediary table yourself and query through it:
class Student(Model):
name = CharField()
class Course(Model):
name = CharField()
class StudentCourse(Model):
student = ForeignKeyField(Student)
course = ForeignKeyField(Course)
To query, let’s say we want to find students who are enrolled in math class:
for student in Student.select().join(StudentCourse).join(Course).where(name='math'):
print student.name
You could also express this as:
for student in Student.filter(studentcourse_set__course__name='math'):
print student.name
To query what classes a given student is enrolled in:
for course in Course.select().join(StudentCourse).join(Student).where(name='da vinci'):
print course.name
# or, similarly
for course in Course.filter(studentcourse_set__student__name='da vinci'):
print course.name
The base class from which all other field types extend.
Parameters: |
|
---|
Parameters: | value – python data type to prep for storage in the database |
---|---|
Return type: | converted python datatype |
Parameters: | value – data coming from the backend storage |
---|---|
Return type: | python data type |
Parameters: |
|
---|---|
Return type: | data type converted for use when querying |
Stores: small strings (0-255 bytes)
Stores: arbitrarily large strings
Stores: python datetime.datetime instances
Stores: python datetime.date instances
Stores: python datetime.time instances
Stores: integers
Stores: True / False
Stores: floating-point numbers
Stores: decimal numbers
Stores: auto-incrementing integer fields suitable for use as primary key
Stores: relationship to another model
Parameters: |
|
---|
class Blog(Model):
name = CharField()
class Entry(Model):
blog = ForeignKeyField(Blog, related_name='entries')
title = CharField()
content = TextField()
# "blog" attribute
>>> some_entry.blog
<Blog: My Awesome Blog>
# "entries" related name attribute
>>> for entry in my_awesome_blog.entries:
... print entry.title
Some entry
Another entry
Yet another entry