精华内容
下载资源
问答
  • 对于多表查询的情况,数据库里定义了关系,在应用程序写sql语句时还需要描述表之间关系吗?两者是否可以只选其一?
  • 外键 通常在实际工作中,数据库中表格都不是独立存在的,且...两张要想有着某种联系,需要设定主键外键两个属性,其中在分类(主)中将cid设置为主键,商品(从)中pid设置为外键。 外键特点:

    外键


    通常在实际工作中,数据库中表格都不是独立存在的,且表与表之间是有种联系的,比如两张表格,一张为分类表category,一张为商品表product。在分类表中有两个信息,cid、cname,商品表中有三个数据信息pid、name、price。两张表要想有着某种联系,需要设定主键和外键两个属性,其中在分类表(主表)中将cid设置为主键商品表(从表)中pid设置为外键

    外键特点:

    从表外键的值是对主表键的引用。

    从表外键类型,必须与主表主键类型一致。


    声明外键约束:

    alter table produnct add constraint key_fk(外键名称) foreign key category_id(从表外键字段名) references category(cid);

    外键名称用于删除外键约束时使用,也可不设置,一般建议“_fk”为结尾。

    删除外键约束

    alter table product drop foreign key key_fk;

    在不接触外键约束时,主表不能直接删除与从表有约束关系的数据信息,如:

    delete from category where cid="XXX";

    实例:

    CREATE TABLE category(
    	cid VARCHAR(32) PRIMARY KEY,
    	cname VARCHAR(100)
    );
    DESC category;
    CREATE TABLE product(
    	pid VARCHAR(32) PRIMARY KEY,
    	pname VARCHAR(40),
    	price DOUBLE,
    	category_id VARCHAR(32)
    );
    INSERT INTO category(cid,cname) VALUES('c001','家电');
    INSERT INTO category(cid,cname) VALUES('c002','服饰');
    INSERT INTO category(cid,cname) VALUES('c003','化妆品');
    
    INSERT INTO product(pid,pname,price,category_id) VALUES('p001','联想','5000','c001');
    INSERT INTO product(pid,pname,price,category_id) VALUES('p002','海尔','5000','c001');
    INSERT INTO product(pid,pname,price,category_id) VALUES('p003','雷神','5000','c001');
    
    INSERT INTO product(pid,pname,price,category_id) VALUES('p004','JACK JONES','800','c002');
    INSERT INTO product(pid,pname,price,category_id) VALUES('p005','真维斯','200','c002');
    INSERT INTO product(pid,pname,price,category_id) VALUES('p006','花花公子','440','c002');
    INSERT INTO product(pid,pname,price,category_id) VALUES('p007','劲霸','2000','c002');
    
    INSERT INTO product(pid,pname,price,category_id) VALUES('p008','香奈儿','800','c003');
    INSERT INTO product(pid,pname,price,category_id) VALUES('p009','相宜本草','200','c003');
    
    ALTER TABLE product ADD CONSTRAINT key_fk FOREIGN KEY(category_id) REFERENCES category(cid); 

    表与表之间的关系:


    1.一对多关系

    一对多建表原则:在从表创建一个字段,字段作为外键指向主表的主键

    实例同上

    2.多对多关系

    多对多关系建表原则:需要创建第三张表,中间表中至少有两个字段,这两个字段分别作为外键指向各自一方的主键。

    实例:

    CREATE TABLE orders(
    	oid VARCHAR(32) PRIMARY KEY,
    	totalprice DOUBLE
    );
    
    CREATE TABLE orderitem(
    	oid VARCHAR(50),
    	pid VARCHAR(50)
    );
    
    CREATE TABLE product(
    	pid VARCHAR(32) PRIMARY KEY,
    	pname VARCHAR(40),
    	price DOUBLE,
    	category_id VARCHAR(32)
    );
    
    订单表和订单项表的主外键关系
    ALTER TABLE orderitem ADD CONSTRAINT orderitem_orders_fk FOREIGN KEY(oid) REFERENCES orders(oid);
    
    商品表和订单项表的主外键关系
    ALTER TABLE orderitem ADD CONSTRAINT orderitem_product_fk FOREIGN KEY(pid) REFERENCES product(pid);

    多表查询


    1.交叉连接查询(一般不用)
    select * from A,B
    2.内连接查询(使用关键字inner join --inner可以省略)
    隐式内连接:select * from A,B where 条件;
    显示内连接:selcet * from A inner join B on 条件;
    3.外连接查询:(使用关键字outer join --outer 可以省略)
    左外连接:left outer join
    select * from A left outer join B on 条件;
    右外连接: right outer join
    select * from A right outer join B on 条件;







    展开全文
  • 本篇博客讲解(子查询)非相关子查询/相关子查询,一对一,一对多,多对一,多对的的关系!准备:首先我们创建一列sex。再为部分行设置好值0(女)或者1(男);delete from stud where age=26; 删除年龄为26的行。 ...

    本篇博客讲解(子查询)非相关子查询/相关子查询,一对一,一对多,多对一,多对的的关系!

    准备:

    首先我们创建一列sex。再为部分行设置好值0(女)或者1(男);

    delete from stud where age=26;
    删除年龄为26的行。

     update stud set sex='1' where saddress like '湖南%';

    将地址中湖南开头的人的的sex修改为1。

    update stud set sex='0' where age>=30 and sex is null;

    将年龄大于等于30的,且性别为null的人的sex设置为0.

    case-when then else end 语句.

    现在要做这样一件事,查询显示的时候sex不显示0,1和null,我们让它0的就显示女,1的就显示男,null就显示未知。
    这时我们需要用到:
    case-when then else end 语句.

    修改 * 当 * 时候 修改成 * 否则修改成 * END
    when then 可以写多句

    select sno,sname,age,saddress,(case sex when '0' then '女' when '1' then '男' else '未知' end) as 性别 from stud;

    有人可能会有疑问,不是定义了sex只能有一个字符嘛,为什么还能用‘未知’啊,因为这里只是显示的,并不是存储到数据库中的数据,只是相当于输出字符。

    子查询:

    子查询:嵌套在其它查询中的查询语句。(又称为内部查询)

    主查询:包含其它子查询的查询称为主查询。(又称外部查询)

    非相关子查询:

    在主查询中,子查询只需要执行一次,子查询结果不再变化,供主查询使用,这种查询方式称为非相关子查询。
    也可以这么理解:
    非相关子查询是独立于外部查询的子查询,子查询总共执行一次,执行完毕后将值传递给外部查询。

    现在我们来对这个表做一个查询:
    查询具有年龄相同的人在2人及以上的,他们的年龄分别是多少。

    select age from stud group by age having count(age)>=2;

    count(age)在这里只是作为供主查询使用的条件。

    相关子查询:

    相关子查询的执行依赖于外部查询的数据,外部查询执行一行,子查询就执行一次。
    也可以这么理解:
    执行查询的时候先取得外部查询的一个属性值,然后执行与此属性值相关的子查询,执行完毕后再取得外部父查询的下一个值,依次再来重复执行子查询;

    我们先把表格增加一列sex并设置好值。

    接下来:
    查询不但具有年龄相同的人在2人及以上的,而且性别是1的那些人的年龄。

    SELECT age,sex FROM stud GROUP BY age,sex HAVING COUNT(age)>=2 AND sex='1';

    表与表之间的关系:

    一对一:

    需要两个表。当然做项目时为了省空间,通常只建一个表,如果要实现一对一的查询,可以建立两个视图。示例如下:
    1)先建物理表,初始化数据、

    create table person(
        id int,
        name varchar(10),
        sex char(1),
        wife int,
        husband int
    );
    insert into person values(1,'小花','0',1,3);
    insert into person values(2,'玉芳','0',0,4);
    insert into person values(3,'张三','1',1,0);
    insert into person values(4,'李四','1',2,0);
    insert into person values(5,'王五','1',0,0);

    2)建立两个视图

    create view women as select * from person where sex='0';
    create view men as select * from person where sex='1';

    3)查询夫妻信息
    92年以前是这样查询的:

    select women.name as 妻子,men.name as 丈夫 from women,men where women.husband=men.id and women.id=men.wife;

    一对多/多对一:

    数据库设计分析:
    案例:一个人可以拥有多辆汽车,要求查询出某人所拥有的所有汽车。

    方案一:(差的设计-用一张表存储–数据冗余太严重)

    编号   姓名  性别   年龄   汽车编号   车型  排量  价格
    P001  Jack   男     25     C001     BMW    12L   80w
    P001  Jack   男     25     C002     Benz   12L   100w
    P001  Jack   男     25     C003     Benz   12L   100w
    P002  Tom    男     25     C004     BMW    12L   80w
    P002  Tom    男     25     C005     Benz   12L   100w
    P003  Rose   女     25     C006     Benz   12L   100w

    方案二(好的设计):
    1)把一方单独建个表

    编号   姓名  性别   年龄
    P001  Jack   男     25
    P002  Tom    男     25
    P003  Rose   女     25

    2)把多方也建个表(依赖一方,通过外键–补一个字段)
    外键:位于依赖一方,它是被依赖一方是主键

    汽车编号   车型  排量  价格    车主
     C001     BMW    12L   80w    P001
     C002     Benz   12L   100w   P001
     C003     Benz   12L   120w   P001
     C004     BMW    12L   80w    P002
     C005     Benz   12L   100w   P002
     C006     Benz   12L   100w   P003

    3)代码实现:

    create table person2(
        id varchar(32) primary key,
        sname varchar(30),
        sex char(1),
        age int
    );
    insert into person2 values('P1001','Jack','0',25);
    insert into person2 values('P1002','Tom','1',22);
    insert into person2 values('P1003','Rose','1',24);
    insert into person2 values('P1004','张三','0',25);
    
    create table car(
        id varchar(32) primary key,
        sname varchar(30),
        price numeric(10,2),
        /*numeric(a,b),a表示一共多少位数,b表示带有几位小数*/
        pid varchar(32),
        /*为字段pid定义一个外键约束(来自person2表的字段id)*/
        constraint car_fk foreign key(pid) references person2(id)
    );
    
    insert into car values('C001','BMW',80.5,'P1001');
    insert into car values('C002','Benz',100,'P1001');
    insert into car values('C003','BMW',120.05,'P1001');
    insert into car values('C004','Benz',88.5,'P1002');
    insert into car values('C005','QQ',8.5,'P1002');
    insert into car values('C006','BIKE',0.5,'P1003');

    查询每个人拥有的车辆:
    92年之前的写法:

    select person2.sname as 车主,car.sname as 车辆 from person2,car where car.pid=person2.id;

    现在的内关联写法:

    select person2.sname as 车主 ,car.sname as 车辆 from person2 join car on car.pid=person2.id;

    一对多和多对一是一样的!反过来理解就是了。

    多对多:

    数据库设计分析
    案例:一个人可以选择多门课程,一门课程又可以被多人选择。

    方案一:(差的设计–数据冗余太严重)
    1)学生表

    编号   姓名  性别   年龄  电话 ...
    P001  Jack   男     25
    P002  Tom    男     25
    P003  Rose   女     25

    2)课程表

    编号   名称   教材  学分...  学生
    S001   Java   ...  ......   P001
    S001   Java   ...  ......   P002
    S001   Java   ...  ......   ...
    S002   数据库  ... ......   P001
    S002   数据库  ... ......   P002

    pass。

    方案二(好的设计:两个实体表+一个关系表):
    1)学生表(独立)—实体

    编号   姓名  性别   年龄  电话 ...
    P001  Jack   男     25
    P002  Tom    男     25
    P003  Rose   女     25

    2)课程表(独立)—实体

    编号   名称   教材  学分... 
    S001   Java   ...  ......
    S002   数据库  ... ......
    S003   XML   ... ......

    3)选课表(专为体现多对多的关系而新增的表)–关系

    课程编号  学生编号
    S001      P001
    S001      P002
    ...
    S002      P002
    S002      P003
    ...
    S003      P001
    ...
    --------------
    外键      外键
     |         |
     |         |
      ---------
          |
       联合主键

    4) 代码实现

    create table stud(
        id varchar(32) primary key,
        sname varchar(30),
        age int
    );
    create table ject(
        id varchar(32) primary key,
        sname varchar(30)
    );
    create table sj(
        studid varchar(32),
        jectid varchar(32)
    );
    /*单独添加约束,必须先添加联合主键,再添加外键*/
    /*创建联合主键*/
    alter table sj add constraint pk_sj primary key(studid,jectid);
    /*创建两个外键*/
    alter table sj add constraint fk_stud foreign key(studid) references stud(id);
    alter table sj add constraint fk_ject foreign key(jectid) references ject(id);

    如果需要删除外键

    alter table sj drop foreign key fk_stud;
    alter table sj drop foreign key fk_ject;

    初始化stud表数据

    insert into stud values('P001','小花',25);
    insert into stud values('P002','Jack',23);
    insert into stud values('P003','Tom',24);
    insert into stud values('P004','张三',24);
    insert into stud values('P005','赵子龙',26);

    初始化ject表:

    insert into ject values('S001','Java');
    insert into ject values('S002','JavaEE');
    insert into ject values('S003','XML');
    insert into ject values('S004','数据库');
    insert into ject values('S005','JQuery');

    初始化sj表:

    insert into sj values('P001','S001');
    insert into sj values('P001','S003');
    insert into sj values('P002','S001');
    insert into sj values('P002','S002');
    insert into sj values('P002','S003');
    insert into sj values('P003','S001');
    insert into sj values('P004','S002');
    insert into sj values('P004','S003');

    关联(也称为连接):
    左关联(left join) 右关联(right join) 内关联(inner join)
    mysql不支持: 全关联(full join) 外关联(outter join)

    可以把关联理解成:几个表合成一个新的表,然后在新表中进行查询!

    查询哪些人选了哪些课:

    92年之前是这样查询的:(没有用关联)

    select stud.sname,ject.sname from stud,sj,ject where stud.id=sj.studid and ject.id=sj.jectid;

    用内关联来:

    select stud.sname,ject.sname from
        stud inner join sj on stud.id=sj.studid
             inner join ject on ject.id=sj.jectid;
    

    内关联可以这样来看,以中间的sj表为主表,来合另外2个表。

    查询哪些人没有选课:

    不用关联的写法:

    select stud.sname from stud where stud.id not in(select studid from sj);

    用左关联的写法:

    select stud.sname from
        stud left join sj on stud.id=sj.studid
             left join ject on ject.id=sj.jectid
        where ject.sname is null;
    /*下面这句也可以查询出*/
    select stud.sname from
        stud left join sj on stud.id=sj.studid
             left join ject on ject.id=sj.jectid
        where ject.id is null;
    

    左关联就是把左边的表作为主表,也就是说,stud必须是完整的,可以增加,但不能减少,再按照sj表的关系,来添加ject表的数据。

    查询哪些课程没人选:

    不用关联的写法:

    select ject.sname from ject where ject.id not in(select jectid from sj);

    用左关联的写法:

    select ject.sname from
        ject left join sj on ject.id=sj.jectid
             left join stud on stud.id=sj.studid
        where stud.id is null;

    最后的那里也可以用stud.sname is null来判断。
    但要注意,需要原来的stud表中的那个属性定义了not null。
    否则会出现bug。

    用右关联写:

    select ject.sname from
        stud right join sj on stud.id=sj.studid
             right join ject on ject.id=sj.jectid
        where stud.sname is null;

    左关联和右关联实质上是差不多的。认真的看下上面的左关联和右关联就可以看出来了。

    展开全文
  • Oracle 查询所有表之间的主外键关系

    千次阅读 2014-10-03 17:44:19
    select a.table_name 主,   b.table_name 子,   column_name 键,   substr(position,1,1) P  from   user_constraints a, user_constraints b, user_cons_colu

    select a.table_name         主表, 
           b.table_name         子表, 
           column_name          键, 
           substr(position,1,1) P 
    from 
          user_constraints a, user_constraints b, user_cons_columns c 
    where 
          a.constraint_name = b.r_constraint_name 
    and   a.constraint_name = c.constraint_name 
    order by 1, 2, 4;

    引用:http://lsx125920.javaeye.com/blog/661737 

     

    查询单个表的所有主外键关系

     

    select a.owner 主键拥有者

             ,a.table_name 主键表

            ,b.column_name 主键列

            ,C.OWNER 外键拥有者

            ,c.table_name 外键表

           ,d.column_name 外键列
    from user_constraints  a
    left join user_cons_columns b

                on  a.constraint_name=b.constraint_name
    left join user_constraints C

                ON C.R_CONSTRAINT_NAME=a.constraint_name
    left join user_cons_columns d

                on c.constraint_name=d.constraint_name
    where  a.constraint_type='P'

        and  a.table_name='XXX' --需要查看主外键关系的表
    order by a.table_name

    展开全文
  • 接着上一篇讲 上一篇我们学习了如何创建节点,以及查询节点,但未涉及二者之间关系relationship,本篇,我们将通过简单的案列来完整的走一遍整个节点--关系--节点的流程,为了降低复杂度,关系是(1...n)单向的...

    接着上一篇讲


           上一篇我们学习了如何创建节点,以及查询节点,但未涉及二者之间的关系relationship,本篇,我们将通过简单的案列来完整的走一遍整个节点--关系--节点的流程,为了降低复杂度,关系是(1...n)单向的,也就是默认关系是Out出去的。



    一、场景


    节点Nodes:


    1.创建一个Coder类型的节点,代表程序员,属性有id,name,sex,hobby(姓名,性别,爱好)

    2.创建一个Cat类型的节点,代表猫,属性有id,name,color(名称,颜色)

    3.创建一个Player类型的节点,代表体育运动员,属性有id,name,height,location(姓名。身高,场上位置)


    关系Relationship:


    Coder(程序员) -- Have(拥有)Cat(

                                --Like(喜欢)Player(运动员



    在neo4j图库中表示为下图:





    为了后台演示关系数据的创建,这里我们把图库中的数据清空:






    执行







    二、构建实体(数据操作部分)+接口(增删改查CRUD)






    (1)抽离Coder、Cat、Player三者共有的属性 -- 抽象类


    package com.appleyk.data.nodeentity;
    
    import org.neo4j.ogm.annotation.GraphId;
    
    /**
     * 抽取共同的属性字段
     * @author yukun24@126.com
     * @blob   http://blog.csdn.net/appleyk
     * @date   2018年1月19日-下午4:35:25
     */
    public abstract class BaseEntity {
    
    	/**
    	 * Neo4j会分配的ID(节点唯一标识 当前类中有效)
    	 */
    	@GraphId
    	private Long id;
    	
    	private String name;
    
    	public Long getId() {
    		return id;
    	}
    
    	public void setId(Long id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    }
    



    (2)Coder


    A. Coder实体Java类映射(包含单边关系---注意关系指向的对象又是一个节点)


    @JsonProperty("别名") :Json注解---> 给关系起别名

    package com.appleyk.data.nodeentity;
    
    import java.util.List;
    
    import org.neo4j.ogm.annotation.NodeEntity;
    import org.neo4j.ogm.annotation.Relationship;
    
    import com.fasterxml.jackson.annotation.JsonProperty;
    
    /**
     * Neo4j的节点实体类:Coder
     * 
     * @author yukun24@126.com
     * @blob http://blog.csdn.net/appleyk
     * @date 2018年1月18日-下午12:06:17
     */
    
    @NodeEntity
    public class Coder extends BaseEntity {
    
    	private String sex;
    	private String hobby;
    
    	@Relationship(type = "Like")
    	@JsonProperty("喜欢")
    	private List<Player> players;
    
    	@Relationship(type = "Have")
    	@JsonProperty("拥有")
    	private List<Cat> cats;
    
    	public Coder() {
    
    	}
    
    	public String getSex() {
    		return sex;
    	}
    
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    
    	public String getHobby() {
    		return hobby;
    	}
    
    	public void setHobby(String hobby) {
    		this.hobby = hobby;
    	}
    
    	public List<Player> getPlayers() {
    		return players;
    	}
    
    	public void setPlayers(List<Player> players) {
    		this.players = players;
    	}
    
    	public List<Cat> getCats() {
    		return cats;
    	}
    
    	public void setCats(List<Cat> cats) {
    		this.cats = cats;
    	}
    
    }
    


    B. Coder实体对应的图形存储器的接口实现(CRUD 增删改查)


    package com.appleyk.data.Repository;
    
    import org.apache.ibatis.annotations.Param;
    import org.springframework.data.neo4j.repository.GraphRepository;
    import org.springframework.stereotype.Repository;
    
    import com.appleyk.data.nodeentity.Coder;
    
    
    /**
     * Coder 节点增删改
     * @author yukun24@126.com
     * @blob   http://blog.csdn.net/appleyk
     * @date   2018年1月18日-下午12:10:53
     */
    
    @Repository
    public interface CoderRepository extends GraphRepository<Coder>{
    
    	/*
    	 CoderRepositiory 继承 GraphRepository类,实现增删查改
    	   实现自己的接口:通过名字查询Coder(可以是单个Coder,也可以是一个List集合),
    	 spring-data-neo4j 支持方法命名约定查询 findBy{Coder的属性名},
    	 findBy后面的属性名一定要Coder类里存在,否则会报错 
    	 */
    	
    	 Coder findByName(@Param("name") String name);
    	 
    


    (3)Player


    A.实体

    package com.appleyk.data.nodeentity;
    
    import org.neo4j.ogm.annotation.NodeEntity;
    
    @NodeEntity
    public class Player extends BaseEntity{
    
    	private double height;
    	private String location;
    	
    	public Player(){
    		
    	}
    	
    	public double getHeight() {
    		return height;
    	}
    	public void setHeight(double height) {
    		this.height = height;
    	}
    	public String getLocation() {
    		return location;
    	}
    	public void setLocation(String location) {
    		this.location = location;
    	}
    }
    

    B.接口


    package com.appleyk.data.Repository;
    
    import org.springframework.data.neo4j.repository.GraphRepository;
    
    import com.appleyk.data.nodeentity.Player;
    
    public interface PlayerRepository extends GraphRepository<Player>{
    
    }
    



    (4)Cat


    A.实体


    package com.appleyk.data.nodeentity;
    
    import org.neo4j.ogm.annotation.NodeEntity;
    
    @NodeEntity
    public class Cat extends BaseEntity {
    
    	private String color;
    
    	public Cat() {
    
    	}
    
    	public String getColor() {
    		return color;
    	}
    
    	public void setColor(String color) {
    		this.color = color;
    	}
    
    }
    


    B.接口


    package com.appleyk.data.Repository;
    
    import org.springframework.data.neo4j.repository.GraphRepository;
    
    import com.appleyk.data.nodeentity.Cat;
    
    public interface CatReponsitory extends GraphRepository<Cat>{
    
    }
    



    三、创建节点Coder(含关系连接Cat节点和Player节点)



    (1)CoderController


    package com.appleyk.controller;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.transaction.annotation.Transactional;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    import com.appleyk.data.Repository.CoderRepository;
    import com.appleyk.data.nodeentity.Coder;
    import com.appleyk.result.ResponseResult;
    
    @RestController
    @RequestMapping("/rest/v1.0.1/database/coder") //restful风格的api接口
    public class CoderController {
    	
    	
    	@Autowired
    	CoderRepository coderRepositiory;
    	
    	@RequestMapping("/get")
    	public Coder GetCoderByName(@RequestParam(value="name") String name){		
    		return coderRepositiory.findByName(name);
    	}
    	
    	@PostMapping("/save")
    	@Transactional
    	public ResponseResult Create(@RequestBody Coder coder) throws Exception{
    	   
    		Coder result = coderRepositiory.save(coder);
    	    if(result!=null){	    		    	
    	    	return new ResponseResult(200,result.getName()+"节点创建成功");
    	    }
    	    return new ResponseResult(500,coder.getName()+"节点创建失败!");
    	}
    		
    }
    


    (2)Coder:Json数据



    {
    	"name": "appleyk",
    	"sex": "男",
    	"hobby": "体育、游戏",
    	"喜欢": [
    		{
    			"name": "科比",
    			"height": 1.98,
    			"location": "得分后卫"
    		},
    		{
    			"name": "孙杨",
    			"height": 1.98,
    			"location": "游泳运动员"
    		}
    	],
    	"拥有": [
    		{
    			"name": "苏格兰折耳猫",
    			"color": "灰白色"
    		}
    	]
    }



    (3)启动项目






    (4)请求数据 -- 创建(save)Coder节点



    restful api:http://localhost:8088/rest/v1.0.1/database/coder/save



    A.




    B.






    C.






    四、创建节点Coder(不包含关系,仅仅是单节点)



    (1)请求数据:JSON


    {
    	"name": "李大锤",
    	"sex": "男",
    	"hobby": "吃饭、睡觉"
    }


    (2)Save







    (3)








    五、查询节点Coder(带关系,name='appleyk')



    (1)请求地址(Get):http://localhost:8088/rest/v1.0.1/database/coder/get




    (2)Get









    六、查询节点Coder(不带关系,name='李大锤')







    展开全文
  • 数据库设计 表和表之间的三种关系

    万次阅读 2017-12-15 17:29:50
    表之间一般存在三种关系,即一对一,一对多,多对多关系。  下面分别就三种关系讲解数据库相关设计的思路思考过程; (1)一对一关系  例如,下面的一张,保存了人的相关信息,有男有女,要求查处所有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 559,403
精华内容 223,761
关键字:

关于查询和表之间的关系