表（修改、排序、分页、表关联）

最新推荐文章于 2024-05-15 22:52:13 发布
最新推荐文章于 2024-05-15 22:52:13 发布
阅读量75 收藏
点赞数
文章标签： 数据库
原文链接：http://www.cnblogs.com/jiangyijiangPython/p/10003770.html
版权

where子句（条件查询）：按照“条件表达式”指定的条件进行查询。

group by子句（分组）：按照“属性名”指定的字段进行分组。group by子句通常和count()、sum()等聚合函数一起使用。

having子句（筛选）：有group by才能having子句，只有满足“条件表达式”中指定的条件的才能够输出。

order by子句（排序）：按照“属性名”指定的字段进行排序。排序方式由“asc”和“desc”两个参数指出，默认是按照“asc”来排序，即升序。

limit（限制结果集）。

 

 

 

 

mysql中五种常用的聚合函数：

（1）max(列名)：求最大值。

（2）min(列名)：求最小值。

（2）sum(列名)：求和。

（4）avg(列名)：求平均值。

（5）count(列名)：统计记录的条数。

 

 

为了方便查看数据，可以对数据进行排序

语法：order by 字段 asc 或者 desc

说明   按照某字段正序，倒序使用desc

将行数据按照列1进行排序，如果某些行列1的值相同时，则按照列2排序，以此类推

默认按照列值从小到大排列（asc）

asc从小到大排列，即升序

desc从大到小排序，即降序

例1：查询学生信息，按学号降序

select * from student order by id desc  

例2：查询学生信息，按名称升序

select * from student order by name asc

例3：显示所有的学生信息，先按照年龄从大-->小排序，当年龄相同时 按照身高从高-->矮排序

select * from student order by age desc,height desc

 

 

聚合函数

 

 

 

1、count函数

 

①count(*)：返回表中满足where条件的行的数量

 

mysql> select count(*) from salary_tab where salary='1000';

+----------+

| count(*) |

+----------+

|        2 |

+----------+

 

mysql> select count(*) from salary_tab;　　#没有条件，默认统计表数据行数

+----------+

| count(*) |

+----------+

|        5 |

+----------+

②count(列)：返回列值非空的行的数量

 

mysql> select count(salary) from salary_tab;

+---------------+

| count(salary) |

+---------------+

|             4 |

+---------------+

③count(distinct 列)：返回列值非空的、并且列值不重复的行的数量

 

mysql> select count(distinct salary) from salary_tab;

+------------------------+

| count(distinct salary) |

+------------------------+

|                      3 |

+------------------------+

④count(expr)：根据表达式统计数据

 

mysql> select * from TT;

+------+------------+

| UNIT | DATE       |

+------+------------+

| a    | 2018-04-03 |

| a    | 2017-12-12 |

| b    | 2018-01-01 |

| b    | 2018-04-03 |

| c    | 2016-06-06 |

| d    | 2018-03-03 |

+------+------------+

6 rows in set (0.00 sec)

 

mysql> select UNIT as '单位',

    ->     COUNT(TO_DAYS(DATE)=TO_DAYS(NOW()) or null) as '今日统计',

    ->     COUNT(YEAR(DATE)=YEAR(NOW()) or null) as '今年统计'

    -> from v_jjd

    -> group by JJDW;

+------+----------+----------+

| 单位  | 今日统计  | 今年统计  |

+------+----------+----------+

| a    |        1 |        1 |

| b    |        1 |        2 |

| c    |        0 |        0 |

| d    |        0 |        1 |

+------+----------+----------+

4 rows in set (0.00 sec)

 

 

2、max和min函数---统计列中的最大最小值

 

mysql> select max(salary) from salary_tab;

+-------------+

| max(salary) |

+-------------+

|     3000.00 |

+-------------+

 

mysql> select min(salary) from salary_tab;

+-------------+

| min(salary) |

+-------------+

|     1000.00 |

+-------------+

注意：如果统计的列中只有NULL值，那么MAX和MIN就返回NULL

 

 

 

3、sum和avg函数---求和与求平均

 

！！表中列值为null的行不参与计算

 

mysql> select sum(salary) from salary_tab;

+-------------+

| sum(salary) |

+-------------+

|     7000.00 |

+-------------+

 

mysql> select avg(salary) from salary_tab;

+-------------+

| avg(salary) |

+-------------+

| 1750.000000 |

+-------------+

 

mysql> select avg(ifnull(salary,0)) from salary_tab;

+-----------------------+

| avg(ifnull(salary,0)) |

+-----------------------+

|           1400.000000 |

+-----------------------+

注意：要想列值为NULL的行也参与组函数的计算，必须使用IFNULL函数对NULL值做转换。

 

 

 

 

 

二、分组SELECT

 

SELECT select_expr [, select_expr ...]

 

    [FROM table_references

 

      [PARTITION partition_list]

 

    [WHERE where_condition]

 

    [GROUP BY {col_name | expr | position}

 

      [ASC | DESC], ... [WITH ROLLUP]]

 

    [HAVING where_condition]

 

    [ORDER BY {col_name | expr | position}

 

      [ASC | DESC], ...]

 

[LIMIT {[offset,] row_count | row_count OFFSET offset}]

分组SELECT的基本格式：

 

　　select [聚合函数] 字段名 from 表名

 

　　　　[where 查询条件]

 

　　　　[group by 字段名]

 

　　　　[having 过滤条件]

 

1、group by子句

 

　　根据给定列或者表达式的每一个不同的值将表中的行分成不同的组，使用组函数返回每一组的统计信息

 

规则：

 

　　①出现在SELECT子句中的单独的列，必须出现在GROUP BY子句中作为分组列

 

　　②分组列可以不出现在SELECT子句中

 

　　③分组列可出现在SELECT子句中的一个复合表达式中

 

　　④如果GROUP BY后面是一个复合表达式，那么在SELECT子句中，它必须整体作为一个表达式的一部分才能使用。

 

1）指定一个列进行分组

 

mysql> select salary,count(*) from salary_tab

    -> where salary>=2000

    -> group by salary;   

+---------+----------+

| salary  | count(*) |

+---------+----------+

| 2000.00 |        1 |

| 3000.00 |        1 |

+---------+----------+

2）指定多个分组列，‘大组中再分小组’

 

mysql> select userid,count(salary) from salary_tab

    -> where salary>=2000

    -> group by salary,userid;   

+--------+---------------+

| userid | count(salary) |

+--------+---------------+

|      2 |             1 |

|      3 |             1 |

+--------+---------------+

3）根据表达式分组

 

mysql> select year(payment_date),count(*)

    -> from PENALTIES

    -> group by year(payment_date);

+--------------------+----------+

| year(payment_date) | count(*) |

+--------------------+----------+

|               1980 |        3 |

|               1981 |        1 |

|               1982 |        1 |

|               1983 |        1 |

|               1984 |        2 |

+--------------------+----------+

5 rows in set (0.00 sec)

4）带有排序的分组：如果分组列和排序列相同，则可以合并group by和order by子句

 

mysql> select teamno,count(*)

    -> from MATCHES

    -> group by teamno

    -> order by teamno desc;

+--------+----------+

| teamno | count(*) |

+--------+----------+

|      2 |        5 |

|      1 |        8 |

+--------+----------+

2 rows in set (0.00 sec)

 

mysql> select teamno,count(*)

    -> from MATCHES

    -> group by teamno desc;　　#可以把desc(或者asc)包含到group by子句中简化

+--------+----------+

| teamno | count(*) |

+--------+----------+

|      2 |        5 |

|      1 |        8 |

+--------+----------+

2 rows in set (0.00 sec)

对于分组聚合注意：

 

　　通过select在返回集字段中，这些字段要么就要包含在group by语句后面，作为分组的依据，要么就要被包含在聚合函数中。我们可以将group by操作想象成如下的一个过程：首先系统根据select语句得到一个结果集，然后根据分组字段，将具有相同分组字段的记录归并成了一条记录。这个时候剩下的那些不存在与group by语句后面作为分组依据的字段就很有可能出现多个值，但是目前一种分组情况只有一条记录，一个数据格是无法放入多个数值的，所以这个时候就需要通过一定的处理将这些多值的列转化成单值，然后将其放在对应的数据格中，那么完成这个步骤的就是前面讲到的聚合函数，这也就是为什么这些函数叫聚合函数了。

 

 

 

2、GROUP_CONCAT()函数

 

　　函数的值等于属于一个组的指定列的所有值，以逗号隔开，并且以字符串表示。

 

例1：对于每个球队，得到其编号和所有球员的编号

 

mysql> select teamno,group_concat(playerno)

    -> from MATCHES

    -> group by teamno;

+--------+------------------------+

| teamno | group_concat(playerno) |

+--------+------------------------+

|      1 | 6,6,6,44,83,2,57,8     |

|      2 | 27,104,112,112,8       |

+--------+------------------------+

2 rows in set (0.01 sec)

如果没有group by子句，group_concat返回一列的所有值

 

例2：得到所有的罚款编号列表

 

mysql> select group_concat(paymentno)

    -> from PENALTIES;

+-------------------------+

| group_concat(paymentno) |

+-------------------------+

| 1,2,3,4,5,6,7,8         |

+-------------------------+

1 row in set (0.00 sec)

 

 

3、with rollup子句：用来要求在一条group by子句中进行多个不同的分组

 

用的比较少点，但是有时可以根据具体的需求使用

 

　　如果有子句GROUP BY E1,E2,E3,E4 WITH ROLLUP

 

　　那么将分别执行以下分组：[E1,E2,E3,E4]、[E1,E2,E3]、[E1,E2]、[E1]、[]

 

注意：[ ]表示所有行都分在一组中

 

示例：按照球员的性别和居住城市，统计球员的总数；统计每个性别球员的总数；统计所有球员的总数

 

mysql> select sex,town,count(*)

    -> from PLAYERS

    -> group by sex,town with rollup;

+-----+-----------+----------+

| sex | town      | count(*) |

+-----+-----------+----------+

| F   | Eltham    |        2 |

| F   | Inglewood |        1 |

| F   | Midhurst  |        1 |

| F   | Plymouth  |        1 |

| F   | NULL      |        5 |

| M   | Douglas   |        1 |

| M   | Inglewood |        1 |

| M   | Stratford |        7 |

| M   | NULL      |        9 |

| NULL | NULL      |       14 |

+-----+-----------+----------+

10 rows in set (0.00 sec)

 

 

4、HAVING子句：对分组结果进行过滤

 

注意：

 

　　不能使用WHERE子句对分组后的结果进行过滤

 

　　不能在WHERE子句中使用组函数，仅用于过滤行

 

mysql> select playerno

    -> from PENALTIES

    -> where count(*)>1

    -> group by playerno;

ERROR 1111 (HY000): Invalid use of group function

因为WHERE子句比GROUP BY先执行，而组函数必须在分完组之后才执行，且分完组后必须使用having子句进行结果集的过滤。

 

基本语法：

 

SELECT   select_expr [, select_expr ...]

 

   FROM  table_name

 

   [WHERE where_condition]

 

   [GROUP BY {col_name | expr} [ASC | DESC], ... [WITH ROLLUP]]

 

[HAVING where_condition]

！！！having子语句与where子语句区别：

 

　　where子句在分组前对记录进行过滤；

 

　　having子句在分组后对记录进行过滤

 

mysql> select salary,count(*) from salary_tab

    -> where salary>=2000

    -> group by salary

    -> having count(*)>=0;

+---------+----------+

| salary  | count(*) |

+---------+----------+

| 2000.00 |        1 |

| 3000.00 |        1 |

+---------+----------+

1）HAVING可以单独使用而不和GROUP BY配合,如果只有HAVING子句而没有GROUP BY，表中所有的行分为一组

 

2）HAVING子句中可以使用组函数

 

3）HAVING子句中的列，要么出现在一个组函数中，要么出现在GROUP BY子句中(否则出错)

 

mysql> select town,count(*)

    -> from PLAYERS

    -> group by town

    -> having birth_date>'1970-01-01';

ERROR 1054 (42S22): Unknown column 'birth_date' in 'having clause'

mysql> select town,count(*)

    -> from PLAYERS

    -> group by town

    -> having town in ('Eltham','Midhurst');

+----------+----------+

| town     | count(*) |

+----------+----------+

| Eltham   |        2 |

| Midhurst |        1 |

+----------+----------+

2 rows in set (0.00 sec)

 

 

limit 分段取值

 

语法 limi m,n

 

m为其实位置，n为取几个

 

select * from student limit 0,2

 

从第一个开始取，取两个，如果不写第一个参数，就是默认从第一个参数取值，取n个

 

select * from student limit 2

 

 

连接查询(join 语法)

 

join 用于多表中字段之间的联系，语法如下：

... FROM table1 INNER|LEFT|RIGHT JOIN table2 ON conditiona

table1:左表；table2:右表。

JOIN 按照功能大致分为如下三类：

INNER JOIN（内连接,或等值连接）：取得两个表中存在连接匹配关系的记录。

LEFT JOIN（左连接）：取得左表（table1）完全记录，即是右表（table2）并无对应匹配记录。

RIGHT JOIN（右连接）：与 LEFT JOIN 相反，取得右表（table2）完全记录，即是左表（table1）并无匹配对应记录。

注意：mysql不支持Full join,不过可以通过UNION 关键字来合并 LEFT JOIN 与 RIGHT JOIN来模拟FULL join.

接下来给出一个列子用于解释下面几种分类。如下两个表(A,B)

  1. mysql> select A.id,A.name,B.name from A,B where A.id=B.id;
  2. +----+-----------+-------------+
  3. | id | name       | name             |
  4. +----+-----------+-------------+
  5. |  1 | Pirate       | Rutabaga      |
  6. |  2 | Monkey    | Pirate            |
  7. |  3 | Ninja         | Darth Vader |
  8. |  4 | Spaghetti  | Ninja             |
  9. +----+-----------+-------------+
  10. 4 rows in set (0.00 sec)

二.Inner join

内连接，也叫等值连接，inner join产生同时符合A和B的一组数据。

  1. mysql> select * from A inner join B on A.name = B.name;
  2. +----+--------+----+--------+
  3. | id | name   | id | name   |
  4. +----+--------+----+--------+
  5. |  1 | Pirate |  2 | Pirate |
  6. |  3 | Ninja  |  4 | Ninja  |
  7. +----+--------+----+--------+

 

三.Left join

  1. mysql> select * from A left join B on A.name = B.name;
  2. #或者：select * from A left outer join B on A.name = B.name;
  4. +----+-----------+------+--------+
  5. | id | name      | id   | name   |
  6. +----+-----------+------+--------+
  7. |  1 | Pirate    |    2 | Pirate |
  8. |  2 | Monkey    | NULL | NULL   |
  9. |  3 | Ninja     |    4 | Ninja  |
  10. |  4 | Spaghetti | NULL | NULL   |
  11. +----+-----------+------+--------+
  12. 4 rows in set (0.00 sec)

left join,（或left outer join:在Mysql中两者等价，推荐使用left join.）左连接从左表(A)产生一套完整的记录,与匹配的记录(右表(B)) .如果没有匹配,右侧将包含null。

 

如果想只从左表(A)中产生一套记录，但不包含右表(B)的记录，可以通过设置where语句来执行，如下：

  1. mysql> select * from A left join B on A.name=B.name where A.id is null or B.id is null;
  2. +----+-----------+------+------+
  3. | id | name      | id   | name |
  4. +----+-----------+------+------+
  5. |  2 | Monkey    | NULL | NULL |
  6. |  4 | Spaghetti | NULL | NULL |
  7. +----+-----------+------+------+
  8. 2 rows in set (0.00 sec)

 

同理，还可以模拟inner join. 如下：

  1. mysql> select * from A left join B on A.name=B.name where A.id is not null and B.id is not null;
  2. +----+--------+------+--------+
  3. | id | name   | id   | name   |
  4. +----+--------+------+--------+
  5. |  1 | Pirate |    2 | Pirate |
  6. |  3 | Ninja  |    4 | Ninja  |
  7. +----+--------+------+--------+
  8. 2 rows in set (0.00 sec)

求差集：

根据上面的例子可以求差集，如下：

  1. SELECT * FROM A LEFT JOIN B ON A.name = B.name
  2. WHERE B.id IS NULL
  3. union
  4. SELECT * FROM A right JOIN B ON A.name = B.name
  5. WHERE A.id IS NULL;
  6. # 结果
  7. +------+-----------+------+-------------+
  8. | id   | name      | id   | name        |
  9. +------+-----------+------+-------------+
  10. |    2 | Monkey    | NULL | NULL        |
  11. |    4 | Spaghetti | NULL | NULL        |
  12. | NULL | NULL      |    1 | Rutabaga    |
  13. | NULL | NULL      |    3 | Darth Vader |
  14. +------+-----------+------+-------------+

 

四.Right join

  1. mysql> select * from A right join B on A.name = B.name;
  2. +------+--------+----+-------------+
  3. | id   | name   | id | name        |
  4. +------+--------+----+-------------+
  5. | NULL | NULL   |  1 | Rutabaga    |
  6. |    1 | Pirate |  2 | Pirate      |
  7. | NULL | NULL   |  3 | Darth Vader |
  8. |    3 | Ninja  |  4 | Ninja       |
  9. +------+--------+----+-------------+
  10. 4 rows in set (0.00 sec)

同left join。

 

 

Mysql建表思路理解

 

一对一   one on one

 

一张表的一条记录一定只能与另外一张表的一条记录进行对应，反之亦然。  学生表：姓名，性别，年龄，身高，体重，籍贯，家庭住址，紧急联系人 其中姓名、性别、年龄、身高，体重属于常用数据，但是籍贯、住址和联系人为不常用数据 如果每次查询都是查询所有数据，不常用的数据就会影响效率，实际又不用 常用信息表：ID(P)，姓名，性别，年龄，身高，体重 不常用信息表：ID(P)，籍贯，家庭住址，紧急联系人  解决方案：将常用的和不常用的信息分享存储，分成两张表 不常用信息表和常用信息表，保证不常用信息表与常用信息表能够对应上：找一个具有唯一性的 字段来共同连接两张表。 一个常用表中的一条记录永远只能在一张不常用表中匹配一条记录，反之亦然。

 

 

 

一对多  one on many

 

 

一张表中有一条记录可以对应另外一张表中的多条记录；但是反过来，另外一张表的一条记录 只能对应第一张表的一条记录，这种关系就是一对多或多对一 母亲与孩子的关系：母亲，孩子两个实体 母亲表：ID(P),名字，年龄，性别 孩子表：ID(P),名字，年龄，性别 以上关系：一个妈妈可以在孩子表中找到多条记录（也可能是一条），但是一个孩子只能找到一个妈妈 是一种典型的一对多的关系。 但是以上设计：解决了实体的设计表问题，但是没有解决关系问题，孩子找不到母亲，母亲也找不到孩子  解决方案：在某一张表中增加一个字段，能够找到另外一张表中的记录:在孩子表中增加一个字段 指向母亲表，因为孩子表的记录只能匹配到一条母亲表的记录。 母亲表：ID(P),名字，年龄，性别 孩子表：ID(P),名字，年龄，性别，母亲表ID（母亲表主键）

 

 

 

 

 

 

多对多 many on many

 

一对表中（A）的一条记录能够对应另外一张表（B）中的多条记录；同时B表中的一条记录 也能对应A表中的多条记录  老师和学生 老师表 T_ID(P),姓名，性别 学生表 S_ID(P),姓名，性别 以上设计方案：实现了实体的设计，但是没有维护实体的关系 一个老师教过多个学生，一个学生也被多个老师教过  解决方案：增加一张中间关系表 老师与学生的关系表：ID(P),T_ID,S_ID  老师表与中间表形成一对多的关系，而中间表是多表；维护了能够唯一找到一表的关系； 同样的学生表与中间表也是一个一对多的关系;  学生找老师：找出学生ID--->中间表寻找匹配记录（多条）--->老师表匹配（一条） 老师找学生：找出老师ID--->中间表寻找匹配记录（多条）--->学生表匹配（一条）

转载于:https://www.cnblogs.com/jiangyijiangPython/p/10003770.html

asa9918
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
防火墙基本介绍及实验（GNS）（ASA的两种工作模式、DMZ隔离区）
LKmnbZ's Blog
01-17 4354
Cisco防火墙简介 硬件与软件防火墙 软件 硬件 ASA安全设备 ASA 5500系列 常见型号 5505、5510、5520、5540、5550、5580 状态化防火墙 状态化防火墙维护一个关于用户信息的连接表，称为Conn表 Conn表中的关键信息 源IP地址 目的IP地址 IP协议(例如TCP或UDP ) IP协议信息(例如TCP/UDP端口号，TCP序列号...
ejercicios_datatables:jQuery 数据表插件练习
06-28
通过插件检查该表是否具有：分页、过滤和按列排序。 指导步骤： 与任何其他 jquery 插件一样，在插件之前加载 jquery 加载插件 (jquery.dataTables.js)。 根据数据表文档，将 jquery 插件与相关表相关联。 通过在...
ASA 防火墙 工作原理与配置实例
weixin_34309543的博客
12-30 1000
ASA是状态化防火墙，会建立一个用户信息连接表（Conn），连接表中包含的相关信息有源IP地址、目的IP地址、IP协议（如TCP或UDP）、IP协议信息（如TCP/UDP的端口号、TCP序列号和TCP控制位）一.工作原理ASA安全算法原理会执行三项基本操作1.访问控制列表—基于特定网络、主机和服务控制网络访问，有两个作用：允许入站连接和控制出站的流量2.连接表—维护每...
思科ASA基础理论与配置
weixin_34221775的博客
12-01 594
思科的ASA防火墙是一个状态化防火墙，维护一个关于用户信息的连接表（conn），默认情况下ASA对TCP和UDP的流量提供状态化连接，对ICMP协议是非状态化的。思科ASA的报文穿越过程如下：一个新来的TCP报文视图建立连接1、ASA检查ACL是否允许连接2、ASA执行路由查询如果有路由则ASA创建一个conn条目3、ASA在检测引擎中检测预定义的一套规则，根据检测引擎检测结...
ASA无法连接小解
zgqtxwd的专栏
04-26 478
<!--google_ad_client = "pub-2947489232296736";/* 728x15, 创建于 08-4-23MSDN */google_ad_slot = "3624277373";google_ad_width = 728;google_ad_height = 15;//--><script type="text/javascript"
oracle多表关联查询创建视图排序,【第31天】Oracle中的分页、联合查询的关键字、序列、视图、表空间...
weixin_39794385的博客
04-14 378
1 伪列与分页1.1 rowid和rownum类似之前说过的伪表(dual)(Oracle中一个不存在的表，只用于测试)，引入一个伪列的概念，意义为假列，根本不存在的列，只在数据库查询表时添加。伪列中的rownum，意为行号(每一行的在表中的序号)，分页的依据。这是Oracle根据查询动态结果动态的编号，用来实现分页查询。是一个有序的整数列，每多一条rownum自动加1。注意，rownum不能和o...
spring-data-jpa 介绍 复杂查询，包括多表关联，分页，排序
愿我如星君如月 ... 夜夜流光相皎洁 ...
12-23 2516
本篇进行Spring-data-jpa的介绍，几乎涵盖该框架的所有方面，在日常的开发当中，基本上能满足所有需求。这里不讲解JPA和Spring-data-jpa单独使用，所有的内容都是在和Spring整合的环境中实现。如果需要了解该框架的入门，百度一下，很多入门的介绍。在这篇文章的接下来一篇，会有一个系列来讲解mybatis，这个系列从mybatis的入门开始，到基本使用，和spring整合，和第...
关于thinkphp union多表关联查询 后排序及分页实现
M.Yang的博客
05-29 6430
遇到的问题：1、union后直接排序或分页报错          Incorrect usage of UNION and ORDER BY?2、fetchSql得到的查询语句是没有"()"括起来的，3、buildSql 得到的查询语句有"()"括起来的；例如：查询语句一：（因为我关联的表有点多，自己适当修改）$matField = "*"   // 查询的字段$matSql = Db::name...
oracle关联查询分页性能优化,分页查询优化--oracle
weixin_31574891的博客
04-11 490
2. 表结构调整以 前该表是一个普通表，没有索引没有PK；后将该表修改为分区表，每一个自然月一个分区。结合这一个应用，页面有3个查询限定条件 (ip，cname，dateCollection ，type为后台隐含条件)，时间条件为必选项，起初只对dateCollection建立索引，但是经过测试发现性能达不到要求(查询第一页的时间在 18~20秒之间)；后来反复查看代码和执行计划发现性能主要消耗在...
Yii关联表的查询和排序
Yaru_so_hard的博客
12-09 710
文章目录介绍需求场景表关系主表：memberinfo表——用户信息表关联一对一关系(hasOne)关联代码：通过中间表，关联多对多关系(via)，实现一对一关联关联代码：via和viaTable关联一对多(hasMony)关联代码：操作步骤Step1:在主表Model(Memberinfo.php)建立关联关系Step2:在SearchModel中添加代码在MemberSearch中添加需要关联的字段要能搜索在MemberinfoSearch中添加关联查询在MemberSearch中添加过滤搜索要能排序St
efadmin:efadmin最初基于eladmin项目改造，实现了CRUD模板，实体属性约束检查，接口国际化，多租户，多条件高级搜索，多表缓存关联一致维护，修改审计等功能
05-13
// 2.1.0+因为使用ejpa框架，在原来的基础上有如下的新特性：更多请参见：基本的CRUD模板，即增删改查操作，此处的查是指正常的分页、排序及id查询；较复杂的多条件的高级查询；提供对持久化实体属性操作检查功能；...
multipleselect：java结合mybatis-plus实现非手写sql多表查询
02-03
多重选择 java mybatis实现简单多表通用查询 ...如何关联表？ 找第一张表注解为TableId（mybatis-plus注解）的属性名，到每二张表查找同样的属性名，如果没找到，反过来找，如果还没找到，挨个属性找。 ，实现关联的条
MySQL从基础到精通视频教程.zip
06-07
08-修改、删除_recv 09-备份与恢复_recv 10-总结_recv 2.MySQL查询 01-复习 02-查询-比较运算符 03-逻辑运算、模糊查询 04-范围、判空 05-聚合函数 06-分组 07-排序 08-分页 09-存储关系 10-建立关系表 11-连接查询 ...
CMEU代码生成器
05-08
生成Mapper映射文件(dao层接口SQL语句,支持生成3表关联(比如：A表关联B表,B表关联C表,一次便可获得3张表的数据),支持主键策略;<如果选择创建Assist支持分页,去重,排序,无注入动态查询等>); 生成service层接口(与dao...
第八章ASA基础
m0_65487180的博客
03-05 491
1.ASA安全设备： ASA 5500系列常见型号： 5505、5510、5520、5540、5550、5580 2.状态化防火墙维护一个关于用户信息的连接表，称为Conn表。 3.Conn表中的关键信息： 源IP地址、目的IP地址、IP协议、IP协议信息 4.ASA使用安全算法执行的基本操作: 1>访问控制列表 2>连接表 3>检测引擎 5.安全算法的原理：*** 建立连接—查询列表—检查（规则）—转发/丢弃—目的主机回应—检查—建立会话 6.接口的名称： 物理名称、逻辑名称
为什么Redis6.0引入了多线程
IT深耕十余载，大道之简
05-11 531
总的来说，Redis 6.0引入多线程是为了提高性能、降低延迟、更好地利用CPU资源，并保持Redis的简单性和高性能特点。这些改进有助于Redis更好地应对不断增长的数据量和并发量需求，同时保持其稳定性和可靠性。Redis 6.0引入多线程的决策是基于其性能优化和适应现代硬件架构的考虑。
实战项目技术点（1）
最新发布
qq_60396437的博客
05-15 1084
分页插件PageHelper 是 Mybatis 的一款功能强大、方便易用的分页插件，支持任何形式的单标、多表的分页查询。官网：https://pagehelper.github.io/。文件上传，是指将本地图片、视频、音频等文件上传到服务器，供其他用户浏览或下载的过程。
简述redis数据类型及应用场景
qq_45927587的博客
05-10 358
每种数据类型的选择应当基于具体的应用需求，比如是否需要排序、是否允许重复元素、是否需要执行集合运算等。Redis作为一种高性能的内存数据存储系统，提供了多种数据结构来满足不同场景下的需求。: 双向链表，可以做栈（LPOP/RPOP）、队列（LPUSH/RPOP）或实现发布/订阅模式。: 最基本的数据类型，可以存储字符串、整数或者浮点数等数据。支持原子性操作，如增、删、改、查。: 无序且不重复的字符串集合，支持集合运算如并集、交集、差集。: 用于存储键值对的集合，每个哈希可以存储多个字段-值对。
pagehelper分页
09-19
另外，PageHelper 还提供了一些高级功能，如多表关联分页、自定义排序等，可以根据具体需求进行使用。 ### 回答2： PageHelper是一个开源的Java分页插件，它可以帮助我们方便地进行数据的分页处理。使用PageHelper...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值