Sunday, July 26, 2009

Aprendiendo MySQL

A continuación publicare una practica básica de MySQL bien interesante y fácil de aprender, la misma fue realizada por el Ing. José Paredes, director de operaciones de la Fundación Código Libre Dominicano (FCLD)...
http://www.codigolibre.org/images/miembros/crhistian%20nunez.jpg

En esta practica de SQL estamos asumiendo que usted ya tiene instalado mysql.


MySQL

Para conectamos a mysql

bash:~$ mysql -U root -p


Para crear una Base Datos:

CREATE DATABASE fcld;

Para usted ver todas la Bases Datos creadas:

SHOW DATABASES;

Para conectarse a una Base Datos:

USE fcld;

Para nos conectamos a mysql desde el SHELL:

bash:~$ mysql -U root -p fcld

Desde su SHELL cargar el script del esquema hr a la base datos creada:

bash:~$ mysql fcld < hr_mysql.sql -u root -p

Para usted crear una tabla llamada fcld:

CREATE TABLE fcld (

estudiantes varchar(70), apellido varchar(70),

cedula integer, cod_curso varchar(10));

Para crear una tabla con Primary Key:

CREATE TABLE curso(

cod_curso varchar(10) PRIMARY KEY,

nom_curso varchar(70));

Para crear una tabla con Foreign KEY

CREATE TABLE seccion (

id_seccion int(5), desc_seccion varchar(70),

cod_curso varchar(10)

CONSTRAINT FOREIGN KEY (cod_curso) REFERENCES curso(cod_curso));

Para crear una tabla con CONSTRAINT NOT NULL, DEFAULT

CREATE TABLE picapollo ( nom_pica varchar(70) DEFAULT 'Chino', piezas varchar(30) NOT NULL);

Para crear una table especificando el motor de almacenamiento InnoDB:

CREATE TABLE estudiantes (id_estudiante int(10), nombre varchar(70), apellido varchar(70),

Telefono varchar(13), direccion varchar(300))

ENGINE=InnoDB;


Para crear una table especificando el motor de almacenamiento MySAM:

CREATE TABLE padres (nombre varchar(70), apellido varchar(70), telefono varchar(13), id_estudiante int(10), direccion varchar(300)) TYPE=MySAM;

Creando indices para la una tabla:

CREATE INDEX i_nombre ON padres(nombre);

Para usted ver todas las tablas creadas en una Base Datos:

SHOW TABLES;

Para ver la estructura de las tablas creadas:

DESC fcld;

Para insertar registros en una tabla:

INSERT INTO fcld (estudiantes, apellido, cedula, cod_curso) VALUES ('Ivelise', 'Matos', 00118999313, 'Secretaria');

Segunda forma:

INSERT INTO fcld VALUES ('Ivelis', 'Perpinan', 001399323, 'GNU/Diplomado');

Insertando registros nulos:

INSERT INTO fcld VALUES ('Miguelito', 'Perpinan', NULL, NULL);

Insertando solo en los campos deseados:

INSERT INTO fcld (estudiantes, cedula) VALUES ('Brianna', 00113499313);

Para extraer toda la informacion de una tabla:

SELECT * FROM fcld;

Para extraer los campos deseados de una tabla:

SELECT apellido, cod_curso FROM fcld;

Utilizando Operadores Aristmeticosy;

SELECT 80+60;

SELECT salary+150 Salario_Sumado, salary FROM employees;

SELECT 90-70;

SELECT salary-1050 Salario_Restado, salary FROM employees;

SELECT 20*60;

SELECT salary*10 Salario_Multiplicado, salary FROM employees;

SELECT 92/20;

SELECT salary/100 Salario_Dividio, salary FROM employees;

Utilizando Alias con las columnas:

SELECT salary AS salario, first_name "Primer Nombre", last_name PRIMER_APELLIDO

FROM employees;

Concatenando Columnas:

SELECT concat(first_name,salary) FROM employees;

Concatenando Columnas y agregando un espacio entre ellas:

SELECT concat(first_name,' ',salary) FROM employees;


Caracteres Literales:

SELECT first_name, 'Salario Es', salary FROM employees;

Utilizando la Clausula DISTINCT, para evitar registros duplicados:

Aqui vemos todos los registros que estan incluyendo los que se repiten:

SELECT department_id FROM employees;

Evitamos los duplicados:

SELECT DISTINCT(department_id) FROM employees;

Utilizando la Clausula WHERE:

Todos los empleado que pernecen al departamento 90:

SELECT * FROM employees WHERE department_id=90;

Todos los empleado que su ID de trabajo es PU_CLERK:

SELECT * FROM employees WHERE job_id='PU_CLERK';

Todos los empleado que iniciaron en una fecha dada:

SELECT * FROM employees WHERE hire_date='2002-08-31';

Condiciones de Comparaciones:

Operador Igual:

Seleccionar todos registros de la tabla de departaments donde su location_id sea igual a 1700:

SELECT * FROM departments WHERE location_id=1700;

Operador Mayor:

Seleccionar los last_name, manager y salario de la tabla de employees donde el salario sean mayor a 10000:

SELECT last_name, manager_id, salary FROM employees WHERE salary > 10000;

Operador Menor:

Seleccionar todos los empleados de la tabla de employees donde el salario sean menor a 15000:

SELECT * FROM employees WHERE salary < 15000;

Operador Mayor e Igual que:

Seleccionar todos los empleados de la tabla de employees donde el salario sean Mayor o Igual qua 11000:

SELECT * FROM employees WHERE salary >= 11000;

Operador Menor e Igual que:

Seleccionar todos los empleados de la tabla de employees donde el salario sean Menor o Igual qua 4800:

SELECT * FROM employees WHERE salary <= 4800;

Operador BETWEEN:

Seleccionar primer nombre, salario para los empleados que su fecha de ingreso sea del 2001 al 2004:

SELECT first_name, salary, hire_date FROM employees WHERE hire_date BETWEEN '2001-01-01' AND '2004-01-01';


Operador IN:

Seleccionar primer nombre, salario, mail para los empleados que estan en los departamentos 30, 40 7 100:

SELECT first_name, salary, email, hire_date, department_id FROM employees

WHERE department_id IN (30, 40, 100);

Operador LIKE:

Seleccionar primer nombre, salario, mail para los empleados que su nombre inicien con A:

SELECT first_name, salary, email, hire_date, department_id FROM employees

WHERE first_name LIKE 'A%';

Seleccionar primer nombre, salario, mail para los empleados que su nombre contenga el caracter con A:

SELECT first_name, salary, email, hire_date, department_id FROM employees

WHERE first_name LIKE '%A%';

Seleccionar primer nombre, salario, mail para los empleados que su nombre inicie con A y que el sexto caracter sea O, no importa los caracteres del medio:

SELECT first_name, salary, email, hire_date, department_id FROM employees

WHERE first_name LIKE 'A_____O';

Operador IS NULL:

Seleccionar los empleados que no tienen commision:

SELECT * FROM employees WHERE commission_pct IS NULL;

Condiciones Logicas:

Operador AND:

Seleccionar primer nombre, salario, mail para los empleados que su nombre inicien con A Y que su codigo de departamento sea 80:

SELECT first_name, salary, email, hire_date, department_id FROM employees WHERE first_name LIKE 'A%' AND department_id=80;

Operador OR:

Seleccionar primer nombre, salario, mail para los empleados que su salario sea mayor a 17000 O su nombre inicien con A:

SELECT first_name, salary, email, hire_date, department_id FROM employees WHERE salary > 16000 OR first_name LIKE 'A%';

SELECT employee_id, last_name, job_id, salary FROM employees WHERE (job_id = 'SA_REP' OR job_id = 'SH_CLERK') AND salary > 10000;

Operador NOT:

Seleccionar primer nombre, salario, mail para todos los empleados que no esten en los departamentos 30, 40 7 100:

SELECT first_name, salary, email, hire_date, department_id FROM employees

WHERE department_id NOT IN (30, 40, 100);



Clausula ORDER BY:

Seleccionar los nombre, salario, fecha de ingreso para todos los empleados ordenado por id empleado:

SELECT * FROM employees ORDER BY employee_id;

La misma consulta per ordenada descendentemente:

SELECT * FROM employees ORDER BY employee_id desc;

Utilizando la posicion del campo para ordenar, aqui estamos ordenando por el campo salario descendentemente;

SELECT * FROM employees ORDER BY 8 desc;

Ordenando Ascendente por los alias;

SELECT salary Salario, first_name FROM employees ORDER BY Salario;

Funciones de Caracteres:

Funcion LOWER:

Selecciona todos los nombre de empleados en Minuscula:

SELECT LOWER(first_name), salary, last_name FROM employees;

Funcion LCASE, es sinonimo de LOWER:

SELECT LCASE(first_name), salary, last_name FROM employees;

Funcion UPPER:

Selecciona todos los nombre de empleados en Mayuscula:

SELECT UPPER(first_name), salary, last_name FROM employees;

Funciones Para la manipulacion de Texto:

Devuelve una subcadena empezando en la posicion dada:

SELECT SUBSTRING(first_name, 1,4), first_name FROM employees;

SELECT LENGTH(first_name), first_name FROM employees;

Devuelve la cadena rellana de Y a la derecha:

SELECT RPAD(first_name, 13, 'Y'), salary, last_name FROM employees;

Devuelve la cadena rellana de Y a la izquierda:

SELECT LPAD(first_name, 13, 'Y'), salary, last_name FROM employees;

Repite una cadena las veces que las desees repetida:

SELECT REPEAT(first_name, 2), salary, last_name FROM employees;

Sustituye donde quiera que encuentra A por PEPE:

SELECT REPLACE(first_name, 'A', 'PEPE'), salary, last_name FROM employees;

Devuelve la encriptacion de una cadena dada:

SELECT MD5(first_name), salary, last_name FROM employees;

Eliminando los espacio en blanco a la izquierda:

SELECT LTRIM(' Fundacion Codigo Libre');

Eliminda los espacio en blanco a la derecha:

SELECT RTRIM('Fundacion Codigo Libre ');

Repite una cadena las veces que las desees repetida:

SELECT REPEAT(first_name, 2), salary, last_name FROM employees;

Devuelve el valor ascii:

SELECT ASCII('@');

SELECT ASCII('t');


Funciones Numericas:

SELECT round(6899,999.00);

SELECT truncate(1.793,7);

SELECT mod(10,4);

SELECT mod(salary, 500) FROM employees;

Funciones de Fechas:

Devuelve la Fecha actual:

SELECT CURRENT_DATE();

Sinonimo de CURRENT_DATE:

SELECT CURDATE();


Devuelve fecha y hora actual:

SELECT CURRENT_TIMESTAMP();

Devuelve fecha y hora actual:

SELECT NOW();

Sinonimo de NOW:

SELECT SYSDATE();

Retorna la hora actual:

SELECT CURTIME();

Retorna el numero de dia entre la fecha inicial y la fecha final:

SELECT DATEDIFF(hire_date, '2009-07-15') FROM employees;

Formatea el valor segun la cadena data:

SELECT DATE_FORMAT(hire_date, '%W %M %Y') FROM employees;

Retorna el dia que entro un empleado:

SELECT DAYNAME(hire_date) FROM employees;


Para extraer el año que iniciaron los empleado:

SELECT EXTRACT(YEAR FROM hire_date), hire_date FROM employees;


Para extraer el mes que iniciaron los empleado:

SELECT EXTRACT(MONTH FROM hire_date), hire_date FROM employees;

Para extraer los minutos de un tiempo dado:

SELECT MINUTE(CURRENT_TIMESTAMP);

Para extraer los segundos de un tiempo dado:

SELECT SECOND(CURRENT_TIMESTAMP);

Conversiones:

Para convertir un Strim a formato DATE:

SELECT CAST('2008-04-20' AS DATE);


Esta funcion sustituye a to_char en termino de fecha:

SELECT DATE_FORMAT(hire_date, '%d-%m-%Y') FROM employees;

Expresiones Condicionales:

Sentencia CASE:

Funcion de control de flujo, si el valor concuerda Pon Tal cosa, jejejeje...

SELECT department_id,

CASE department_id WHEN 20 THEN 'Gualey'

WHEN 30 THEN 'Capotillo'

WHEN 40 THEN 'Guandule'

WHEN 50 THEN 'Cristo Rey'

WHEN 60 THEN 'Almirante'

ELSE 'Otro de Gente Pura'

END

FROM employees;

COALESCE:

Retorna el primer valor no NULL de una lista, sustituyendo el valor NULL:

SELECT COALESCE(commission_pct, 99)

FROM employees;

Funciones de Grupos:

Funcion AVG:

Para saber el salario promedio de los empleado:

SELECT AVG(salary) FROM employees;

Funcion COUNT:

Para saber la cantidad de empleado:

SELECT COUNT(*) FROM employees;

Funcion MAX:

Para saber salario mas alto:

SELECT MAX(salary) FROM employees;




Funcion MIN:

Para saber salario mas minimo:

SELECT MIN(salary) FROM employees;

Funcion SUM:

Para saber el monto total de todos los salario:

SELECT SUM(salary) FROM employees;

Todas Juntas:

SELECT SUM(salary) Suma_Total, AVG(salary) Salario_Promedio,

MAX(salary) Salario_Maximo, MIN(salary) Salario_Minimo

FROM employees;

Funcion GROUP BY:

Si queremos el total de empleado por departamentos:

SELECT count(*) Total_Empleado, department_id AS Departamentos FROM employees

GROUP BY department_id;

Funcion HAVING:

Esta Funcion se utiliza para manejar las funciones de grupo:

Si queremos saber el salario promedio para todos los departamentos, pero que el promedio sea mayo a 5000:

SELECT department_id, AVG(salary) Promedio FROM employees GROUP BY department_id

HAVING AVG(salary) >5000;

Obteniendo Datos de varias tablas:

NATURAL JOIN une dos tablas mediante todas las columnas que tengan el mismo nombre.

Selecciona los registros que provienen de las dos tablas siempre y cuando los valores de las columnas que tienen el mismo nombre coincidan.

Si el tipo de dato es diferente en las columnas que tienen el mismo nombre, se produce un error.

SELECT department_id, department_name, first_name FROM employees NATURAL JOIN departments;

USING Utilizar la cláusula USING solamente cuando existe mas de una columna que coincide.

SELECT department_id, department_name, first_name FROM employees

JOIN departments USING (department_id);

Utilizando Alias:

SELECT a.department_id, b.department_name, a.first_name, a.salary

FROM employees a JOIN departments b USING (department_id);

Utilizando ON Se utiliza la cláusula ON para especificar la unión de las columnas

con distinto nombre o condiciones arbitrarias:

SELECT e.department_id, d.department_name, e.first_name, l.city FROM employees e

JOIN departments d ON e.department_id=d.department_id

JOIN locations l ON l.location_id=d.location_id;




Para retornar aquellos registros que no coinciden mediante una relación entre tablas, LEFT OUTER JOIN Seleccionamos todos los empleados incluyendo los que no esten a un departamento:

SELECT e.department_id, d.department_name, e.first_name, e.employee_id FROM employees e

LEFT OUTER JOIN departments d ON e.department_id=d.department_id ORDER BY 1;

RIGHT OUTER JOIN

Seleccionamos todos los departamentos tienen empleados y pero que tambien me traiga los que no tienen empleados:

SELECT e.department_id, d.department_name, e.first_name, e.employee_id FROM employees e

RIGHT OUTER JOIN departments d ON e.department_id=d.department_id ORDER BY 1;

Nota esto es forzando un FULL OUTER JOIN en mysql ya que no existe:

SELECT e.department_id, d.department_name, e.first_name, e.employee_id FROM employees e

LEFT OUTER JOIN departments d ON e.department_id=d.department_id UNION

SELECT e.department_id, d.department_name, e.first_name, e.employee_id FROM employees e

RIGHT OUTER JOIN departments d ON e.department_id=d.department_id;


Ahora el clasico Join:

SELECT e.department_id, d.department_name, e.first_name, e.employee_id FROM employees e, departments d where e.department_id=d.department_id;


Subconsultas:

Para obtener el nombre del empleado que mas alto tiene su salario:

SELECT first_name, salary FROM employees WHERE salary =(SELECT MAX(salary)

FROM employees);

Para saber el salario y nombre de los empleados que su salario es mayor al empleado Abel:

SELECT last_name, salary FROM employees WHERE salary > (SELECT salary FROM employees

WHERE last_name LIKE 'Abel');

Saber el salario minimo por departamento donde su salario minimo sea mayor al minimo del id departamento 50:

SELECT department_id, MIN(salary) FROM employees GROUP BY department_id HAVING MIN(salary) > (SELECT MIN(salary) FROM employees WHERE department_id = 50);

Operadores para Multiples Registros:

Operador ANY:

Compara el valor de la consulta por cualquiera de los valores que son retornados por la subconsulta.

SELECT employee_id, last_name, job_id, salary FROM employees WHERE salary < ANY (SELECT salary FROM employees WHERE job_id = 'IT_PROG') AND job_id <> 'IT_PROG';

Operador IN

Compara si uno o mas de los elementos retornados por la subconsulta coinciden con los de la lista de la consulta principal:

SELECT emp.last_name, manager_id FROM employees emp WHERE emp.employee_id NOT IN(SELECT mgr.manager_id FROM employees mgr);

SELECT emp.last_name, manager_id FROM employees emp WHERE emp.employee_id IN(SELECT mgr.manager_id FROM employees mgr);

Operador ALL:

Compara el valor de la consulta con todos los valores que retorna la subconsulta:

SELECT employee_id, last_name, job_id, salary FROM employees

WHERE salary < ALL (SELECT salary FROM employees WHERE job_id = 'IT_PROG')

AND job_id <> 'IT_PROG';


Operadores de Conjuntos:

Operador UNION:Une distintas consultas, no muestra los registros duplicados:

Lista los códigos de cada empleado, con su cargo actual y su historio.

SELECT employee_id, job_id FROM employees UNION

SELECT employee_id, job_id FROM job_history;


Operador UNION:Une distintas consultas, muestra los registros duplicados:

Lista los códigos de cada empleado, con su cargo actual y su historio, sin importar que se repitan:

SELECT employee_id, job_id, department_id FROM employees

UNION ALL SELECT employee_id, job_id, department_id FROM job_history ORDER BY employee_id;

Utilizando la Sentencia UPDATE:

Vamos actualizar el salario al empleado Id 146 A 56000:

Primero vemos cuanto gana este empleado:

SELECT * FROM employees WHERE employee_id=146;

Su salario es de RD$13500

Actualizacion del mismo:

UPDATE employees SET salary=56000

WHERE employee_id=146;

Ahora consultado haber si se realizo la actualizacion correctamente:

SELECT * FROM employees WHERE employee_id=146;

Si queremos actualizar varios campos:

Actualizaremos el nombre, apellido y email al empleado de id 144:

Primero vemos sus datos

SELECT * FROM employees WHERE employee_id=144;


UPDATE employees

SET first_name='Antonio',

last_name='Perpinan',

email='info@codigolibre.org'

WHERE employee_id=144;

Validamos la informacion actualizada:

SELECT * FROM employees WHERE employee_id=144;



Modificando desde Subconsultas:

Modificando los datos del job_id y el salary del empleado cuyo código es 114, obteniendo los datos a modificar del empleado cuyo código es 205.

Nota: Para realizar este UPDATE tenemos que crear la tabla employee2, ya que MysSqL tiene problema tomando valores de la misma tabla por tanto realice una copia de la tabla employees:

Creando la tabla employees2

CREATE TABLE employees2 AS SELECT * FROM employees

Ahora realizaremos el UPDATE:

UPDATE employees e

SET e.job_id = (SELECT e1.job_id

FROM employees2 e1

WHERE e1.employee_id = 205),

e.salary = (SELECT e2.salary

FROM employees2 e2

WHERE e2.employee_id = 205)

WHERE e.employee_id = 114;

Usando la sentencia DELETE:

Eliminamos el empleado con id 114 de la tabla employees2:

Nota:Si no especificamos con WHERE cual es el registro lo eliminara todos:

DELETE FROM employees2 WHERE employee_id=114;

Eliminando registro con un SubSelect:

Eliminamos los registros de la tabla employees2 que su id de departamento sea igual al id departamento que tienen de nombre Public:

DELETE FROM employees2 WHERE department_id = (SELECT department_id FROM departments WHERE department_name LIKE '%Public%');

Sentencia TRUNCATE:

Elimina todos los registros de una tabla y automaticamente realiza un COMMIT:

TRUNCATE TABLE employees2;

Comandos de Controles de Transacciones:

Necesitamos desactivar el AUTOCOMMIT:

SET AUTOCOMMIT=0;

Para este ejercicio vamos a insertar datos en la tabla employees2:

INSERT INTO employees2 (employee_id, first_name, last_name, salary)

SELECT employee_id, first_name, last_name, salary FROM employees;

Ahora vamos a confirmar que insertamos en la employees2;

SELECT * FROM employees2;

Ahora vamos a actualizar un registro para luego deshacer la actualizacion:

UPDATE employees2

SET first_name='Ivelis Perpinan',

salary='89000'

WHERE employee_id=114;


Confirmamos la actualizacion:

SELECT * FROM employees2 WHERE employee_id=114;

Ahora vamos hacer uso del comando ROLLBACK:

ROLLBACK;


Confirmamos si se deshiso los cambios realizados:

SELECT * FROM employees2 WHERE employee_id=114;

Si queremos que los cambios sean permanentes tenemos que aplicar COMMIT luego de la transaccion: Ya no importa los ROLLBACK que ejecutemos: Ahora vamos a actualizar un registro para luego confirmar la transaccion de la actualizacion:

UPDATE employees2

SET first_name='Brianna Melissa',

salary='98000'

WHERE employee_id=114;

Confirmamos la actualizacion:

SELECT * FROM employees2 WHERE employee_id=114;

Ahora vamos hacer uso del comando COMMIT:

COMMIT;

Ejecutamos para deshacer los cambios:

ROLLBACK;

Confirmamos si se deshizo los cambios realizados:

SELECT * FROM employees2 WHERE employee_id=114;

SAVE POINT:

SAVEPOINT fcld;

Ahora borraremos unos registros para recuperar los mismos hasta el punto de salvamento creado:

DELETE FROM employees2 WHERE employee_id=114;

Consultamos el registro y vemos que no esta:

SELECT * FROM employees2 WHERE employee_id=114;

Ahora vamos a realizar ROLLBACK hasta el punto creado:

ROLLBACK TO fcld;

Consultamos el registro esta recuperado:

SELECT * FROM employees2 WHERE employee_id=114;


Borrando Objetos:

Borrando tablas

DROP TABLE padres;

Borrando Bases Datos:

DROP TABLE fcld;

Para Borrar un Indice:

DROP INDEX i_nombre ON padres;

Para cambias el nombre de una tabla:

RENAME TABLE padres to tutores;

Ahora vamos con mi comando favorito *ALTER*:

Vamos agregar el campo sex a la tabla estudiantes:

ALTER TABLE estudiantes ADD COLUMN sex char(2);

Vemos la estructura de la tabla y confirmamos que el campo esta agregado;

DESC estudiantes;

Vamos a borrar el campo direccion de la tabla estudiantes:

ALTER TABLE estudiantes DROP COLUMN direccion;

Vemos la estructura de la tabla y confirmamos que el campo esta agregado;

DESC estudiantes;

Vamos a cambiar el nombre de la columna sex a sexo:

ALTER TABLE estudiantes CHANGE sex sexo char;

Vamos a cambiar el tipo de dato de la columna sexo:

ALTER TABLE estudiantes MODIFY sexo varchar(2);

Vamos cambiar el nombre de la tabla tutores a padres;

ALTER TABLE tutores RENAME padres;

Vamos añadir un indice a la table padre:

ALTER TABLE padres ADD INDEX id_nombre (nombre);

Para cambiar el motor de almacenamiento de una tabla:

ALTER TABLE padres ENGINE = InnoDB;

Y para terminar Creacion de Usuario:

CREATE USER fcld;

Si queremos dos usuario con su password:

CREATE USER fcld IDENTIFIED BY 'kikla';

CREATE USER jp IDENTIFIED BY 'kikla';

Para ver si el usuario esta creado:

SELECT user, password FROM mysql.user;


Para cambiar el password al usuario fcld:

UPDATE mysql.user set password=PASSWORD('1234') where user='fcld';

UPDATE mysql.user SET Password=PASSWORD('1234'), host='localhost' WHERE User='fcld';

Recargue las tablas de permisos usando:

FLUSH PRIVILEGES;

Para borrar un usuario:

DROP USER fcld;

DROP USER jp;

Otorgamos permisos en Objetos con GRANT y REVOKE:

Vamos a darle todos los privilegios al usuario fcld en la Base Datos fcld:

GRANT ALL ON fcld.* TO 'fcld'@'localhost';

Vamos a quitarle todos los privilegios al usuario fcld en la Base Datos fcld:

REVOKE ALL ON fcld.* FROM'fcld'@'localhost';

Quitando privilegios de SELECT al usario jp en la tabla employees;

REVOKE SELECT ON hr.employees FROM 'jp'@'localhost';

Otorgando privilegios de SELECT al usario jp en la tabla employees;

GRANT SELECT ON hr.employees TO 'jp'@'localhost';

Para Salir del Prompt de SQL:

CRLT+D

EXIT

QUIT

No es cuestion de certificacion, no es cuestion de blablabla, es cuestion de trabajar....

Espere muy pronto GNU/Diplomado de Bases Datos:

MySQL

PostgreSQL

Oracle



No comments:

Post a Comment