【miniob】JOIN TABLE DEBUG

最新推荐文章于 2024-12-09 22:12:02 发布
最新推荐文章于 2024-12-09 22:12:02 发布
阅读量943 收藏 26
点赞数 18
分类专栏： MINIOB 文章标签： sql 数据库 mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73553411/article/details/143617049
版权

pro1

INSERT INTO join_table_1 VALUES (4, '16a'); Select * from join_table_1 inner join join_table_2 on join_table_1.name<join_table_2.age and join_table_1.id=join_table_2.id; + failed to receive response from observer. reason=Failed to receive from server. poll return POLLHUP=16 or POLLERR=str(event & select.POLLERR) failed to receive response from observer. reason=Failed to receive from server. poll return POLLHUP=16 or POLLERR=str(event & select.POLLERR)

就是对于表达式当中的比较类型，如果不一致的话，一开始是没考虑，后面是直接返回类型不一致的报错，但是没过，看别人的思路，应该就是要进行强转比较

——————
 

就是当类型不可比的时候，如何处理？

char为什么能转换成double?是否能转为Int或其它类型? 

subpro1

这个就是在.h文件中，就不用再声明类名前缀了

将Value::去掉即可

subpro2

就是运行以下make clean，清理一下缓存

subpro3

这个很抽象的一点是代码内部自己定义了一个string,和std::string不一样（？

但确实不太理解之间的区别

用.c_str()就能正常打印和输出了

test

大数据

select * from join_table_large_1
inner join join_table_large_2 on join_table_large_1.id=join_table_large_2.id
inner join join_table_large_3 on join_table_large_1.id=join_table_large_3.id
inner join join_table_large_4 on join_table_large_3.id=join_table_large_4.id
inner join join_table_large_5 on 1=1
inner join join_table_large_6 on join_table_large_5.id=join_table_large_6.id
where
join_table_large_3.num3 <10
and
join_table_large_5.num5>90;

select * from join_table_large_1 inner join join_table_large_2 on join_table_large_1.id=join_table_large_2.id inner join join_table_large_3 on join_table_large_1.id=join_table_large_3.id inner join join_table_large_4 on join_table_large_3.id=join_table_large_4.id inner join join_table_large_5 on 1=1 inner join join_table_large_6 on join_table_large_5.id=join_table_large_6.id where join_table_large_3.num3 <10 and join_table_large_5.num5>90;
 

select * from join_table_1 inner join join_table_2 on 1=1

select * from join_table_large_5

CREATE TABLE join_table_1(id int, name char);

INSERT INTO join_table_1 VALUES (1, 'a');

INSERT INTO join_table_1 VALUES (2, 'b');

CREATE TABLE join_table_2(id int, num int);

INSERT INTO join_table_2 VALUES (1, 2);
INSERT INTO join_table_2 VALUES (2, 15);

create table join_table_large_1(id int, num1 int);
create table join_table_large_2(id int, num2 int);
create table join_table_large_3(id int, num3 int);
create table join_table_large_4(id int, num4 int);
create table join_table_large_5(id int, num5 int);
create table join_table_large_6(id int, num6 int);

insert into join_table_large_1 values(1, 1);
insert into join_table_large_1 values(2, 2);
insert into join_table_large_1 values(3, 3);
insert into join_table_large_1 values(4, 4);
insert into join_table_large_1 values(5, 5);
insert into join_table_large_1 values(6, 6);
insert into join_table_large_1 values(7, 7);
insert into join_table_large_1 values(8, 8);
insert into join_table_large_1 values(9, 9);
insert into join_table_large_1 values(10, 10);
insert into join_table_large_1 values(11, 11);
insert into join_table_large_1 values(12, 12);

insert into join_table_large_2 values(1, 1);
insert into join_table_large_2 values(2, 2);
insert into join_table_large_2 values(3, 3);
insert into join_table_large_2 values(4, 4);
insert into join_table_large_2 values(5, 5);
insert into join_table_large_2 values(6, 6);
insert into join_table_large_2 values(7, 7);
insert into join_table_large_2 values(8, 8);
insert into join_table_large_2 values(9, 9);
insert into join_table_large_2 values(10, 10);
insert into join_table_large_2 values(11, 11);
insert into join_table_large_2 values(12, 12);

insert into join_table_large_3 values(1, 1);
insert into join_table_large_3 values(2, 2);
insert into join_table_large_3 values(3, 3);
insert into join_table_large_3 values(4, 4);
insert into join_table_large_3 values(5, 5);
insert into join_table_large_3 values(6, 6);
insert into join_table_large_3 values(7, 7);
insert into join_table_large_3 values(8, 8);
insert into join_table_large_3 values(9, 9);
insert into join_table_large_3 values(10, 10);
insert into join_table_large_3 values(11, 11);
insert into join_table_large_3 values(12, 12);

insert into join_table_large_4 values(1, 1);
insert into join_table_large_4 values(2, 2);
insert into join_table_large_4 values(3, 3);
insert into join_table_large_4 values(4, 4);
insert into join_table_large_4 values(5, 5);
insert into join_table_large_4 values(6, 6);
insert into join_table_large_4 values(7, 7);
insert into join_table_large_4 values(8, 8);
insert into join_table_large_4 values(9, 9);
insert into join_table_large_4 values(10, 10);
insert into join_table_large_4 values(11, 11);
insert into join_table_large_4 values(12, 12);

insert into join_table_large_5 values(87, 87);
insert into join_table_large_5 values(88, 88);
insert into join_table_large_5 values(89, 89);
insert into join_table_large_5 values(90, 90);
insert into join_table_large_5 values(91, 91);
insert into join_table_large_5 values(92, 92);
insert into join_table_large_5 values(93, 93);
insert into join_table_large_5 values(94, 94);
insert into join_table_large_5 values(95, 95);
insert into join_table_large_5 values(96, 96);
insert into join_table_large_5 values(97, 97);
insert into join_table_large_5 values(98, 98);
insert into join_table_large_5 values(99, 99);
insert into join_table_large_5 values(100, 100);

insert into join_table_large_6 values(86, 86);
insert into join_table_large_6 values(87, 87);
insert into join_table_large_6 values(88, 88);
insert into join_table_large_6 values(89, 89);
insert into join_table_large_6 values(90, 90);
insert into join_table_large_6 values(91, 91);
insert into join_table_large_6 values(92, 92);
insert into join_table_large_6 values(93, 93);
insert into join_table_large_6 values(94, 94);
insert into join_table_large_6 values(95, 95);
insert into join_table_large_6 values(96, 96);
insert into join_table_large_6 values(97, 97);
insert into join_table_large_6 values(98, 98);
insert into join_table_large_6 values(99, 99);
insert into join_table_large_6 values(100, 100);

大数据下没问题，就是数据要求可判断的

miniob > select * from join_table_large_1 inner join join_table_large_2 on join_table_large_1.id=join_table_large_2.id inner join join_table_large_3 on join_table_large_1.id=join_table_large_3.id inner join join_table_large_4 on join_table_large_3.id=join_table_large_4.id inner join join_table_large_5 on 1=1 inner join join_table_large_6 on join_table_large_5.id=join_table_large_6.id where join_table_large_3.num3 <10 and join_table_large_5.num5>90;
id | num1 | id | num6 | id | num5 | id | num4 | id | num3 | id | num2
1 | 1 | 91 | 91 | 91 | 91 | 1 | 1 | 1 | 1 | 1 | 1
1 | 1 | 92 | 92 | 92 | 92 | 1 | 1 | 1 | 1 | 1 | 1
1 | 1 | 93 | 93 | 93 | 93 | 1 | 1 | 1 | 1 | 1 | 1
1 | 1 | 94 | 94 | 94 | 94 | 1 | 1 | 1 | 1 | 1 | 1
1 | 1 | 95 | 95 | 95 | 95 | 1 | 1 | 1 | 1 | 1 | 1
1 | 1 | 96 | 96 | 96 | 96 | 1 | 1 | 1 | 1 | 1 | 1
1 | 1 | 97 | 97 | 97 | 97 | 1 | 1 | 1 | 1 | 1 | 1
1 | 1 | 98 | 98 | 98 | 98 | 1 | 1 | 1 | 1 | 1 | 1
1 | 1 | 99 | 99 | 99 | 99 | 1 | 1 | 1 | 1 | 1 | 1
1 | 1 | 100 | 100 | 100 | 100 | 1 | 1 | 1 | 1 | 1 | 1
2 | 2 | 91 | 91 | 91 | 91 | 2 | 2 | 2 | 2 | 2 | 2
2 | 2 | 92 | 92 | 92 | 92 | 2 | 2 | 2 | 2 | 2 | 2
2 | 2 | 93 | 93 | 93 | 93 | 2 | 2 | 2 | 2 | 2 | 2
2 | 2 | 94 | 94 | 94 | 94 | 2 | 2 | 2 | 2 | 2 | 2
2 | 2 | 95 | 95 | 95 | 95 | 2 | 2 | 2 | 2 | 2 | 2
2 | 2 | 96 | 96 | 96 | 96 | 2 | 2 | 2 | 2 | 2 | 2
2 | 2 | 97 | 97 | 97 | 97 | 2 | 2 | 2 | 2 | 2 | 2
2 | 2 | 98 | 98 | 98 | 98 | 2 | 2 | 2 | 2 | 2 | 2
2 | 2 | 99 | 99 | 99 | 99 | 2 | 2 | 2 | 2 | 2 | 2
2 | 2 | 100 | 100 | 100 | 100 | 2 | 2 | 2 | 2 | 2 | 2
3 | 3 | 91 | 91 | 91 | 91 | 3 | 3 | 3 | 3 | 3 | 3
3 | 3 | 92 | 92 | 92 | 92 | 3 | 3 | 3 | 3 | 3 | 3
3 | 3 | 93 | 93 | 93 | 93 | 3 | 3 | 3 | 3 | 3 | 3
3 | 3 | 94 | 94 | 94 | 94 | 3 | 3 | 3 | 3 | 3 | 3
3 | 3 | 95 | 95 | 95 | 95 | 3 | 3 | 3 | 3 | 3 | 3
3 | 3 | 96 | 96 | 96 | 96 | 3 | 3 | 3 | 3 | 3 | 3
3 | 3 | 97 | 97 | 97 | 97 | 3 | 3 | 3 | 3 | 3 | 3
3 | 3 | 98 | 98 | 98 | 98 | 3 | 3 | 3 | 3 | 3 | 3
3 | 3 | 99 | 99 | 99 | 99 | 3 | 3 | 3 | 3 | 3 | 3
3 | 3 | 100 | 100 | 100 | 100 | 3 | 3 | 3 | 3 | 3 | 3
4 | 4 | 91 | 91 | 91 | 91 | 4 | 4 | 4 | 4 | 4 | 4
4 | 4 | 92 | 92 | 92 | 92 | 4 | 4 | 4 | 4 | 4 | 4
4 | 4 | 93 | 93 | 93 | 93 | 4 | 4 | 4 | 4 | 4 | 4
4 | 4 | 94 | 94 | 94 | 94 | 4 | 4 | 4 | 4 | 4 | 4
4 | 4 | 95 | 95 | 95 | 95 | 4 | 4 | 4 | 4 | 4 | 4
4 | 4 | 96 | 96 | 96 | 96 | 4 | 4 | 4 | 4 | 4 | 4
4 | 4 | 97 | 97 | 97 | 97 | 4 | 4 | 4 | 4 | 4 | 4
4 | 4 | 98 | 98 | 98 | 98 | 4 | 4 | 4 | 4 | 4 | 4
4 | 4 | 99 | 99 | 99 | 99 | 4 | 4 | 4 | 4 | 4 | 4
4 | 4 | 100 | 100 | 100 | 100 | 4 | 4 | 4 | 4 | 4 | 4
5 | 5 | 91 | 91 | 91 | 91 | 5 | 5 | 5 | 5 | 5 | 5
5 | 5 | 92 | 92 | 92 | 92 | 5 | 5 | 5 | 5 | 5 | 5
5 | 5 | 93 | 93 | 93 | 93 | 5 | 5 | 5 | 5 | 5 | 5
5 | 5 | 94 | 94 | 94 | 94 | 5 | 5 | 5 | 5 | 5 | 5
5 | 5 | 95 | 95 | 95 | 95 | 5 | 5 | 5 | 5 | 5 | 5
5 | 5 | 96 | 96 | 96 | 96 | 5 | 5 | 5 | 5 | 5 | 5
5 | 5 | 97 | 97 | 97 | 97 | 5 | 5 | 5 | 5 | 5 | 5
5 | 5 | 98 | 98 | 98 | 98 | 5 | 5 | 5 | 5 | 5 | 5
5 | 5 | 99 | 99 | 99 | 99 | 5 | 5 | 5 | 5 | 5 | 5
5 | 5 | 100 | 100 | 100 | 100 | 5 | 5 | 5 | 5 | 5 | 5
6 | 6 | 91 | 91 | 91 | 91 | 6 | 6 | 6 | 6 | 6 | 6
6 | 6 | 92 | 92 | 92 | 92 | 6 | 6 | 6 | 6 | 6 | 6
6 | 6 | 93 | 93 | 93 | 93 | 6 | 6 | 6 | 6 | 6 | 6
6 | 6 | 94 | 94 | 94 | 94 | 6 | 6 | 6 | 6 | 6 | 6
6 | 6 | 95 | 95 | 95 | 95 | 6 | 6 | 6 | 6 | 6 | 6
6 | 6 | 96 | 96 | 96 | 96 | 6 | 6 | 6 | 6 | 6 | 6
6 | 6 | 97 | 97 | 97 | 97 | 6 | 6 | 6 | 6 | 6 | 6
6 | 6 | 98 | 98 | 98 | 98 | 6 | 6 | 6 | 6 | 6 | 6
6 | 6 | 99 | 99 | 99 | 99 | 6 | 6 | 6 | 6 | 6 | 6
6 | 6 | 100 | 100 | 100 | 100 | 6 | 6 | 6 | 6 | 6 | 6
7 | 7 | 91 | 91 | 91 | 91 | 7 | 7 | 7 | 7 | 7 | 7
7 | 7 | 92 | 92 | 92 | 92 | 7 | 7 | 7 | 7 | 7 | 7
7 | 7 | 93 | 93 | 93 | 93 | 7 | 7 | 7 | 7 | 7 | 7
7 | 7 | 94 | 94 | 94 | 94 | 7 | 7 | 7 | 7 | 7 | 7
7 | 7 | 95 | 95 | 95 | 95 | 7 | 7 | 7 | 7 | 7 | 7
7 | 7 | 96 | 96 | 96 | 96 | 7 | 7 | 7 | 7 | 7 | 7
7 | 7 | 97 | 97 | 97 | 97 | 7 | 7 | 7 | 7 | 7 | 7
7 | 7 | 98 | 98 | 98 | 98 | 7 | 7 | 7 | 7 | 7 | 7
7 | 7 | 99 | 99 | 99 | 99 | 7 | 7 | 7 | 7 | 7 | 7
7 | 7 | 100 | 100 | 100 | 100 | 7 | 7 | 7 | 7 | 7 | 7
8 | 8 | 91 | 91 | 91 | 91 | 8 | 8 | 8 | 8 | 8 | 8
8 | 8 | 92 | 92 | 92 | 92 | 8 | 8 | 8 | 8 | 8 | 8
8 | 8 | 93 | 93 | 93 | 93 | 8 | 8 | 8 | 8 | 8 | 8
8 | 8 | 94 | 94 | 94 | 94 | 8 | 8 | 8 | 8 | 8 | 8
8 | 8 | 95 | 95 | 95 | 95 | 8 | 8 | 8 | 8 | 8 | 8
8 | 8 | 96 | 96 | 96 | 96 | 8 | 8 | 8 | 8 | 8 | 8
8 | 8 | 97 | 97 | 97 | 97 | 8 | 8 | 8 | 8 | 8 | 8
8 | 8 | 98 | 98 | 98 | 98 | 8 | 8 | 8 | 8 | 8 | 8
8 | 8 | 99 | 99 | 99 | 99 | 8 | 8 | 8 | 8 | 8 | 8
8 | 8 | 100 | 100 | 100 | 100 | 8 | 8 | 8 | 8 | 8 | 8
9 | 9 | 91 | 91 | 91 | 91 | 9 | 9 | 9 | 9 | 9 | 9
9 | 9 | 92 | 92 | 92 | 92 | 9 | 9 | 9 | 9 | 9 | 9
9 | 9 | 93 | 93 | 93 | 93 | 9 | 9 | 9 | 9 | 9 | 9
9 | 9 | 94 | 94 | 94 | 94 | 9 | 9 | 9 | 9 | 9 | 9
9 | 9 | 95 | 95 | 95 | 95 | 9 | 9 | 9 | 9 | 9 | 9
9 | 9 | 96 | 96 | 96 | 96 | 9 | 9 | 9 | 9 | 9 | 9
9 | 9 | 97 | 97 | 97 | 97 | 9 | 9 | 9 | 9 | 9 | 9
9 | 9 | 98 | 98 | 98 | 98 | 9 | 9 | 9 | 9 | 9 | 9
9 | 9 | 99 | 99 | 99 | 99 | 9 | 9 | 9 | 9 | 9 | 9
9 | 9 | 100 | 100 | 100 | 100 | 9 | 9 | 9 | 9 | 9 | 9

类型检测

CREATE TABLE join_table_1(id int, name char);
CREATE TABLE join_table_2(id int, num int);

INSERT INTO join_table_1 VALUES (1, 'a');
INSERT INTO join_table_1 VALUES (2, 'b');
INSERT INTO join_table_1 VALUES (3, 'c');
INSERT INTO join_table_2 VALUES (1, 2);
INSERT INTO join_table_2 VALUES (2, 15);

select * from join_table_1 inner join join_table_2 on join_table_1.name<join_table_2.num and join_table_1.id=join_table_2.id

select * from join_table_1

select * from join_table_1 inner join join_table_2 on join_table_1.id=join_table_2.id

select * from join_table_1 inner join join_table_2 on join_table_1.id=join_table_2.id

select * from join_table_1 inner join join_table_2 on join_table_1.id=join_table_2.id

CQU_JIAKE
关注
专栏目录
flink实战--Temporal Table JOIN
阿华田的博客
05-16 2485
Temporal Table简介 在ANSI-SQL 2011中提出了Temporal 的概念，Oracle，SQLServer，DB2等大的数据库厂商也先后实现了这个标准。Temporal Table记录了历史上任何时间点所有的数据改动，Temporal Table是Append Only表上的参数化视图，它把Append Only的表变化解释为表的Changel...
一文聊透 Flink 的 Temporal Join
Laurence的技术博客
03-25 2239
Flink的Temporal Join以及Temporal Table （时态表）关系密切，在知识结构上有点混乱，可能是历史原因造成的。本文希望把所有与 Temporal Join 相关的概念进行一次统一梳理，用更规范的知识结构把 Flink 的 Temporal Join 介绍清楚，包括：以 Temporal Table DDL 方式实现基于事件时间的 Temporal Join;以 Temporal Table DDL 方式实现基于处理时间的 Temporal Join;以 Temporal Table
miniob代码解析
weixin_62375715的博客
09-17 1587
啦啦啦
@JoinTable注解
Gr_lbxx的博客
11-07 1万+
  属性 是否必须 说明 name 否 指定该连接表的表名 JoinColumns 否 该属性值可接受多个@JoinColumn，用于配置连接表中外键列的信息，这些外键列参照当前实体对应表的主键列 inverseJoinColumns 否 该属性值可接受多个@JoinColumn，用于配置连接表中外键列的信息，这些外键列参照当前实体的...
@JoinTable的使用
热门推荐
atarik@163.com
10-27 1万+
两张表通过中间的关联表做联系时使用,即多对多关系,见权限分配 @ManyToMany(cascade = { CascadeType.DETACH, CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH } , fetch = FetchType.EAGER) @JoinTable(name = "position_source_...
@JoinTable注解简单记录
qq_42879471的博客
07-15 2716
@JoinTable(name = “t_clinic_role_menu”, joinColumns = {@JoinColumn(name = “role_id”)}, inverseJoinColumns = {@JoinColumn(name = “menu_id”)}) 其中 joinColumns 写的是本表在中间表的外键名称， inverseJoinColumns写的是另一个表在中间表的外键名称。 如果不注明外键名，则默认用关联的表名作为外键名。 ...
JPA - 多对多关系 - [@ManyToMany、@JoinTable]
sinat_34003720的博客
05-13 1803
???? JPA注解 在JPA中，JPA注解作用有两个 根据JPA注解生成table 根据JPA注解生成sql 如果，你想生成多对多关系的表或者多对多查询sql，使用@ManyToMany和@JoinTable @ManyToMany - 表示生成多对多关系的table @JoinTable - 用来对多对多关系table进行定制 ???? @ManyToMany和@JoinTable @ManyToMany - 表示生成多对多关系，属性如下 targetEntity - 关联的类 cascad
@JoinTable和@JoinColumn
04-26 7787
学习 原文地址：@JoinTable和@JoinColumn作者：雪后DE阳光 ----转载过来的。根据自己的理解修改了一下，便于以后阅读 默认情况下，JPA 持续性提供程序在映射多对多关联（或在单向的一对多关联中）的拥有方上的实体关联时使用一个连接表。连接表名称及其列名均在默认情况下指定，且 JPA 持续性提供程序假设：在关系的拥有方上的实体主表中，每个主键列有一个连接列。 通过
SQL中使用update inner join
changhong009的专栏
08-30 2458
update table1 set uName = t2.uName from table1 t1 inner join table2 t2 on t1.uID = t2.uID
full join 与 union
叁木大数据
05-17 2160
full join 与 union描述一、表简介二、转换步骤2.1 完整sql2.2 转换中的问题2.2.1 nvl2.2.2 full join ods_table_c_rnk 表三、UNION效验总结 描述 有三张表需要对每个表进行去除重复后关联进行列的补充，并且保留未匹配上的所有数据。由于有列的补充并保留所有数据，所以选择了full join进行操作处理，最终使用union进行数据量的验证 提示：以下是本篇文章正文内容，下面案例可供参考 一、表简介 ods_table_a(主键 product_id
jointable 的用法
DDRTDTD的专栏
07-16 5933
前任从来没有用过jointable， 官方的例子也少得可怜，先贴上一段代码 IDataQuery dq1 = session.createDataQuery();        dq1.setTarget(session.getObjectDef("PMSF"));            dq1.addFilter("hs_is_deleted", SATConstants.SQL_OP_E
（6）ManyToMany单向、双向：@JoinTable
FixedStar 的博客
11-12 7764
一、manytomany单向 单向是指类层面，在下面例子中老师类可以知道要教哪些学生，学生不知被哪些老师教 **需要用到连接表**@JoinTable(name="t_s", joinColumns={@JoinColumn(name="teacher_id")},inverseJoinColumns={@JoinColumn(name="student_id")} )
Oracle进阶（十一）表连接（Table Join）
一二山人的博客
05-07 1324
1、简介 2、基本语法 注：如果使用from子句指定内、外连接，则必须要使用on子句指定连接条件； 如果使用（+）操作符指定外连接，则必须使用where子句指定连接条件。 SELECT TABLE1.COLUMN,TABLE2.COLUMN FROM TABLE1 [INNER | LEFT | RIGHT | FULL ] JOIN TABLE2 ON TABLE1.COLUMN1 = TABLE2.COLUMN2; 3、表连接 3.1 内连接（[INNER JOI...
SQL面试题——百度SQL面试题 合并用户浏览行为
12-06 1970
其实这种合并问题和连续问题是同一类的，解决思路都一样。
SQL多行数据合并到一行中的一个字段
ItContentShare
12-05 535
在SQL中，将多行数据转换为一行数据通常涉及到使用聚合函数和字符串函数。这种转换在数据库中被称为“行转列”或“透视”操作。
Mybatis中SQL的执行过程
最新发布
骑个小蜗牛的博客
12-09 890
Mybatis 框架 SQL执行过程 数据库操作映射方式 SQL的执行过程 - SQL解析 - SQL参数映射 - SQL预编译 - SQL执行 - 结果映射 - 事务处理 - 缓存处理 - 日志记录与监控 扩展 #与$的区别 - $ 符号 - # 符号 总结示例 Mybatis SQL分类 - 动态 SQL - 静态 SQL 静态SQL和动态SQL选择 ${}、#{}与SQL是否静态SQL、动态SQL无直接关系
ORM框架详解：为什么不直接写SQL？
brhhh_sehe的博客
12-05 708
ORM是"Object-Relational Mapping"的缩写，中文通常翻译为"对象关系映射"。这个术语听起来可能有点抽象，让我们通过一个简单的比喻来理解它：想象你是一位翻译官，你的工作是在两种完全不同的语言之间进行翻译。在编程世界中，ORM就像这样一位翻译官，它在面向对象的编程语言（如Java、Python、C#等）和关系型数据库（如MySQL、PostgreSQL、Oracle等）之间进行"翻译"。使用面向对象的方式来操作数据库将数据库表映射到编程语言中的类。
sqlmap常用脚本
weixin_46729014的博客
12-05 453
【代码】sqlmap常用脚本。
HIVESql 语法详解，包含DDL、DML、DQL语言，一文了解到 hivesql（适合收藏）
摇光是颗星
12-09 653
DDL是什么？DDL是SQL语言集中对数据库内部的对象结构进行创建，删除，修改等操作语言。对象结构：数据库(database)、表(table)、视图(view)、索引(index)等DDL核心语法由 CREATE、ALTER、DROP 三个组成，DDL并不涉及表内部数据的操作UDF函数：普通函数，一进一出。
@JoinTable的用法
06-01
`@JoinTable` 注解用于定义两个实体类之间的多对多关系，并且指定用于关系维护的中间表的细节。 以下是 `@JoinTable` 注解的一些常用属性： - `name`：指定用于关系维护的中间表的名称。 - `joinColumns`：指定关系维护方的外键列的细节，包括列名、引用的列名等。 - `inverseJoinColumns`：指定关系被维护方的外键列的细节，包括列名、引用的列名等。 以下是一个使用 `@JoinTable` 注解的多对多关系的示例： ``` @Entity public class Student { @Id private Long id; @ManyToMany @JoinTable(name = "student_course", joinColumns = @JoinColumn(name = "student_id"), inverseJoinColumns = @JoinColumn(name = "course_id")) private Set<Course> courses = new HashSet<>(); // getters and setters } @Entity public class Course { @Id private Long id; @ManyToMany(mappedBy = "courses") private Set<Student> students = new HashSet<>(); // getters and setters } ``` 在这个示例中，我们创建了两个实体类 `Student` 和 `Course`，它们之间是多对多关系。我们使用 `@JoinTable` 注解来定义中间表，指定中间表的名称为 `student_course`，关系维护方的外键列为 `student_id`，关系被维护方的外键列为 `course_id`。 在 `Student` 实体类中，我们使用 `@ManyToMany` 和 `@JoinTable` 注解来定义多对多关系，并将多对多关系映射到 `courses` 属性中。 在 `Course` 实体类中，我们使用 `@ManyToMany(mappedBy = "courses")` 注解来定义多对多关系，并指定 `mappedBy = "courses"`，表示多对多关系的映射属性为 `courses`。 通过使用 `@JoinTable` 注解，我们可以方便地定义多对多关系，并指定用于关系维护的中间表的细节。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值