MySQL rutinas OJ comunes

Manual de consulta MySQL:

1. Palabras clave comunes:

Priorización:

desde + en + unir + donde + agrupar por + 聚合函数 + tener + seleccionar + diferenciar + ordenar por + límite compensado + partición por

on & where: situaciones en las que se puede usar al mismo tiempo

• El punto fatal de las conexiones izquierda y derecha:

  Al conectar izquierda y derecha, si una fila en la tabla de la izquierda no corresponde a una fila en la tabla de la derecha, mantenga una fila izquierda + información vacía

  Es imposible filtrar una fila con una columna vacía en cul no es nulo

• Ventajas de las uniones internas:

  Filtrar automáticamente las filas que contienen valores nulos

• Al usar join on + where al mismo tiempo:Prepárese para usar información nula

  1. Contiene valores nulos después de unirse
  2. Usar where para filtrar valores nulos

tener: un buen ayudante para el grupo por

• Después de agrupar por, todas las operaciones se basan en la primera fila de cada grupo de forma predeterminada.Si desea ingresar las estadísticas internas de cada grupo, solo puede usar tener

  select * from employees group by emp_no having count(salary) > 15;
  

en y no en: que contiene y no

• en & =：

  //当明确后者的数据集中只有一个数据时，只能使用 = 
  //反之，数据集中有多个元素时使用in
  

La ubicación agregada por distinto:

• Posición básica: después de seleccionar

  //select的执行优先级高于order by高于limit offset
  //所以只要 select 先筛一层，order by再排序，limit offset再筛一层，即可
  

• Ubicación de la función cohesiva: conteo interno ()

  select distinct salary
  from employee e1
  where (select count(distinct salary) from employee e2 where e1.salary < e2.salary) = N-1;
  

La relación entre agrupar por y dividir por:

• Semánticamente:
  1. Enfatice los datos como un todo después de agrupar por: cada movimiento se basa en el primero de un grupo
  2. Énfasis en los datos individuales después de la partición por: una columna se usa para agrupar + clasificar dentro del grupo de acuerdo con otras columnas del grupo
• Sintácticamente:
  1. agrupar por se puede utilizar de forma independiente
  2. La partición por solo se puede usar con funciones integradas y se usa dentro de over()
• Después de agrupar por, la operación de no tener solo muestra la instancia de primera línea para cada grupo:
  

vista:

• Semánticamente: descubra una subtabla, cree una vista para guardarla, que es equivalente a una referencia

  Gramaticalmente: no es necesario agregar la instrucción sql de la subtabla de consulta interna;

  create view view_name as(
  	select * from table1 group by id order by score
  );
  

o y unión:

• Usar o hará que el índice falle y la eficiencia de la búsqueda sea baja cuando la cantidad de datos sea grande
• Por lo general, se recomienda utilizar unión en lugar de o

juntarse():

• Parámetros: múltiples parámetros
• Función: genera el primer parámetro no vacío de izquierda a derecha
• Escenario de aplicación: Sentencia especial de rescisión

Asignación temporal de una fila en la tabla: case

• gramática:

  select (
  case
      when mod(id, 2) == 1 and id != sum then id+1
      when mod(id, 2) == 1 and id == sum then id
      else id-1
  end
  ) student, id
  from seat, (select count(*) sum from seat) sum_table
  

En segundo lugar, el modelo clásico:

Deduplicado/Diferente:

• Método 1: descripción

  select desc salary from salaries order by salary desc;
  

• Houji: grupo por

  select salary from salaries group by salary order by salary desc;
  

• Dentro y fuera del grupo por:

  1. Interior: tener una inspección dominante de múltiples elementos dentro de un grupo
  2. Externo: seleccione dónde unirse domina la revisión de un grupo como un todo como un elemento

Satisfacer el valor máximo: se puede obtener más de una fila

• Satisfacer la singularidad de lo más valioso: clasificar

  select * from employees order by hire_date limit 1;
  

• Satisfacer el mayor valor no es único: en subtabla o = subtabla

  select * from employees where hire_date in (select MAX(hire_date) from employees); 
  
  select * from employees where hire_date = (select MAX(hire_date) from employees); 
  

Rango enésimo:

• rank() over(): el resultado de la clasificación se usa como una subtabla y participa directamente en la consulta

  # rank()效果为 1 1 3
  select * from (select *,rank() over(order by score desc) as 'Rank' from table1) where Rank = n;
  

• dense_rank() over(): El resultado de la clasificación se usa como una subtabla, participando directamente en la consulta, correcto

  # dense_rank()效果为 1 1 2
  select * from (select *,dense_rank() over(order by score desc) as 'Dense_Rank' from table1) where Dense_Rank = n;
  

• row_number (): el resultado de la clasificación se utiliza como una subtabla, participando directamente en la consulta

  # row_number()效果为 1 2 3
  select * from (select *, row_number() over(order by score desc) as 'Row' from table1) where row_number = n;
  

• seleccionar distinto + ordenar por: más consulta de subtabla

  select distinct score from table1 order by score limit 1 offset n-1;
  

• group by + order by: Solo queda un grupo después de group by, y se ejecuta con prioridad sobre order by

  select score from table1 group by score order by score limit 1 offset n-1;
  

• contar + distinto: más consulta de subtabla

  select distinct salary from employee e1
  where (select count(distinct salary) from employee e2 where e1.salary <= e2.salary)=N+1
  

• contar + agrupar por: más consulta de tabla de unión

  select distinct e1.salary
  from employee e1, employee e2
  where e1.salary <= e2.salary
  group by e1.salary
  having count(distinct e2.salary) = N+1
  

Agrupación, consulta de información dentro del grupo:

• Contar con información estadística dentro del grupo:

  select *, count(course) from student group by id having count(course) >= 2;
  

• Ya sea que agrupe por y cuente el conflicto:

  select title, count(title) s from titles group by title having s>1;
  				分组依据列可以是count参数
  # 虽然group by之后非having操作每组都是对组首操作，但是count()等函数是对整组操作
  				组内列也可以是count参数
  select title, count(emp_no) s from titles group by title having s>1;
  

• Agrupación como subtabla: el contenido obtenido por consulta de subtabla no se repetirá por ser la cabecera del grupo

  select Email from Person
  where id in (select id from Person group by email having count(Email) > 1));
  

Información nula en la combinación de varias tablas:

• Use la unión izquierda y derecha + es nulo para resolver el problema de encontrar filas que no sean XXX:

  select * from employee e left join depart d 
  on e.dep_no = d.dep_no and e.emp_no = d.emp_no
  where d.emp_no is null;
  

• El efecto es equivalente a no en

  select * from employee
  where emp_no is not in (select distinct emp_no from depart);
  

• Las uniones izquierda y derecha + no son nulas, cambiar ligeramente la semántica también puede resolver el problema:

  select * from employee e left join depart d 
  on e.dep_no = d.dep_no and e.emp_no != d.emp_no
  where d.emp_no is not null;
  

• Usar con coalesce():

  select s1.id id, coalesce(s2.student, s1.student);
  from seat s1 left join seat s2
  on ((s1.id + 1)^1)-1 = s2.id
  order by s1.id;
  

El número de ocurrencias de un carácter en una cadena

• Concatenación de cadenas:

  concat("MySQL中字符串连接");
  

• Reemplazo de cadena:

  replace(string, 'a', 'b');
  

• Longitud de la cuerda:

  length();
  

• En la cadena, el número de ocurrencias:

  select length(string)-length(replace(string, ',', ''))
  from strings;
  

Rankings empatados y no empatados:

• 1 1 2：rango_denso()

  select dense_rank() over(order by socre) 'dense_rank'
  from table1;
  

• 1 1 3：rango()

  select rank() over(order by desc) 'rank'
  from table1;
  

• 1 2 3：número_fila()

  select rank() over(order by desc) 'row_number'
  from table1;
  

La diferencia entre la consulta de subtabla y la consulta de tabla de unión:

• Consulta de subtabla: tome la información de una fila en esta tabla y compárela fila por fila en otra tabla

  select * 
  from scores s1
  where (select count(distinct salary) from scores s2 where s1.score <= s2.score) = N;
  

• Consulta de tabla conjunta: primero producto cartesiano, luego en filtro y luego extraer información, la información nula también es particularmente útil

  select * 
  from scores s1, scores s2
  where e1.salary <= e2.salary
  group by s1.id 
  having count(distinct e2.salary) = N;