Models

Defining your data models with Statik is a breeze. It's important to note that every YAML file in your project's models/ folder represents a database table in the in-memory SQLite database. Therefore, if you create a file called models/MyModel.yml, Statik will create a corresponding MyModel table (the filename minus the extension) with the relevant fields within it.

Model Format

Your model file should adhere to the following format:

field1-name: Field1Type
field2-name: Field2Type
field3-name: Field3Type
# etc.

Field names with hyphens in the names will automatically have their hyphens converted into underscores (_), so field1-name will be converted into field1_name, and so on.

Standard Fields

The following standard field types are currently supported:

• String - A simple string field (a standard VARCHAR field in SQLite)
• Integer - A 32-bit signed integer (INT field in SQLite)
• DateTime - A standard DATETIME type in SQLite
• Text - A larger text field than the String field (TEXT field in SQLite)
• Boolean - Simple boolean true/false value field
• Content - A Text field whose contents are automatically interpreted as Markdown content from the main content of a Markdown file.

One-to-Many and Many-to-One Relationships

Standard SQL foreign key relationships are supported in the following way: if you have two models defined, say Post and Author, where Author is defined as:

# models/Author.yml
first-name: String
last-name: String
email: String

and Post is defined as:

# models/Post.yml
title: String
author: Author

you will see that Post has a FOREIGN KEY relationship to Author on the field author. This allows you to query the related model in your views' queries:

# yourview.yml
# ...
context:
  dynamic:
    posts: session.query(Post).all()

<!-- yourtemplate.html -->
{{ posts[0].author.first_name }}

Reverse Relationships

To define a "reverse" relationship (i.e. backwards from the foreign model), simply do the following:

# models/Post.yml
title: String
author: Author -> posts

This allows you to perform such queries:

<!-- yourtemplate.html -->
{% for post in author.posts %}
  <!-- ... -->
{% endfor %}

Many-to-Many Relationships

Defining many-to-many relationships is just as easy:

# models/Post.yml
title: String
tags: Tag[] -> posts

# models/Tag.yml
name: String

The syntax <ForeignModel>[] with the [] brackets indicates to Statik that this field must be considered to be a many-to-many relationship. As you can also see in the example above, the Tag model will now have a reverse relationship called posts for easy lookup of the posts associated with the tag:

<!-- yourtemplate.html -->
{% for tag in post.tags %}
  <!-- do something with tag -->
{% endfor %}

{% for post in tag.posts %}
  <!-- do something with post -->
{% endfor %}