如何在数据库级别为一对多关联设置唯一性？

Question

我的问题很简单，但我找不到任何 GORM 语法。

考虑以下类：

class Article {
  String text

  static hasMany = [tags: String]

  static constraints= {
    tags(unique: true) //NOT WORKING
  }

}

我想在我的约束中定义每篇文章一个唯一的标签名称，但我无法使用上述语法来实现它。 显然，我在数据库模式中需要类似的东西：

create table article_tags (article_id bigint, tags_string varchar(255), unique (article_id , tags_string))

我该怎么做？

PS：我也陷入了对标签最小和最大尺寸设置限制的困境

Answer 1

仅供参考，您还可以在域类中使用自定义验证器：

    static constraints = {
    tags(validator: { 
        def valid = tags == tags.unique()
        if (!valid) errors.rejectValue(
            "tags", "i18n.message.code", "default message")
        return valid
    })

在数据库级别，您可以自定义 DDL 生成以下代码位于 grails-app/conf/hibernate/hibernate.cfg.xml 中：

<hibernate-mapping>
    <database-object>
        <create>
        ALTER TABLE article_tags
        ADD CONSTRAINT article_tags_unique_constraint 
        UNIQUE(article_id, tags_string);
    </create>
        <drop>
        ALTER TABLE article_tags 
        DROP CONSTRAINT article_tags_unique_constraint;
    </drop>
    </database-object>
</hibernate-mapping>

Answer 2

最初我查看了 joinTable 映射以查看它是否支持 unique 键，但事实并非如此。

我能想到的最好的解决方案是以下组合：

• 手动运行SQL语句添加唯一约束。如果您有某种数据库管理工具（例如 Liquibase），那将是理想的地方。

• 将关联显式声明为Set。无论如何，这应该可以避免 Hibernate 遇到唯一约束。

  类文章 {
      静态 hasMany = [标签：字符串]
      设置<字符串>标签 = new HashSet()
  }
  

另一种解决方案是显式声明您的子域 (Tag) 并设置多对多关系，使用 unique 键将 unique 键添加到连接表中代码>约束。但这也不是一个很好的解决方案。这是一个原始示例：

class Article {
    static hasMany = [articleTags: ArticleTag]
}

class Tag {
    static hasMany = [articleTags: ArticleTag]
}

class ArticleTag {
    Article article
    Tag tag
    static constraints = {
        tag(unique: article)
    }
}

但是，有了这个，您必须显式管理代码中的多对多关系。这有点不方便，但它让你可以完全控制整个关系。您可以在此处找到详细信息（链接示例中的 Membership 类类似于我的 ArticleTag ）。

也许一位更熟悉 GORM 的大师会提出一个更优雅的解决方案，但我在文档中找不到任何内容。

Answer 3

编辑：请注意，此方法不考虑unique(article_id,tags_id)约束。它还引发了两个具有相同标签的 Article 问题。 - 抱歉。

虽然这没有正式记录（请参阅 Grails 参考文档的相关部分此处 和 这里）一对多关联的约束被 GORM 简单地忽略。这包括唯一和可为空约束，以及可能的任何约束。

这可以通过设置 dbCreate="create" 以及接下来查看数据库模式定义来证明。对于您的 Article 示例和 PostgreSQL 数据库，这将是：

CREATE TABLE article_tags
(
  article_id bigint NOT NULL,
  tags_string character varying(255),
  CONSTRAINT fkd626473e45ef9ffb FOREIGN KEY (article_id)
      REFERENCES article (id) MATCH SIMPLE
      ON UPDATE NO ACTION ON DELETE NO ACTION,
  CONSTRAINT article0_tags_article0_id_key UNIQUE (article_id)
)
WITH (
  OIDS=FALSE
);

如上所示，tags_string 列没有任何限制。

与关联字段的约束相反，域类的“正常”实例字段的约束确实按预期工作。

因此，我们需要某种 Tag 或 TagHolder 域类，并且我们需要找到一种仍然提供 Article 的模式 具有干净的公共 API。

首先，我们引入 TagHolder 域类：

class TagHolder {
    String tag

    static constraints = {
        tag(unique:true, nullable:false, 
            blank:false, size:2..255)
    }
}

并将其与 Article 类关联：

class Article {
    String text

    static hasMany = [tagHolders: TagHolder]
}

为了提供干净的公共 API，我们添加方法 String[] getTags(), void setTags(String[]。这样，我们还可以使用命名参数调用构造函数，例如，new Article(text: " text", Tags: ["foo", "bar"])。我们还添加了 addToTags(String) 闭包，它模仿了 GORM 相应的“魔术方法”。

class Article {
    String text

    static hasMany = [tagHolders: TagHolder]

    String[] getTags() { 
        tagHolders*.tag
    }

    void setTags(String[] tags) {
        tagHolders = tags.collect { new TagHolder(tag: it) }
    } 

    {
        this.metaClass.addToTags = { String tag ->
            tagHolders = tagHolders ?: []
            tagHolders << new TagHolder(tag: tag)
        }
    }
}

这是一个解决方法，但不涉及太多编码。
一个缺点是，我们得到了一个额外的 JOIN 表。然而，这种模式允许应用任何可用的约束。

最后，测试用例可能如下所示：

class ArticleTests extends GroovyTestCase {
    void testUniqueTags_ShouldFail() {
        shouldFail { 
            def tags = ["foo", "foo"] // tags not unique
            def article = new Article(text: "text", tags: tags)
            assert ! article.validate()
            article.save()
        }
    }

    void testUniqueTags() {     
        def tags = ["foo", "bar"]
        def article = new Article(text: "text", tags: tags)
        assert article.validate()
        article.save()
        assert article.tags.size() == 2
        assert TagHolder.list().size() == 2
    }

    void testTagSize_ShouldFail() {
        shouldFail { 
            def tags = ["f", "b"] // tags too small
            def article = new Article(text: "text", tags: tags)
            assert ! article.validate()
            article.save()
        }
    }

    void testTagSize() {        
        def tags = ["foo", "bar"]
        def article = new Article(text: "text", tags: tags)
        assert article.validate()
        article.save()
        assert article.tags.size() == 2
        assert TagHolder.list().size() == 2
    }

    void testAddTo() {
        def article = new Article(text: "text")
        article.addToTags("foo")
        article.addToTags("bar")
        assert article.validate()
        article.save()
        assert article.tags.size() == 2
        assert TagHolder.list().size() == 2
    }
}

Answer 4

试试这个：

http://johnrellis.blogspot.com/2009/ 09/grails-constraints-across-relationships.html

Answer 5

我发现执行此操作的唯一方法是编写自定义约束并对数据库进行重复检查。我认为没有内置的方法可以使用 GORM 约束来完成此任务。