如何在不使用键名称的情况下确保 Google 应用引擎中对象的数据完整性？

Question

我在 Google App Engine 中遇到了一些麻烦，确保在使用没有键名称的祖先关系时我的数据正确。

让我再解释一下：我有一个父实体类别，并且我想创建一个子实体项目。我想创建一个函数，它接受类别名称和项目名称，并创建两个实体（如果它们不存在）。最初，我创建了一个事务，并在需要时使用密钥名称在事务中创建了两个事务，效果很好。但是，我意识到我不想使用名称作为密钥，因为它可能需要更改，并且我尝试在事务中执行此操作：

def add_item_txn(category_name, item_name):
  category_query = db.GqlQuery("SELECT * FROM Category WHERE name=:category_name", category_name=category_name)
category = category_query.get()
if not category:
    category = Category(name=category_name, count=0)

item_query = db.GqlQuery("SELECT * FROM Item WHERE name=:name AND ANCESTOR IS :category", name=item_name, category=category)
item_results = item_query.fetch(1)
if len(item_results) == 0:
  item = Item(parent=category, name=name)

db.run_in_transaction(add_item_txn, "foo", "bar")

当我尝试运行此命令时，我发现 App Engine 拒绝了此命令，因为它不允许您在事务中运行查询：事务内仅允许祖先查询。

查看 Google 给出的示例，了解如何解决这个：

def decrement(key, amount=1):
    counter = db.get(key)
    counter.count -= amount
    if counter.count < 0:    # don't let the counter go negative
        raise db.Rollback()
    db.put(counter)

q = db.GqlQuery("SELECT * FROM Counter WHERE name = :1", "foo")
counter = q.get()
db.run_in_transaction(decrement, counter.key(), amount=5)

我试图将类别的获取移至事务之前：

def add_item_txn(category_key, item_name):
    category = category_key.get()
    item_query = db.GqlQuery("SELECT * FROM Item WHERE name=:name AND ANCESTOR IS :category", name=item_name, category=category)
    item_results = item_query.fetch(1)
    if len(item_results) == 0:
         item = Item(parent=category, name=name)

category_query = db.GqlQuery("SELECT * FROM Category WHERE name=:category_name", category_name="foo")
category = category_query.get()
if not category:
    category = Category(name=category_name, count=0)
db.run_in_transaction(add_item_txn, category.key(), "bar")

这似乎有效，但我发现当我使用多个请求运行此命令时，我创建了重复的类别，这是有道理的，因为类别是在外部查询的事务和多个请求可以创建多个类别。

有谁知道我如何正确创建这些类别？我尝试将类别创建放入事务中，但仅再次收到有关祖先查询的错误。

谢谢！

西蒙

Answer 1

这是解决您的问题的方法。从很多方面来说，这都不是一种理想的方法，我真诚地希望其他 AppEnginer 能够提出比我更简洁的解决方案。如果没有，请尝试一下。

我的方法采用以下策略：它创建充当类别实体别名的实体。类别的名称可以更改，但别名实体将保留其键，我们可以使用别名键的元素为您的类别实体创建键名，因此我们将能够通过名称查找类别，但是它的存储与其名称是分离的。

别名全部存储在单个实体组中，这允许我们使用事务友好的祖先查询，因此我们可以查找或创建 CategoryAlias，而不必冒创建多个副本的风险。

当我想要查找或创建类别和项目组合时，我可以使用类别的键名以编程方式在事务内生成密钥，并且允许我们通过事务内的密钥获取实体。

class CategoryAliasRoot(db.Model):
    count = db.IntegerProperty()
    # Not actually used in current code; just here to avoid having an empty
    # model definition.

    __singleton_keyname = "categoryaliasroot"

    @classmethod
    def get_instance(cls):
            # get_or_insert is inherently transactional; no chance of
            # getting two of these objects.
        return cls.get_or_insert(cls.__singleton_keyname, count=0)

class CategoryAlias(db.Model):
    alias = db.StringProperty()

    @classmethod
    def get_or_create(cls, category_alias):
        alias_root = CategoryAliasRoot.get_instance()
        def txn():
            existing_alias = cls.all().ancestor(alias_root).filter('alias = ', category_alias).get()
            if existing_alias is None:
                existing_alias = CategoryAlias(parent=alias_root, alias=category_alias)
                existing_alias.put()

            return existing_alias

        return db.run_in_transaction(txn)

    def keyname_for_category(self):
        return "category_" + self.key().id

    def rename(self, new_name):
        self.alias = new_name
        self.put()

class Category(db.Model):
    pass

class Item(db.Model):
    name = db.StringProperty()

def get_or_create_item(category_name, item_name):

    def txn(category_keyname):
        category_key = Key.from_path('Category', category_keyname)

        existing_category = db.get(category_key)
        if existing_category is None:
            existing_category = Category(key_name=category_keyname)
            existing_category.put()

        existing_item = Item.all().ancestor(existing_category).filter('name = ', item_name).get()
        if existing_item is None:
            existing_item = Item(parent=existing_category, name=item_name)
            existing_item.put()

        return existing_item

    cat_alias = CategoryAlias.get_or_create(category_name)
    return db.run_in_transaction(txn, cat_alias.keyname_for_category())

买者自负：我还没有测试过这段代码。显然，您需要更改它以匹配您的实际模型，但我认为它使用的原理是合理的。

更新：
西蒙，在你的评论中，你的想法大多是正确的；不过，有一个重要的微妙之处您不应错过。您会注意到类别实体不是虚拟根的子实体。它们不共享父实体，并且它们本身就是自己实体组中的根实体。如果类别实体确实都具有相同的父级，那么这将形成一个巨大的实体组，并且您将面临性能噩梦，因为每个实体组一次只能运行一个事务。

相反，CategoryAlias 实体是虚假根实体的子实体。这允许我在事务内部进行查询，但实体组不会变得太大，因为属于每个类别的项目未附加到类别别名。

此外，CategoryAlias 实体中的数据可以更改，而无需更改实体的键，并且我使用 Alias 的键作为数据点来生成可用于创建实际类别实体本身的键名。因此，我可以更改存储在 CategoryAlias 中的名称，而不会失去将该实体与相同类别相匹配的能力。

Answer 2

有几点需要注意（我认为它们可能只是拼写错误） -

1. 事务方法的第一行在键上调用 get() - 这不是记录的函数。无论如何，您不需要在函数中拥有实际的类别对象 - 在您使用类别实体的两个地方，该键就足够了。

2. 您似乎没有在类别或项目上调用 put() （但既然您说您正在数据存储区中获取数据，我假设您为了简洁而忽略了这一点？）

就解决方案而言 -您可以尝试在内存缓存中添加一个具有合理到期时间的值 -

if memcache.add("category.%s" % category_name, True, 60): create_category(...)

这至少会阻止您创建多个值。如果查询没有返回类别，但你无法从内存缓存中获取锁，那么知道该怎么办仍然有点棘手。这意味着该类别正在创建过程中。

如果原始请求来自任务队列，则只需抛出异常，以便任务重新运行。

否则，您可以稍等一下，然后再次查询，尽管这有点狡猾。

如果请求来自用户，那么您可以告诉他们存在冲突并重试。