¿Cómo utilizar la consulta de índice para crear un índice en la base de datos?

1. El uso razonable de indexes\x0d\Index es una estructura de datos importante en la base de datos y su propósito fundamental es mejorar la eficiencia de las consultas. La mayoría de los productos de bases de datos utilizan ahora la estructura de índice ISAM propuesta por primera vez por IBM. \x0d\El uso de índices debe ser apropiado y los principios de uso son los siguientes: \x0d\Cree índices en columnas que se conectan con frecuencia pero que no están designadas como claves externas, mientras que el optimizador genera automáticamente índices para campos que no se conectan con frecuencia. conectado. \x0d\Crear índices en columnas que se ordenan o agrupan con frecuencia (es decir, agrupar u ordenar por operaciones). \x0d\Cree búsquedas en columnas con muchos valores diferentes que se utilizan a menudo en expresiones condicionales. No cree índices en columnas con pocos valores diferentes. Por ejemplo, solo hay dos valores diferentes en la columna "Sexo" de la tabla de empleados, "Hombre" y "Mujer", por lo que no es necesario crear un índice. Si crea un índice, no solo no mejorará la eficiencia de las consultas, sino que reducirá seriamente la velocidad de actualización. \x0d\Si hay varias columnas para ordenar, se puede crear un índice compuesto en estas columnas. \x0d\Usar herramientas del sistema. Por ejemplo, la base de datos Informix tiene una herramienta tbcheck que puede comprobar índices sospechosos. En algunos servidores de bases de datos, el índice puede no ser válido o la eficiencia de lectura puede verse reducida debido a operaciones frecuentes. Si una consulta que utiliza el índice se ralentiza sin motivo aparente, puede intentar utilizar la herramienta tbcheck para comprobar la integridad del índice. y repararlo si es necesario. Además, cuando una tabla de base de datos actualiza una gran cantidad de datos, eliminar y reconstruir el índice puede mejorar la velocidad de la consulta. \x0d\(1) En las siguientes dos declaraciones de selección: \x0d\SELECT * FROM table1 WHERE field1=0; \x0d\SELECT * FROM table1 WHERE field1gt =0 AND field1=0, entonces la primera declaración de selección debe ser; mucho más eficiente que la segunda declaración de selección, porque la primera condición de la segunda declaración de selección consume muchos recursos del sistema. \x0d\El primer principio: poner la condición más restrictiva primero en la cláusula donde. \x0d\(2) En la siguiente instrucción de selección:\x0d\SELECT * FROM tab WHERE a=? AND b=? AND c=?;\x0d\Si hay un índice (a, b, c), entonces donde El orden de los campos en la cláusula debe ser coherente con el orden de los campos en el índice. \x0d\El segundo principio: el orden de los campos en la cláusula donde debe ser coherente con el orden de los campos en el índice. \x0d\———————————————————————————— \x0d\ Lo siguiente supone que hay un índice único I1 en el campo1 y un índice no índice único I2 en el campo2. \x0d\————————————————————————————— \x0d\(3) SELECCIONE campo3, campo4 DESDE tb DONDE campo1='sdf' Rápido \x0d \SELECT * FROM tb WHERE field1='sdf' es lento[/cci]\x0d\porque este último requiere un paso más de acceso a la tabla ROWID después del escaneo del índice. \x0d\(4) SELECT field3, field4 FROM tb WHERE field1gt; ='sdf' es rápido \x0d\SELECT field3, field4 FROM tb WHERE field1gt; 'sdf' es lento\x0d\ porque el primero puede localizar rápidamente el índice.

\x0d\(5) SELECCIONE campo3, campo4 DESDE tb DONDE campo2 COMO 'R' es rápido \x0d\SELECT campo3, campo4 DESDE tb DONDE campo2 COMO 'R' es lento, \x0d\ porque este último no usa índices. \x0d\(6) Utilice funciones como: \x0d\SELECT campo3, campo4 FROM tb WHERE superior(campo2)='RMN' no utiliza índices. \x0d\ Si una tabla tiene 20.000 registros, se recomienda no utilizar funciones; si una tabla tiene más de 50.000 registros, ¡el uso de funciones está estrictamente prohibido! No hay límite por debajo de 20.000 registros. \x0d\(7) Los valores NULL no se almacenan en el índice, por lo que \x0d\SELECT field3, field4 FROM tb WHERE field2 IS[NOT] NULL no usa el índice. \x0d\(8) Desigualdades como \x0d\SELECT campo3, campo4 FROM tb WHERE campo2!='TOM' no utilizan índices. \x0d\De manera similar, \x0d\SELECT campo3, campo4 DESDE tb DONDE campo2 NO EN('M', 'P') no usa un índice. \x0d\(9) Índice de varias columnas, el índice solo se puede usar cuando la primera columna del índice en la consulta se usa para la condición. \x0d\(10) MAX, MIN y otras funciones utilizan índices. \x0d\SELECT max(field2) FROM tb Por lo tanto, si necesita obtener el máximo, el mínimo, la suma, etc. para un campo, debe agregar un índice. \x0d\Solo use una función agregada a la vez, como: \x0d\SELECT “min”=min(field1), “max”=max(field1) FROM tb \x0d\No es tan bueno como: SELECT “ min”=(SELECT min(field1 ) FROM tb), "max"=(SELECT max(field1) FROM tb)\x0d\(11) El optimizador de consultas no utilizará índices con demasiados valores duplicados. Y debido a que el índice está construido, el índice debe modificarse al modificar el valor del campo, por lo que la operación de actualización del campo es más lenta que sin el índice. \x0d\(12) Si el valor del índice es demasiado grande (como crear un índice en un campo char(40)), causará una gran sobrecarga de E/S (incluso excediendo la sobrecarga de E/S del escaneo de la tabla) . Por lo tanto, intente utilizar índices enteros. Sp_estspace puede calcular la sobrecarga de tablas e índices. \x0d\(13) Para índices de varias columnas, el orden de ORDER BY debe ser coherente con el orden de los campos del índice. \x0d\(14) En sybase, si los campos de ORDER BY forman un índice de clúster, entonces no hay necesidad de realizar ORDER BY. El orden de los registros es coherente con el índice del grupo. \x0d\(15) Unión de varias tablas (el plan de consulta específico debe obtenerse mediante pruebas) \x0d\Intente utilizar campos relacionados en las condiciones de calificación en la cláusula donde e intente colocar los campos relacionados al frente. \x0d\SELECT a.field1, b.field2 FROM a, b WHERE a.field3=b.field3\x0d\field3 Cuando no hay índice: \x0d\Realice un escaneo completo de la tabla en a y los resultados se ordenarán\ x0d\ b Escanee toda la tabla y ordene los resultados \x0d\ combine los resultados. \x0d\Es adecuado para mesas muy pequeñas o mesas enormes.

\x0d\Hay un índice en el campo3\x0d\De acuerdo con el orden de conexión de la tabla, b es la tabla controladora y a es la tabla controlada\x0d\Realice un escaneo completo de la tabla en b\x0d\Realice un escaneo de rango de índice en a\x0d\Si coincide, acceda a \x0d\(16) a través del ID de fila de a para evitar uniones de uno a muchos. Por ejemplo: \x0d\SELECT tb1.field3, tb1.field4, tb2.field2 FROM tb1, tb2 DONDE tb1.field2=tb2.field2 AND tb1.field2='BU1032' AND tb2.field2= 'aaa' \x0d\Not tan bueno como: \x0d\declare @a varchar(80) \x0d\SELECT @a=field2 FROM tb2 WHERE field2='aaa' \x0d\SELECT tb1.field3, tb1.field4, @a FROM tb1 WHERE field2= ' aaa'\x0d \(16) Subconsulta\x0d\El uso existe/no existe en lugar de en/no en operación\x0d\Comparación: \x0d\SELECT a.field1 FROM a WHERE a.field2 IN(SELECT b.field1 FROM b DONDE b.field2 =100) \x0d\SELECT a.field1 DESDE a DONDE EXISTE( SELECCIONE 1 DE b DONDE a.field2=b.field1 Y b.field2=100) \x0d\SELECT campo1 DESDE a DONDE campo1 NO EN( SELECCIONE campo2 DE b ) \x0d\SELECT campo1 DE a DONDE NO EXISTE (SELECCIONE 1 DE b DONDE b.field2=a.field1)\x0d\(17) Las claves primarias y externas se utilizan principalmente para restricciones de datos al crear un primario. key en Sybase, se creará automáticamente un índice, las claves externas no tienen nada que ver con los índices y se deben crear índices para mejorar el rendimiento. \x0d\(18) No indexar un campo de tipo char es peor que no indexar un campo de tipo int. El rendimiento es sólo ligeramente peor después de la indexación. \x0d\(19) Use count(*) en lugar de count(column_name), evite usar count(DISTINCT column_name). \x0d\(20) Intente no utilizar nombres de campos en el lado derecho del signo igual, como por ejemplo: \x0d\SELECT * FROM tb WHERE campo1 = campo3\x0d\(21) Evite utilizar la condición o, porque o No utilizar índices. \x0d\2. Evite el uso de las palabras ordenar por y agrupar por. \x0d\Debido a que el uso de estas dos cláusulas ocupará una gran cantidad de espacio temporal (espacio temporal), si debe usarlas, puede usar vistas o tablas temporales generadas artificialmente. \x0d\Si debe usarlo, primero verifique el tamaño de la memoria y tempdb. \x0d\ Las pruebas han demostrado que es especialmente importante evitar el uso de unir y agrupar en una consulta, ya que la velocidad será muy lenta. \x0d\3. Utilice subconsultas lo menos posible, especialmente subconsultas correlacionadas. Porque esto conducirá a una disminución de la eficiencia. \x0d\La etiqueta de una columna aparece tanto en la consulta principal como en la consulta en la cláusula donde, por lo que es probable que cuando el valor de la columna en la consulta principal cambie, se deba volver a consultar la subconsulta. Cuantos más niveles anidados tenga una consulta, menor será su eficiencia, por lo que se deben evitar las subconsultas tanto como sea posible.

Si una subconsulta es inevitable, filtre tantas filas como sea posible en la subconsulta. \x0d\4． Elimine el acceso secuencial a datos de filas de tablas grandes\x0d\En consultas anidadas, el acceso secuencial a la tabla puede tener un impacto fatal en la eficiencia de la consulta. \x0d\Por ejemplo, utilizando una estrategia de acceso secuencial, una consulta anidada de tres niveles, si cada nivel consulta 1000 filas, esta consulta consultará mil millones de filas de datos. \x0d\La forma principal de evitar esta situación es indexar las columnas unidas. \x0d\Por ejemplo, dos tablas: tabla de estudiantes (número de estudiante, nombre, edad) y tabla de selección de cursos (número de estudiante, número de curso, calificaciones). Si se van a conectar dos tablas, se debe crear un índice en el campo de conexión "número de estudiante". \x0d\También puedes usar uniones para evitar el acceso secuencial. Aunque hay índices en todas las columnas de verificación, algunas formas de cláusulas donde obligan al optimizador a utilizar acceso secuencial. \x0d\La siguiente consulta forzará operaciones secuenciales en la tabla de pedidos: \x0d\SELECT * FROM pedidos WHERE (núm_cliente=104 AND núm_pedido; 1001) O núm_pedido=1008 \x0d\Aunque hay índices creados en núm_cliente y núm_pedido, pero En la declaración anterior, el optimizador aún escanea toda la tabla utilizando rutas de acceso secuenciales. Debido a que esta declaración recupera un conjunto separado de filas, debe cambiarse a la siguiente declaración: \x0d\SELECT * FROM pedidos WHERE núm_cliente=104 AND núm_pedido 1001 \x0d\UNION \x0d\SELECT * FROM pedidos WHERE núm_pedido=1008 \ x0d\Esto permite utilizar la ruta del índice para procesar consultas. \x0d\5. Evite expresiones regulares difíciles Las palabras clave \x0d\MATCHES y LIKE admiten coincidencias con comodines, técnicamente denominadas expresiones regulares. Pero este tipo de emparejamiento requiere mucho tiempo. Por ejemplo: SELECCIONAR * DEL cliente DONDE código postal COMO “98_ _ _” \x0d\ Incluso si se crea un índice en el campo del código postal, en este caso se sigue utilizando el escaneo secuencial. Si la declaración se cambia a SELECT * FROM customer WHERE zipcode gt; "98000", el índice se utilizará para consultar al ejecutar la consulta, lo que obviamente mejorará enormemente la velocidad. \x0d\Además, evite las subcadenas que no comiencen. Por ejemplo, la declaración: SELECT * FROM customer WHERE zipcode[2, 3] > "80" usa una subcadena que no comienza en la cláusula donde, por lo que esta declaración no usa el índice. \x0d\6． Utilice tablas temporales para acelerar las consultas \x0d\ Ordene un subconjunto de la tabla y cree una tabla temporal, lo que a veces puede acelerar las consultas. Ayuda a evitar múltiples operaciones de clasificación y, por lo demás, simplifica el trabajo del optimizador.

Por ejemplo: \x0d\SELECT cust.name,rcvbles.balance,other COLUMNS \x0d\FROM cust,rcvbles \x0d\WHERE cust.customer_id = rcvlbes.customer_id \x0d\AND rcvblls.balancegt;0 \x0d\AND cust. postcodegt ;"98000" \x0d\ORDER BY cust.name \x0d\Si esta consulta se va a ejecutar varias veces en lugar de solo una vez, puede encontrar todos los clientes no pagados en un archivo temporal y ordenarlos por nombre de cliente: \x0d\ SELECCIONE cust.name,rcvbles.balance,otras COLUMNAS \x0d\FROM cust,rcvbles \x0d\WHERE cust.customer_id = rcvlbes.customer_id \x0d\AND rcvblls.balancegt;;0 \x0d\ORDER BY cust. INTO TEMP cust_with_balance \x0d\Luego consulta en la tabla temporal de la siguiente manera: \x0d\SELECT * FROM cust_with_balance \x0d\WHERE postcodegt; "98000" \x0d\Las filas de la tabla temporal son más grandes que las de la tabla principal. Hay menos filas y el orden físico es el orden requerido, lo que reduce la E/S del disco, por lo que la carga de trabajo de consultas se puede reducir considerablemente. \x0d\Nota: La tabla temporal no reflejará la modificación de la tabla principal después de su creación. Cuando los datos de la tabla principal se modifican con frecuencia, tenga cuidado de no perderlos. \x0d\7． Reemplazar el acceso no secuencial con clasificación\x0d\El acceso al disco no secuencial es la operación más lenta, que se manifiesta en el movimiento hacia adelante y hacia atrás del brazo de acceso al disco. La declaración SQL oculta esta situación, lo que nos facilita escribir consultas que requieren acceso a una gran cantidad de páginas no secuenciales al escribir aplicaciones.