Diretório de artigos
- Tópico 1: Organização da lista de competição
- Tópico 2: Classificação dos principais jogos
- Tópico 3: Análise de cobertura do aplicativo Community Fresh
- Tópico 4: Análise do comportamento de compra do grupo comunitário
- Tópico 5: Conte as ocorrências de caracteres
- Tópico 6: Encontre o produto com mais vendas em cada categoria
- Tópico 7: Encontre o segundo funcionário mais bem pago em cada departamento
- Tópico 8: Análise da Situação de Login do Jogador do Jogo
- Tópico 9: Valor do primeiro pedido do usuário
- Tópico 10: Produtos que participam de atividades promocionais
Tópico 1: Organização da lista de competição
Existe uma tabela easy_competition_list de nomes de times participantes da competição, e os dados na tabela easy_competition_list são os seguintes:
mysql> select * from easy_competition_list;
-- team_name 参数队名
+------------+
| team_name |
+------------+
| 谁与争锋队 |
| 必胜队 |
| 乘风破浪队 |
| 群英汇队 |
| 梦之队 |
+------------+
5 rows in set (0.00 sec)
[Pergunta 1] Cada equipe participante conduzirá uma competição de equipe com outras equipes participantes, e é necessário produzir todas as combinações de situação de jogo das duas equipes participantes (equipe A e equipe B, respectivamente) e organizá-las em ordem crescente de acordo com os nomes das equipes. O conteúdo de saída inclui: Equipe A, Equipe B e os resultados de amostra são os seguintes:
+------------+------------+
| 队伍A | 队伍B |
+------------+------------+
| 乘风破浪队 | 必胜队 |
| 乘风破浪队 | 梦之队 |
| 乘风破浪队 | 群英汇队 |
| 乘风破浪队 | 谁与争锋队 |
| 必胜队 | 梦之队 |
| 必胜队 | 群英汇队 |
| 必胜队 | 谁与争锋队 |
| 梦之队 | 群英汇队 |
| 梦之队 | 谁与争锋队 |
| 群英汇队 | 谁与争锋队 |
+------------+------------+
10 rows in set (0.00 sec)
[Explicação do Tópico 1] Use a junção automática da tabela para garantir que a equipe não corresponda a si mesma conectando os nomes da equipe na forma de < e organize-os em ordem crescente de acordo com os nomes da equipe. O código SQL para esta questão é a seguinte:
mysql> SELECT a.team_name AS 队伍A,b.team_name AS 队伍B FROM easy_competition_list
-> a INNER JOIN easy_competition_list b ON a.team_name < b.team_name ORDER BY 队伍A,队伍B;
Tópico 2: Classificação dos principais jogos
Agora existe uma tabela de classificação de download de jogos easy_game_ranking, os dados da tabela easy_game_ranking são os seguintes:
mysql> SELECT * FROM easy_game_ranking;
-- ① game: 游戏名称 VARCHAR ② category: 游戏类别 VARCHAR ③ downloads: 游戏下载量 INT
+------+----------+-----------+
| game | category | downloads |
+------+----------+-----------+
| A | puzzle | 13628 |
| B | shooting | 2830 |
| C | shooting | 1920 |
| D | action | 23800 |
| E | puzzle | 842 |
| F | shooting | 48201 |
| G | action | 4532 |
| H | puzzle | 1028 |
| I | action | 48910 |
| J | shooting | 342 |
| K | puzzle | 32456 |
| L | action | 2801 |
| M | puzzle | 1248 |
| N | action | 8756 |
+------+----------+-----------+
14 rows in set (0.00 sec)
[Pergunta 2] Consulte os dois melhores jogos em cada categoria por volume de download. O conteúdo de saída inclui: categoria (categoria do jogo), jogo (nome do jogo) e a amostra do resultado é mostrada na figura abaixo:
[Análise da questão 2] Um problema típico de classificação de grupo pode ser realizado usando a função de janela, usando o DENSE_RANK () função Gere os resultados da classificação de cada jogo em cada categoria de jogo e, finalmente, filtre os dados que precisamos através dos resultados da classificação. O código de referência é o seguinte:
-- ① 使用窗口函数+分组聚合
mysql> SELECT category, GROUP_CONCAT(game) as game
-> FROM (SELECT *, DENSE_RANK() OVER (PARTITION BY category ORDER BY downloads DESC) AS 'downloads_rank'
-> FROM easy_game_ranking)
-> AS a
-> WHERE a.downloads_rank < 3
-> GROUP BY category;
-- ② 使用分组聚合+文本字符串处理函数
-- 通过分组统计，在每组内按照游戏下载量降序排列并使用GROUP_CONCAT()函数进行连接，然后使用
-- SUBSTRING_INDEX()函数提取出前两个游戏名称即可得到结果
mysql> SELECT category, SUBSTRING_INDEX(GROUP_CONCAT(game ORDER BY downloads DESC), ',', 2) AS game
-> FROM easy_game_ranking
-> GROUP BY category;
Tópico 3: Análise de cobertura do aplicativo Community Fresh
Existe uma tabela de aplicativos novos da comunidade easy_fresh_food instalada pelos usuários, e os dados na tabela easy_fresh_food são os seguintes:
mysql> SELECT * FROM easy_fresh_food;
-- user_id(用户ID): VARCHAR app(用户安装的社区生鲜App列表): VARCHAR
+---------+-------+
| user_id | app |
+---------+-------+
| u001 | A,B |
| u002 | C,D,A |
| u003 | E |
| u004 | A |
| u005 | F,D |
| u006 | E,G |
| u007 | C,B |
| u008 | H,J |
| u009 | J |
| u010 | A,K,E |
+---------+-------+
10 rows in set (0.00 sec)
[Questão 3] Consultar o número de usuários que instalaram Ao App. A saída inclui: num (o número de usuários), e a amostra do resultado é mostrada na figura abaixo:
[Análise do Tópico 3] Ideia ①: Correspondência difusa, conte enquanto houver um A, você pode usar a palavra-chave like ou a função interna FIND_IN_SET ou INSTR do mysql . Ideia ②: Divida de acordo com ,, divida um dado em várias linhas de dados e conte-os em grupos. O código de referência é o seguinte:
-- 第①种写法: 模糊匹配使用LIKE或者是REGEXP关键字
mysql> SELECT COUNT(*) AS num FROM easy_fresh_food WHERE app LIKE '%A%';
mysql> SELECT COUNT(*) AS num FROM easy_fresh_food WHERE app REGEXP 'A';
-- 第②种写法: 模糊匹配使用mysql内置函数 FIND_IN_SET或者是INSTR
mysql> SELECT SUM(IF(FIND_IN_SET('A', app), 1, 0)) AS num
-> FROM easy_fresh_food;
mysql> SELECT SUM(CASE WHEN INSTR(app, 'A') > 0 THEN 1 ELSE 0 END) AS num
-> FROM easy_fresh_food;
-- 第③种写法: 先将一行数据拆分为多行 然后分组计算
-- 如果 mysql.help_topic 没有权限，可以自己创建一张临时表，用来与要查询的表连接查询
-- 创建临时表，并给临时表添加数据: 注意:
-- 1.临时表必须有一列从 0 或者 1 开始的自增数据
-- 2.临时表表名随意，字段可以只有一个
-- 3.临时表示的数据量必须比 (LENGTH(easy_fresh_food.app)-LENGTH(REPLACE(easy_fresh_food.app, ',', '')) + 1) 的值大
mysql> SELECT *
-> FROM (SELECT
-> SUBSTRING_INDEX(SUBSTRING_INDEX(easy_fresh_food.app, ',', b.help_topic_id + 1), ',', - 1) AS app_name,
-> COUNT(user_id) AS num
-> FROM easy_fresh_food
-> INNER JOIN mysql.help_topic b ON b.help_topic_id < (LENGTH(easy_fresh_food.app) -
-> LENGTH(REPLACE(easy_fresh_food.app, ',', '')) + 1)
-> WHERE `app` <> ''
-> GROUP BY app_name) a
-> WHERE a.app_name = 'A';
+----------+-----+
| app_name | num |
+----------+-----+
| A | 4 |
+----------+-----+
1 row in set (0.00 sec)
Tópico 4: Análise do comportamento de compra do grupo comunitário
Existe uma tabela de pedidos do usuário de compra em grupo da comunidade easy_group_buy, que registra a situação em que os usuários fazem login na página de compra em grupo e geram pedidos por meio de diferentes canais em datas diferentes. Os dados na tabela easy_group_buy são mostrados na tabela a seguir:
mysql> SELECT * FROM easy_group_buy;
-- user_id(用户id):VARCHAR login_source(登录渠道):VARCHAR login_date(登录日期):DATE order_count(产生订单数量):INT
+---------+--------------+------------+-------------+
| user_id | login_source | login_date | order_count |
+---------+--------------+------------+-------------+
| a001 | applet | 2021-03-20 | 1 |
| a002 | application | 2021-03-20 | 0 |
| a003 | web | 2021-03-21 | 0 |
| a002 | application | 2021-03-21 | 2 |
| a001 | applet | 2021-03-21 | 4 |
| a003 | application | 2021-03-22 | 1 |
| a001 | applet | 2021-03-22 | 1 |
| a004 | application | 2021-03-23 | 1 |
+---------+--------------+------------+-------------+
8 rows in set (0.00 sec)
[Título 4-1] Consulte o nome do canal em que cada usuário se conecta pela primeira vez. A saída inclui: user_id (ID do usuário), login_source (canal de login), e o exemplo de resultado é mostrado na figura abaixo:
[Análise da Questão 4-1] Ideia ①: Use a função MIN() para encontrar o tempo de login mais cedo de cada usuário e defina INNER JOIN na tabela original e o horário de login mais antigo de cada usuário para obter o ID do usuário e o canal de login do usuário. Idéia ②: função de janela, o código de referência é o seguinte:
-- 第①种写法
mysql> SELECT a1.user_id, a1.login_source
-> FROM easy_group_buy a1
-> INNER JOIN (SELECT user_id, MIN(login_date) AS first_login_date FROM easy_group_buy GROUP BY user_id) a2
-> ON a1.login_date = a2.first_login_date AND a1.user_id = a2.user_id;
-- 第②种写法
mysql> SELECT user_id, login_source
-> FROM (SELECT user_id, login_source, DENSE_RANK() OVER (PARTITION BY user_id ORDER BY login_date ASC ) AS login_date_rank
-> FROM easy_group_buy) temp_table
-> WHERE temp_table.login_date_rank = 1;
[Título 4-2] Consulte a data de login do usuário e a quantidade cumulativa do pedido. A saída inclui: user_id (ID do usuário), login_date (data de login), total_order_count (quantidade cumulativa do pedido), a amostra do resultado é mostrada na figura abaixo: [Questão 4-2 Análise] Use a
função SUM() para agrupar por usuário ID E classifique de acordo com a data de login, você pode obter a data de login do usuário e a quantidade cumulativa do pedido, envolvendo pontos de conhecimento: função da janela, o código de referência é o seguinte:
mysql> SELECT user_id,
-> login_date,
-> SUM(order_count) OVER (PARTITION BY user_id ORDER BY login_date)
-> AS total_order_count
-> FROM easy_group_buy;
Tópico 5: Conte as ocorrências de caracteres
Existe uma tabela de texto original easy_original_text e os dados da tabela easy_original_text são mostrados na seguinte tabela:
mysql> SELECT * FROM easy_original_text;
-- text_id（文本ID）: VARCHAR text_content（文本内容）: VARCHAR
+---------+--------------+
| text_id | text_content |
+---------+--------------+
| t001 | !**@%& |
| t002 | * |
| t003 | @@!***&* |
| t004 | %&*$@ |
| t005 | ******* |
| t006 | 123456 |
+---------+--------------+
6 rows in set (0.00 sec)
【题目5】Conte o número de ocorrências de símbolos em cada texto . A saída inclui: text_id (ID do texto), num (o número de vezes que o símbolo * aparece), e o exemplo do resultado é mostrado na figura abaixo: [Análise da
Questão 5] Use a função REPLACE() para substituir o texto em o texto com uma string vazia (string vazia O comprimento do texto é 0), a diferença entre o comprimento do texto antes e depois da substituição é o número de ocorrências de * no texto, envolvendo pontos de conhecimento: funções de processamento de string, o código de referência é o seguinte:
mysql> SELECT text_id, LENGTH(text_content) - LENGTH(REPLACE(text_content, '*', '')) AS num
-> FROM easy_original_text table1;
Tópico 6: Encontre o produto com mais vendas em cada categoria
Existe uma tabela de vendas de produtos easy_product_sale, que registra as informações do produto de diferentes categorias de vendas de produtos. Os dados na tabela easy_product_sale são mostrados na tabela a seguir:
mysql> SELECT * FROM easy_product_sale;
-- product_id: 商品ID VARCHAR product_category: 商品类别 VARCHAR sale: 商品销量 INT
+------------+------------------+-------+
| product_id | product_category | sale |
+------------+------------------+-------+
| p001 | c001 | 14600 |
| p002 | c001 | 23300 |
| p003 | c001 | 8000 |
| p004 | c002 | 40800 |
| p005 | c002 | 5300 |
| p006 | c003 | 12900 |
+------------+------------------+-------+
6 rows in set (0.00 sec)
[Questão 6] Consultar as informações do produto com maior volume de vendas de diferentes categorias de produtos. A saída inclui: product_category (categoria de mercadoria), product_id (ID de mercadoria), venda (venda de mercadoria), e o exemplo de resultado é mostrado na figura abaixo: [Análise da Questão 6] Use a função DENSE_RANK()
para gerar uma nova coluna , ou seja, classificação de vendas de diferentes categorias de produtos (sale_rank) e, em seguida, use essa parte como parte interna da subconsulta, filtre os registros com sale_rank=1 até WHERE fora da subconsulta e obtenha as informações do produto com as vendas mais altas de diferentes categorias de produtos. O código de referência é o seguinte:
mysql> SELECT temp_table.product_category, temp_table.product_id, temp_table.sale
-> FROM (SELECT *, DENSE_RANK() OVER (PARTITION BY product_category ORDER BY sale DESC ) AS sale_rank
-> FROM easy_product_sale) temp_table
-> WHERE temp_table.sale_rank = 1;
Tópico 7: Encontre o segundo funcionário mais bem pago em cada departamento
Existe uma tabela de informações do funcionário da empresa easy_employee e os dados na tabela easy_employee são mostrados na tabela a seguir:
mysql> SELECT * FROM easy_employee;
-- employee_id（员工ID）: VARCHAR employee_name（员工姓名）: VARCHAR employee_salary（员工薪资）: INT
-- department（员工所属部门ID）: VARCHAR
+-------------+---------------+-----------------+------------+
| employee_id | employee_name | employee_salary | department |
+-------------+---------------+-----------------+------------+
| a001 | Bob | 7000 | b1 |
| a002 | Jack | 9000 | b1 |
| a003 | Alice | 8000 | b2 |
| a004 | Ben | 5000 | b2 |
| a005 | Candy | 4000 | b2 |
| a006 | Allen | 5000 | b2 |
| a007 | Linda | 10000 | b3 |
+-------------+---------------+-----------------+------------+
7 rows in set (0.00 sec)
Há também uma tabela de informações do departamento easy_department, os dados da tabela easy_department são mostrados na tabela a seguir:
mysql> SELECT * FROM easy_department;
-- department_id（部门ID）: VARCHAR department_name（部门名称）: VARCHAR
+---------------+-----------------+
| department_id | department_name |
+---------------+-----------------+
| b1 | Sales |
| b2 | IT |
| b3 | Product |
+---------------+-----------------+
3 rows in set (0.00 sec)
[Título 7] Consultar as informações do funcionário com o segundo maior salário de cada departamento. A saída inclui: Employees_id (ID do funcionário), Employees_name (nome do funcionário), Employees_salary (salário do funcionário), Department_name (nome do departamento do funcionário), o exemplo de resultado é mostrado na figura abaixo: [Análise do Problema 7] Usando a função de janela, de acordo com o
ID do departamento O grupo é classificado em ordem decrescente de salário do funcionário no grupo e registrado como employee_salary_rank, e employee_salary_rank=2 é usado como a segunda condição de salário mais alta para executar a filtragem WHERE e, em seguida, a tabela processada é conectada à tabela de informações do departamento para associar o nome do departamento. , selecione a coluna desejada para obter o resultado, o código de referência é o seguinte:
mysql> SELECT a2.employee_id, a2.employee_name, a2.employee_salary, easy_department.department_name
-> FROM (SELECT *
-> FROM (SELECT *, RANK() OVER (PARTITION BY department ORDER BY employee_salary DESC ) AS employee_salary_rank
-> FROM easy_employee) AS a1
-> WHERE a1.employee_salary_rank = 2) AS a2
-> INNER JOIN easy_department ON a2.department = easy_department.department_id;
Tópico 8: Análise da Situação de Login do Jogador do Jogo
Existe uma tabela de login do jogador easy_game_login, e os dados na tabela easy_game_login são mostrados na seguinte tabela:
mysql> SELECT * FROM easy_game_login;
-- user_id（玩家ID）: VARCHAR login_time（登录时间）: VARCHAR
+---------+---------------------+
| user_id | login_time |
+---------+---------------------+
| u001 | 2021-03-01 06:01:12 |
| u001 | 2021-03-01 07:14:20 |
| u002 | 2021-03-01 07:20:22 |
| u003 | 2021-03-01 08:22:45 |
| u001 | 2021-03-01 11:10:23 |
| u004 | 2021-03-01 12:00:10 |
| u002 | 2021-03-01 18:03:52 |
| u005 | 2021-03-01 20:10:29 |
| u003 | 2021-03-01 21:11:50 |
+---------+---------------------+
9 rows in set (0.00 sec)
[Título 8-1] Consulte os jogadores que se conectaram ao jogo várias vezes em um dia e o número de vezes que eles se conectaram. A saída inclui: user_id (ID do jogador), login_date (data de login), num (horas de login), e a amostra do resultado é mostrada na figura abaixo: [Análise da Questão 8-1]
Para converter a hora em formato de string, use ESQUERDA A função ( ) intercepta a parte da data e usa HAVING para filtrar jogadores que se conectaram várias vezes em um dia por meio da agregação de grupo. O código de referência é o seguinte:
mysql> SELECT a.user_id, a.login_date, COUNT(a.login_date) AS 'num'
-> FROM (SELECT user_id, LEFT(login_time, 10) AS 'login_date' FROM easy_game_login)
-> AS a
-> GROUP BY a.user_id, a.login_date
-> HAVING COUNT(a.login_date) > 1;
[Pergunta 8-2] Para jogadores que fazem login no jogo várias vezes ao dia, apenas o último registro do dia é pesquisado. A saída inclui: user_id (ID do jogador), login_time (horário de login), e o exemplo de resultado é mostrado na figura abaixo:
[Análise da Questão 8-2] Com base nos jogadores que fizeram login várias vezes em um dia encontrado no anterior pergunta, use A função RANK() seleciona o último registro de acordo com o grupo de usuários e ordenado por tempo. O código de referência é o seguinte:
mysql> SELECT user_id, login_time
-> FROM (SELECT e1.user_id,
-> e1.login_time,
-> RANK() OVER (PARTITION BY e1.user_id,LEFT(login_time, 10) ORDER BY login_time DESC ) AS login_time_rank
-> FROM easy_game_login e1
-> INNER JOIN (
-> SELECT a.user_id, a.login_date
-> FROM (SELECT user_id, LEFT(login_time, 10) AS 'login_date' FROM easy_game_login)
-> AS a
-> GROUP BY a.user_id, a.login_date
-> HAVING COUNT(a.login_date) > 1) e2 ON e1.user_id = e2.user_id AND left(e1.login_time, 10) = e2.login_date) b
-> WHERE b.login_time_rank = 1;
Tópico 9: Valor do primeiro pedido do usuário
Há uma tabela de informações de pedido de compras do usuário easy_user_order no site de comércio eletrônico, que registra as compras do usuário e outras informações relacionadas. Os dados na tabela easy_user_order são mostrados na tabela a seguir:
mysql> SELECT * FROM easy_user_order;
-- user_id（用户ID）：VARCHAR payment（订单金额）：INT paytime（下单时间）：DATETIME
+---------+---------+---------------------+
| user_id | payment | paytime |
+---------+---------+---------------------+
| a001 | 500 | 2021-02-01 13:25:00 |
| a001 | 800 | 2021-02-03 09:10:00 |
| b001 | 150 | 2021-02-03 15:18:00 |
| a002 | 90 | 2021-02-05 08:10:00 |
| a001 | 1050 | 2021-02-06 10:34:00 |
| b001 | 400 | 2021-02-07 18:19:00 |
+---------+---------+---------------------+
6 rows in set (0.00 sec)
[Questão 9] O primeiro pedido do usuário no site de comércio eletrônico (o pedido com o menor tempo de pedido) pode refletir a capacidade de consumo do usuário, sendo necessário contar as informações do primeiro pedido de cada usuário. O conteúdo de saída inclui: user_id (ID do usuário), pagamento (valor do pedido), e a amostra do resultado é mostrada na figura abaixo:
[Análise da Questão 9] Use a função DENSE_RANK() para agrupar por ID do usuário e organizá-los em ordem crescente ordem por padrão por tempo de pedido para obter a classificação de tempo de pedido de cada usuário, consultar fora da subconsulta e filtrar as informações de pedido de cada usuário classificado 1 (ou seja, as informações do primeiro pedido) envolve pontos de conhecimento: subconsulta, função de janela. O código de referência é o seguinte:
mysql> SELECT user_id, payment
-> FROM (SELECT user_id, payment, DENSE_RANK() OVER (PARTITION BY user_id ORDER BY paytime ASC) AS 'paytime_rank'
-> FROM easy_user_order)
-> AS a
-> WHERE a.paytime_rank = 1;
Tópico 10: Produtos que participam de atividades promocionais
Agora existe uma programação de promoção de produto easy_product_promotion e os dados na tabela easy_product_promotion são os seguintes:
mysql> SELECT * FROM easy_product_promotion;
-- commodity_id（商品ID）：VARCHAR start_date（商品优惠活动起始日期）：DATE end_date（商品优惠活动结束日期）：DATE
+--------------+------------+------------+
| commodity_id | start_date | end_date |
+--------------+------------+------------+
| a001 | 2021-01-01 | 2021-01-06 |
| a002 | 2021-01-01 | 2021-01-10 |
| a003 | 2021-01-02 | 2021-01-07 |
| a004 | 2021-01-05 | 2021-01-07 |
| b001 | 2021-01-05 | 2021-01-10 |
| b002 | 2021-01-04 | 2021-01-06 |
| c001 | 2021-01-06 | 2021-01-08 |
| c002 | 2021-01-02 | 2021-01-04 |
| c003 | 2021-01-08 | 2021-01-15 |
+--------------+------------+------------+
9 rows in set (0.00 sec)
[Questão 10] Informe-se sobre os produtos participantes das ações promocionais de 07 de janeiro de 2021 a 09 de janeiro de 2021. A saída inclui: commodity_id (ID da mercadoria) exemplo de resultado conforme mostrado na figura abaixo:
[Análise 10] Esta questão é adequada para usar o método gráfico para enumerar primeiro todas as disposições de tempo possíveis e, em seguida, escrever o código SQL. Suponha que 7 de janeiro de 2021 seja a hora a, 9 de janeiro de 2021 seja a hora b, a hora de início de cada atividade promocional seja s e a hora final seja e, então todas as sequências possíveis são "sabe", "saeb", "asbe" , e "asseb". Pontos de conhecimento envolvidos: julgamento de tempo complexo. O código SQL para esta questão é o seguinte:
mysql> SELECT commodity_id FROM easy_product_promotion
-> WHERE (start_date <= '2021-01-09' AND start_date >= '2021-01-07')
-> OR (end_date <= '2021-01-09' AND end_date >='2021-01-07')
-> OR (start_date >= '2021-01-07' AND end_date <= '2021-01-09')
-> OR (start_date <= '2021-01-07' AND end_date >= '2021-01-09');
Por enquanto, o estudo de hoje acabou. O autor declara aqui que o autor escreve o artigo apenas para aprender e se comunicar, e para que mais leitores que estudam o banco de dados evitem alguns desvios, economizem tempo e não o usem para outros fins. Se houver qualquer violação, entre em contato O blogueiro pode ser excluído. Obrigado por ler esta postagem no blog, espero que este artigo possa se tornar um líder em sua jornada de programação. Leitura feliz!
Um bom livro não cansa de ler cem vezes, e a criança se conhece quando conhece a turma. E se eu quiser ser o menino mais bonito da plateia, devo persistir em adquirir mais conhecimento por meio do aprendizado, mudar meu destino com conhecimento, testemunhar meu crescimento com blogs e provar que trabalho duro com ações. Se meu
blog é útil para você, se você gosta do conteúdo do meu blog, por favor点赞,评论收藏clique em três links! Ouvi dizer que quem gosta não vai ter azar, e vai estar cheio de energia todos os dias! Se você realmente quer se prostituir por nada, desejo-lhe feliz todos os dias, bem-vindo a visitar meu blog com frequência.
Codificar não é fácil, o apoio de todos é a motivação para eu perseverar. Não关注me esqueça depois de gostar!