精华内容
下载资源
问答
  • 关联查询标签数量

    2018-07-04 16:34:00
    需求  产品表:product  标签表:tag  中间表:tagassoc ... 一个产品可以有多个标签, 标签删除后,tagassoc.tagid值为0  查询产品中有标签的数量和没有标签的数量 实现参考 SELECT...

    需求

      产品表:product

      标签表:tag

      中间表:tagassoc

      关联关系:product.id = tagassoc.objectID,    

           tag.id = tagassoc.tagid

      一个产品可以有多个标签, 标签删除后, tagassoc.tagid值为0

      查询产品中有标签的数量和没有标签的数量

    实现参考

    SELECT
     IF (t.id IS NULL, -1, t.id) AS id,
     count(p.id) AS count
    FROM
        product AS p
    LEFT JOIN `tagassoc` AS tc ON tc.objectType = 2 AND tc.objectID = p.id AND tc.tagid != 0
    LEFT JOIN `tag` AS t ON t.id = tc.tagid
    WHERE
        p.deleted = '0'
    AND 
        CASE
            WHEN t.deleted IS NULL THEN
                '0'
            ELSE
                t.deleted
        END = '0'
    AND p. STATUS = '0'
    GROUP BY
        t.id

    结果

    id count
    -1 13045
    1 2
    2 3

     

    转载于:https://www.cnblogs.com/muyibg/p/9263945.html

    展开全文
  • 2.通过jpa生成pojo,用到了many2many 注释来表示关联关系后。只会生成2个实体pojo 类。中间关联表不会生成pojo类 [java] view plaincopy package com.alcor.acl.domain;

    1. 表单结构 :

    • 一个角色表TRole 
    • 一个菜单表TMenu
    • 一个角色-菜单表TRoleMenu

    2.通过jpa生成pojo,用到了many2many 注释来表示关联关系后。只会生成2个实体pojo 类。中间关联表不会生成pojo类

    [java] view plaincopy
    1. package com.alcor.acl.domain;  
    2. import java.io.Serializable;  
    3. import javax.persistence.*;  
    4. import java.util.Set;  
    5. /** 
    6.  * The persistent class for the t_menu database table. 
    7.  *  
    8.  */  
    9. @Entity  
    10. @Table(name="t_menu")  
    11. public class TMenu implements Serializable {  
    12.     private static final long serialVersionUID = 1L;  
    13.     @Id  
    14.     @Column(name="menu_id")  
    15.     private String menuId;  
    16.     @Column(name="menu_name")  
    17.     private String menuName;  
    18.     private int menuorder;  
    19.     private String module;  
    20.     @Column(name="parent_id")  
    21.     private String parentId;  
    22.     private String url;  
    23.     //bi-directional many-to-many association to TRole  
    24.     @ManyToMany(mappedBy="TMenus", fetch=FetchType.EAGER)  
    25.     private Set<TRole> TRoles;  
    26.     public TMenu() {  
    27.     }  
    28.     public String getMenuId() {  
    29.         return this.menuId;  
    30.     }  
    31.     public void setMenuId(String menuId) {  
    32.         this.menuId = menuId;  
    33.     }  
    34.     public String getMenuName() {  
    35.         return this.menuName;  
    36.     }  
    37.     public void setMenuName(String menuName) {  
    38.         this.menuName = menuName;  
    39.     }  
    40.     public int getMenuorder() {  
    41.         return this.menuorder;  
    42.     }  
    43.     public void setMenuorder(int menuorder) {  
    44.         this.menuorder = menuorder;  
    45.     }  
    46.     public String getModule() {  
    47.         return this.module;  
    48.     }  
    49.     public void setModule(String module) {  
    50.         this.module = module;  
    51.     }  
    52.     public String getParentId() {  
    53.         return this.parentId;  
    54.     }  
    55.     public void setParentId(String parentId) {  
    56.         this.parentId = parentId;  
    57.     }  
    58.     public String getUrl() {  
    59.         return this.url;  
    60.     }  
    61.     public void setUrl(String url) {  
    62.         this.url = url;  
    63.     }  
    64.     public Set<TRole> getTRoles() {  
    65.         return this.TRoles;  
    66.     }  
    67.     public void setTRoles(Set<TRole> TRoles) {  
    68.         this.TRoles = TRoles;  
    69.     }  
    70.       
    71. }  

    [java] view plaincopy
    1. package com.alcor.acl.domain;  
    2. import java.io.Serializable;  
    3. import javax.persistence.*;  
    4. import java.util.Set;  
    5. /** 
    6.  * The persistent class for the t_role database table. 
    7.  *  
    8.  */  
    9. @Entity  
    10. @Table(name="t_role")  
    11. public class TRole implements Serializable {  
    12.     private static final long serialVersionUID = 1L;  
    13.     @Id  
    14.     @Column(name="role_id")  
    15.     private String roleId;  
    16.     private String description;  
    17.     @Column(name="role_name")  
    18.     private String roleName;  
    19.     //bi-directional many-to-many association to TMenu  
    20.     @ManyToMany(fetch=FetchType.EAGER)  
    21.     @JoinTable(  
    22.         name="t_role_menu"  
    23.         , joinColumns={  
    24.             @JoinColumn(name="role_id")  
    25.             }  
    26.         , inverseJoinColumns={  
    27.             @JoinColumn(name="menu_id")  
    28.             }  
    29.         )  
    30.     private Set<TMenu> TMenus;  
    31.     //bi-directional many-to-many association to TUser  
    32.     @ManyToMany(mappedBy="TRoles", fetch=FetchType.EAGER)  
    33.     private Set<TUser> TUsers;  
    34.     public TRole() {  
    35.     }  
    36.     public String getRoleId() {  
    37.         return this.roleId;  
    38.     }  
    39.     public void setRoleId(String roleId) {  
    40.         this.roleId = roleId;  
    41.     }  
    42.     public String getDescription() {  
    43.         return this.description;  
    44.     }  
    45.     public void setDescription(String description) {  
    46.         this.description = description;  
    47.     }  
    48.     public String getRoleName() {  
    49.         return this.roleName;  
    50.     }  
    51.     public void setRoleName(String roleName) {  
    52.         this.roleName = roleName;  
    53.     }  
    54.     public Set<TMenu> getTMenus() {  
    55.         return this.TMenus;  
    56.     }  
    57.     public void setTMenus(Set<TMenu> TMenus) {  
    58.         this.TMenus = TMenus;  
    59.     }  
    60.       
    61.     public Set<TUser> getTUsers() {  
    62.         return this.TUsers;  
    63.     }  
    64.     public void setTUsers(Set<TUser> TUsers) {  
    65.         this.TUsers = TUsers;  
    66.     }  
    67.       
    68. }  

    3.如果需求是只要求解除菜单和角色的关联关系,而不是去删除菜单或者角色。就需要用这样的语法

    [java] view plaincopy
    1. tRole.getTMenus().remove(tMenu);  
    2.             em.merge(tRole);  

    注意:只能通过tRole来发起

     

    不能写成这样

    [java] view plaincopy
    1. tMenu.getTRole().remove(tRole);         em.merge(tMenu);  

    这是因为:在pojo的@Many2Many标签只有在TRole这个里面设置了joinColumns属性,指定关系维护端(owner side),即TRole类本身.


    使用JoinColumn,name指向数据库字段,referencedColumnName指向实体类里面的属 性,当数据库字段与实体类的名字相同的时候可以省略.


    设置inverseJoinColumns,指定关系被维护端(inverse side),即映射到TMenu类,设置方法与joinColumns一样.

    展开全文
  • 在我的工程中,有这么两个...现在我想在后台管理平台删除一个标签,但是这个标签已经有日记使用了,那么我就需要先删除标签和日记的关联。 原本我是这样写的: @RequestMapping(value = "/delete", method = Reque

    在我的工程中,有这么两个实体:GrowthDiary.java(成长日记)和DiaryTag.java(日记标签)。

    大概就是和csdn发表文章给文章打标签一个意思吧。

    现在我想在后台管理平台删除一个标签,但是这个标签已经有日记使用了,那么我就需要先删除标签和日记的关联。

    原本我是这样写的:

    @RequestMapping(value = "/delete", method = RequestMethod.POST)
        public @ResponseBody
        Message delete(Long[] ids)
        {
            for(Long id:ids){
                DiaryTag diaryTag = diaryTagService.find(id);
                if(diaryTag!=null){
                    diaryTag.setGrowthDiaries(null);
                    diaryTagService.update(diaryTag);
                    diaryTagService.delete(diaryTag);
                }
            }
            return SUCCESS_MESSAGE;
        }

    看方法体里面就好,我想先将标签里面的日记置空,更新标签,再删除,然而这样写并没有什么卵用。

    貌似我们一直没有看看这两个类,看看这两个实体是怎么关联的:

    GrowthDiary.java:
    /** 日志标签 */
        private Set<DiaryTag> diaryTags = new HashSet<DiaryTag>();
    
    
    /**
         * 
         * @return
         * @see [类、类#方法、类#成员]
         */
        @ManyToMany(fetch = FetchType.LAZY)
        @JoinTable(name = "t_pe_growth_diary_tag")
        @OrderBy("createDate asc")
        public Set<DiaryTag> getDiaryTags()
        {
            return diaryTags;
        }
    
        /**
         * @param 对diaryTags进行赋值
         */
        public void setDiaryTags(Set<DiaryTag> diaryTags)
        {
            this.diaryTags = diaryTags;
        }

    DiaryTag.java
    /** 日志标签 */
        private Set<GrowthDiary> growthDiaries = new HashSet<GrowthDiary>();
    
     /**
         * @return 返回 growthDiaries
         */
        @ManyToMany(mappedBy = "diaryTags", fetch = FetchType.LAZY)
        public Set<GrowthDiary> getGrowthDiaries()
        {
            return growthDiaries;
        }
    
        /**
         * @param 对growthDiaries进行赋值
         */
        public void setGrowthDiaries(Set<GrowthDiary> growthDiaries)
        {
            this.growthDiaries = growthDiaries;
        }

    看到了吧,这两张表的GrowthDiary.java里面通过@JoinTable(name = "t_pe_growth_diary_tag"关联的。所有这个实体才是维护这两个实体联系的主人。那么我们就需要从GrowthDiary开始动手,下面就简单了,我的代码:
    @RequestMapping(value = "/delete", method = RequestMethod.POST)
        public @ResponseBody
        Message delete(Long[] ids)
        {
            for (Long id : ids)
            {
                DiaryTag diaryTag = diaryTagService.find(id);
                if (diaryTag != null)
                {
                    List<GrowthDiary> growthDiaries = growthDiaryService.findByDiaryTag(diaryTag);
                    if (growthDiaries != null && growthDiaries.size() > 0)
                    {
                        for (GrowthDiary growthDiary : growthDiaries)
                        {
                            growthDiary.getDiaryTags().remove(diaryTag);
                            growthDiaryService.update(growthDiary);
                        }
                    }
                    diaryTagService.delete(diaryTag);
                }
            }
            return SUCCESS_MESSAGE;
        }
    参考文章:http://blog.csdn.net/remote_roamer/article/details/5690341

    展开全文
  • 主外键表关联数据的同时删除

    千次阅读 2016-07-26 19:26:16
    主外键表关联数据的同时删除 2008-07-31 18:28:00 标签:主外键表 关联数据 删除 休闲 职场 原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任...
    主外键表关联数据的同时删除 2008-07-31 18:28:00
    
    
    原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。http://zhaizhenxing.blog.51cto.com/643480/134530
           今天产品有个操作,要求将满足某个条件的主表和相关联的几个子表的数据全部删除,其实这个要求很简单,如果子表在创建外键的时候指定了ON DELETE CASCADE,则直接从主表中删除相关记录,子表中数据也会一起删除。但是现在的子表外键创建时候没有加此语句,看来此方法不通;
            接着想到了mysql里面支持一次进行多表删除,即delete a,b from a,b where ...这种语法,尝试如下:

    mysql> delete a,b from parent a,child2 b where a.id=b.parent_id and a.id=2;
    ERROR 1451 (23000): Cannot delete or update a parent row: a foreign key constraint fails (`test/child2`, CONSTRAINT `child2_ibfk_1` FOREIGN KEY (`parent_id`) REFERENCES `parent` (`id`))

     显然,违反了外键约束而报错,也就是说上述语句是按照先主后从的的顺序进行删除操作,而从表中由于存在相应记录而导致删除失败;那么,如果将表的删除顺序颠倒一下就可以按照先从后主的顺序删除呢?我们测试一下:

    mysql> delete a,b from child2 a,parent b where a.parent_id=b.id and b.id=2;
    ERROR 1451 (23000): Cannot delete or update a parent row: a foreign key constraint fails (`test/child2`, CONSTRAINT `child2_ibfk_1` FOREIGN KEY (`parent_id`) REFERENCES `parent` (`id`))

    看来还是不行,母子表的关联删除看来和表的连接顺序无关,我们再次验证一下:
    mysql> set profiling=1;
    Query OK, 0 rows affected (0.03 sec)

    mysql> select @@profiling;
    +-------------+
    | @@profiling |
    +-------------+
    |           1 |
    +-------------+
    1 row in set (0.00 sec)

    mysql> show profiles;
    +----------+------------+--------------------+
    | Query_ID | Duration   | Query              |
    +----------+------------+--------------------+
    |        1 | 0.00011900 | select @@profiling |
    +----------+------------+--------------------+
    1 row in set (0.00 sec)

    mysql> delete a,b from child2 a,parent b where a.parent_id=b.id and b.id=2;
    ERROR 1451 (23000): Cannot delete or update a parent row: a foreign key constraint fails (`test/child2`, CONSTRAINT `child2_ibfk_1` FOREIGN KEY (`parent_id`) REFERENCES `parent` (`id`))
    mysql> show profiles;
    +----------+------------+---------------------------------------------------------------------+
    | Query_ID | Duration   | Query                                                               |
    +----------+------------+---------------------------------------------------------------------+
    |        1 | 0.00011900 | select @@profiling                                                  |
    |        2 | 0.03273800 | delete a,b from child2 a,parent b where a.parent_id=b.id and b.id=2 |
    +----------+------------+---------------------------------------------------------------------+
    2 rows in set (0.00 sec)

    mysql> show profile for query 2;
    +--------------------------+----------+
    | Status                   | Duration |
    +--------------------------+----------+
    | (initialization)         | 0.000077 |
    | init                     | 0.000011 |
    | Opening tables           | 0.000018 |
    | System lock              | 0.000009 |
    | Table lock               | 0.00002  |
    | init                     | 0.000027 |
    | deleting from main table | 0.000007 |
    | optimizing               | 0.000016 |
    | statistics               | 0.000106 |
    | preparing                | 0.000024 |
    | executing                | 0.000007 |
    | Sending data             | 0.000615 |
    | end                      | 0.000017 |
    | query end                | 0.000008 |
    | freeing items            | 0.000015 |
    | closing tables           | 0.031749 |
    | logging slow query       | 0.000012 |
    +--------------------------+----------+
    17 rows in set (0.03 sec)

    可以看到,执行步骤中有一句“deleting from main table”,也就是从主表删除,而没有删除子表的语句,看来子表的数据按照这种方式是无法删除的。

            那么如果指定了on delete cascade,执行步骤又是什么样呢?
    mysql> delete parent from parent where id=2;;
    Query OK, 1 row affected (0.03 sec)
    mysql> show profile for query 14
        -> ;
    +--------------------------------+----------+
    | Status                         | Duration |
    +--------------------------------+----------+
    | (initialization)               | 0.000062 |
    | init                           | 0.000008 |
    | Opening tables                 | 0.000018 |
    | System lock                    | 0.000008 |
    | Table lock                     | 0.000018 |
    | init                           | 0.000023 |
    | deleting from main table       | 0.000007 |
    | optimizing                     | 0.000012 |
    | statistics                     | 0.000068 |
    | preparing                      | 0.000015 |
    | executing                      | 0.000007 |
    | Sending data                   | 0.000145 |
    | deleting from reference tables | 0.000007 |
    | end                            | 0.02809  |
    | query end                      | 0.000014 |
    | freeing items                  | 0.000016 |
    | closing tables                 | 0.000017 |
    | logging slow query             | 0.000006 |
    +--------------------------------+----------+
    18 rows in set (0.00 sec)

    这次,多了一步“deleting from reference tables ”,显然主从表都会进行删除操作的。

    最后,只能按照最笨的办法,先删除子表,再删除主表:
    mysql> delete from child2 where id=3;
    Query OK, 0 rows affected (0.00 sec)

    mysql> delete from parent where id=3;
    Query OK, 1 row affected (0.03 sec)

    如果有多层的母子表,则按照从最内层的子表开始,一直到最外层的主表的顺利来完成删除操作,如下:
    delete d
    from a,b,c,d
    where a.id=b.order_id  and b.id=c.order_record_id  and c.id=d.ORDER_FACTORY_ID
    and a.old_id>=20171059 and (a.card_type_id=21 or a.card_type_id=22) and a.guangzhou_order_id is not null;

    delete c
    from a,b,c
    where a.id=b.order_id  and b.id=c.order_record_id
    and a.old_id>=20171059 and (a.card_type_id=21 or a.card_type_id=22) and a.guangzhou_order_id is not null;

    delete b
    from a,b
    where a.id=b.order_id
    and a.old_id>=20171059 and (a.card_type_id=21 or a.card_type_id=22) and a.guangzhou_order_id is not null;

    delete a
    from order_tab a
    where a.old_id>=20171059 and (a.card_type_id=21 or a.card_type_id=22) and a.guangzhou_order_id is not null;

    看来设置外键的时候还是应该考虑好on delete 和on udpate的操作action,防止这些无谓的麻烦。

    本文出自 “帅小伙的博客” 博客,请务必保留此出处http://zhaizhenxing.blog.51cto.com/643480/134530

    分享至 一键收藏,随时查看,分享好友!
    展开全文
  • 为了实现删除日记的同时也一起清理掉think_tagged表和think_tag那些过时的数据,我写了一个函数,在看下面函数时,要先弄清think_tagged表、think_tag和think_blog表的关联关系。 函数如下: 复制代码 代码如下:...
  • git删除远程仓库的某个标签或分支

    千次阅读 2019-10-27 00:13:13
    这两条命令分别的作用是:先在本地删除删除标签,然后再将其推送到关联的远程仓库。 Git相关原理——Refspec Refspec用来定义本地仓库和远程哪个仓库进行关联。Refspec的格式是一个可选的+号,...
  • 一对多关联删除(在一的这边进行如下配置就可以了) 在删除“一”的这一方的数据时,“多”的这一方的相关数据也会被删除; @OneToMany(mappedBy="articleCategory",fetch=FetchType.EAGER,cascade=CascadeType....
  • 1.知识点的新增:可概括为4大步 ...在Word文档输入内容或粘贴网页等内容,输入标题、备注或重新设置分类、标签关联等。其中仅输入标题为必须,其余为可选。如图 d)点击“保存”或直接点击“关闭”,退出知识点...
  • ThinkPHP关联模型操作

    2016-06-16 21:58:28
    ThinkPHP关联模型操作 (2012-04-01 14:50:08) 转载▼ 标签: thinkphp ...关联模型 ...比如:你要求删除用户的时候,同时删除与用户有关的所有信息。    一对一: 有(HAS_ONE) 属于 (BE
  • 资源跨度大,需要跨资源类型、跨地域,将关联的资源打上标签。资源数量多,几百甚至上千个资源,如何批量编辑?命名不一致,如何规整资源命名不一致的标签删除改名难,如何快速对资源标签完成删除和改名?如何导出...
  • 资源跨度大,需要跨资源类型、跨地域,将关联的资源打上标签。资源数量多,几百甚至上千个资源,如何批量编辑?命名不一致,如何规整资源命名不一致的标签删除改名难,如何快速对资源标签完成删除和改名?如何导出...
  • 使用联系人记录来创建、编辑、修改或删除联系人,并将联系人与父级记录关联。这些联系人可以是同事、朋友和其它熟悉的人,你会把信息记录在联系人中。 你可以为公司输入联系人,也可以输入只有你有权限访问的联系人...
  • 资源跨度大,需要跨资源类型、跨地域,将关联的资源打上标签。 资源数量多,几百甚至上千个资源,如何批量编辑? 命名不一致,如何规整资源命名不一致的标签删除改名难,如何快速对资源标签完成删除和改名? ...
  • Mybatis多对多关联查询

    2016-03-15 21:51:00
    mybatis3.0添加了association和collection标签专门用于对多个相关实体类数据进行级联查询,但仍不支持多个相关实体类数据的级联保存和级联删除操作。因此在进行实体类多对多映射表设计时,需要专门建立一个关联对象...
  • Mybatis常用标签

    2018-09-07 17:02:24
    1、insert、update、select、delete相信大家都熟悉,就是增加、修改、查询、...4、include标签作用于包含某个封装的SQL语句,其中refid关联到sql封装语句中的id 总结: sql 标签和include标签配合使用,好处在于经常...
  • mybatis--多对多关联

    2019-09-28 05:46:18
    mybatis3.0 添加了association和collection标签专门用于对多个相关实体类数据进行级联查询,但仍不支持多个相关实体类数据的级联保存和级联删除操作。因此在进行实体类多对多映射表设计时,需要专门建立一个关联对象...
  • 一、关联【association】 1、含义:指的是类之间的引用关系,如果类A与类B...(1)删除从表对应的实体类中的外键属性 (2)在配置的xml中外键属性上添加 (3)在配置的xml中的many-to-one标签中添加 2、Casecad...
  • 标签动作-源码

    2021-02-10 04:41:34
    生成与latest标签关联的新发行版(删除所有以前的关联发行版)。 用指定的标题更新这个新版本(例如Development Build )。 上载LICENSE.txt和任何jar文件作为发行资产。 将此发行版标记为pre-release 。 您
  • 一对多关联映射(注解) @OneToMany@Where:相当于set标签的where属性@Cascade:相当于set标签的cascade属性@OrderBy:相当于set标签的order-by属性cascade:为级联操作,里面有级联保存,级联删除等,all为所有,配置...
  • 推送分支是把本地分支推送到远程仓库的分支,推送前要确保本地分支已经于远程分支关联,如果没有关联,可以把本地分支关联到远程的指定分支。如果没有关联,也可以把本地...删除远程标签 git tag -d 标签名 ...
  • SQL update 多表关联更新

    千次阅读 2018-03-15 06:29:41
    转载 2012年10月13日 23:41:41 标签: 多表关联更新 / 27875 编辑 删除 有A、B张表,其记录如下:A表c1 c2--------------1 a12 a23 a38 a8B表c1 c3--------------1 b12 b13 b310 b1...
  • hibernate默认配置双向关联时,删除一这边的时候,不会删除多那边,而是把多的那边的关联字段设置为null,刚刚调试一直报错.解决办法: 在Set标签上加上: inverse=”true”,inverse的真正作用就是指定由哪一方来维护...
  • 前言 动态tab水平菜单,这个需求很常见,特别是对于后台管理系统来说; ... 而有了这个,我们就能节省不少时间,体验上来...单个删除删除其他的标签 只有一个时候是不允许关闭,所以也不会显示关闭的按钮,关闭其他也不...
  • 比如文章article表 有一个文章标签关联表article_tag,一篇文章,存在多个tag。在更新文章的时候,需要更新关联表,我想到的有两种方法,但是感觉都比较不爽。1.更新article的时候,更新关联表的时候,把关联表中...
  • 故障分析:某个软件甚至可能是病毒(也可能是杀毒软件)把扩展名为EXE的文件关联删除或修改了。常用方法无效:从控制面板中执行“文件夹选项”命令,选择“文件类型”标签, 在“已注册的文件类型”列表中找不到扩展...
  • Hibernate标签总结

    2016-06-01 07:32:36
    一对多:在实体类用Set集合,映射文件hbm.xml中 属性名" cascade="级联操作"> ...只有在一的一方删除时,多的一方会级联的删除,其他操作无效 只有多对一 = 单向关联 多对一 + 一对多 = 双向关联
  • 适应标签-源码

    2021-03-02 17:38:31
    适应标签 Tabs是Kineo演示组件。 该组件显示垂直或水平堆叠的标题选项卡列表。 每个标题都与一个隐藏的内容面板相关联。 单击标题可切换其内容面板的可见性。 默认情况下,第一个内容面板是可见的。 内容面板可能...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 415
精华内容 166
关键字:

删除关联标签