comment modéliser un flux suiveur dans appengine?

Question

J'essaye de concevoir des tables pour construire une relation de suiveur. Dire que j'ai un flux de 140char enregistrements qui ont l'utilisateur, hashtag et autre texte.

Les utilisateurs suivent d'autres utilisateurs et peuvent également suivre des hashtags.

Je suis en train de décrire la façon dont j'ai conçu ceci ci-dessous, mais il y a deux limites dans ma conception. Je me demandais si les autres avaient des moyens plus intelligents pour atteindre le même objectif.

Les questions à ce sujet sont

1. La liste des disciples est copié dans pour chaque enregistrement
2. Si un nouveau suiveur est ajouté ou supprimé un, « tous » les documents doivent être mis à jour.

Le code

class HashtagFollowers(db.Model): 
    """ 
    This table contains the followers for each hashtag 
    """ 
    hashtag = db.StringProperty() 
    followers = db.StringListProperty() 

class UserFollowers(db.Model): 
    """ 
    This table contains the followers for each user 
    """ 
    username = db.StringProperty() 
    followers = db.StringListProperty() 

class stream(db.Model): 
    """ 
    This table contains the data stream 
    """ 
    username = db.StringProperty() 
    hashtag = db.StringProperty() 
    text = db.TextProperty() 

    def save(self): 
     """ 
     On each save all the followers for each hashtag and user 
     are added into a another table with this record as the parent 
     """ 
     super(stream, self).save() 
     hfs = HashtagFollowers.all().filter("hashtag =", self.hashtag).fetch(10) 
     for hf in hfs: 
      sh = streamHashtags(parent=self, followers=hf.followers) 
      sh.save() 
     ufs = UserFollowers.all().filter("username =", self.username).fetch(10) 
     for uf in ufs: 
      uh = streamUsers(parent=self, followers=uf.followers) 
      uh.save() 



class streamHashtags(db.Model): 
    """ 
    The stream record is the parent of this record 
    """ 
    followers = db.StringListProperty() 

class streamUsers(db.Model): 
    """ 
    The stream record is the parent of this record 
    """ 
    followers = db.StringListProperty() 

Now, to get the stream of followed hastags 

    indexes = db.GqlQuery("""SELECT __key__ from streamHashtags where followers = 'myusername'""") 
    keys = [k,parent() for k in indexes[offset:numresults]] 
    return db.get(keys) 

Y at-il une façon plus intelligente de le faire?

Answer 1

Oui c'est le problème de ventilateur comme d'autres l'ont noté et le discours de Brett Slatkin devraient être examinées par les personnes intéressées.

Cependant, j'ai soulevé 2 limitations spécifiques à savoir

• La liste des disciples est copié dans pour chaque enregistrement

Ce qu'ils disent est pas un bug mais une fonctionnalité. En fait, c'est de cette façon que l'éventail sur les échelles appengine.

• Si un nouveau suiveur est ajouté ou qu'un élément supprimé, tous les enregistrements doivent être mis à jour.

Que ce soit OU ne rien faire, les enregistrements futurs ne sont pas suivis. En d'autres termes, on ne suit pas simplement les flux des gens, on suit le flux des gens à un moment donné.Donc si le jour 2 vous ne suivez pas, votre flux suiveur affichera toujours les enregistrements de l'utilisateur qui est entré le premier jour, mais pas le deuxième jour et les suivants. [Note: Ceci est différent de comment Twitter le fait]

Answer 2

Vous pouvez utiliser une propriété reference puis une table commune avec les adeptes de ce qui vous faites référence à

Answer 3

Je ne sais pas comment faire cela dans Google App-Engine, mais une base de données schéma I considéreraient serait:

 
Tables: 
    User -- a table of users with their attributes 
    HashTag -- a table of HashTags with their attributes 
    Follows -- a table that defines who follows whom 

Columns in the Follows table: 
    followed int,   -- the id of the followed entity (could be 
          User or Hashtag) 
    followed_is_user bit, -- whether the followed item is a User 
    followed_is_tag bit, -- whether the followed item is a HashTag 
    follower int   -- the id of the follower (this can only be 
          a User so you may want to make this a foreign 
          key on the User table) 

vous pourriez probablement se condenser en un seul, mais les deux colonnes de bits ceci vous permettra d'ajouter d'autres choses que les utilisateurs pourraient suivre à l'avenir.

Answer 4

Le problème que vous voulez résoudre s'appelle le problème de déploiement. Brett Slatkin de l'équipe Google App Engine a donné une conférence avec une solution efficace/évolutive de problème de diffusion sur App Engine. Vous pouvez trouver une vidéo de la conversation ici:

http://code.google.com/events/io/2009/sessions/BuildingScalableComplexApps.html