MYSQL RESUMEN

Esta es la traducción del libro para certificación de MYSQL, si bien el idioma inglés es de suma importancia para

las bases de datos, se resume para facilitar el conocimiento a las personas.

SELECT

---

ORDER BY

---

 mysql> SELECT id, last_name, first_name, birth FROM t -> ORDER BY birth;

Esta consulta selescciona todas las columnas y las ordena por birth, entonces todas van a ordenarse por la menor fecha.

Select: La sintaxis para representar SELECT statement :

SELECT values_to_display FROM table_name WHERE expression GROUP BY how_to_group HAVING

expression ORGER BY how_to_sort LIMIT row_count;

La columna de sálida (values_to_display) son opcionales por ejemplo, no se necesita Incluir a LIMIT cuando se escribe un SELECT.

Se aplica USE para seleccionar una base de datos por ejemplo seleccionamos la base de datos city:

mysql> USE city;

+--------------------+-----------------+------+-----+---------+--------------------------------+

| ID                                      | int(11)                        | NO      | PRI    | NULL           | auto_increment                              |

| Name                             | char(35)                 | NO       |           |                     |                                                                |

| CountryCode              | char(3)                    | NO       |           |                     |                                                                |

| District                           | char(20)                  | NO       |           |                      |                                                               |

| Population                    | int(11)                         | NO       |           |          0        |                                                                 |

+---------------------+----------------+-------+-----------+--------------+--------------------+

SELECT ID, Name, CountryCode, District, Population FROM City; SELECT *FROM City;

El “*” es mas conveniente, para listar que escribir los nombres de todas las columnas. Sin embargo hay que saber cuando es útil y cuando no: Cuando se quiere retornar todas las columnas de una table y no interesa el orden en el cual aparezcan de izquierda a derecha. Si se quiere asegurar que las columnas aparezcan de izquierda a derecha en un orden particular, el “*” no debe ser utilizado porque no da control sobre el orden en que las columnas aparecen. Se debe nombrar las columnas explicitamente en el orden que se desea verlas. Si no se quiere retornar todos los nombrs de las columnas, se debe nombrar las columnas en el orden en que deseamos que aparezcan. Para modificar la estructura interna de las tablas puede ser modificada por ALTER TABLE, asi que un SELECT *, puede retornar diferentes resultados antes y despues de un ALTER TABLE. Para cambiar de nombre las columnas podemos utilizar AS:

mysql> SELECT 1 AS One, 4*3 ‘Cuatro veces 3”;

Para seleccionar de una base de datos una tabla en específico:

SELECT * FROM world.Country;

Especificar que filas retonar:

SELECT * FROM Country WHERE IndepYear >1990;

SELECT*FROM Country WHERE Population >=1000000 AND Population <=2000000;

SELECT * FROM Country WERE Population BETWEEN 1000000 AND 2000000;

Predominancia del AND por encima del OR, las consultas son diferentes:

WHERE GNP < 1000 AND Continent = ‘Africa’ OR Continent = ‘Asia’ WHERE (GNP < 1000 AND Continent = ‘Africa’) OR Continent = ‘Asia’

mysql> SELECT id, last_name, first_name, birth FROM t -> ORDER BY last_name, first_name;

+------+---------------+-----------------+-----------------+

| id         | last_name         | first_name             | birth                         |

+------+---------------+------------------+-----------------+

| 3           | Brown                 | Betty                          |           1971-07-12       |

| 1            | Brown                 |  Bill                              |           1972-10-14      |

| 4           | Larsson              | Selma                         |         1968-05-29     |

| 2            | Larsson              | Sven                            |         1965-01-03     |

+------+----------------+-------------------+-----------------+

Cuando se hacen llamados a columnas seguidas por ASC o DESC,

la Dirección del orden se aplica solamente a esa columna, sin afectar otras columnas.

CREATE TABLE t ( mon ENUM(‘Jan’,’Feb’,’Mar’,’Apr’,’May’,’Jun’, ‘Jul’,’Aug’,’Sep’,’Oct’,’Nov’,’Dec’) );

Asumiendo que la tabla t tiene 12 filas, una por cada posible enumeración.

Cuando se ordene la columna, los valores saldrán en orden del mes y del año.

Si colocamos

mysql> SELECT mon FROM t ORDER BY CAST(mon AS CHAR);

+------+ | mon | +------+

| Apr |

| Aug |

| Dec |

| Feb |

| Jan |

| Jul |

| Jun |

| Mar |

| May |

| Nov |

| Oct |

| Sep |

+-------+

Limitando una sección de la tabla con LIMIT: LIMIT debe ser dado por uno o dos argumentos:

LIMIT row_count LIMIT skip_count, row_count Para usar retornar las primeras 10 filas:

SELECT* FROM Country LIMIT 10;

Para evitar las primeras 20 filas y luego retornar las siguientes 10, hacer esto:

SELECT * FROM Country LIMIT 20,10;

DISTINCT para eliminar duplicados: DISTINCT permite retornar solo valores únicos. mysql> SELECT DISTINCT last_name FROM t; Tambien se puede podemos seleccionar de dos filas solo los valores distintos, al hacer Esto producimos diferentes combinaciones para escoger solo los únicos.

mysql> SELECT DISTINCT i, j FROM t;

+------+------+

| i             | j           |

+------+------+

| 1            | 2          |

| 1             | NULL   |

+-----+------+

mysql> SELECT DISTINCT i, j FROM t;

Para contar cuantos valores distintos tenemos en la tabla para j usamos COUNT:

mysql> SELECT COUNT(DISTINCT j) FROM t;

Tenemos: MIN(), MAX(), SUM(), AVG(), GROUP_CONCAT()

mysql> SELECT title, MIN(salary), MAX(salary), AVG(salary) -> FROM personnel -> GROUP BY title;

+------------------+-------------- +-------------------+------------------+

| title | MIN(salary) | MAX(salary) | AVG(salary) |

+-------------------+--------------- +-------------------+------------------+

| Accountant               | 40000.00             | 40000.00                     | 40000.000000        |

| President                    | 78000.00              | 78000.00                    | 78000.000000           |

| Programmer             | 41000.00               | 48000.00                    | 44500.000000           |

| Secretary                   | 32000.00              | 33000.00                     | 32500.000000          |

Union

---

 

UNION permite concatenar los resultados de dos o mas SELECTs, la sintaxis es asi:

SELECT … UNION SELECT … UNION SELECT....

El resultado consiste en filas que retornan el primer SELECT, seguidas por las filas que retornan un segundo SELECT y asi. Cada SELECT debe producir el mismo número de columnas.

Por defecto UNION elimina las filas duplicadas del conjunto del resultado. Para obtener todas las filas, remplazar cada instancia de UNION por UNION ALL. Produce tambien mayor trafico de red.

• Se tiene información similar en múltiples tablas y se quiere retornar filas de todas a la misma vez.

• Se quiere seleccionar conjuntos de filas de la misma tabla, pero la condición que caracteriza cada conjunto no son con un simple WHERE, se combinana y producen un resultado final.

CREATE TABLE list1

 ( 

subscriber  CHAR(60),

 email       CHAR(60) 

);

 

CREATE TABLE list2

 (

 name        CHAR(96),

 address     CHAR(128) 

);

CREATE TABLE list3 

( 

email       CHAR(50), 

real_name   CHAR(30)

 );

 

SELECT subscriber, email FROM list1

 UNION SELECT name, address FROM list2

 UNION SELECT real_name, email FROM list3;

 

Updating Data:

Update Operations:

 

-El término “unique-valued index” es un termino generico  para cualquier indice que contiene solamente valores unicos.

- El término “primary key” es un termino genérico que significa un único valor indice creado utilizando la keyword UNIQUE.

- “PRIMARY KEY” significa especialmente un valor único de indice creado utilizando las keywords PRIMARY KEY.

 

CREATE TABLE people 

(

 id     INT UNSIGNED NOT NULL AUTO_INCREMENT,

 name   CHAR(40) NOT NULL DEFAULT ‘’,

 age    INT NOT NULL DEFAULT 0,

 PRIMARY KEY (id) 

);

Insert & Replace

---

Insert:

Inserta nuevos registros a la tabla, tiene dos formas básicas una que permite la inseción de multiples filas utilizando:

 

INSERT INTO table_name (column_list) VALUES (value_list);

INSERT INTO table_name 

      SET column_name = value [, column_name = value] ... ;

 

INSERT INTO people (id,name,age) VALUES(12,’William’,25);

 

Para agregar varios registros en un único insert:

INSERT INTO people(name, age)

VALUES(‘William”,25),(‘Bart’,’15),(‘Mary’,12);

 

CREATE TABLE t( i INT);

mysql> INSERT INTO t (i) VALUES(1), (2),(3),(4),(5);

Como manejar valores duplicados de claves:

 

Si la tabla tiene un valor de indice unico, quizas no sea posible usar INSERT

Para agregar un registro a la tabla. Esto ocurre cuando el nuevo registro contiene una

Clave e valor para el indice que ya se encuentra presente en la tabla. 

Suponiendo que cada persona en la tabla “people” tiene un valor único.

 

Podemos aplicar el ON DUPLICATE KEY UPDATE para actualizar una columna especifica del registro existente.

 

mysql> SELECT * FROM log;

 +--------+---------------+-------------+ 

 | name  | location     | counter |

 +--------+---------------+-------------+

 | Tantor | Waterhole |       1 | 

+---------+---------------+-------------+ 

 

mysql> INSERT INTO log (name, location, counter) 

-> VALUES (‘Tantor’, ‘Waterhole’, 1)

 -> ON DUPLICATE KEY UPDATE counter=counter+1;

 

Replace:

REPLACE, como el INSERT agrega nuevos registros a una tabla. Ambos tienen

una sintaxis similar, la diferencia reside en como manejan los registros duplicados. También, REPLACE no soporta el “ON DUPLICATE KEY UPDATE clause”.

 

• Si el nuevo registro no duplica un valor de id, MySQL lo inserta.

• Si un nuevo registro duplica un valor de id que ya existe,

 

REPLACE retorna información string que indica cuántas filas afectadas. Si al contar el resultado es 1, la fila fue insertada sin reemplazar una fila ya existente. Si la cuenta es dos, la fila es eliminada antes que la nueva fila sea insertada. Si al contar es mayor que dos, significa que la tabla tiene multiples indices de valores únicos y el nuevo registro emparejado con múltiples valores en las filas.

 

Esta consulta inserta diferentes filas:

 

REPLACE INTO people (id,name,age) VALUES(12,’William’,25),(13,’Bart’,15),(14,’Mary’,12);

mysql> SELECT * FROM multikey; 

 

+---+---+---+

 | i   | j | k  | 

+---+---+----+ 

| 1  | 1 | 1   |

| 2 | 2   | 2 |

| 3 | 3   | 3 |

| 4 | 4   | 4 |

 +---+---+---+

 

 REPLACE INTO multikey (i,j,k) VALUES(1,2,3); 

mysql> SELECT * FROM multikey;

 +---+-+---+ 

| i   | j |   k |

 +---+---+---+

 | 1 | 2 | 3    |  

| 4 | 4 | 4     |

 +---+---+---+

 

UPDATE:

UPDATE modifica el contenido de registros existentes. Para utilizarlo, hay que nombrar la tabla que se quiere actualizar, brindar una clausula SET que liste uno o mas columnas de asignación de valor, y opcionalmente especificar un WHERE que identifique que se quiere actualizar.

 

UPDATE table_name 

SET column_name = value [, column_name = value] …

 WHERE ... ;

 

UPDATE people SET age = 30, name = ‘Wilhelm’ WHERE id = 12;

 

WHERE, especifica las condiciones que el registro deba satisfacer para seleccionar la actualización. Si no se coloca WHERE se actualizara en todas las filas de la tabla.

 

Para prevenir UPDATEs peligrosos: Un UPDATE sin WHERE es catastrofico.

Delete y Truncate table :

Para remover solamente registros especificos en una tabla TRUNCATE TABLE no pude ser utilizado.  Al trabajar con un DELETE se incluye un WHERE que identifique los registros a remover:

 

DELETE FROM table_name WHERE …;

 

Cuando se omite el WHERE del DELETE, es logicamente equivalente a TRUNCATE           TABLE, pero hay una diferencai operacional. Si necesitas saber cuantos registros son borrados, DELETE retorna un conteo de filas de verdad pero TRUNCATE TABLE retorna 0.

 

Si una tabla contiene una columna AUTO_INCREMENT, vaciarla completamente con TRUNCATE TABLE puede tener el efecto secundario de restablecer la secuencia. Esto también puede suceder con una sentencia DELETE que no incluye una cláusula WHERE. Restablecer la secuencia hace que al siguiente registro insertado en la tabla se le asigne un valor AUTO_INCREMENT 1. Si este efecto secundario no es deseable al vaciar la tabla, use una cláusula WHERE que siempre se evalúe como verdadera:

DELETE FROM table_name WHERE 1;

 

La presencia de la cláusula WHERE en esta declaración hace que MySQL la evalúe para cada fila. La expresión 1 siempre es verdadera, por lo que el efecto de la cláusula WHERE es producir una operación de vaciado de tablas fila por fila. Tenga en cuenta que aunque esta forma de DELETE evita el efecto secundario de restablecer la secuencia AUTO_INCREMENT al realizar una eliminación completa de la tabla, la desventaja es que la instrucción se ejecuta de manera más lenta que un DELETE sin WHERE.

 

DELETE:

-Puede eliminar filas específicas de una tabla si se incluye una cláusula WHERE.

-Por lo general, se ejecuta más lentamente.

- Devuelve un conteo real de filas que indica el número de registros eliminados.

TRUNCATE TABLE:

-No se pueden eliminar solo ciertas filas de una tabla; Siempre lo vacía por completo.

- Generalmente se ejecuta más rápidamente.

-Devuelve un conteo de filas de cero en lugar del número real de registros eliminados

 

Mysql developer

 

Join

+-------------+------------------+ 

| CountryCode | Language|

 +-------------+------------------+ 

| ABW         | Dutch     |

| ABW         | English     |

 | ABW         | Papiamento |

 | ABW         | Spanish   |

 | AFG         | Balochi     |

 | AFG         | Dari       |

 | AFG         | Pashto     |

 | AFG         | Turkmenian |

 | AFG         | Uzbek     |

 | AGO         | Ambo     |

| AGO         | Chokwe     |

 | AGO         | Kongo     |

 | AGO         | Luchazi     |

 | AGO         | Luimbe-nganguela |

 | AGO         | Luvale     |

Tabla 

Inner Joins:

Una unión que identifica combinaciones o hace emparejamiento de filas

de dos tablas se llama inner join.

Inner joins pueden ser escritas de dos maneras diferentes.

Una sintaxis lista las tables que serán unidas separadas por una coma.

 

Al incluir la "," le avisamos en los oins que vamos a procesar multiples tablas.

-Al incluir un WHERE que indica como vamos a emparejar dos registros en dos

Tablas. Una unión tiene el potencial de generar todas las combinaciones

de filas de las dos tablas. 

 

mysql> SELECT Name, Language, Percentage FROM CountryLanguage, Country 

-> WHERE CountryCode = Code;

 

mysql> SELECT Name, Language, Percentage FROM CountryLanguage, Country

 -> WHERE CountryCode = Code ORDER BY Name, Percentage

 

Las uniones pueden utilizar cualquier construcción permitida por SELECT. 

Las siguientes uniones utilizan la función COUNT() y una clase GROUP BY, para sumar el número de lenguajes hablados por un país, y teniendo HAVING restringe el output para solo incluir a los paises donde hablan más de 10 países.

 

mysql> SELECT COUNT(*), Name 

-> FROM CountryLanguage, Country 

-> WHERE CountryCode = Code

 -> GROUP BY Name 

-> HAVING COUNT(*) > 10; 

 

Al agregar ON, la unión entre country code se une entre CountryLanguage y las tablas Country.

Con la operación de coma se escribe la unión de esta manera:

 

 SELECT Name, Language FROM CountryLanguage, Country WHERE CountryCode = Code;

 

Con INNER JOIN y ON:

 

 SELECT Name, Language FROM CountryLanguage INNER JOIN Country ON CountryCode = Code;

 

-Si el nombre de la columna es el mismo en ambas tablas, se agrega USING() en lugar de ON, y se incluye el nombre común entre las tablas  en el parentesis:

 

SELECT Name, Language FROM CountryLanguage INNER JOIN Country USING(Code);

 

JOIN y CROSS JOIN son sinónimos para INNER JOIN.