gorm 一对一 一对多 例子

gorm 一对一 一对多 例子

数据库sql

CREATE TABLE `allin_asset` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `instance_id` varchar(255) DEFAULT ‘‘ COMMENT ‘实例ID‘,
  `instance_name` varchar(255) DEFAULT ‘‘ COMMENT ‘标签‘,
  `host_name` varchar(255) DEFAULT ‘‘ COMMENT ‘系统名字‘,
  `zone` varchar(255) DEFAULT ‘‘ COMMENT ‘可用区‘,
  `business_id` varchar(255) DEFAULT ‘‘ COMMENT ‘产品线‘,
  `private_ip` varchar(255) DEFAULT ‘‘ COMMENT ‘内网IP‘,
  `public_ip` varchar(255) DEFAULT ‘‘ COMMENT ‘外网IP‘,
  `os_name` varchar(255) DEFAULT ‘‘ COMMENT ‘系统版本‘,
  `cpu` int(11) unsigned  DEFAULT NULL COMMENT ‘CPU‘,
  `memory` int(11) unsigned  DEFAULT NULL COMMENT ‘内存‘,
  `created_on` int(11) unsigned DEFAULT NULL COMMENT ‘创建时间‘,
  `modified_on` int(11) unsigned DEFAULT NULL COMMENT ‘更新时间‘,
  `expired_on` int(11) unsigned DEFAULT NULL COMMENT ‘过期时间‘,
  `status`  varchar(255) DEFAULT ‘‘ COMMENT ‘运行状态‘,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT=‘资产管理‘;

CREATE TABLE `allin_business` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(255)  COMMENT ‘产品线名字‘,
  `created_on` int(11) unsigned DEFAULT NULL COMMENT ‘创建时间‘,
  `modified_on` int(11) unsigned DEFAULT NULL COMMENT ‘更新时间‘,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT=‘产品线管理‘;

CREATE TABLE `allin_module` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(255)  COMMENT ‘模块名字‘,
  `created_on` int(11) unsigned DEFAULT NULL COMMENT ‘创建时间‘,
  `modified_on` int(11) unsigned DEFAULT NULL COMMENT ‘更新时间‘,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT=‘模块管理‘;

CREATE TABLE `allin_asset_module` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `asset_id` int(11) unsigned DEFAULT NULL COMMENT ‘资产ID‘,
  `module_id` int(11) unsigned DEFAULT NULL COMMENT ‘组ID‘,
  `created_on` int(11) unsigned DEFAULT NULL COMMENT ‘创建时间‘,
  `modified_on` int(11) unsigned DEFAULT NULL COMMENT ‘更新时间‘,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT=‘资产_模块_管理‘;

表结构

type Business struct {
    Model
    Name string `json:"name"`
}

type Module struct {
    Model
    Name string `json:"name"`
}

type Asset struct {
    Model

    InstanceId   string        `json:"instance_id"`
    InstanceName string        `json:"instance_name"`
    HostName     string        `json:"host_name"`
    Zone         string        `json:"zone"`
    PrivateIp    string        `json:"private_ip"`
    PublicIp     string        `json:"public_ip"`
    OsName       string        `json:"os_name"`
    Cpu          int           `json:"cpu"`
    Memory       int           `json:"memory"`
    ExpiredOn    int           `json:"expired_on"`
    Status       string        `json:"status"`
    BusinessId   int           `json:"business_id" gorm:"index"`
    Business     Business      `json:"business"`     // 产品线   一对一
    Module       []Module `json:"module" gorm:"many2many:asset_module;"`   // 模块  多对多
}

func GetAsset(id int) (asset Asset) {
    db.Where("id = ?", id).First(&asset)
    db.Model(&asset).Related(&asset.Business).Related(&asset.Module, "module")
    return
}

函数

func GetAsset(id int) (asset Asset) {
    db.Where("id = ?", id).First(&asset)
    db.Model(&asset).Related(&asset.Business).Related(&asset.Module, "Module")
    return
}

func GetAssets(pageNum int, pageSize int, maps interface{}) (assets []Asset) {
    db.Preload("Business",).Preload("Module",).Where(maps).Offset(pageNum).Limit(pageSize).Find(&assets)
    return
}

func AddAsset(data map[string]interface{}, modules []int ) bool {
    asset := &Asset{
        InstanceId:   data["instance_id"].(string),
        InstanceName: data["instance_name"].(string),
        HostName:     data["host_name"].(string),
        Zone:         data["zone"].(string),
        BusinessId:   data["business_id"].(int),
        PrivateIp:    data["private_ip"].(string),
        PublicIp:     data["public_ip"].(string),
        OsName:       data["os_name"].(string),
        Cpu:          data["cpu"].(int),
        Memory:       data["memory"].(int),
        ExpiredOn:    data["expired_on"].(int),
        Status:       data["status"].(string),
    }
    module := []Module{}
    db.Where("id in (?)", modules).Find(&module)
    db.Create(&asset).Association("Module").Append(module)  //.Delete   .Replace  .Clear() .Count()

    return true
}

func ExistAssetByID(id int) bool {
    var asset Asset
    db.Select("id").Where("id = ?", id).First(&asset)
    if asset.ID > 0 {
        return true
    }

    return false
}

func DeleteAsset(id int) bool {
    asset := Asset{}
    db.Where("id = ?", id).Find(&asset)
    db.Model(&asset).Association("Module").Clear()
    db.Where("id = ?", id).Delete(asset)

    return true
}

func EditAsset(id int, data interface{},modules []int) bool {
    module := []Module{}
    db.Where("id in (?)", modules).Find(&module)
    asset := Asset{}
    db.Where("id = ?", id).Find(&asset)

    db.Model(&asset).Association("Module").Replace(module)
    db.Model(&asset).Updates(data)

    return true
}

原文地址:http://blog.51cto.com/hequan/2333058

时间: 2024-10-13 20:49:01

gorm 一对一 一对多 例子的相关文章

多对多 一对一 一对多 主从 关联 字典

 "订单"表中的主键.  "产品"表中的主键.  一个订单可以包含多种产品 ...   ... 且每种产品可以出现在多个订单上.   课程文本 在多对多关系中,一个表中的一个记录与第二个表中的多个记录相关,第二个表中的一个记录与第一个表中的多个记录相关. 这种类型的关系需要一个称为连接表的第三个表.连接表包含另两个表中的主键,并将它们用作其外键. 例如,"订单"表和"产品"表具有多对多关系.一个订单可以包含多种产品,每种产品可

mybatis 一对一 一对多 多对多

一对一 一对多 多对多 原文地址:https://www.cnblogs.com/cwone/p/11909271.html

mysql表的一对一/一对多/多对多联系

1.数据库中的多对多关联关系一般需采用中间表的方式处理,将多对多转化为两个一对多. 2.通过表的关系,来帮助我们怎样建表,建几张表. 一对一 一张表的一条记录一定只能与另外一张表的一条记录进行对应,反之亦然. 学生表:姓名,性别,年龄,身高,体重,籍贯,家庭住址,紧急联系人 其中姓名.性别.年龄.身高,体重属于常用数据,但是籍贯.住址和联系人为不常用数据 如果每次查询都是查询所有数据,不常用的数据就会影响效率,实际又不用 常用信息表:ID(P),姓名,性别,年龄,身高,体重 不常用信息表:ID(

映射关系模板--一对一, 一对多

一对一: <!-- {1}属性, 本类与{2}的一对一, 采用基于外键的一对一映射, 本方有外键 --><many-to-one name="{1}" class="{2}" column="{1}Id" unique="true"></many-to-one> 多对一: <!--{1}属性, 本类与{2}的多对一 --> <many-to-one name="1

SQLAlchemy_定义(一对一/一对多/多对多)关系

目录 Basic Relationship Patterns One To Many One To One Many To Many Basic Relationship Patterns 基本关系模式 The imports used for each of the following sections is as follows: 下列的 import 语句,应用到接下来所有的代章节中: from sqlalchemy import Table, Column, Integer, Forei

Hibernate 映射文件的配置 核心文件的配置 一对一 一对多 多对多 hibernate实现分页 Hibernate中session的关闭问题总结

以留言系统为实例 1 .配置映射文件:首先得引入约束dtd <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 然后<hibernate-mapping></hibernate-mapping>映射标签 <

表关系(一对一,一对多,多对多)

可以在数据库图表中的表之间创建关系,以显示一个表中的列与另一个表中的列是如何相链接的. 在一个关系型数据库中,利用关系可以避免多余的数据.例如,如果设计一个可以跟踪图书信息的数据库,您需要创建一个名为 titles 的表,它用来存储有关每本书的信息,例如书名.出版日期和出版社.您也可能保存有关出版社的信息,诸如出版社的电话.地址和邮政编码.如果您打算在 titles 表中保存所有这些信息,那么对于某出版社出版的每本书都会重复该出版社的电话号码. 更好的方法是将有关出版社的信息在单独的表,publ

flask中一对一,一对多以及多对多关系的设定

一对多关系: class Grade(db.Model): id=db.Column(db.Integer,primary_key=True) name=db.Column(db.String(20),nullable=False) num = db.Column(db.Integer, default=0) time = db.Column(db.String(20), default='2018-01-01') students=db.relationship('Student',backr

django mysql 表的一对一 一对多 多对多

表结构的设计 一对一 多对一  将key写在多 多对多 外键: 描述  多对一的关系 写在多的一方 class Book(models.Model) title = models.CharField(max_length=32,unique=Ture) publisher = models.ForeignKey (to=Publisher,on_deleete=models.CASADE) publisher = models.ForeignKey(to='Publisher', on_dele