21. VISTAS (VIEWS) Las vistas (incluyendo vistas actualizables

21. VISTAS (VIEWS)
Las vistas (incluyendo vistas actualizables) fueron introducidas en la versión 5.0 del servidor de base de
datos MySQL
En este capítulo se tratan los siguientes temas:
·
Creación o modificación de vistas con CREATE VIEW o ALTER VIEW
·
Eliminación de vistas con DROP VIEW
·
Obtención de información de definición de una vista (metadatos) con SHOW CREATE VIEW
Para obtener información sobre las restricciones en el uso de vistas consulte Apéndice H, Restricciones en
características de MySQL.
Si ha actualizado a MySQL 5.0.1 desde una versión anterior, debería actualizar las tablas de permisos para
que contengan los privilegios relacionados con vistas. Consulte Sección 2.10.2, “Aumentar la versión de las
tablas de privilegios”.
21.1. Sintaxis de ALTER VIEW
ALTER [ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]
VIEW nombre_vista [(columnas)]
AS sentencia_select
[WITH [CASCADED | LOCAL] CHECK OPTION]
Esta sentencia modifica la definición de una vista existente. La sintaxis es semejante a la empleada en
CREATE VIEW. Consulte Sección 21.2, “Sintaxis de CREATE VIEW”. Se requiere que posea los permisos
CREATE VIEW y DELETE para la vista, y algún privilegio en cada columna seleccionada por la sentencia
SELECT.
Esta sentencia se introdujo en MySQL 5.0.1.
21.2. Sintaxis de CREATE VIEW
CREATE [OR REPLACE] [ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]
VIEW nombre_vista [(columnas)]
AS sentencia_select
[WITH [CASCADED | LOCAL] CHECK OPTION]
Esta sentencia crea una vista nueva o reemplaza una existente si se incluye la cláusula OR REPLACE. La
sentencia_select es una sentencia SELECT que proporciona la definición de la vista. Puede estar dirigida a
tablas de la base o a otras vistas.
Se requiere que posea el permiso CREATE VIEW para la vista, y algún privilegio en cada columna
seleccionada por la sentencia SELECT. Para columnas incluidas en otra parte de la sentencia SELECT
debe poseer el privilegio SELECT. Si está presente la cláusula OR REPLACE, también deberá tenerse el
privilegio DELETE para la vista.
Toda vista pertenece a una base de datos. Por defecto, las vistas se crean en la base de datos actual.
Pera crear una vista en una base de datos específica, indíquela con base_de_datos.nombre_vista al
momento de crearla.
mysql> CREATE VIEW test.v AS SELECT * FROM t;
Las tablas y las vistas comparten el mismo espacio de nombres en la base de datos, por eso, una base de
datos no puede contener una tabla y una vista con el mismo nombre.
Al igual que las tablas, las vistas no pueden tener nombres de columnas duplicados. Por defecto, los
nombres de las columnas devueltos por la sentencia SELECT se usan para las columnas de la vista . Para
dar explícitamente un nombre a las columnas de la vista utilice la clásula columnas para indicar una lista de
nombres separados con comas. La cantidad de nombres indicados en columnas debe ser igual a la
cantidad de columnas devueltas por la sentencia SELECT.
Las columnas devueltas por la sentencia SELECT pueden ser simples referencias a columnas de la tabla,
pero tambien pueden ser expresiones conteniendo funciones, constantes, operadores, etc.
Los nombres de tablas o vistas sin calificar en la sentencia SELECT se interpretan como pertenecientes a
la base de datos actual. Una vista puede hacer referencia a tablas o vistas en otras bases de datos
precediendo el nombre de la tabla o vista con el nombre de la base de datos apropiada.
Las vistas pueden crearse a partir de varios tipos de sentencias SELECT. Pueden hacer referencia a tablas
o a otras vistas. Pueden usar combinaciones, UNION, y subconsultas. El SELECT inclusive no necesita
hacer referencia a otras tablas. En el siguiente ejemplo se define una vista que selecciona dos columnas
de otra tabla, así como una expresión calculada a partir de ellas:
mysql> CREATE TABLE t (qty INT, price INT);
mysql> INSERT INTO t VALUES(3, 50);
mysql> CREATE VIEW v AS SELECT qty, price, qty*price AS value FROM t;
mysql> SELECT * FROM v;
+------+-------+-------+
| qty | price | value |
+------+-------+-------+
|
3|
50 | 150 |
+------+-------+-------+
La definición de una vista está sujeta a las siguientes limitaciones:
·
La sentencia SELECT no puede contener una subconsulta en su cláusula FROM.
·
La sentencia SELECT no puede hacer referencia a variables del sistema o del usuario.
·
La sentencia SELECT no puede hacer referencia a parámetros de sentencia preparados.
·
Dentro de una rutina almacenada, la definición no puede hacer referencia a parámetros de la rutina
o a variables locales.
·
Cualquier tabla o vista referenciada por la definición debe existir. Sin embargo, es posible que
después de crear una vista, se elimine alguna tabla o vista a la que se hace referencia. Para
comprobar la definición de una vista en busca de problemas de este tipo, utilice la sentencia
CHECK TABLE.
·
La definición no puede hacer referencia a una tabla TEMPORARY, y tampoco se puede crear una
vista TEMPORARY.
·
Las tablas mencionadas en la definición de la vista deben existir siempre.
·
No se puede asociar un disparador con una vista.
En la definición de una vista está permitido ORDER BY, pero es ignorado si se seleccionan columnas de
una vista que tiene su propio ORDER BY.
Con respecto a otras opciones o cláusulas incluidas en la definición, las mismas se agregan a las opciones
o cláusulas de cualquier sentencia que haga referencia a la vista creada, pero el efecto es indefinido. Por
ejemplo, si la definición de una vista incluye una cláusula LIMIT, y se hace una selección desde la vista
utilizando una sentencia que tiene su propia cláusula LIMIT, no está definido cuál se aplicará. El mismo
principio se extiende a otras opciones como ALL, DISTINCT, o SQL_SMALL_RESULT que se ubican a
continuación de la palabra reservada SELECT, y a cláusulas como INTO, FOR UPDATE, LOCK IN SHARE
MODE, y PROCEDURE.
Si se crea una vista y luego se modifica el entorno de proceso de la consulta a traves de la modificación de
variables del sistema, puede afectar los resultados devueltos por la vista:
mysql> CREATE VIEW v AS SELECT CHARSET(CHAR(65)), COLLATION(CHAR(65));
Query OK, 0 rows affected (0.00 sec)
mysql> SET NAMES 'latin1';
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT * FROM v;
+-------------------+---------------------+
| CHARSET(CHAR(65)) | COLLATION(CHAR(65)) |
+-------------------+---------------------+
| latin1
| latin1_swedish_ci |
+-------------------+---------------------+
1 row in set (0.00 sec)
mysql> SET NAMES 'utf8';
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT * FROM v;
+-------------------+---------------------+
| CHARSET(CHAR(65)) | COLLATION(CHAR(65)) |
+-------------------+---------------------+
| utf8
| utf8_general_ci
|
+-------------------+---------------------+
1 row in set (0.00 sec)
La cláusula opcional ALGORITHM es una extensión de MySQL al SQL estándar. ALGORITHM puede
tomar tres valores: MERGE, TEMPTABLE, o UNDEFINED. El algoritmo por defecto es UNDEFINED si no
se encuentra presente la cláusula ALGORITHM. El algoritmo afecta la manera en que MySQL procesa la
vista.
Para MERGE, el texto de una sentencia que haga referencia a la vista y la definición de la vista son
mezclados de forma que parte de la definición de la vista reemplaza las partes correspondientes de la
consulta.
Para TEMPTABLE, los resultados devueltos por la vista son colocados en una tabla temporal, la cual es
luego utilizada para ejecutar la sentencia.
Para UNDEFINED, MySQL determina el algoritmo que utilizará. En ese caso se prefiere MERGE por sobre
TEMPTABLE si es posible, ya que MERGE por lo general es más eficiente y porque la vista no puede ser
actualizable si se emplea una tabla temporal.
Una razón para elegir explícitamente TEMPTABLE es que los bloqueos en tablas subyacentes pueden ser
liberados despues que la tabla temporal fue creada, y antes de que sea usada para terminar el
procesamiento de la sentencia. Esto podría resultar en una liberación del bloqueo más rápida que en el
algoritmo MERGE, de modo que otros clientes que utilicen la vista no estarán bloqueados mucho tiempo.
El algoritmo de una vista puede ser UNDEFINED en tres situaciones:
·
No se encuentra presente una cláusula ALGORITHMen la sentencia CREATE VIEW.
·
La sentencia CREATE VIEW tiene explícitamente una cláusula ALGORITHM = UNDEFINED.
·
Se especificó ALGORITHM = MERGE para una vista que solamente puede ser procesada usando
una tabla temporal. En este caso, MySQL emite una advertencia y establece el algoritmo en
UNDEFINED.
Como se dijo anteriormente, MERGE provoca que las partes correspondientes de la definición de la vista
se combinen dentro de la sentencia que hace referencia a la vista. El siguiente ejemplo muestra
brevemente cómo funciona el algoritmo MERGE. El ejemplo asume que hay una vista v_merge con esta
definición:
CREATE ALGORITHM = MERGE VIEW v_merge (vc1, vc2) AS
SELECT c1, c2 FROM t WHERE c3 > 100;
Ejemplo 1: Suponiendo que se utilice esta sentencia:
SELECT * FROM v_merge;
MySQL la gestiona del siguiente modo:
·
v_merge se convierte en t
·
* se convierte en vc1, vc2, que corresponden a c1, c2
·
Se agrega la cláusula WHERE de la vista
La sentencia ejecutada resulta ser:
SELECT c1, c2 FROM t WHERE c3 > 100;
Ejemplo 2: Suponiendo que se utilice esta sentencia:
SELECT * FROM v_merge WHERE vc1 < 100;
Esta sentencia se gestiona en forma similar a la anterior, a excepción de que vc1 < 100 se convierte en c1
< 100 y la cláusula WHERE de la vista se agrega a la cláusula WHERE de la sentencia empleando un
conector AND (y se agregan paréntesis para asegurarse que las partes de la cláusula se ejecutarán en el
orden de precedencia correcto). La sentencia ejecutada resulta ser:
SELECT c1, c2 FROM t WHERE (c3 > 100) AND (c1 < 100);
Necesariamente, la sentencia a ejecutar tiene una cláusula WHERE con esta forma:
WHERE (WHERE de la sentencia) AND (WHERE de la vista)
El algoritmo MERGE necesita una relación uno-a-uno entre los registros de la vista y los registros de la
tabla subyacente. Si esta relación no se sostiene, debe emplear una tabla temporal en su lugar. No se
tendrá una relación uno-a-uno si la vista contiene cualquiera de estos elementos:
·
Funciones agregadas (SUM(), MIN(), MAX(), COUNT(), etcétera)
·
DISTINCT
·
GROUP BY
·
HAVING
·
UNION o UNION ALL
·
Hace referencia solamente a valores literales (en tal caso, no hay una tabla subyacente)
Algunas vistas son actualizables. Esto significa que se las puede emplear en sentencias como UPDATE,
DELETE, o INSERT para actualizar el contenido de la tabla subyacente. Para que una vista sea
actualizable, debe haber una relación uno-a-uno entre los registros de la vista y los registros de la tabla
subyacente. Hay otros elementos que impiden que una vista sea actualizable. Más específicamente, una
vista no será actualizable si contiene:
·
Funciones agregadas (SUM(), MIN(), MAX(), COUNT(), etcétera)
·
DISTINCT
·
GROUP BY
·
HAVING
·
UNION o UNION ALL
·
Una subconsulta en la lista de columnas del SELECT
·
Join
·
Una vista no actualizable en la cláusula FROM
·
Una subconsulta en la cláusula WHERE que hace referencia a una tabla en la cláusula FROM
·
Hace referencia solamente a valores literales (en tal caso no hay una) tabla subyacenta para
actualizar.
·
ALGORITHM = TEMPTABLE (utilizar una tabla temporal siempre resulta en una vista no
actualizable)
Con respecto a la posibilidad de agregar registros mediante sentencias INSERT, es necesario que las
columnas de la vista actualizable también cumplan los siguientes requisitos adicionales:
·
No debe haber nombres duplicados entre las columnas de la vista.
·
La vista debe contemplar todas las columnas de la tabla en la base de datos que no tengan
indicado un valor por defecto.
·
Las columnas de la vista deben ser referencias a columnas simples y no columnas derivadas. Una
columna derivada es una que deriva de una expresión. Estos son algunos ejemplos de columnas
derivadas:
·
3.14159
·
col1 + 3
·
UPPER(col2)
·
col3 / col4
·
(subquery)
No puede insertar registros en una vista conteniendo una combinación de columnas simples y derivadas,
pero puede actualizarla si actualiza únicamente las columnas no derivadas. Considere esta vista:
CREATE VIEW v AS SELECT col1, 1 AS col2 FROM t;
En esta vista no pueden agregarse registros porque col2 es derivada de una expresión. Pero será
actualizable si no intenta actualizar col2. Esta actualización es posible:
UPDATE v SET col1 = 0;
Esta actualización no es posible porque se intenta realizar sobre una columna derivada:
UPDATE v SET col2 = 0;
A veces, es posible que una vista compuesta por múltiples tablas sea actualizable, asumiendo que es
procesada con el algoritmo MERGE. Para que esto funcione, la vista debe usar inner join (no outer join o
UNION). Además, solamente puede actualizarse una tabla de la definición de la vista, de forma que la
cláusula SET debe contener columnas de sólo una tabla de la vista. Las vistas que utilizan UNION ALL no
se pueden actualizar aunque teóricamente fuese posible hacerlo, debido a que en la implementación se
emplean tablas temporales para procesarlas.
En vistas compuestas por múltiples tablas, INSERT funcionará si se aplica sobre una única tabla. DELETE
no está soportado.
La cláusula WITH CHECK OPTION puede utilizarse en una vista actualizable para evitar inserciones o
actualizaciones excepto en los registros en que la cláusula WHERE de la sentencia_select se evalúe como
true.
En la cláusula WITH CHECK OPTION de una vista actualizable, las palabras reservadas LOCAL y
CASCADED determinan el alcance de la verificación cuando la vista está definida en términos de otras
vistas. LOCAL restringe el CHECK OPTION sólo a la vista que está siendo definida. CASCADED provoca
que las vistas subyacentes también sean verificadas. Si no se indica, el valor por defecto es CASCADED.
Considere las siguientes definiciones de tabla y vistas:
mysql> CREATE TABLE t1 (a INT);
mysql> CREATE VIEW v1 AS SELECT * FROM t1 WHERE a < 2
-> WITH CHECK OPTION;
mysql> CREATE VIEW v2 AS SELECT * FROM v1 WHERE a > 0
-> WITH LOCAL CHECK OPTION;
mysql> CREATE VIEW v3 AS SELECT * FROM v1 WHERE a > 0
-> WITH CASCADED CHECK OPTION;
Las vistas v2 y v3 estan definidas en términos de otra vista, v1. v2 emplea check option LOCAL, por lo que
las inserciones sólo atraviesan la verificación de v2 . v3 emplea check option CASCADED de modo que las
inserciones no solamente atraviesan su propia verificación sino tambien las de las vistas subyacentes. Las
siguientes sentencias demuestran las diferencias:
ql> INSERT INTO v2 VALUES (2);
Query OK, 1 row affected (0.00 sec)
mysql> INSERT INTO v3 VALUES (2);
ERROR 1369 (HY000): CHECK OPTION failed 'test.v3'
La posibilidad de actualización de las vistas puede verse afectada por el valor de la variable del sistema
updatable_views_with_limit. Consulte Sección 5.3.3, “Variables de sistema del servidor”.
La sentencia CREATE VIEW fue introducida en MySQL 5.0.1. La cláusula WITH CHECK OPTION fue
implementada en MySQL 5.0.2.
INFORMATION_SCHEMA contiene una tabla VIEWS de la cual puede obtenerse información sobre los
objetos de las vistas. Consulte Sección 22.1.15, “La tabla INFORMATION_SCHEMA VIEWS”.
21.3. Sintaxis de DROP VIEW
DROP VIEW [IF EXISTS]
nombre_vista [, nombre_vista] ...
[RESTRICT | CASCADE]
DROP VIEW elimina una o más vistas de la base de datos. Se debe poseer el privilegio DROP en cada
vista a eliminar.
La cláusula IF EXISTS se emplea para evitar que ocurra un error por intentar eliminar una vista inexistente.
Cuando se utiliza esta cláusula, se genera una NOTE por cada vista inexistente. Consulte
Sección 13.5.4.22, “Sintaxis de SHOW WARNINGS”.
RESTRICT y CASCADE son ignoradas.
Esta sentencia se introdujo en MySQL 5.0.1.
21.4. Sintaxis de SHOW CREATE VIEW
SHOW CREATE VIEW nombre_vista
Muestra la sentencia CREATE VIEW que se utilizó para crear la vista.
mysql> SHOW CREATE VIEW v;
+-------+----------------------------------------------------+
| Table | Create Table
|
+-------+----------------------------------------------------+
|v
| CREATE VIEW `test`.`v` AS select 1 AS `a`,2 AS `b` |
+-------+----------------------------------------------------+
Esta sentencia fue introducida en MySQL 5.0.1.
22. La base de datos de información INFORMATION_SCHEMA
El soporte para INFORMATION_SCHEMA está disponible en MySQL 5.0.2 y posterior. Proporciona acceso
a los metadatos de la base de datos.
Metadatos son datos acerca de los datos, tales como el nombre de la base de datos o tabla, el tipo de
datos de una columna, o permisos de acceso. Otros términos que a veces se usan para esta información
son diccionario de datos o catálogo del sistema .
Ejemplo:
mysql> SELECT table_name, table_type, engine
-> FROM information_schema.tables
-> WHERE table_schema = 'db5'
-> ORDER BY table_name DESC;
+------------+------------+--------+
| table_name | table_type | engine |
+------------+------------+--------+
| v56
| VIEW
| NULL |
| v3
| VIEW
| NULL |
| v2
| VIEW
| NULL |
|v
| VIEW
| NULL |
| tables
| BASE TABLE | MyISAM |
| t7
| BASE TABLE | MyISAM |
| t3
| BASE TABLE | MyISAM |
| t2
| BASE TABLE | MyISAM |
|t
| BASE TABLE | MyISAM |
| pk
| BASE TABLE | InnoDB |
| loop
| BASE TABLE | MyISAM |
| kurs
| BASE TABLE | MyISAM |
|k
| BASE TABLE | MyISAM |
| into
| BASE TABLE | MyISAM |
| goto
| BASE TABLE | MyISAM |
| fk2
| BASE TABLE | InnoDB |
| fk
| BASE TABLE | InnoDB |
+------------+------------+--------+
17 rows in set (0.01 sec)
Explicación: El comando pide una lista de todas las tablas en la base de datos db5, en orden alfabético
inverso, mostrando tres informaciones: el nombre de la tabla, su tipo y su motor.
INFORMATION_SCHEMA es la base de datos de información, que almacena información acerca de todas
las otras bases de datos que mantiene el servidor MySQL . Dentro del INFORMATION_SCHEMA hay
varias tablas de sólo lectura. En realidad son vistas, no tablas, así que no puede ver ningún fichero
asociado con ellas.
Cada usuario MySQL tiene derecho a acceder a estas tablas, pero sólo a los registros que se
corresponden a los objetos a los que tiene permiso de acceso.
Ventajas de SELECT
El comando SELECT ... FROM INFORMATION_SCHEMA es una forma más consistente de proporcionar
acceso a la información proporcionada por los comandos SHOW que soporta MySQL (SHOW
DATABASES, SHOW TABLES, y así). Usar SELECT tiene las siguientes ventajas, en comparación a
SHOW:
·
Cumple las reglas de Codd. Esto es, todo acceso se hace por tabla.
·
Nadie necesita aprender una nueva sintaxis. Conocen cómo funciona SELECT , sólo necesitan
aprender los nombres de los objetos.
·
El implementador no tiene que preocuparse de palabras clave.
·
Hay millones de variaciones de la salida, en lugar de sólo una. Esto proporciona flexibilidad a las
aplicaciones con requerimientos cambiantes acerca de los metadatos que necesitan
·
La migración es más fácil ya que todos los otros DBMS funcionan así.
Sin embargo, como SHOW es popular entre los empleados y usuarios de MySQL, y como puede ser
confuso si desaparece, las ventajas de una sintaxis convencional no es razón para eliminar SHOW. De
hecho, hay mejoras a SHOW en MySQL 5.0. Se describen en Sección 22.2, “Extensiones a las sentencias
SHOW ”.
Estandars
La implementación de la estructura de tablas para el INFORMATION_SCHEMA en MySQL sigue el
estándar ANSI/ISO SQL:2003 Parte 11 Schemata. Nuestra intención es aproximar el cumplimiento de
SQL:2003 característica básica F021 Basic information schema.
Los usuarios de SQL Server 2000 (que también sigue el estándar) pueden ver una gran similitud. Sin
embargo, MySQL omite varias columnas no relevantes para nuestra implementación, y añade columnas
que són específicas de MySQL. Una de estas columnas es engine en la tabla
INFORMATION_SCHEMA.TABLES.
Aunque otros DBMS usan una variedad de nombres, como syscat o system, el nombre estándar es
INFORMATION_SCHEMA.
En efecto, tenemos una nueva base de datos llamada INFORMATION_SCHEMA, aunque no hay
necesidad de hacer un fichero llamado así. Es posible seleccionar INFORMATION_SCHEMA como base
de datos por defecto con un comando USE , pero la única forma de acceder al contenido de sus tablas es
con SELECT. No puede insertar, actualizar o borrar su contenido.
Permisos
No hay diferencia entre el requerimiento de permisos para (SHOW) y para SELECT . En cada caso, debe
tener algún permiso de un objeto para consultar información acerca de el mismo.
22.1. Las tablas INFORMATION_SCHEMA
Explicación de las siguientes secciones
En las siguientes secciones, tomamos tablas y columnas del INFORMATION_SCHEMA. Para cada
columna, hay tres informaciones:
·
“Standard Name” indica el nombre SQL estándar para la columna.
·
“SHOW name” indica el nombre equivalente al comando SHOW más parecido, si lo hay.
·
“Remarks” proporciona información adicional donde sea aplicable.
Para evitar usar nombres reservados del estándar o de DB2, SQL Server, o Oracle, hemos cambiado los
nombres de las columnas marcados como extensión MySQL. (Por ejemplo, cambiamos COLLATION a
TABLE_COLLATION en la tabla TABLES .) Consulte la lista de palabras reservadas al final del artículo:
http://www.dbazine.com/gulutzan5.shtml.
La definición para columnas de caracteres (por ejemplo, TABLES.TABLE_NAME), generalmente es
VARCHAR(N) CHARACTER SET utf8 donde N es como mínimo 64.
Cada sección indica qué comando SHOW es equivalente al SELECT que proporciona información de
INFORMATION_SCHEMA, o si no hay tal equivalente.
Nota: Por ahora, hay algunas columnas no presentes y algunas que no funcionan. Estamos trabajando en
ello y tratamos de actualizar la documentación tal y como se producen los cambios.
22.1.1. La tabla INFORMATION_SCHEMA SCHEMATA
Un esquema es una base de datos, así que la tabla SCHEMATA proporciona información acerca de bases
de datos.
Standard Name
SHOW
name
Remarks
CATALOG_NAME
-
NULL
SCHEMA_NAME
base
datos
de
DEFAULT_CHARACTER_
SET_NAME
DEFAULT_COLLATION_N
AME
SQL_PATH
NULL
Notas:
·
Para SQL_PATH, podemos soportar eventualmente algo en MySQL 5.x. De momento siempre es
NULL.
·
DEFAULT_COLLATION_NAME se añadió en MySQL 5.0.6.
Los siguientes comandos son equivalentes:
SELECT SCHEMA_NAME AS `Database`
FROM INFORMATION_SCHEMA.SCHEMATA
[WHERE SCHEMA_NAME LIKE 'wild']
SHOW DATABASES
[LIKE 'wild']
22.1.2. La tabla INFORMATION_SCHEMA TABLES
La tabla TABLES proporciona información acerca de las tablas en las bases de datos.
Standard
Name
SHOW
name
TABLE_CATA
LOG
Remarks
NULL
TABLE_SCHE
MA
Table_...
TABLE_NAME
Table_...
TABLE_TYPE
ENGINE
Engine
Extensión
MySQL
VERSION
Version
Extensión
MySQL
ROW_FORMA
T
Row_format
Extensión
MySQL
TABLE_ROWS
Rows
Extensión
MySQL
AVG_ROW_LE
NGTH
Avg_row_le
ngth
Extensión
MySQL
DATA_LENGT
H
Data_length
Extensión
MySQL
MAX_DATA_L
ENGTH
Max_data_l
ength
Extensión
MySQL
INDEX_LENGT
H
Index_lengt
h
Extensión
MySQL
DATA_FREE
Data_free
Extensión
MySQL
AUTO_INCRE
MENT
Auto_incre
ment
Extensión
MySQL
CREATE_TIM
E
Create_time
Extensión
MySQL
UPDATE_TIM
E
Update_tim
e
Extensión
MySQL
CHECK_TIME
Check_time
Extensión
MySQL
TABLE_COLL
ATION
Collation
Extensión
MySQL
CHECKSUM
Checksum
Extensión
MySQL
CREATE_OPTI
ONS
Create_opti
ons
Extensión
MySQL
TABLE_COM
MENT
Comment
Extensión
MySQL
Notas:
·
TABLE_SCHEMA y TABLE_NAME son campos simples en SHOW , por ejemplo Table_in_db1.
·
TABLE_TYPE debe ser BASE TABLE o VIEW. Si la tabla es temporal, entonces TABLE_TYPE =
TEMPORARY. (No hay vistas temporales, así que no es ambíguo.)
·
La columna TABLE_ROWS es NULL si la tabla está en la base de datos INFORMATION_SCHEMA
.
·
No tneemos nada para el conjunto de caracteres por defecto de la tabla. TABLE_COLLATION se
acerca, ya que los nombres de colación comienzan con el nombre del conjunto de caracteres.
Los siguientes comandos son equivalentes:
SELECT table_name FROM INFORMATION_SCHEMA.TABLES
[WHERE table_schema = 'db_name']
[WHERE|AND table_name LIKE 'wild']
SHOW TABLES
[FROM db_name]
[LIKE 'wild']
22.1.3. La tabla INFORMATION_SCHEMA COLUMNS
La tabla COLUMNS proporciona información acerca de columnas en tablas.
Standard Name
SHOW
name
TABLE_CATALOG
Remarks
NULL
TABLE_SCHEMA
TABLE_NAME
COLUMN_NAME
Field
ORDINAL_POSITION
vea las notas
COLUMN_DEFAULT
Default
IS_NULLABLE
Null
DATA_TYPE
Type
CHARACTER_MAXIMU
M_LENGTH
Type
CHARACTER_OCTET_L
ENGTH
NUMERIC_PRECISION
Type
NUMERIC_SCALE
Type
CHARACTER_SET_NA
ME
COLLATION_NAME
Collation
COLUMN_KEY
Key
Extensión
MySQL
EXTRA
Extra
Extensión
MySQL
COLUMN_COMMENT
Commen
t
Extensión
MySQL
Notas:
·
En SHOW, el Type incluye valores de varias columnas COLUMNS distintas.
·
ORDINAL_POSITION es necesario ya que puede algún día querer decir ORDER BY
ORDINAL_POSITION. Al contrario que SHOW, SELECT no tiene ordenación automática.
·
CHARACTER_OCTET_LENGTH debe ser el mismo que CHARACTER_MAXIMUM_LENGTH,
excepto para conjuntos de caracteres de múltiples bytes.
·
CHARACTER_SET_NAME puede derivarse de Collation. Por ejemplo, si dice SHOW FULL
COLUMNS FROM t, y ve en la columna Collation un valor de latin1_swedish_ci, el conjunto de
caracteres es lo que hay antes del primer subrayado: latin1.
Los siguientes comandos son casi equivalentes:
SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT
FROM INFORMATION_SCHEMA.COLUMNS
WHERE table_name = 'tbl_name'
[AND table_schema = 'db_name']
[AND column_name LIKE 'wild']
SHOW COLUMNS
FROM tbl_name
[FROM db_name]
[LIKE wild]
22.1.4. La tabla INFORMATION_SCHEMA STATISTICS
La tabla STATISTICS proporciona información acerca de los índices de las tablas.
Standard
Name
SHOW
name
Remarks
TABLE_CAT
ALOG
NULL
TABLE_SCH
EMA
=
Base
datos
de
=
Base
datos
de
TABLE_NA
ME
Table
NON_UNIQ
UE
Non_uniq
ue
INDEX_SCH
EMA
INDEX_NAM
E
Key_nam
e
SEQ_IN_IND
EX
Seq_in_in
dex
COLUMN_N
AME
Column_n
ame
COLLATION
Collation
CARDINALI
TY
Cardinalit
y
SUB_PART
Sub_part
Extensión
MySQL
PACKED
Packed
Extensión
MySQL
NULLABLE
Null
Extensión
MySQL
INDEX_TYP
E
Index_typ
e
Extensión
MySQL
COMMENT
Comment
Extensión
MySQL
Notas:
·
No hay una tabla estándar para índices. La lista precedente es similar a lo que retorna SQL Server
2000 para sp_statistics, excepto que hemos cambiado el nombre QUALIFIER con CATALOG y
OWNER con SCHEMA.
Claramente, la tabla precedente y la salida de SHOW INDEX se derivan del mismo padre. Así que
la correlación está cercana.
Los siguientes comandos son equivalentes:
SELECT * FROM INFORMATION_SCHEMA.STATISTICS
WHERE table_name = 'tbl_name'
[AND table_schema = 'db_name']
SHOW INDEX
FROM tbl_name
[FROM db_name]
22.1.5. La tabla INFORMATION_SCHEMA USER_PRIVILEGES
La tabla USER_PRIVILEGES proporciona información acerca de permisos globales. Esta información
viene de la tabla de permisos mysql.user .
Standard
Name
GRANTEE
SHOW
name
Remarks
e.g.
'user'@'host'
TABLE_CAT
ALOG
NULL
PRIVILEGE_
TYPE
IS_GRANTA
BLE
Notas:
·
Esta tabla no es estándar. Toma sus valores de la tabla mysql.user .
22.1.6. La tabla INFORMATION_SCHEMA SCHEMA_PRIVILEGES
La tabla SCHEMA_PRIVILEGES proporciona información acerca del esquema de permisos (base de
datos). Esta información viene de la tabla de permisos mysql.db .
Standard
Name
SHOW
name
Remarks
GRANTEE
e.g.
'user'@'host'
TABLE_CAT
ALOG
NULL
TABLE_SCH
EMA
PRIVILEGE_
TYPE
IS_GRANTA
BLE
Notas:
·
Esta tabla no es estándar. Toma sus valores de la tabla mysql.db .
22.1.7. La tabla INFORMATION_SCHEMA TABLE_PRIVILEGES
La tabla TABLE_PRIVILEGES proporciona información de permisos de tablas. Esta información viene de
la tabla de permisos mysql.tables_priv .
Standard
Name
SHOW
name
Remarks
GRANTEE
e.g.
'user'@'host'
TABLE_CAT
ALOG
NULL
TABLE_SCH
EMA
TABLE_NA
ME
PRIVILEGE_
TYPE
IS_GRANTA
BLE
Los siguientes comandos no son equivalentes:
22.1.8. La tabla INFORMATION_SCHEMA COLUMN_PRIVILEGES
La tabla COLUMN_PRIVILEGES proporciona información acerca de permisos de columnas. Esta
información viene de la tabla de permisos mysql.columns_priv .
Standard
Name
SHOW
name
Remarks
GRANTEE
e.g.
'user'@'host'
TABLE_CAT
ALOG
NULL
TABLE_SCH
EMA
TABLE_NA
ME
COLUMN_N
AME
PRIVILEGE_
TYPE
IS_GRANTA
BLE
Notas:
·
En la salida de SHOW FULL COLUMNS, los permisos están todos en un campo y en minúsculas,
por ejemplo, select,insert,update,references. En COLUMN_PRIVILEGES, hay un registro por
permiso, y en mayúsculas.
·
PRIVILEGE_TYPE puede contener uno ( y sólo uno ) de estos valores: SELECT, INSERT,
UPDATE, REFERENCES.
·
Si el usuario tiene el permiso GRANT OPTION , entonces IS_GRANTABLE debe ser YES. De otro
modo, IS_GRANTABLE debe ser NO. La salida no lista GRANT OPTION como permisos separado.
Los siguientes comandos no son equivalentes:
SELECT ... FROM INFORMATION_SCHEMA.COLUMN_PRIVILEGES
SHOW GRANTS ...
22.1.9. La tabla INFORMATION_SCHEMA CHARACTER_SETS
La tabla CHARACTER_SETS proporciona información acerca de los conjuntos de caracteres disponibles.
Standard Name
SHOW
name
Remarks
CHARACTER_SET_
NAME
Charset
DEFAULT_COLLAT
E_NAME
Default
collation
DESCRIPION
Description
Extensión
MySQL
MAXLEN
Maxlen
Extensión
MySQL
Notas:
·
Hemos añadido dos columnas no estándar que se corresponden a Description y Maxlen en la
salida de SHOW CHARACTER SET.
Los siguientes comandos son equivalentes:
SELECT * FROM INFORMATION_SCHEMA.CHARACTER_SETS
[WHERE name LIKE 'wild']
SHOW CHARACTER SET
[LIKE 'wild']
22.1.10. La tabla INFORMATION_SCHEMA COLLATIONS
La tabla COLLATIONS proporciona información acerca de colaciones para cada conjunto de caracteres.
Standard
Name
SHOW
name
COLLATION
_NAME
Collation
Remarks
Notas:
·
Hemos añadido cinco columnas no estándar que se corresponden a Charset, Id, Default,
Compiled, y Sortlen de la salida de SHOW COLLATION.
Los siguientes comandos son equivalentes:
SELECT COLLATION_NAME FROM INFORMATION_SCHEMA.COLLATIONS
[WHERE collation_name LIKE 'wild']
SHOW COLLATION
[LIKE 'wild']
22.1.11. La tabla INFORMATION_SCHEMA COLLATION_CHARACTER_SET_APPLICABILITY
La tabla COLLATION_CHARACTER_SET_APPLICABILITY indica qué conjunto de caracteres es aplicable
a cada colación. Las columnas son equivalentes a los dos primeros campos mostrados por SHOW
COLLATION.
Standard Name
SHOW
name
COLLATION_NA
ME
Collation
Remarks
CHARACTER_SE
T_NAME
Charset
22.1.12. La tabla INFORMATION_SCHEMA TABLE_CONSTRAINTS
La tabla TABLE_CONSTRAINTS describe qué tablas tienen restricciones.
Standard Name
SHOW
name
CONSTRAINT_C
ATALOG
Remarks
NULL
CONSTRAINT_S
CHEMA
CONSTRAINT_N
AME
TABLE_SCHEMA
TABLE_NAME
CONSTRAINT_TY
PE
Notas:
·
El valor CONSTRAINT_TYPE puede ser UNIQUE, PRIMARY KEY, o FOREIGN KEY.
·
La información UNIQUE y PRIMARY KEY es acerca de lo mismo que obtiene del campo
Key_name en la salida de SHOW INDEX cuando el campo Non_unique es 0.
·
La columna CONSTRAINT_TYPE puede contener uno de estos valores: UNIQUE, PRIMARY KEY,
FOREIGN KEY, CHECK. Esta es una columna CHAR (no ENUM) . El valor CHECK no estará
disponible hasta que soportemos CHECK.
22.1.13. La tabla INFORMATION_SCHEMA KEY_COLUMN_USAGE
La tabla KEY_COLUMN_USAGE describe qué columnas clave tienen restricciones.
Standard Name
CONSTRAINT_CATALOG
CONSTRAINT_SCHEMA
CONSTRAINT_NAME
TABLE_CATALOG
TABLE_SCHEMA
TABLE_NAME
COLUMN_NAME
ORDINAL_POSITION
SHOW
name
Remarks
NULL
POSITION_IN_UNIQUE_C
ONSTRAINT
REFERENCED_TABLE_S
CHEMA
REFERENCED_TABLE_N
AME
REFERENCED_COLUMN_
NAME
Notas:
·
Si la restricción es una clave foránea, entonces esta es la columna de la clave foránea, no la
columna a la que la clave foránea hace referencia.
·
El valor de ORDINAL_POSITION es la posición de la columna en la restricción, no la posición de la
columna en la tabla. Las posiciones de columnas se numeran comenzando por 1.
·
El valor de POSITION_IN_UNIQUE_CONSTRAINT es NULL para restricciones de claves primárias
y únicas. Para restricciones de claves foráneas, es la posición ordinal en la clave de la tabla a la
que se referencia.
Por ejemplo, suponga que hay dos tablas llamadas t1 y t3 con las siguientes definiciones:
CREATE TABLE t1
(
s1 INT,
s2 INT,
s3 INT,
PRIMARY KEY(s3)
) ENGINE=InnoDB;
CREATE TABLE t3
(
s1 INT,
s2 INT,
s3 INT,
KEY(s1),
CONSTRAINT CO FOREIGN KEY (s2) REFERENCES t1(s3)
) ENGINE=InnoDB;
Para estas dos tablas, la tabla KEY_COLUMN_USAGE tiene dos registros:
o
Un
registro
con
CONSTRAINT_NAME='PRIMARY',
TABLE_NAME='t1',
COLUMN_NAME='s3',
ORDINAL_POSITION=1,
POSITION_IN_UNIQUE_CONSTRAINT=NULL.
o
Un registro con CONSTRAINT_NAME='CO', TABLE_NAME='t3', COLUMN_NAME='s2',
ORDINAL_POSITION=1, POSITION_IN_UNIQUE_CONSTRAINT=1.
§
REFERENCED_TABLE_SCHEMA,
REFERENCED_TABLE_NAME,
REFERENCED_COLUMN_NAME se añadieron en MySQL 5.0.6.
22.1.14. La tabla INFORMATION_SCHEMA ROUTINES
y
La tabla ROUTINES proporciona información acerca de rutinas almacenadas (procedimientos y funciones).
La tabla ROUTINES no incluye funciones definidas por el usuario (UDFs) de momento.
La columna llamada “mysql.proc name” indica la columna de la tabla mysql.proc que se corresponde a la
columna de la tabla INFORMATION_SCHEMA.ROUTINES, si hay alguna.
Standard Name
mysql.proc
name
SPECIFIC_NAM
E
specific_na
me
ROUTINE_CATA
LOG
Remarks
NULL
ROUTINE_SCHE
MA
db
ROUTINE_NAME
name
ROUTINE_TYPE
type
{PROCEDURE|
FUNCTION}
DTD_IDENTIFIE
R
(descriptor del tipo de
datos)
ROUTINE_BODY
SQL
ROUTINE_DEFI
NITION
body
EXTERNAL_NA
ME
EXTERNAL_LAN
GUAGE
NULL
language
PARAMETER_S
TYLE
NULL
SQL
IS_DETERMINIS
TIC
is_determini
stic
SQL_DATA_ACC
ESS
sql_data_ac
cess
SQL_PATH
NULL
SECURITY_TYP
E
security_typ
e
CREATED
created
LAST_ALTERED
modified
SQL_MODE
sql_mode
Extensión MySQL
ROUTINE_COM
MENT
comment
Extensión MySQL
DEFINER
definer
Extensión MySQL
Notas:
·
MySQL calcula EXTERNAL_LANGUAGE así:
o
Si mysql.proc.language='SQL', entonces EXTERNAL_LANGUAGE es NULL
o
En caso contrario, EXTERNAL_LANGUAGE es lo que hay en mysql.proc.language. Sin
embargo, no tenemos idiomas externos de momento, así que siempre es NULL.
22.1.15. La tabla INFORMATION_SCHEMA VIEWS
La tabla VIEWS proporciona información acerca de las vistas en las bases de datos.
Standard
Name
SHOW
name
TABLE_CAT
ALOG
Remarks
NULL
TABLE_SCH
EMA
TABLE_NA
ME
VIEW_DEFI
NITION
CHECK_OP
TION
IS_UPDATA
BLE
Notas:
·
Hay un nuevo permiso, SHOW VIEW, sin el cual no puede ver la tabla VIEWS.
·
La columna VIEW_DEFINITION tiene la mayoría de lo que ve en el campo Create Table que
produce SHOW CREATE VIEW . Ignora las palabras antes de SELECT y tras WITH CHECK
OPTION. Por ejemplo, si el comando original era:
·
CREATE VIEW v AS
·
SELECT s2,s1 FROM t
·
WHERE s1 > 5
·
ORDER BY s1
·
WITH CHECK OPTION;
entonces la definición de la vista es:
SELECT s2,s1 FROM t WHERE s1 > 5 ORDER BY s1
·
La columna CHECK_OPTION siempre tiene un valor de NONE.
·
La columna IS_UPDATABLE es YES si la vista es actualizable, NO si la vista no es actualizable.
22.1.16. La tabla INFORMATION_SCHEMA TRIGGERS
La tabla TRIGGERS proporciona información acerca de disparadores.
Esta tabla se implementó inicialmente en MySQL 5.0.10.
Debe tener el permiso SUPER para ver esta tabla.
Standard Name
SHOW
name
TRIGGER_CATALOG
Remarks
NULL
TRIGGER_SCHEMA
TRIGGER_NAME
Trigger
EVENT_MANIPULATION
Event
EVENT_OBJECT_CATAL
OG
NULL
EVENT_OBJECT_SCHEM
A
EVENT_OBJECT_TABLE
Table
ACTION_ORDER
0
ACTION_CONDITION
NULL
ACTION_STATEMENT
Stateme
nt
ACTION_ORIENTATION
ACTION_TIMING
ROW
Timing
ACTION_REFERENCE_O
LD_TABLE
NULL
ACTION_REFERENCE_N
EW_TABLE
NULL
ACTION_REFERENCE_O
LD_ROW
OLD
ACTION_REFERENCE_N
EW_ROW
NEW
CREATED
NULL (0)
Notas:
·
Las columnas TRIGGER_SCHEMA y TRIGGER_NAME contienen el nombre de la base de datos
en que se produce el dispardor, y el nombre del disparador, respectivamente.
·
La columna EVENT_MANIPULATION contiene uno de los valores 'INSERT', 'DELETE', o
'UPDATE'.
·
Como se explica en Capítulo 20, Disparadores (triggers), cada disparador se asocia exactamente
con una tabla. Las columnas EVENT_OBJECT_SCHEMA y EVENT_OBJECT_TABLE contienen la
base de datos en que ocurre esta tabla, y el nombre de la tabla.
·
El comando ACTION_ORDER contiene la posición ordinal de la acción del disparador en la lista de
todos los disparadores similares en la misma tabla. Actualmente, este valor siempre es 0, porque
no es posible tener más de un disparador con el mismo EVENT_MANIPULATION y
ACTION_TIMING en la misma tabla.
·
La columna ACTION_STATEMENT contiene el comando a ejecutarse cuando el disparador se
invoca. Esto es lo mismo que el texto mostrado en la columna Statement de la salida de SHOW
TRIGGERS. Tenga en cuenta que este texto usa codificación UTF-8 .
·
La columna ACTION_ORIENTATION siempre contiene el valor 'ROW'.
·
La columna ACTION_TIMING contiene uno de los dos valores 'BEFORE' o 'AFTER'.
·
Las columnas ACTION_REFERENCE_OLD_ROW y ACTION_REFERENCE_NEW_ROW
contienen el antiguo y nuevo identificador de columna, respectivamente. Esto significa que
siempre
contiene
el
valor
y
ACTION_REFERENCE_OLD_ROW
'OLD'
ACTION_REFERENCE_NEW_ROW siempre contiene el valor 'NEW'.
·
Las siguientes columnas actualmente siempre contiene NULL: TRIGGER_CATALOG,
EVENT_OBJECT_CATALOG,
ACTION_CONDITION,
ACTION_REFERENCE_OLD_TABLE,
ACTION_REFERENCE_NEW_TABLE, y CREATED.
Ejemplo, usando el disparador ins_sum definido en Sección 20.3, “Utilización de disparadores”:
mysql> SELECT * FROM INFORMATION_SCHEMA.TRIGGERS\G
*************************** 1. row ***************************
TRIGGER_CATALOG: NULL
TRIGGER_SCHEMA: test
TRIGGER_NAME: ins_sum
EVENT_MANIPULATION: INSERT
EVENT_OBJECT_CATALOG: NULL
EVENT_OBJECT_SCHEMA: test
EVENT_OBJECT_TABLE: account
ACTION_ORDER: 0
ACTION_CONDITION: NULL
ACTION_STATEMENT: SET @sum = @sum + NEW.amount
ACTION_ORIENTATION: ROW
ACTION_TIMING: BEFORE
ACTION_REFERENCE_OLD_TABLE: NULL
ACTION_REFERENCE_NEW_TABLE: NULL
ACTION_REFERENCE_OLD_ROW: OLD
ACTION_REFERENCE_NEW_ROW: NEW
CREATED: NULL
1 row in set (1.54 sec)
Consulte Sección 13.5.4.20, “Sintaxis de SHOW TRIGGERS”.
22.1.17. Otras tablas INFORMATION_SCHEMA
Pretendemos implementar tablas adicionales INFORMATION_SCHEMA . En particular, sabemos de la
necesidad
de
INFORMATION_SCHEMA.PARAMETERS
y
INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS.
22.2. Extensiones a las sentencias SHOW
Algunas extensiones de comandos SHOW acompañan la implementación de INFORMATION_SCHEMA:
·
SHOW puede usarse para
INFORMATION_SCHEMA mismo.
·
Varios comandos SHOW aceptan una cláusula WHERE que proporciona más flexibilidad al
especificar qué registros mostrar.
obtener
información
acerca
de
la
estructura
de
Estas extensiones están disponibles desde MySQL 5.0.3.
INFORMATION_SCHEMA es una base de datos de información, así que su nombre se incluye en la salida
de SHOW DATABASES. Similarmente, SHOW TABLES puede usarse con INFORMATION_SCHEMA
para obtener una lista de sus tablas:
mysql> SHOW TABLES FROM INFORMATION_SCHEMA;
+---------------------------------------+
| Tables_in_information_schema
|
+---------------------------------------+
| SCHEMATA
|
| TABLES
|
| COLUMNS
|
| CHARACTER_SETS
|
| COLLATIONS
|
| COLLATION_CHARACTER_SET_APPLICABILITY |
| ROUTINES
|
| STATISTICS
|
| VIEWS
| TRIGGERS
|
|
| USER_PRIVILEGES
|
| SCHEMA_PRIVILEGES
| TABLE_PRIVILEGES
|
|
| COLUMN_PRIVILEGES
|
| TABLE_CONSTRAINTS
|
| KEY_COLUMN_USAGE
|
+---------------------------------------+
SHOW COLUMNS y DESCRIBE pueden mostrar información acerca de las columns en tablas
INFORMATION_SCHEMA individuales.
Varios comandos SHOW se han extendido para permitir cláusulas WHERE :
SHOW CHARACTER SET
SHOW COLLATION
SHOW COLUMNS
SHOW DATABASES
SHOW FUNCTION STATUS
SHOW KEYS
SHOW OPEN TABLES
SHOW PROCEDURE STATUS
SHOW STATUS
SHOW TABLE STATUS
SHOW TABLES
SHOW VARIABLES
La cláusula WHERE , si está presente, se evalúa contra los nombres de columna mostrados por el
comando SHOW. Por ejemplo, el comando SHOW COLLATION produce estas columnas de salida:
Por ejemplo, el comando SHOW CHARACTER SET produce estas columnas de salida:
mysql> SHOW CHARACTER SET;
+----------+-----------------------------+---------------------+--------+
| Charset | Description
| Default collation | Maxlen |
+----------+-----------------------------+---------------------+--------+
| big5
| Big5 Traditional Chinese
| dec8
| DEC West European
| cp850
| DOS West European
| big5_chinese_ci
|
2|
| dec8_swedish_ci
|
| cp850_general_ci
| hp8
| HP West European
| hp8_english_ci
| koi8r
| KOI8-R Relcom Russian
| latin1 | ISO 8859-1 West European
1|
|
|
| koi8r_general_ci
1|
1|
|
1|
| latin1_swedish_ci |
1|
| latin2 | ISO 8859-2 Central European | latin2_general_ci |
1|
...
Para usar una cláusula WHERE con SHOW CHARACTER SET, se referiría a esos nombres de columna.
Como ejemplo, el siguiente comando muestra información acerca de conjuntos de caracteres para los que
la colación por defecto contiene la cadena "japanese":
mysql> SHOW CHARACTER SET WHERE `Default collation` LIKE '%japanese%';
+---------+---------------------------+---------------------+--------+
| Charset | Description
| Default collation | Maxlen |
+---------+---------------------------+---------------------+--------+
| ujis
| EUC-JP Japanese
| sjis
| Shift-JIS Japanese
| ujis_japanese_ci
| sjis_japanese_ci
|
3|
|
2|
| cp932 | SJIS for Windows Japanese | cp932_japanese_ci |
| eucjpms | UJIS for Windows Japanese | eucjpms_japanese_ci |
2|
3|
+---------+---------------------------+---------------------+--------+
Este comando muestra los conjuntos de caracteres de múltiples bytes:
mysql> SHOW CHARACTER SET WHERE Maxlen > 1;
+---------+---------------------------+---------------------+--------+
| Charset | Description
| Default collation | Maxlen |
+---------+---------------------------+---------------------+--------+
| big5
| Big5 Traditional Chinese | big5_chinese_ci
|
2|
| ujis
| EUC-JP Japanese
| sjis
| Shift-JIS Japanese
| ujis_japanese_ci
| sjis_japanese_ci
| euckr | EUC-KR Korean
|
3|
|
2|
| euckr_korean_ci
|
2|
| gb2312 | GB2312 Simplified Chinese | gb2312_chinese_ci |
| gbk
| GBK Simplified Chinese
| utf8
| UTF-8 Unicode
| ucs2
| UCS-2 Unicode
| gbk_chinese_ci
| utf8_general_ci
| ucs2_general_ci
|
|
2|
2|
3|
|
2|
| cp932 | SJIS for Windows Japanese | cp932_japanese_ci |
| eucjpms | UJIS for Windows Japanese | eucjpms_japanese_ci |
+---------+---------------------------+---------------------+--------+
2|
3|