MySQL em 2018:o que há no 8.0 e outras observações

Funções

• 
  mysql.role_edges - Aqui você encontra essas funções e os usuários a elas atribuídas.
  

  mysql> DESC mysql.role_edges;
  +-------------------+---------------+------+-----+---------+-------+
  | Field             | Type          | Null | Key | Default | Extra |
  +-------------------+---------------+------+-----+---------+-------+
  | FROM_HOST         | char(60)      | NO   | PRI |         |       |
  | FROM_USER         | char(32)      | NO   | PRI |         |       |
  | TO_HOST           | char(60)      | NO   | PRI |         |       |
  | TO_USER           | char(32)      | NO   | PRI |         |       |
  | WITH_ADMIN_OPTION | enum('N','Y') | NO   |     | N       |       |
  +-------------------+---------------+------+-----+---------+-------+
  5 rows in set (0.01 sec)

• 
  mysql.default_roles - Armazena quaisquer funções padrão e os usuários atribuídos.
  

  mysql> DESC mysql.default_roles;
  +-------------------+----------+------+-----+---------+-------+
  | Field             | Type     | Null | Key | Default | Extra |
  +-------------------+----------+------+-----+---------+-------+
  | HOST              | char(60) | NO   | PRI |         |       |
  | USER              | char(32) | NO   | PRI |         |       |
  | DEFAULT_ROLE_HOST | char(60) | NO   | PRI | %       |       |
  | DEFAULT_ROLE_USER | char(32) | NO   | PRI |         |       |
  +-------------------+----------+------+-----+---------+-------+
  4 rows in set (0.00 sec)

NoSQL Misturando com SQL - O Armazenamento de Documentos

• O tipo de dados JSON tem suporte desde a versão 5.7.8 do MySQL, mas a versão 8 introduziu melhorias significativas para trabalhar com JSON. Novas funções específicas de JSON junto com 'shorthand ' operadores que podem ser usados ​​no lugar de várias chamadas de função - com resultados/saída iguais.
• Talvez um dos principais benefícios seja você não precisar mais implementar e trabalhar com várias soluções de banco de dados, pois NoSQL, SQL ou uma combinação dos dois são compatíveis com o armazenamento de documentos.
• Uma "DevAPI" fornece recursos de fluxo de trabalho contínuos em um contexto de dados NoSQL (coleções e documentos). (Visite a documentação oficial do guia do usuário DevAPI para obter mais informações).
• Sessões de linha de comando poderosas usando Python, SQL ou Javascript como a linguagem 'shell'.
• Compatível com ACID.
• Explore e descubra rapidamente seus dados sem definir um esquema, como faria em um modelo relacional.

Expressões de tabela comuns (CTEs ou cláusula WITH)

mysql> DESC name;
+--------+-------------+------+-----+---------+-------+
| Field  | Type        | Null | Key | Default | Extra |
+--------+-------------+------+-----+---------+-------+
| f_name | varchar(20) | YES  |     | NULL    |       |
| l_name | varchar(20) | YES  |     | NULL    |       |
+--------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

mysql> SELECT * FROM name;
+--------+------------+
| f_name | l_name     |
+--------+------------+
| Jim    | Dandy      |
| Johhny | Applesauce |
| Ashley | Zerro      |
| Ashton | Zerra      |
| Ashmon | Zerro      |
+--------+------------+
5 rows in set (0.00 sec)

mysql> SELECT *
    -> FROM name
    -> WHERE l_name LIKE 'Z%';
+--------+--------+
| f_name | l_name |
+--------+--------+
| Ashley | Zerro  |
| Ashton | Zerra  |
| Ashmon | Zerro  |
+--------+--------+
3 rows in set (0.00 sec)

 WITH last_Z AS (
           SELECT *
           FROM name
           WHERE l_name LIKE 'Z%')
   SELECT * FROM last_Z;
+--------+--------+
| f_name | l_name |
+--------+--------+
| Ashley | Zerro  |
| Ashton | Zerra  |
| Ashmon | Zerro  |
+--------+--------+
3 rows in set (0.00 sec)

WITH last_Z AS ( 
           SELECT *
           FROM name
           WHERE l_name LIKE 'Z%')
   SELECT f_name, l_name FROM last_Z WHERE l_name LIKE '%a';
+--------+--------+
| f_name | l_name |
+--------+--------+
| Ashton | Zerra  |
+--------+--------+
1 row in set (0.00 sec)

WITH last_Z AS ( 
           SELECT *
           FROM name
           WHERE l_name LIKE 'Z%'),
        best_friend AS (
           SELECT f_name, l_name
           FROM last_Z
           WHERE l_name LIKE '%a')
   SELECT * from best_friend;
+--------+--------+
| f_name | l_name |
+--------+--------+
| Ashton | Zerra  |
+--------+--------+
1 row in set (0.00 sec)

• Outros fornecedores de SQL deram suporte a CTEs (muitos desde versões anteriores em seus ecossistemas individuais) e agora o MySQL 8 fechou a lacuna nessa área.
• Uma inclusão SQL padrão.
• Em alguns casos (quando apropriado), os CTEs são uma opção melhor do que tabelas temporárias, visualizações, tabelas derivadas (ou visualizações em linha) e algumas subconsultas.
• Os CTEs podem fornecer um 'on-the-fly ' conjunto de resultados de cálculos que você pode consultar.
• Um CTE pode fazer referência a si mesmo - conhecido como CTE recursivo (não demonstrado aqui).
• CTEs podem nomear e usar outros CTEs

Funções da janela

mysql> SELECT * FROM pipe_vw;
+---------+-------------+-----------+-------+-------------+------------+----------------+
| pipe_id | pipe_name   | joint_num | heat  | pipe_length | has_degree | wall_thickness |
+---------+-------------+-----------+-------+-------------+------------+----------------+
|     181 | Joint-278   | 39393A    | 9111  |       17.40 |          1 |          0.393 |
|     182 | Joint-8819  | 19393Y    | 9011  |       16.60 |          0 |          0.427 |
|     183 | Joint-9844  | 39393V    | 8171  |       10.40 |          0 |          0.393 |
|     184 | Joint-2528  | 34493U    | 9100  |       11.50 |          1 |          0.427 |
|     185 | Joint-889   | 18393z    | 9159  |       13.00 |          0 |          0.893 |
|     186 | Joint-98434 | 19293Q    | 8174  |        9.13 |          0 |          0.893 |
|     187 | Joint-78344 | 17QTT     | 179   |       44.40 |          1 |          0.893 |
|     188 | Joint-171C  | 34493U    | 17122 |        9.45 |          1 |          0.893 |
|     189 | Joint-68444 | 17297Q    | 6114  |       11.34 |          0 |          0.893 |
|     190 | Joint-4841R | 19395Q    | 5144  |       25.55 |          0 |          0.115 |
|     191 | Joint-1224C | 34493U    | 8575B |       15.22 |          1 |          0.893 |
|     192 | Joint-2138  | 34493C    | 91    |       13.55 |          1 |          0.893 |
|     193 | Joint-122B  | 34493U    | 9100B |        7.78 |          1 |          0.893 |
+---------+-------------+-----------+-------+-------------+------------+----------------+
13 rows in set (0.00 sec)

mysql> SELECT pipe_name, pipe_length,
    -> RANK() OVER(ORDER BY pipe_length DESC) AS long_to_short
    -> FROM pipe_vw;
+-------------+-------------+---------------+
| pipe_name   | pipe_length | long_to_short |
+-------------+-------------+---------------+
| Joint-78344 |       44.40 |             1 |
| Joint-4841R |       25.55 |             2 |
| Joint-278   |       17.40 |             3 |
| Joint-8819  |       16.60 |             4 |
| Joint-1224C |       15.22 |             5 |
| Joint-2138  |       13.55 |             6 |
| Joint-889   |       13.00 |             7 |
| Joint-2528  |       11.50 |             8 |
| Joint-68444 |       11.34 |             9 |
| Joint-9844  |       10.40 |            10 |
| Joint-171C  |        9.45 |            11 |
| Joint-98434 |        9.13 |            12 |
| Joint-122B  |        7.78 |            13 |
+-------------+-------------+---------------+
13 rows in set (0.01 sec)

mysql> SELECT pipe_name, pipe_length, wall_thickness,
    -> RANK() OVER(PARTITION BY wall_thickness ORDER BY pipe_length DESC) AS long_to_short
    -> FROM pipe_vw;
+-------------+-------------+----------------+---------------+
| pipe_name   | pipe_length | wall_thickness | long_to_short |
+-------------+-------------+----------------+---------------+
| Joint-4841R |       25.55 |          0.115 |             1 |
| Joint-278   |       17.40 |          0.393 |             1 |
| Joint-9844  |       10.40 |          0.393 |             2 |
| Joint-8819  |       16.60 |          0.427 |             1 |
| Joint-2528  |       11.50 |          0.427 |             2 |
| Joint-78344 |       44.40 |          0.893 |             1 |
| Joint-1224C |       15.22 |          0.893 |             2 |
| Joint-2138  |       13.55 |          0.893 |             3 |
| Joint-889   |       13.00 |          0.893 |             4 |
| Joint-68444 |       11.34 |          0.893 |             5 |
| Joint-171C  |        9.45 |          0.893 |             6 |
| Joint-98434 |        9.13 |          0.893 |             7 |
| Joint-122B  |        7.78 |          0.893 |             8 |
+-------------+-------------+----------------+---------------+
13 rows in set (0.00 sec)

Suporte e recursos espaciais aprimorados

1. 
   Sistema de Referência Espacial ou SRS - Aqui está uma definição parcial da Wikipedia:
   
   "Um sistema de referência espacial (SRS) ou sistema de referência de coordenadas (CRS) é um sistema local, regional ou global baseado em coordenadas usado para localizar entidades geográficas. Um sistema de referência espacial define uma projeção de mapa específica, bem como transformações entre diferentes referências espaciais. sistemas."
   
2. 
   Identificador do Sistema de Referência Espacial ou SRID - Além disso, a Wikipedia tem SRIDs definidos como tal:
   
   "Um Identificador de Sistema de Referência Espacial (SRID) é um valor exclusivo usado para identificar inequivocamente definições de sistema de coordenadas espaciais projetadas, não projetadas e locais. Esses sistemas de coordenadas formam o coração de todos os aplicativos GIS."
   

Outras observações notáveis

• utf8mb4 agora é o conjunto de caracteres padrão (anteriormente latin1) - Melhor suporte para aqueles que devem ter emojis, além de alguns idiomas...
• Dicionário de dados transacionais - os metadados do MySQL agora são armazenados em tabelas InnoDB.
• Índices invisíveis - Defina a visibilidade de um índice para o otimizador, determinando, em última análise, se adicioná-lo ou removê-lo (o índice) é uma coisa boa ou ruim. Adicionar um índice a uma tabela grande existente pode ser 'caro ' em termos de bloqueio e recursos.
• Índices decrescentes - melhor desempenho em valores indexados que são armazenados em ordem decrescente.
• Instant Add Column - Para alterações de esquema, especifique ALGORITHM=INSTANT nas instruções ALTER TABLE e (se possível para a operação) evite bloqueios de metadados. (Para mais informações, veja este ótimo post do MySQL Server Team, e a seção ALTER TABLE dos documentos oficiais.)

Seção de bônus:algo que eu esperava ver...