![image.png](/static/img/d808344917622fed7bd1282253bdcb1e.image.webp)

![image.png](/static/img/28f4bacf018e1dcb2dd5335a2473be39.image.webp)



![image.png](/static/img/4e842842b081f389140727f6c653e86e.image.webp)
```sql

CREATE TABLE Movies (
  movie_id INT PRIMARY KEY,
  title VARCHAR(100)
);

CREATE TABLE Users (
  user_id INT PRIMARY KEY,
  name VARCHAR(100)
);

CREATE TABLE MovieRating (
  movie_id INT,
  user_id INT,
  rating INT,
  created_at DATE,
  PRIMARY KEY (movie_id, user_id)
);


drop table Movies;


INSERT INTO Movies (movie_id, title) VALUES
  (1, 'Avengers'),
  (2, 'Frozen 2'),
  (3, 'Joker');

INSERT INTO Users (user_id, name) VALUES
  (1, 'Daniel'),
  (2, 'Monica'),
  (3, 'Maria'),
  (4, 'James');

INSERT INTO MovieRating (movie_id, user_id, rating, created_at) VALUES
  (1, 1, 3, '2020-01-12'),
  (1, 2, 4, '2020-02-11'),
  (1, 3, 2, '2020-02-12'),
  (1, 4, 1, '2020-01-01'),
  (2, 1, 5, '2020-02-17'),
  (2, 2, 2, '2020-02-01'),
  (2, 3, 2, '2020-03-01'),
  (3, 1, 3, '2020-02-22'),
  (3, 2, 4, '2020-02-25');


select r1.results from (

select u.name as results from  Users as u left join MovieRating as  m on
 u.user_id=m.user_id
group by u.user_id,u.name
order by count(u.user_id) desc,u.name asc
limit 1

) as r1

union all

select r2.results from (
  select m2.title as results from
  Movies as m2 left join MovieRating as m on
  m.movie_id=m2.movie_id
  and m.created_at like '2020-02%'
  group by m2.title
  order by avg(m.rating) desc,m2.title asc
  limit 1
) r2;





-- 查找评论电影数量最多的用户名
SELECT u.name AS results
FROM Users u
JOIN (SELECT user_id, COUNT(DISTINCT movie_id) AS num_movies
FROM MovieRating GROUP BY user_id
HAVING num_movies = (SELECT MAX(num_movies)
FROM (SELECT COUNT(DISTINCT movie_id) AS num_movies
FROM MovieRating GROUP BY user_id) t)) m ON u.user_id = m.user_id
ORDER BY u.name
LIMIT 1;


SELECT m.title AS results
FROM Movies m
JOIN (
    SELECT movie_id, AVG(rating) AS avg_rating
    FROM MovieRating
    WHERE created_at >= '2020-02-01' AND created_at < '2020-03-01'
    GROUP BY movie_id
    HAVING avg_rating = (
        SELECT MAX(avg_rating)
        FROM (
            SELECT movie_id, AVG(rating) AS avg_rating
            FROM MovieRating
            WHERE created_at >= '2020-02-01' AND created_at < '2020-03-01'
            GROUP BY movie_id
        ) t
    )
) r ON m.movie_id = r.movie_id
ORDER BY m.title
LIMIT 1;



SELECT results
FROM (
  SELECT name AS results, RANK() OVER(ORDER BY COUNT(*) DESC, name) AS RANKING
  FROM Users
  INNER JOIN MovieRating USING(user_id)
  GROUP BY user_id
  UNION ALL
  SELECT title AS results, RANK() OVER(ORDER BY AVG(rating) DESC, title) AS RANKING
  FROM MovieRating
  INNER JOIN Movies USING(movie_id)
  WHERE DATE_FORMAT(created_at, '%Y-%m') = '2020-02'
  GROUP BY movie_id
) T
WHERE T.RANKING = 1

```
## 窗口函数。
第一个子查询选择的是评论电影数量最多的用户名。通过内连接（INNER JOIN）Users和MovieRating表，使用user_id进行连接，并使用GROUP BY对user_id进行分组。然后使用RANK() OVER进行排名，根据评论数量降序排列，并根据用户名的字典序升序排列（如果评论数量相同）。
第二个子查询选择的是在2020年2月份平均评分最高的电影名称。通过内连接Movies和MovieRating表，使用movie_id进行连接，并使用WHERE子句筛选出2020年2月份的数据。然后使用GROUP BY对movie_id进行分组，计算平均评分。再使用RANK() OVER进行排名，根据平均评分降序排列，并根据电影名称的字典序升序排列（如果平均评分相同）。

![image.png](/static/img/45d64f3c89509e6e88547d70ffa6d501.image.webp)

![image.png](/static/img/cb684c2efc64b30db80b81e090e12618.image.webp)

```sql
CREATE TABLE Employees (
  id INT PRIMARY KEY,
  name VARCHAR(100)
);

CREATE TABLE EmployeeUNI (
  id INT,
  unique_id INT,
  PRIMARY KEY (id, unique_id)
);



INSERT INTO Employees (id, name) VALUES
  (1, 'Alice'),
  (7, 'Bob'),
  (11, 'Meir'),
  (90, 'Winston'),
  (3, 'Jonathan');

INSERT INTO EmployeeUNI (id, unique_id) VALUES
  (3, 1),
  (11, 2),
  (90, 3);


select unique_id,name from
Employees as e1 left join
EmployeeUNI as e2 on e1.id=e2.id ;
```

SQL语句练习18号

```go
// Copyright 2022 <mzh.scnu@qq.com>. All rights reserved. 
 // Use of this source code is governed by a BSD-style 
 // license that can be found in the LICENSE file. 
  
 package main 
  
 import ( 
         "flag" 
         "fmt" 
         "strings" 
  
         "google.golang.org/protobuf/compiler/protogen" 
 ) 
  
 func main() { 
         g := rpc{} 
  
         var flags flag.FlagSet 
         genCli := flags.Bool("gen-cli", false, "--tinyrpc_out=gen-cli=true:.") 
  
         protogen.Options{ 
                 ParamFunc: flags.Set, 
         }.Run(func(p *protogen.Plugin) error { 
                 err := g.Generate(p) 
                 if err != nil { 
                         return err 
                 } 
                 if *genCli { 
                         return generateCli(p) 
                 } 
                 return nil 
         }) 
 } 
  
 type rpc struct{} 
  
 // Generate generate service code 
 func (md *rpc) Generate(plugin *protogen.Plugin) error { 
         for _, f := range plugin.Files { 
                 if len(f.Services) == 0 { 
                         continue 
                 } 
                 fileName := f.GeneratedFilenamePrefix + ".svr.go" 
                 t := plugin.NewGeneratedFile(fileName, f.GoImportPath) 
                 t.P("// Code generated by protoc-gen-tinyrpc.") 
                 t.P() 
                 pkg := fmt.Sprintf("package %s", f.GoPackageName) 
                 t.P(pkg) 
                 t.P() 
                 for _, s := range f.Services { 
                         serviceCode := fmt.Sprintf(`%stype %s struct{}`, 
                                 getComments(s.Comments), s.Desc.Name()) 
                         t.P(serviceCode) 
                         t.P() 
                         for _, m := range s.Methods { 
                                 funcCode := fmt.Sprintf(`%sfunc(this *%s) %s(args *%s,reply *%s)error{ 
                                         // define your service ... 
                                         return nil 
                                 } 
                                 `, getComments(m.Comments), s.Desc.Name(), 
                                         m.Desc.Name(), m.Input.Desc.Name(), m.Output.Desc.Name()) 
                                 t.P(funcCode) 
                         } 
                 } 
         } 
         return nil 
 } 
  
 func generateCli(plugin *protogen.Plugin) error { 
         for _, f := range plugin.Files { 
                 if len(f.Services) == 0 { 
                         continue 
                 } 
                 fileName := f.GeneratedFilenamePrefix + ".cli.go" 
                 t := plugin.NewGeneratedFile(fileName, f.GoImportPath) 
                 t.P("// Code generated by protoc-gen-tinyrpc. DO NOT EDIT.") 
                 t.P() 
                 pkg := fmt.Sprintf("package %s", f.GoPackageName) 
                 t.P(pkg) 
                 t.P() 
                 importCode := `import ( 
                 "github.com/zehuamama/tinyrpc" 
                 "net" 
                 )` 
                 t.P(importCode) 
                 t.P() 
                 for _, s := range f.Services { 
                         clientCode := fmt.Sprintf(`%stype %sClient struct{ 
                                 client *tinyrpc.Client 
                         } 
                         `, 
                                 getComments(s.Comments), s.Desc.Name()) 
                         t.P(clientCode) 
                         t.P() 
                         newClientCode := fmt.Sprintf(`func New%sClient(conn net.Conn) %sClient { 
                                 return %sClient{client: tinyrpc.NewClient(conn)} 
                         } 
                         `, 
                                 s.Desc.Name(), s.Desc.Name(), s.Desc.Name()) 
                         t.P(newClientCode) 
                         t.P() 
                         for _, m := range s.Methods { 
                                 funcCode := fmt.Sprintf(`%sfunc(this *%sClient) %s(args *%s,reply *%s)error{ 
                                         return this.client.Call("%s.%s", args, reply) 
                                 } 
                                 `, getComments(m.Comments), s.Desc.Name(), 
                                         m.Desc.Name(), m.Input.Desc.Name(), m.Output.Desc.Name(), s.Desc.Name(), m.Desc.Name()) 
                                 t.P(funcCode) 
                         } 
                 } 
         } 
         return nil 
 } 
  
 // getComments get comment details 
 func getComments(comments protogen.CommentSet) string { 
         c := make([]string, 0) 
         c = append(c, strings.Split(string(comments.Leading), "\n")...) 
         c = append(c, strings.Split(string(comments.Trailing), "\n")...) 
  
         res := "" 
         for _, comment := range c { 
                 if strings.TrimSpace(comment) == "" { 
                         continue 
                 } 
                 res += "//" + comment + "\n" 
         } 
         return res 
 }

```

mrpc代码生成工具

grpc利用proto进行代码生成

## RPC框架的重试制度



当调用端发起请求失败时，我们希望RPC框架自身发起一个重试行为，重新发送请求，是否开启重试和重试次数是可配置的。

![image.png](/static/img/44004333f4cb359a0ebaa8f87b045dfa.image.webp)
一般只有网络超时或者连接失败异常才会进行重试。

每次重试需要对请求超时时间重置。重试的时候保证不会选择上一个出现问题的节点

重试白名单：在白名单里的异常才能被重试，其他的不行。因为有些业务异常也需要重试。

![image.png](/static/img/f792ec345ce39210c112573b67b21e05.image.webp)

异常重试

## 实现一个自适应的负载均衡策略
不进行自适应，出现以下情况，可以提前设置权重。但是我们可能增加服务实例，性能忽高忽低，当然可以热加载配置。如果是某台服务器示例在工作中突然应为某些影响，性能降低或者反应迟缓但是还能工作，这时候就需要一种自适应的策略来对他进行降低权重。保持服务的高可用。
![image.png](/static/img/7238d617ed0a20531ceba518e5667517.image.webp)



#### 简单web应用的负载均衡

![image.png](/static/img/7f226be30527ea18596a9b344d053a55.image.webp)

负载均衡分为软负载和硬负载，软负载就是通过安装负载均衡的软件，LVS,Nginx,硬负载就是通过硬件设备进行负载均衡

硬负载负载均衡是一种负载均衡技术，它使用物理设备或专用硬件来分发网络流量。相对于软负载均衡，硬负载均衡依赖于专门设计的硬件设备来处理负载均衡任务，因此可以提供更高的性能和吞吐量。

硬负载均衡器通常是专门的硬件设备，如负载均衡交换机或负载均衡硬件设备。它们具有专用的硬件处理器、高速缓存和网络接口，可以处理大量的网络流量并快速地进行请求分发。

硬负载均衡器通常具有以下特点：

1. **高性能和可扩展性**：硬负载均衡器使用专门的硬件组件和高速处理器，可以处理大量的并发请求并快速地进行负载均衡。它们通常具有良好的可扩展性，可以适应高流量和大规模的网络环境。

2. **高可用性和可靠性**：硬负载均衡器通常具有冗余设计和故障转移功能，以确保在硬件故障或网络中断的情况下，负载均衡服务的连续运行。它们可以检测到故障并自动切换到备份节点，从而提供高可用性和可靠性。

3. **专用负载均衡算法**：硬负载均衡器通常提供多种负载均衡算法，如轮询、加权轮询、最少连接等，以根据特定的需求和配置选择合适的负载均衡策略。

4. **协议支持**：硬负载均衡器通常支持多种协议，如TCP、HTTP、HTTPS等，以适应不同类型的应用和服务。

硬负载均衡器适用于高流量、对性能要求较高的场景，如大型网站、云计算环境、高并发的分布式应用等。它们通过专用的硬件资源和优化的负载均衡算法，可以提供高效、可靠和可扩展的负载均衡服务。

## RPC负载均衡
传统web负载均衡性能损失大。

![image.png](/static/img/e421aebcb9cedb0d375894fd293f62ac.image.webp)

RPC的负载均衡由框架自主实现

![image.png](/static/img/7803c2075ee7f6c98c846165b9ac2abb.image.webp)

![image.png](/static/img/870d5250f6b50518a8ae2e84a4d11a49.image.webp)

![image.png](/static/img/f82a957b24beeac21ddbfbf1e14dd308.image.webp)

自适应主要就是通过打分动态进行设置权重。

路由策略进行路由分组，负载均衡在某一组中选择一台机器。