Changeset 1070:045c95f337bb

Timestamp:

06/01/09 14:13:11 (3 years ago)

Author:

mitsuhiko

Branch:

default

Message:

Switched to splitted tables for comments, posts and texts.

Files:

: 4 edited

sql/001-add-comment-count-column.sql (modified) (1 diff)
zine/database.py (modified) (4 diffs)
zine/models.py (modified) (8 diffs)
zine/widgets.py (modified) (3 diffs)

Legend:

: Unmodified
: Added
: Removed

sql/001-add-comment-count-column.sql

r1063	r1070
2	2
3	3	alter table posts add column comment_count integer after comments_enabled not null;
	4
	5	-- We're missing a migration that splits texts and posts into the old
	6	-- table contents and the new "texts" one. Migrations should follow
	7	-- soon. Last revision with old tables is 198cd0bdbc05.

zine/database.py

-                      r1069
+                      r1070
 def create_engine(uri, relative_to=None, echo=False):
+def create_engine(uri, relative_to=None, echo=True):
     """Create a new engine.  This works a bit like SQLAlchemy's
     `create_engine` with the difference that it automaticaly set's MySQL
 …
+)
+texts = db.Table('texts', metadata,
+    db.Column('text_id', db.Integer, primary_key=True),
+    db.Column('text', db.Text),
+    db.Column('parser_data', db.ZEMLParserData),
+    db.Column('extra', db.PickleType)
+)
 posts = db.Table('posts', metadata,
     db.Column('post_id', db.Integer, primary_key=True),
 …
     db.Column('uid', db.String(250)),
     db.Column('title', db.String(150)),
     db.Column('text', db.Text),
+    db.Column('text_id', db.Integer, db.ForeignKey('texts.text_id')),
     db.Column('author_id', db.Integer, db.ForeignKey('users.user_id')),
-    db.Column('parser_data', db.ZEMLParserData),
     db.Column('comments_enabled', db.Boolean),
     db.Column('comment_count', db.Integer, nullable=False, default=0),
     db.Column('pings_enabled', db.Boolean),
     db.Column('content_type', db.String(40), index=True),
+    db.Column('extra', db.PickleType),
+    db.Column('status', db.Integer)
+    db.Column('status', db.Integer),
+)
 …
     db.Column('email', db.String(250)),
     db.Column('www', db.String(200)),
     db.Column('text', db.Text),
+    db.Column('text_id', db.Integer, db.ForeignKey('texts.text_id')),
     db.Column('is_pingback', db.Boolean, nullable=False),
-    db.Column('parser_data', db.ZEMLParserData),
     db.Column('parent_id', db.Integer, db.ForeignKey('comments.comment_id')),
     db.Column('pub_date', db.DateTime),

zine/models.py

-                      r1068
+                      r1070
 from zine.database import users, categories, posts, post_links, \
      post_categories, post_tags, tags, comments, groups, group_users, \
      privileges, user_privileges, group_privileges, db
+     privileges, user_privileges, group_privileges, texts, db
 from zine.utils import zeml
 from zine.utils.text import gen_slug, gen_timestamped_slug, build_tag_uri, \
 …
 class PostQuery(db.Query):
+class _PostQueryBase(db.Query):
     """Add some extra methods to the post model."""
 …
         args = map(db.lazyload, lazy or ()) + map(db.defer, deferred or ())
         return self.options(*args)
-    def summary_lightweight(self):
-        """A query with lightweight settings for summaries.  (Like widgets
-        etc.)  Does not load text or comments or anything related.
-        """
-        return self.lightweight(lazy=('comments', 'categories', 'tags'),
-                                deferred=('parser_data', 'text', 'extra'))
-    def theme_lightweight(self, key):
-        """A query for lightweight settings based on the theme.  For example
-        to use the lightweight settings for the author overview page you can
-        use this query::
-            Post.query.theme_lightweight('author_overview')
-        """
-        theme_settings = get_application().theme.settings
-        deferred = theme_settings.get('sql.%s.deferred' % key)
-        lazy = theme_settings.get('sql.%s.lazy' % key)
-        return self.lightweight(deferred, lazy)
     def type(self, content_type):
 …
 class Post(_ZEMLDualContainer):
+class _PostBase(object):
     """Represents one blog post."""
+    @property
+    def _privileges(self):
+        return get_application().content_type_privileges[self.content_type]
+    @property
+    def EDIT_OWN_PRIVILEGE(self):
+        """The edit-own privilege for this content type."""
+        return self._privileges[1]
+    @property
+    def EDIT_OTHER_PRIVILEGE(self):
+        """The edit-other privilege for this content type."""
+        return self._privileges[2]
+    @property
+    def root_comments(self):
+        """Return only the comments for this post that don't have a parent."""
+        return [x for x in self.comments if x.parent is None]
+    @property
+    def visible_comments(self):
+        """Return only the comments for this post that are visible to
+        the user.
+        """
+        return [x for x in self.comments if x.visible]
+    @property
+    def visible_root_comments(self):
+        """Return only the comments for this post that are visible to
+        the user and that don't have a parent.
+        """
+        return [x for x in self.comments if x.visible and x.parent is None]
+    @property
+    def comment_count(self):
+        """The number of visible comments."""
+        req = get_request()
+        # if the model was loaded with .lightweight() there are no comments
+        # but a _comment_count we can use.
+        if not db.attribute_loaded(self, 'comments'):
+            return self._comment_count
+        # otherwise the comments are already available and we can savely
+        # filter it.
+        if req and req.user.is_manager:
+            return len(self.comments)
+        return len([x for x in self.comments if not x.blocked])
+    @property
+    def comment_feed_url(self):
+        """The link to the comment feed."""
+        return make_external_url(self.slug.rstrip('/') + '/feed.atom')
+    @property
+    def is_draft(self):
+        """True if this post is unpublished."""
+        return self.status == STATUS_DRAFT
+    def sync_comment_count(self):
+        """Sync the reflected comment count."""
+        self._comment_count = self.query \
+            .published(ignore_privileges=True).count()
+    def set_auto_slug(self):
+        """Generate a slug for this post."""
+        cfg = get_application().cfg
+        slug = gen_slug(self.title)
+        if not slug:
+            slug = to_blog_timezone(self.pub_date).strftime('%H%M')
+        full_slug = gen_timestamped_slug(slug, self.content_type, self.pub_date)
+        if full_slug != self.slug:
+            while Post.query.autoflush(False).filter_by(slug=full_slug) \
+                      .limit(1).count():
+                full_slug = increment_string(full_slug)
+            self.slug = full_slug
+    def touch_times(self, pub_date=None):
+        """Touches the times for this post.  If the pub_date is given the
+        `pub_date` is changed to the given date.  If it's not given the
+        current time is assumed if the post status is set to published,
+        otherwise it's set to `None`.
+        Additionally the `last_update` is always set to now.
+        """
+        now = datetime.utcnow()
+        if pub_date is None and self.status == STATUS_PUBLISHED:
+            pub_date = now
+        self.pub_date = pub_date
+        self.last_update = now
+    def bind_slug(self, slug=None):
+        """Binds a new slug to the post.  If the slug is `None`/empty a new
+        automatically generated slug is created.  Otherwise that slug is
+        used and assigned.
+        """
+        if not slug:
+            self.set_auto_slug()
+        else:
+            self.slug = slug
+    def bind_tags(self, tags):
+        """Rebinds the tags to a list of tags (strings, not tag objects)."""
+        current_map = dict((x.name, x) for x in self.tags)
+        currently_attached = set(x.name for x in self.tags)
+        new_tags = set(tags)
+        # delete outdated tags
+        for name in currently_attached.difference(new_tags):
+            self.tags.remove(current_map[name])
+        # add new tags
+        for name in new_tags.difference(currently_attached):
+            self.tags.append(Tag.get_or_create(name))
+    def bind_categories(self, categories):
+        """Rebinds the categories to the list passed.  The list of objects
+        must be a list of category objects.
+        """
+        currently_attached = set(self.categories)
+        new_categories = set(categories)
+        # delete outdated categories
+        for category in currently_attached.difference(new_categories):
+            self.categories.remove(category)
+        # attach new categories
+        for category in new_categories.difference(currently_attached):
+            self.categories.append(category)
+    def can_edit(self, user=None):
+        """Checks if the given user (or current user) can edit this post."""
+        if user is None:
+            user = get_request().user
+        return (
+            user.has_privilege(self.EDIT_OTHER_PRIVILEGE) or
+            (self.author == user and
+             user.has_privilege(self.EDIT_OWN_PRIVILEGE))
+        )
+    def can_read(self, user=None):
+        """Check if the current user or the user provided can read-access
+        this post. If there is no user there must be a request object
+        for this thread defined.
+        """
+        # published posts are always accessible
+        if self.status == STATUS_PUBLISHED and self.pub_date is not None and \
+           self.pub_date <= datetime.utcnow():
+            return True
+        if user is None:
+            user = get_request().user
+        # users that are allowed to look at drafts may pass
+        if user.has_privilege(VIEW_DRAFTS):
+            return True
+        # if this is protected and user can view protected, allow them
+        if self.status == STATUS_PROTECTED and self.pub_date is not None and \
+            self.pub_date <= datetime.utcnow() and \
+            user.has_privilege(VIEW_PROTECTED):
+             return True
+        # if we have the privilege to edit other entries or if we are
+        # a blog administrator we can always look at posts.
+        if user.has_privilege(self.EDIT_OTHER_PRIVILEGE):
+            return True
+        # otherwise if the user has the EDIT_OWN_PRIVILEGE and the
+        # author of the post, he may look at it as well
+        if user.id == self.author_id and \
+           user.has_privilege(self.EDIT_OWN_PRIVILEGE):
+            return True
+        return False
+    @property
+    def is_published(self):
+        """`True` if the post is visible for everyone."""
+        return self.can_read(AnonymousUser())
+    @property
+    def is_private(self):
+        """`True` if the post is marked private."""
+        return self.status == STATUS_PRIVATE
+    @property
+    def is_protected(self):
+        """`True` if the post is marked protected."""
+        return self.status == STATUS_PROTECTED
+    @property
+    def is_scheduled(self):
+        """True if the item is scheduled for appearing."""
+        return self.status == STATUS_PUBLISHED and \
+               self.pub_date > datetime.utcnow()
+    def get_url_values(self):
+        return self.slug
+    def __repr__(self):
+        return '<%s %r>' % (
+            self.__class__.__name__,
+            self.title
+        )
+class PostQuery(_PostQueryBase):
+    """Add some extra methods to the post model."""
+    def theme_lightweight(self, key):
+        """A query for lightweight settings based on the theme.  For example
+        to use the lightweight settings for the author overview page you can
+        use this query::
+            Post.query.theme_lightweight('author_overview')
+        """
+        theme_settings = get_application().theme.settings
+        deferred = theme_settings.get('sql.%s.deferred' % key)
+        lazy = theme_settings.get('sql.%s.lazy' % key)
+        return self.lightweight(deferred, lazy)
+class SummarizedPostQuery(_PostQueryBase):
+    """Add some extra methods to the summarized post model."""
+class Post(_PostBase, _ZEMLDualContainer):
+    """A full blown post."""
     query = db.query_property(PostQuery)
 …
         self.uid = uid
+    @property
+    def _privileges(self):
+        return get_application().content_type_privileges[self.content_type]
+    @property
+    def EDIT_OWN_PRIVILEGE(self):
+        """The edit-own privilege for this content type."""
+        return self._privileges[1]
+    @property
+    def EDIT_OTHER_PRIVILEGE(self):
+        """The edit-other privilege for this content type."""
+        return self._privileges[2]
+    @property
+    def root_comments(self):
+        """Return only the comments for this post that don't have a parent."""
+        return [x for x in self.comments if x.parent is None]
+    @property
+    def visible_comments(self):
+        """Return only the comments for this post that are visible to
+        the user.
+        """
+        return [x for x in self.comments if x.visible]
+    @property
+    def visible_root_comments(self):
+        """Return only the comments for this post that are visible to
+        the user and that don't have a parent.
+        """
+        return [x for x in self.comments if x.visible and x.parent is None]
+    @property
+    def comment_count(self):
+        """The number of visible comments."""
+        req = get_request()
+        # if the model was loaded with .lightweight() there are no comments
+        # but a _comment_count we can use.
+        if not db.attribute_loaded(self, 'comments'):
+            return self._comment_count
+        # otherwise the comments are already available and we can savely
+        # filter it.
+        if req and req.user.is_manager:
+            return len(self.comments)
+        return len([x for x in self.comments if not x.blocked])
+    @property
+    def comment_feed_url(self):
+        """The link to the comment feed."""
+        return make_external_url(self.slug.rstrip('/') + '/feed.atom')
+    @property
+    def is_draft(self):
+        """True if this post is unpublished."""
+        return self.status == STATUS_DRAFT
+    def sync_comment_count(self):
+        """Sync the reflected comment count."""
+        self._comment_count = self.query \
+            .published(ignore_privileges=True).count()
+    def set_auto_slug(self):
+        """Generate a slug for this post."""
+        cfg = get_application().cfg
+        slug = gen_slug(self.title)
+        if not slug:
+            slug = to_blog_timezone(self.pub_date).strftime('%H%M')
+        full_slug = gen_timestamped_slug(slug, self.content_type, self.pub_date)
+        if full_slug != self.slug:
+            while Post.query.autoflush(False).filter_by(slug=full_slug) \
+                      .limit(1).count():
+                full_slug = increment_string(full_slug)
+            self.slug = full_slug
+    def touch_times(self, pub_date=None):
+        """Touches the times for this post.  If the pub_date is given the
+        `pub_date` is changed to the given date.  If it's not given the
+        current time is assumed if the post status is set to published,
+        otherwise it's set to `None`.
+        Additionally the `last_update` is always set to now.
+        """
+        now = datetime.utcnow()
+        if pub_date is None and self.status == STATUS_PUBLISHED:
+            pub_date = now
+        self.pub_date = pub_date
+        self.last_update = now
+    def bind_slug(self, slug=None):
+        """Binds a new slug to the post.  If the slug is `None`/empty a new
+        automatically generated slug is created.  Otherwise that slug is
+        used and assigned.
+        """
+        if not slug:
+            self.set_auto_slug()
+        else:
+            self.slug = slug
+    def bind_tags(self, tags):
+        """Rebinds the tags to a list of tags (strings, not tag objects)."""
+        current_map = dict((x.name, x) for x in self.tags)
+        currently_attached = set(x.name for x in self.tags)
+        new_tags = set(tags)
+        # delete outdated tags
+        for name in currently_attached.difference(new_tags):
+            self.tags.remove(current_map[name])
+        # add new tags
+        for name in new_tags.difference(currently_attached):
+            self.tags.append(Tag.get_or_create(name))
+    def bind_categories(self, categories):
+        """Rebinds the categories to the list passed.  The list of objects
+        must be a list of category objects.
+        """
+        currently_attached = set(self.categories)
+        new_categories = set(categories)
+        # delete outdated categories
+        for category in currently_attached.difference(new_categories):
+            self.categories.remove(category)
+        # attach new categories
+        for category in new_categories.difference(currently_attached):
+            self.categories.append(category)
+    def can_edit(self, user=None):
+        """Checks if the given user (or current user) can edit this post."""
+        if user is None:
+            user = get_request().user
+        return (
+            user.has_privilege(self.EDIT_OTHER_PRIVILEGE) or
+            (self.author == user and
+             user.has_privilege(self.EDIT_OWN_PRIVILEGE))
+        )
+    def can_read(self, user=None):
+        """Check if the current user or the user provided can read-access
+        this post. If there is no user there must be a request object
+        for this thread defined.
+        """
+        # published posts are always accessible
+        if self.status == STATUS_PUBLISHED and self.pub_date is not None and \
+           self.pub_date <= datetime.utcnow():
+            return True
+        if user is None:
+            user = get_request().user
+        # users that are allowed to look at drafts may pass
+        if user.has_privilege(VIEW_DRAFTS):
+            return True
+        # if this is protected and user can view protected, allow them
+        if self.status == STATUS_PROTECTED and self.pub_date is not None and \
+            self.pub_date <= datetime.utcnow() and \
+            user.has_privilege(VIEW_PROTECTED):
+             return True
+        # if we have the privilege to edit other entries or if we are
+        # a blog administrator we can always look at posts.
+        if user.has_privilege(self.EDIT_OTHER_PRIVILEGE):
+            return True
+        # otherwise if the user has the EDIT_OWN_PRIVILEGE and the
+        # author of the post, he may look at it as well
+        if user.id == self.author_id and \
+           user.has_privilege(self.EDIT_OWN_PRIVILEGE):
+            return True
+        return False
+    @property
+    def is_published(self):
+        """`True` if the post is visible for everyone."""
+        return self.can_read(AnonymousUser())
+    @property
+    def is_private(self):
+        """`True` if the post is marked private."""
+        return self.status == STATUS_PRIVATE
+    @property
+    def is_protected(self):
+        """`True` if the post is marked protected."""
+        return self.status == STATUS_PROTECTED
+    @property
+    def is_scheduled(self):
+        """True if the item is scheduled for appearing."""
+        return self.status == STATUS_PUBLISHED and \
+               self.pub_date > datetime.utcnow()
+    def get_url_values(self):
+        return self.slug
+    def __repr__(self):
+        return '<%s %r>' % (
+            self.__class__.__name__,
+            self.title
+        )
+class SummarizedPost(_PostBase):
+    """Like a regular post but without text and parser data."""
+    query = db.query_property(SummarizedPostQuery)
+    def __init__(self):
+        raise TypeError('You cannot create %r instance' % type(self).__name__)
 …
                                           query_class=PostQuery)
 }, order_by=categories.c.name)
 db.mapper(Comment, comments, properties={
+db.mapper(Comment, db.join(comments, texts), properties={
     'id':           comments.c.comment_id,
+    'text':         db.synonym('_text', map_column=True),
+    'author':       db.synonym('_author', map_column=True),
+    'email':        db.synonym('_email', map_column=True),
+    'www':          db.synonym('_www', map_column=True),
+    'status':       db.synonym('_status', map_column=True),
+    'text_id':      [comments.c.text_id, texts.c.text_id],
+    '_text':        texts.c.text,
+    'text':         db.synonym('_text'),
+    '_author':      comments.c.author,
+    'author':       db.synonym('_author'),
+    '_email':       comments.c.email,
+    'email':        db.synonym('_email'),
+    '_www':         comments.c.www,
+    'www':          db.synonym('_www'),
+    '_status':      comments.c.status,
+    'status':       db.synonym('_status'),
     'children':     db.relation(Comment,
         primaryjoin=comments.c.parent_id == comments.c.comment_id,
 …
                                       query_class=PostQuery)
 }, order_by=tags.c.name)
 db.mapper(Post, posts, properties={
+db.mapper(Post, db.join(posts, texts), properties={
     'id':               posts.c.post_id,
+    'text':             db.synonym('_text', map_column=True),
+    'text_id':          [posts.c.text_id, texts.c.text_id],
+    '_text':            texts.c.text,
+    'text':             db.synonym('_text'),
     'comments':         db.relation(Comment, backref='post',
                                     primaryjoin=posts.c.post_id ==
 …
     'tags':             db.relation(Tag, secondary=post_tags, lazy=False,
                                     order_by=[tags.c.name]),
+    '_comment_count':   posts.c.comment_count,
+    'comment_count':    db.synonym('_comment_count')
+}, order_by=posts.c.pub_date.desc())
+db.mapper(SummarizedPost, posts, properties={
+    'id':               posts.c.post_id,
+    'comments':         db.relation(Comment,
+                                    primaryjoin=posts.c.post_id ==
+                                        comments.c.post_id,
+                                    order_by=[db.asc(comments.c.pub_date)],
+                                    lazy=True, viewonly=True),
+    'links':            db.relation(PostLink, viewonly=True, lazy=True),
+    'categories':       db.relation(Category, secondary=post_categories, lazy=True,
+                                    order_by=[db.asc(categories.c.name)],
+                                    viewonly=True),
+    'tags':             db.relation(Tag, secondary=post_tags, lazy=True,
+                                    viewonly=True, order_by=[tags.c.name]),
     'comment_count':    db.synonym('_comment_count', map_column=True)
 }, order_by=posts.c.pub_date.desc())

zine/widgets.py

-                      r1068
+                      r1070
 """
 from zine.application import render_template
 from zine.models import Post, Category, Tag, Comment
+from zine.models import Post, SummarizedPost, Category, Tag, Comment
 …
     def __init__(self, detail='months', limit=6, show_title=False):
         self.__dict__.update(Post.query.summary_lightweight()
                                  .get_archive_summary(detail, limit))
+        self.__dict__.update(SummarizedPost.query
+            .get_archive_summary(detail, limit))
         self.show_title = show_title
 …
     def __init__(self, limit=5, show_title=False, content_types=None):
-        query = Post.query.summary_lightweight()
         if content_types is None:
             query = query.for_index()
+            query = SummarizedPost.query.for_index()
         else:
+            query = query.filter(Post.content_type.in_(content_types))
+            query = SummarizedPost.query.filter(SummarizedPost
+                .content_type.in_(content_types))
         self.posts = query.latest().limit(limit).all()
         self.show_title = show_title

Note: See TracChangeset for help on using the changeset viewer.

Zine

open source content publishing system