精华内容
下载资源
问答
  • mybatis查询有关联关系并且有相同字段的两张问题解决

    正好遇到这样的问题,要更具外键查询出外键所在表数据。

    解决办法:

    1、直接通过设计表,外键名即为关联表的主键名而不是来年改革表的主键都为id,这样可以直接查询出。--------这是通常的关联办法,即两张表的主键名称不同

    2、在两张表注解名称相同并且实体又没有设置这个外键字段而是以实体的情况下,关联实体主键字段不管怎么设置都无法得到主键,所关联的实体主键就是主表所在的主键值,所以需要使用另一个实体字段来转换这个关联表的主键。


    第一种思路的通用的方法,而我正好遇到了第二种情况,不管我怎么样设置或者是用别名实在获取的都是主表的id。当然有更好思路的你可以帮我更好的解决就最好了。


    代码:

    Mapper.xml

       //表关联映射

       <resultMap id="stream" type="com.sohu.bms.model.content.Stream">
            <id column="id" property="id" jdbcType="INTEGER" />
            <result column="name" property="name" jdbcType="VARCHAR" />
            <result column="index" property="index" jdbcType="INTEGER" />
            <result column="template" property="template" javaType="int" jdbcType="INTEGER" />
            <result column="display" property="display"  jdbcType="BOOLEAN" />
            <association property="room" column="room_id" javaType="com.sohu.bms.model.room.Room" jdbcType="INTEGER" resultMap="room"/>
            <association property="tag" column="tag_id" javaType="com.sohu.bms.model.content.Tag" jdbcType="INTEGER" resultMap="tag"/>
        </resultMap>
        <resultMap id="BaseResultMap" type="com.sohu.bms.model.cooperation.AutoAlbumStream" >
            <id column="id" property="id" jdbcType="INTEGER" />
            <result column="album_id" property="album_id" jdbcType="VARCHAR" />
            <result column="album_type" property="album_type" jdbcType="INTEGER" />
           <!-- <result column="stream_id" property="stream_id" javaType="int" jdbcType="INTEGER" />-->
            <result column="begin_time" property="begin_time" javaType="java.util.Date" jdbcType="TIMESTAMP" />
            <result column="end_time" property="end_time" javaType="java.util.Date" jdbcType="TIMESTAMP" />
            <association property="stream" column="stream_id" javaType="com.sohu.bms.model.content.Stream" jdbcType="INTEGER" resultMap="stream"/>
        </resultMap>

        //查询方法

       <select id="getAutoalbumById" parameterType="java.lang.Integer" resultMap="BaseResultMap">
            select
            album.id,album.album_id,album.album_type,album.begin_time,album.end_time,album.stream_id as template
            from cooperation_auto_album album left outer join content_stream con on album.stream_id=con.id where album.id=#{id,jdbcType=INTEGER}
        </select>

    实体

    Stream.java

        private int id;
        private String name;//名称
        private Room room;
        private int index=1;//位置
        private int template=0;//模板
        private boolean display=true;//是否显示
        private Tag tag;


    AutoAlbumStream.java

        private int id;
        private String album_id;
        private int album_type=0;
        private Stream stream;
        private Date begin_time;//开始抓取时间
        private Date end_time;//结束抓取时间


    展开全文
  • 表关系

    千次阅读 2004-09-24 11:14:00
    表关系分几种类型:一、一对一关系 需要一个主键表,一个外键表,主键表中存在的数据,外键表中才可以添加,实际上每个 列都为主键,比如: 主键表中ID为1、2、3,外键表中ID只能为1或者2或者3,不能添加主键表中...

    表关系分几种类型:
    一、一对一关系
      需要一个主键表,一个外键表,主键表中存在的数据,外键表中才可以添加,实际上每个
      列都为主键,比如:
            主键表中ID为1、2、3,外键表中ID只能为1或者2或者3,不能添加主键表中没有的数据。
            并且可以级联更新或者删除数据。
    二、一对多关系
      在这种关系类型中,表 A 中的行可以在表 B 中有许多匹配行,但是表 B 中的行只能在表 A 中有一个匹配行。例如,publishers 表和 titles 表是一对多的关系:每一个出版商可出版许多书,但每一本书只能有一个出版商。(个人理解:主建表publishers中的pub_id为主键,所以只能有一个匹配行。外键表中的pub_id不是主键,所以可以有很多行)
    三、多对多关系
            在多对多关系 中,表 A 中的一行可与表 B 中的多行相匹配,反之亦然。通过定义称为 连接表 的第三方表创建这样的关系,该连接表的主键包括表 A 和表 B 中的外键。例如,authors 表和 titles 表是多对多关系,该关系通过从这些表中的每个表与 titleauthors 表的一对多关系定义。titleauthors 表的主键由 au_id 列(authors 表的主键)和 title_id 列(titles 表的主键)组成。


            

    展开全文
  • 随着公司平台用户数量与数量的不断增多,各种之间的数据流向也变得更加复杂,特别是某个任务中会对源读取并进行一系列复杂的变换后又生成新的数据,因此需要一套血缘关系解析机制能清晰地解析出每个任务所...

          随着公司平台用户数量与表数量的不断增多,各种表之间的数据流向也变得更加复杂,特别是某个任务中会对源表读取并进行一系列复杂的变换后又生成新的数据表,因此需要一套表血缘关系解析机制能清晰地解析出每个任务所形成的表血缘关系链。

          实现思路:

          spark对sql的操作会形成一个dataframe,dataframe中的logicplan包含了sql的语法树,通过对logicplan的语法树解析可以获取当前stage所操作的输入表和输出表,将整套表关系链连接起来,再去除中间表即可获取当前作业的输入表和输出表信息。

          核心代码:

    def resolveLogicPlan(plan: LogicalPlan, currentDB:String): (util.Set[DcTable], util.Set[DcTable]) ={
        val inputTables = new util.HashSet[DcTable]()
        val outputTables = new util.HashSet[DcTable]()
        resolveLogic(plan, currentDB, inputTables, outputTables)
        Tuple2(inputTables, outputTables)
    }
    
    def resolveLogic(plan: LogicalPlan, currentDB:String, inputTables:util.Set[DcTable], outputTables:util.Set[DcTable]): Unit ={
        plan match {
    
             case plan: Project =>
                    val project = plan.asInstanceOf[Project]
                    resolveLogic(project.child, currentDB, inputTables, outputTables)
    
             case plan: Union =>
                    val project = plan.asInstanceOf[Union]
                    for(child <- project.children){
                        resolveLogic(child, currentDB, inputTables, outputTables)
                    }
    
             case plan: Join =>
                    val project = plan.asInstanceOf[Join]
                    resolveLogic(project.left, currentDB, inputTables, outputTables)
                    resolveLogic(project.right, currentDB, inputTables, outputTables)
    
             case plan: Aggregate =>
                    val project = plan.asInstanceOf[Aggregate]
                    resolveLogic(project.child, currentDB, inputTables, outputTables)
    
             case plan: Filter =>
                    val project = plan.asInstanceOf[Filter]
                    resolveLogic(project.child, currentDB, inputTables, outputTables)
    
             case plan: Generate =>
                    val project = plan.asInstanceOf[Generate]
                    resolveLogic(project.child, currentDB, inputTables, outputTables)
    
             case plan: RepartitionByExpression =>
                    val project = plan.asInstanceOf[RepartitionByExpression]
                    resolveLogic(project.child, currentDB, inputTables, outputTables)
    
             case plan: SerializeFromObject =>
                    val project = plan.asInstanceOf[SerializeFromObject]
                    resolveLogic(project.child, currentDB, inputTables, outputTables)
    
             case plan: MapPartitions =>
                    val project = plan.asInstanceOf[MapPartitions]
                    resolveLogic(project.child, currentDB, inputTables, outputTables)
    
             case plan: DeserializeToObject =>
                    val project = plan.asInstanceOf[DeserializeToObject]
                    resolveLogic(project.child, currentDB, inputTables, outputTables)
    
             case plan: Repartition =>
                    val project = plan.asInstanceOf[Repartition]
                    resolveLogic(project.child, currentDB, inputTables, outputTables)
    
             case plan: Deduplicate =>
                    val project = plan.asInstanceOf[Deduplicate]
                    resolveLogic(project.child, currentDB, inputTables, outputTables)
    
             case plan: Window =>
                    val project = plan.asInstanceOf[Window]
                    resolveLogic(project.child, currentDB, inputTables, outputTables)
    
             case plan: MapElements =>
                    val project = plan.asInstanceOf[MapElements]
                    resolveLogic(project.child, currentDB, inputTables, outputTables)
    
             case plan: TypedFilter =>
                    val project = plan.asInstanceOf[TypedFilter]
                    resolveLogic(project.child, currentDB, inputTables, outputTables)
    
             case plan: Distinct =>
                    val project = plan.asInstanceOf[Distinct]
                    resolveLogic(project.child, currentDB, inputTables, outputTables)
    
             case plan: SubqueryAlias =>
                    val project = plan.asInstanceOf[SubqueryAlias]
                    val childInputTables = new util.HashSet[DcTable]()
                    val childOutputTables = new util.HashSet[DcTable]()
    
                    resolveLogic(project.child, currentDB, childInputTables, childOutputTables)
                    if(childInputTables.size()>0){
                        for(table <- childInputTables) inputTables.add(table)
                    }else{
                        inputTables.add(DcTable(currentDB, project.alias))
                    }
    
             case plan: CatalogRelation =>
                    val project = plan.asInstanceOf[CatalogRelation]
                    val identifier = project.tableMeta.identifier
                    val dcTable = DcTable(identifier.database.getOrElse(currentDB), identifier.table)
                    inputTables.add(dcTable)
    
             case plan: UnresolvedRelation =>
                    val project = plan.asInstanceOf[UnresolvedRelation]
                    val dcTable = DcTable(project.tableIdentifier.database.getOrElse(currentDB), project.tableIdentifier.table)
                    inputTables.add(dcTable)
    
             case plan: InsertIntoTable =>
                    val project = plan.asInstanceOf[InsertIntoTable]
                    resolveLogic(project.table, currentDB, outputTables, inputTables)
                    resolveLogic(project.query, currentDB, inputTables, outputTables)
    
             case plan: CreateTable =>
                    val project = plan.asInstanceOf[CreateTable]
                    if(project.query.isDefined){
                        resolveLogic(project.query.get, currentDB, inputTables, outputTables)
                    }
                    val tableIdentifier = project.tableDesc.identifier
                    val dcTable = DcTable(tableIdentifier.database.getOrElse(currentDB), tableIdentifier.table)
                    outputTables.add(dcTable)
    
             case plan: GlobalLimit =>
                    val project = plan.asInstanceOf[GlobalLimit]
                    resolveLogic(project.child, currentDB, inputTables, outputTables)
    
             case plan: LocalLimit =>
                    val project = plan.asInstanceOf[LocalLimit]
                    resolveLogic(project.child, currentDB, inputTables, outputTables)
    
             case `plan` => logger.info("******child plan******:\n"+plan)
            }
        }

          上述代码是对logicplan做递归解析的,当logicplan为LocalLimit、GlobalLimit、Window等类型时,继续解析其子类型;当logicplan为CataLogRelation、UnresolvedRelation时,解析出的表名作为输入表;当logicplan为CreateTable、InsertIntoTable时,解析出的表名为输出表。

          这里需要考虑一种特殊情况,某些源表是通过spark.read加载得到的,这样logicplan解析出来的类型为LogicRDD,不能直接获取到表名,以下面的python代码为例:       

    schema = StructType([StructField('id', IntegerType(), True), StructField('name', StringType(), True), StructField('age', IntegerType(), True)])
    rdd = sparkSession.sparkContext.textFile('/user/hive/warehouse/bigdata.db/tdl_spark_test/testdata.txt').map(lambda r:r.split(',')).map(lambda p: Row(int(p[0]), p[1], int(p[2])))
    df = sparkSession.createDataFrame(rdd, schema)
    df.createOrReplaceTempView('tdl_spark_test')
    sparkSession.sql('create table tdl_file_test as select * from tdl_spark_test')

          上述代码首先通过textFile读取文件得到rdd,再对rdd进行变换,最后将rdd注册成dataframe,这里对df的logicplan进行解析会得到LogicRDD,对于这种情况的解决思路是在调用textFile时记录产生的rdd,解析df的logicplan时获取其rdd,判断之前产生的rdd是否为当前rdd的祖先,如果是,则将之前rdd对应的表名计入。

          判断rdd依赖关系的逻辑为:

    def checkRddRelationShip(rdd1:RDD[_], rdd2:RDD[_]): Boolean ={
        if (rdd1.id == rdd2.id) return true
        dfsSearch(rdd1, rdd2.dependencies)
    }
    
    def dfsSearch(rdd1:RDD[_], dependencies:Seq[Dependency[_]]): Boolean ={
        for(dependency <- dependencies){
            if(dependency.rdd.id==rdd1.id) return true
            if(dfsSearch(rdd1, dependency.rdd.dependencies)) return true
        }
        false
    }

          对LogicRDD的解析为:

    case plan: LogicalRDD =>
         val project = plan.asInstanceOf[LogicalRDD]
         try{
             for(rdd <- rddTableMap.keySet()){
                 if(checkRddRelationShip(rdd, project.rdd)){
                    val tableName = rddTableMap.get(rdd)
                    val db = StringUtils.substringBefore(tableName, ".")
                    val table = StringUtils.substringAfter(tableName, ".")
                    inputTables.add(DcTable(db, table))
                 }
            }
         }catch {
            case e:Throwable => logger.error("resolve LogicalRDD error:", e)
         }

          在spark中会生成dataframe的代码段中通过aspect进行拦截,并且解析dataframe得到表的关系链,此时的关系链是一张有向无环图,图中可能包含中间表,去除掉中间表节点,则得到最终的数据流向图。

                                            

          例如上图的左边是一张原始的表数据流向,其中tempC和tempE为临时表,去除这个图中的临时表节点,得到右图的数据流向图。对于前面给出的python代码,执行过后获取的数据流向为:

      [bigdata.tdl_spark_test]--->bigdata.tdl_file_test

          当然这种解析方式也存在一些缺点,比如首先通过spark.read读取数据注册一张临时表,再将临时表中的某些字段值拉到本地缓存,然后创建一个空的datadrame,将缓存的字段值直接插入到该df中,由于当前创建的df与之前创建的df已经没有依赖关系,因此这种情况将无法解析出准确的数据流向。

    展开全文
  • SQL创建多及多之间的关系

    千次阅读 2018-11-29 22:46:32
    ### SQL 会创建多及多关系 #### 需求: 分类和商品之间是不是有关系? 如果有关系,在数据库中如何表示这种关系 ```sql create table category(  cid int primary key auto_increment,  cname varchar...

    ### SQL 会创建多表及多表的关系

    #### 需求:

    分类表和商品表之间是不是有关系? 如果有关系,在数据库中如何表示这种关系

    ```sql
    create table category(
      cid int primary key auto_increment,
      cname varchar(10),
      cdesc varchar(31)
    );

    insert into category values(null,'手机数码','电子产品,生产');
    insert into category values(null,'鞋靴箱包','江南皮鞋厂倾情打造');
    insert into category values(null,'香烟酒水','黄鹤楼,茅台,二锅头');
    insert into category values(null,'酸奶饼干','娃哈哈,蒙牛酸酸乳');
    insert into category values(null,'馋嘴零食','瓜子花生,八宝粥,辣条');

    select * from category;
    select cname,cdesc from category;

    --所有商品
    1.商品ID
    2.商品名称
    3.商品的价格
    4.生产日期
    5.商品分类ID

    商品和商品分类 : 所属关系
    create table product(
        pid int primary key auto_increment,
          pname varchar(10),
          price double,
          pdate timestamp,
          cno int
    );

    insert into product values(null,'小米mix4',998,null,1);
    insert into product values(null,'锤子',2888,null,1);
    insert into product values(null,'阿迪王',99,null,2);
    insert into product values(null,'老村长',88,null,3);
    insert into product values(null,'劲酒',35,null,3);
    insert into product values(null,'小熊饼干',1,null,4);
    insert into product values(null,'卫龙辣条',1,null,5);
    insert into product values(null,'旺旺大饼',1,null,5);

    //插入数据会失败
    insert into product values(null,'副表',1,null,12);

    ```

    #### 技术分析:

    - 多表之间的关系如何来维护

      外键约束: foreign key

      - 给product中的这个cno 添加一个外键约束

        alter table product add foreign key(cno)  references  category(cid);

      - 自己挖坑

      - 从分类表中,删除分类为5信息,

        - delete from category where cid =5;  //删除失败
        - 首先得去product表, 删除所有分类ID=5的所有商品

    - 建数据库原则:

      - 通常情况下,一个项目/应用建一个数据库


    - 多表之间的建表原则

      - 一对多 : 商品和分类

        - 建表原则: 在多的一方添加一个外键,指向一的一方的主键

          ​

      - 多对多: 老师和学生, 学生和课程

        建表原则: 建立一张中间表,将多对多的关系,拆分成一对多的关系,中间表至少要有两个外键,分别指向原来的那两张表

        ​

      - 一对一: 班级和班长, 公民和身份证, 国家和国旗

        - 建表原则:  

          - 将一对一的情况,当作是一对多情况处理,在任意一张表添加一个外键,并且这个外键要唯一,指向另外一张表
          - 直接将两张表合并成一张表
          - 将两张表的主键建立起连接,让两张表里面主键相等

        - 实际用途: 用的不是很多.    (拆表操作  )

          - 相亲网站: 
            - 个人信息 : 姓名,性别,年龄,身高,体重,三围,兴趣爱好,(年收入,  特长,学历, 职业, 择偶目标,要求)
            - 拆表操作 : 将个人的常用信息和不常用信息,减少表的臃肿, 

    展开全文
  • 一对一关系一对一的表关系: 例如:qq和qq的详尽信息 建立外键的时候 如果明确主从关系? 被引用的表是主表,外键在从表中建立 关联主表12345实现代码如下: CREATE TABLE qq( qqid int PRIMARY KEY, password ...
  • 28.多查询——跨关联关系的多查询

    千次阅读 多人点赞 2021-08-31 15:23:28
    查询—跨关联关系的查询 **Django 提供一种强大而又直观的方式来“处理”查询中的关联关系,它在后台自动帮你处理JOIN。 若要跨越关联关系,只需使用关联的模型字段的名称,并使用双下划线分隔,直至你想要的...
  • 事实与维度的区别与关系

    万次阅读 2016-11-21 20:24:43
    事实数据的主要特点是包含数字数据(事实),并且这些数字信息可以汇总,以提供有关单位作为历史的数据,每个事实数据包含一个由多个部分组成的索引,该索引包含作为外键的相关性纬度的主键,而维度包含事实...
  • mysql咋同时添加两张中的数据并且两张关联 有一张要循环 添加![图片说明](https://img-ask.csdn.net/upload/201707/02/1498963512_692396.png)
  • Oracle创建空间、用户、全程指南 ...每个空间由一个或多个物理文件(.dbf)组成,一个用户可以分配多个空间,但只能有一个默认空间,每张可以存在于一个或多个空间中(比如图中的1)
  • 如果说:两张之间的数据存在一种“部分”参照关系,也就是说的如果A中有部分数据是需要参照B中的数据,而有的则可以没有参照,那么,使用关联对两张之间的数据进行关联可能是更好的选择!这种关系的微妙...
  • 、子、主键、外键的关系

    千次阅读 2015-10-19 14:11:46
    相信初学数据库的学员来说,父和子、主键和外键这两对关系的理解肯定比较模糊,其实这个四者可以放一起理解。 简单的讲:当两个建立一对多关系的时候,"一"的那一端是父,"多"的那一端是子. 父设置一个...
  • 知识点:数据库的相关概念、创建数据库的方法、设计数据库、向数据库中插入数据、建立不同数据库之间的关系、删除数据库。 1、数据相关的一些概念 1.1 数据库里的数据是如何保存的? 数据库...
  • 多对多关系的多关联查询

    万次阅读 多人点赞 2017-11-23 19:14:20
    1.什么是多对多关系   多对多关系 (百度): 多对多关系关系数据库中两个之间的一种关系, 该关系中第一个中的一个行可以与第二个中的一个或多个行相关。第二个中的一个行也可以与第一个中的一个或...
  • 表关系(一对一,一对多,多对多)

    千次阅读 2016-08-25 20:28:08
    可以在数据库图表中的之间创建关系,以显示一个中的列与另一个中的列是如何相链接的。 在一个关系型数据库中,利用关系可以避免多余的数据。例如,如果设计一个可以跟踪图书信息的数据库,您需要创建一个名...
  • 本博文主要介绍 Laravel 框架中 Eloquent 对一对多关系的处理,在 Laravel Administrator(后台扩展包) 您的数据库可能是彼此相关的。比如,一篇博客文章可能有许多评论,或者一个订单与下订单的用户相关。Eloquent ...
  • 数据库中的数据之间的关系

    万次阅读 2012-12-14 16:56:16
    主键:能够唯一表示数据中的每个记录的字段或者字段的组合就称为主键。...唯一约束是用于指定一个或多个列的组合值具有唯一性,以防止在列中输入重复的值,所以,主键的值对用户而言是没有什么意义,并且
  • 因为大多数的数据库教程上都是告诉你关系数据库如何去创建1:1、1:N和N:M的数据库关系,但我发现很多开源产品中,并没有直接使用关系数据库的关系查询、关系删除等功能,而是直接在代码中对多个的查询结果进行...
  • 一、什么关系型数据库1. 关系数据库:是建立在关系模型基础上的数据库,借助于集合代数等数学概念和方法来处理数据库中的数据。简单说来就是关系型数据库用了选择、投影、连接、并、交、差、除、增删查改等数学...
  • Oracle数据库、实例、用户、空间、之间的关系

    万次阅读 多人点赞 2015-11-06 16:21:04
    空间是一个用来管理数据存储逻辑概念,空间只是和数据文件(ORA或者DBF文件)发生关系,数据文件是物理的,一个空间可以包含多个数据文件,而一个数据文件只能隶属一个空间。 数据文件(dbf、ora): ...
  • 在这种关系中,A 中的一行可以匹配 B 中的多行,但是 B 中的一行只能匹配 A 中的一行。例如,publishers 和 titles 之间具有一对多关系:每个出版社出版很多书,但是每本书名只能出自一个出版社。 ...
  • MyBatis:一对多表关系详解(从案例中解析)

    万次阅读 多人点赞 2013-11-11 12:36:00
    客户(Customer)和订单(Order)之间的关系是一对多的关系,即一个用户可以有多个订单。 (1)建立,并建立一对多关联。 主 create table Customer( id int primary key, name varchar(32) ); 从...
  • 我现在 有主 A 和从B  A表字段有: XM nvarchar2(100), RY_ID nvarchar2(32) B表字段有: RY_ID ...B的RY_ID为外键关联到A的RY_ID,所以A/B形成了一对多的关系。 想查询的结果集包括A中的记录,同时在B
  • 而开始遇到的最纠结的问题,就是怎么理清oracle中数据库、用户、方案、空间、对象之间的关系,如果这个问题搞不清楚,接下来的学习也就会雨里雾里了。所以,下定决心一定把它研究清楚,便开始了搜索各种资料的...
  • 文章目录简介关系数据设计出版社信息书种类入库记录销售记录小结 简介 最近学完了疯狂java讲义,知识掌握了,立马摩拳擦掌想好好练练,于是打算随便写写课后习题,自己写了一个之后看了看答案,才...
  • HBase一对多关系结构设计

    千次阅读 2017-03-22 10:27:03
    最近有个任务是把系统中的站内消息移到HBase当中去,才开始查HBase中的一对多关系,发现网上的资料讲的都不甚详尽,这篇blog记录一下我的设计和想法,这些想法毕竟未经证实,尚需验证。如果有大虾认为有不妥甚至错误...
  • PostgreSQL 空间、数据库、模式、、用户/角色
  • 本文主要介绍什么是循环依赖关系错误circular dependency,以及如何排查在单张中出现循环依赖错误,特别是使用CALCULATE函数产出的循环依赖错误。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 829,906
精华内容 331,962
关键字:

并且表什么关系