FAQ de Base de Datos

[Cain]

BD: MySQL

Pregunta: ¿Como puedo concatenar campos y valores cuando pueden haber NULL?

Respuesta:

La función CONCAT() devuelve NULL siempre que alguno de sus argumentos es NULL. Esto nos puede dar problemas al usar instrucciones como:

Código:

UPDATE tabla SET nombre_completo = CONCAT(nombre, " - ", apellidos)

Los registros donde nombre y apellido no sean NULL, podrán obtener un nombre_completo, pero si nombre o apellido son NULL, el registro no tendrá <i>nombre_completo</i>.

¿Cómo solucionamos este problema? Utilizando la función COALESCE().

COALESCE devuelve el primer argumento diferente de NULL que se le atorgue. Es decir:

Código:

COALESCE("hola", NULL)

Devuelve "hola"

Código:

COALESCE(NULL, "hola")

Devuelve "hola"

Aprovechando esto, podemos hacer:

Código:

UPDATE tabla SET nombre_completo = CONCAT(COALESCE(nombre, ""), " - ", COALESCE(apellidos, ""))

Ahora ya podremos obtener un nombre_completo para todos los registros :D

[urjose]

RDBMS: Todas

Pregunta: ¿Qué es una base de datos y que es un DBMS?


Respuesta:

Por C.J. Date:

Entre la base de datos física- es decir, los datos como estan almacenados fisicamente- y los usuarios del sistema hay una capa de software conocida de manera indistinta como el administrador de base de datos o el servidor de base de datos; o mas comunmente como el sistema de administración de base de datos (DBMS). Todas las solicitudes de acceso a la base de datos son manejadas por el DBMS

------------------

El DBMS es por mucho, el componente de software más importante del sistema en general, aunque no es el único. Otros comprenden utilerias, herramientas de desarrollo de aplicaciones, ayudas de diseño, generadores de informes y (el mas importante) el administrador de transacciones o monitor.

------------------

Una base de datos es un conjunto de datos persistentes que es utilizado por los sistemas de aplicación de alguna empresa dada.

[mauriciolangea]

Tema : Interbase/Firebird

Pregunta : ¿Como creo campos auto incremenables?

Respuesta

Para este punto, InterBase/Firebird usa generadores (generators), así como Oracle usa Secuencias. Cada generador tiene un valor, a continuación mostraré unos ejemplos de como usar los Generadores :


CREATE TABLE prueba
(
campo1 integer not null,
campo2 char(10),
PRIMARY KEY (campo1)
);

CREATE GENERATOR gen_prueba_id;


Para insertar valores:


INSERT INTO prueba (campo1, campo2) VALUES (gen_id(gen_prueba_id, 1), 'prueba me');


Para el mismo INSERT, también podrías crear un TRIGGER:


SET TERM ^ ;
CREATE TRIGGER prueba_bi FOR prueba
BEFORE INSERT POSITION 0
AS
BEGIN
if (new.campo1 is null) then
new.campo1 = gen_id(gen_prueba_id, 1);
END^
SET TERM ; ^


y el INSERT quedaría así :


INSERT INTO prueba (campo2) VALUES ('prueba me');


Puedes notar que ya en el INSERT no aparece el primer campo, esto es porque al realizar el INSERT, lo que hace es ejecutar el TRIGGER, que antes de insertar (BEFORE INSERT), revisa si CAMPO1 es nulo, si lo es, ejecuta el GENERADOR gen_prueba_id.

Esto puede parecer un poco complicado, pero los generadores te dan mayor potencia que los campos autoincrementables, puesto que simpre puedes leer un generador sin incrementarlo:


SELECT gen_id(gen_prueba_id, 0) FROM ...


y para cambiar el valor actual del generador con:


SET GENERATOR gen_prueba_id TO [algún_valor];

[mauriciolangea]

Pregunta : ¿Como puedo saber si tengo indices redundantes en mi base de datos?

Respuesta :

Simple, con el script que está a continuación ...


select u1.name || '.' || o1.name || ' redundante con ' || u2.name || '.' || o2.name "INDICES REDUNDANTES"
from sys.user$ u1,sys.obj$ o1,sys.ind$ i1,sys.icol$ ic1,sys.user$ u2,
sys.obj$ o2,sys.ind$ i2,sys.icol$ ic2
where
o1.obj# = i1.obj#
and o1.owner# != 0
and o1.owner# = u1.user#
and o2.obj# = i2.obj# and o2.owner# != 0
and o2.owner# = u2.user#
and i1.bo# = i2.bo#
and i1.cols = 1
and i2.cols > 1
and ic1.obj# = i1.obj#
and ic2.obj# = i2.obj#
and ic1.bo# = i1.bo#
and ic2.bo# = i2.bo#
and ic1.col# = ic2.col#
and ic1.pos# = ic2.pos#

[mauriciolangea]

Tema : Interbase/Firebird

Pregunta : ¿Como se utiliza ISQL?

Respuesta


Configurando variables de entorno

Para utilizar ISQL lo primero que debes configurar son las variables de entorno para las variables ISC_USER y ISC_PASSWORD. Que nos serviría para autentificar nuestro usuario en Interbase/Firebird, de no configurar éstas variables arrojará el error diciendo que el usuario y contraseña no están definidas.

Ejemplo :

Desde una sesión DOS ejecuta éstas dos líneas ...

SET ISC_USER=SYSDBA
SET ISC_PASSWORD=masterkey

En Linux ...

export ISC_USER=SYSDBA
export ISC_PASSWORD=masterkey

... sin embargo, en Linux existe otro programa llamado isql (unixodbc), así que sería recomandable renombrar el archivo, por ejemplo a fsql.

También podrías dejar configurado permanente, agregando estas líneas en el archivo AUTOEXEC.BAT, para ordenadores con Windows 9x, o para los ordenadores con NT, 2000 o XP, agregar a la variables de usuario dos nuevas variables, la primera sería ISC_USER con valor SYSDBA y la otra sería ISC_PASSWORD con valor masterkey.


Creando base de datos

Entonces para continuar, lo primero que podríamos hacer sería crear una base de datos ...

SQL> create database "d:\interbase\prueba.gdb" user 'SYSDBA' password 'masterkey';


Conectar a base de datos

después de haber creado la base de datos, nos conectaremos a ella ...

SQL> connect "d:\interbase\prueba.gdb";
Database: "d:\interbase\prueba.gdb"


Crear tablas en la base de datos

después de habernos conectado, crearemos tablas en nuestra base de datos recién creada ...

SQL> create table T1(col_1 int, col_2 char(10), col_3 varchar(25));


Conclusión

Con lo que he explicado hasta ahora basta para que se saquen conclusiones de la continuación de cualquier trabajo que se desee hacer con InterBase/FireBird.

[cubis]

Tema : Todas

Pregunta : ¿Qué es SQL?

Respuesta

SQL es el lenguaje con el cual le "Hablamos" a una base de datos, las bases de datos (la mayoria) funcionan bajo sentencias SQL.

SQL se programa atravez de scripts (programas), que usan la sintax de SQL que es muy simple.

SQL al mismo tiempo lo podemos llamar como lenguaje de programación porque con el programamos diferentes tipos de funciones para nuestro DBMS.

La sintax de SQL varia en algunos DBMS, la sintax de MySQL no es la misma que de Oracle.

[mauriciolangea]

Tema : Interbase

Pregunta : Mi base de datos esta corrupta, ¿Que puedo hacer?

Respuesta

La corrupción de base de datos puede ser reparado y en la mayoría de los casos corregido por GFIX o combinando GFIX y GBAK.

1. Las siguientes variables tienen que estar definidas.

SET ISC_USER=SYSDBA
SET ISC_PASSWORD=masterkey

2. Siempre debes asegurarte que estás trabajando con una copia de la base de datos, no la base de datos de producción. Usa en sistema operativo para hacer una copia de la base de datos. Debes tener acceso exclusivo para hacer esto.

copy employee.gdb basededatos.gdb

3. Ahora revisaremos si hay corrupción de base de datos.

gfix -v -full basededatos.gdb

4. Si con el comando anterior indica que hay problemas con la base de datos, necesitaremos repararlo.

gfix -mend -full -ignore basededatos.gdb

5. Ahora veremos si la corrupción ha sido reparada.

gfix -v -full basededatos.gdb

6. Si aún sigue habiendo problemas, necesitaremos realizar un respaldo y restauración completo. El su formato más simple el la línea de comando de respaldo sería:

gbak -backup -v -ignore basededatos.gdb basededatos.gbk

7. Sin embargo si GBAK se cae porque está teniendo problemas con la basura, entonces usa el siguiente comando:

gbak -backup -v -ignore -garbage basededatos.gdb basededatos.gbk

8. Si hay corrupción en las versiones del registro de una transacción del limbo, entonces usted necesitas incluir el interruptor -limbo:

gbak -backup -v -ignore -garbage -limbo basededatos.gdb basededatos.gbk

9. Ahora crea una nueva base de datos del respaldo:

gbak -create -v basededatos.gbk nuevabasededatos.gdb

[mauriciolangea]

Tema : Interbase

Pregunta : ¿Como se crean los usuarios en Interbase ?

Respuesta


La seguridad de InterBase está basada en el concepto de usuario. Los usuarios autorizados están almacenados en una base de datos de seguridad, que se llama ISC4.GDB. Cada servidor InterBase tiene su propia base de datos de seguridad, lo que significa que la definición del usuario sólo pertenece al servidor en donde está almacenado. El mismo usuario puede existir en varios servidores distintos, pero debe ser creado en cada uno de esos servidores donde es requerido. La base de datos también almacena la contraseña encriptada para cada usuario. Los usuarios en la base de datos de seguridad pueden acceder a todas las bases de datos que estén el servidor, siempre que estén autorizados para hacerlo.

El usuario puede tener un largo máximo de 31 caracteres. El usuario en discrimina entre mayúsculas o minúsculas. La contraseña puede tener un largo de 8 caracteres, y si distingue entre mayúsculas y minúsculas.

Para crear un usuario en Interbase, se hace con la siguiente línea de comando;


gsec -add prueba -pw prueba

Para mostrar los usuario que existen en la base de datos de seguridad;

gsec -display

user name uid gid full name
--------------------------------------------------------------------------------
SYSDBA 0 0
PRUEBA 0 0


Para eliminar un usuario Interbase;

gsec -del prueba

[mauriciolangea]

Tema : Interbase

Pregunta : ¿Cuanta información puede almacenar Interbase?

Respuesta


La mayoría de los límites reales de la base de datos Interbase/Firebird son prácticos en lugar de definidos por el software. Por ejemplo, puedes definir hasta 32767 columnas en una tabla.

Hoy dos restricciones significativas:

El máximo de indices por tablas es de 64.

El tamaño máximo de un índice es 254 bytes y es menos para las llaves compuestas.

Otros límites:

Los nombres de metadatos están restringido a 31 caracteres.

Las filas están restringidas a 32767 bytes

Una base de datos no puede contener más de 32767 tablas.

El tamaño máximo para una base de datos es alrededor de 7 terabytes.

Cada tabla puede almacenar aproximadamente 2**31 filas. Una tabla con filas largas - con muchos campos o campos largos - almacenará menos registros que una tabla con campos muy cortos.

[fenix4]

Pregunta: Se puede agregar un registro a una tabla, dependiendo del ultimo valor actualizado en un campo de otra tabla

Respuesta: Si. Solo se tiene que revisar en la tabla inserted, que es la tabla del sistema donde se guardan los ultimos insert o update de las tablas (es como una tabla tmp). Esto se hace atravez de un desencadenador o trigger es cual se ejecutara cuando se haga un cambio en la tabla a la cual esta asignada el trigger. Luego de revisar si el campo de la tabla fue moficado con la funcion IF UPDATE (CAMPO ) se compara ese valor que se ha obtenido de la tabla inserted con el valor que se desea comparar. Posteriormente es buena idea revisar la tabla destino a ver si ese valor ya no esta alli. y luego se realiza el inser o update dependiendo del caso.


Ejemplo:

Código:

CREATE TRIGGER export_dir ON [dbo].[prog_acreditados_tmp] 
AFTER UPDATE 
AS
declare @situacion int
declare @nro_exp int
select @situacion = situacion, @nro_exp = nro_exp from inserted --revisa en la tabla inserted los valores de los campos
begin
IF UPDATE (situacion)	-- verifica si se modifico el campo situacion
	begin		
	if ((@situacion = 17) or (@situacion = 168) ) -- verifica si es informe favorable o si es acreditado
		begin
		if (select id from dbo.directorio_tmp where nro_exp = @nro_exp and tipo_exp = 90) is null --revisa en la tabla a ver si ya esta el registro
			begin   
			insert into dbo.directorio_tmp	(
					nivel,
					programa,
					mencion,
					areaconocimiento,
					grado,
					sede,
					instituto,
					nro_exp,
					tipo_exp
					) 
					SELECT
					nivel,
					LOWER(nombre),
					LOWER(mencion),
					area_conocimiento,
					grado,
					LOWER(sede),				
					institucion,
					nro_exp,
					'90' 
					from dbo.prog_acreditados_tmp 
					where nro_exp = @nro_exp    			
			end
		end
	end	
--raiserror('Situacion de dir_tmp %d de exp %d ',16,1,@situacion,@nro_exp) -- para verificar los valores
end

[victork_py]

BD : Firebird

Pregunta : ¿Cómo conectar a la base de datos desde JSP?

Repuesta : Suponiendo los siguientes puntos :
- Firebird ya esta instalado.
- Se quiere acceder a la BD “ejemplo.gdb” desde una aplicación JSP ubicada en la carpeta “C:\ejemplo” del servidor web.
- La BD esta ubicada en la carpeta “C:\db_ejemplo”
- La BD contiene una tabla llamada clientes y se quiere hacer un SELECT a dicha tabla.

Siga los siguientes pasos:

- Bajar el archivo FirebirdSQL-1.0.1.ZIP
- En la carpeta donde están ubicados los archivos JSP, crear la carpeta WEB-INF y dentro de WEB-INF la carpeta lib.
- Copiar todos los archivo con extensión JAR a la carpeta lib
- El siguiente código es para conectarse a la BD:

Class.forName("org.firebirdsql.jdbc.FBDriver");
conn = DriverManager.getConnection("jdbc:firebirdsql:loca lhost:C:\\ejemplo\\ejemplo.gdb?lc_ctype=ISO8859_1" , “SYSDBA”, “masterkey”);

Observaciones :
- La variable lc_ctype indica el charset que se usa para la conexión, si no se indica explícitamente el ISO8859_1, usará el charset por defecto y lanzará una excepción cuando se intenta insertar “ñ”, o vocales con acento.
- Esta usando el usuario SYSDBA con su password por defecto, si desea usar otro usuario o cambió la contraseña de SYSDBA debe cambiar al usuario y la contraseña adecuada.
- La variable conn es de tipo Connection

Espero que les sirva.

[mauriciolangea]

Tema : Interbase

Pregunta : ¿Como permito que los usuarios puedan modificar su propia contraseña?

Respuesta

La manera más sencilla es hacer un GRANT UPDATE a la tabla USERS para que sea una tabla PUBLICA, además de crear u TRIGGER para prevenir que los usuarios puedan cambiar la contraseña de otros usuarios, a excepción de SYSDBA.

Debes conectarte a la base de datos de seguridad de Interbase (isc4.gdb) ...


En windows ...

CONNECT 'C:\Archivos de programa\Borland\InterBase\isc4.gdb'
USER 'SYSDBA'
PASSWORD 'masterkey';


En Linux ...

CONNECT /opt/interbase/isc4.gdb
USER 'SYSDBA'
PASSWORD 'masterkey';


Creamos el TRIGGER, para que los usuarios no se cambién la contraseña entre sí, a excepción de SYSDBA.


CREATE EXCEPTION E_NO_RIGHT
'No estás autorizado para modificar a éste usuario.';

SET TERM !!;
CREATE TRIGGER user_name_bu
FOR USERS
BEFORE UPDATE
AS
BEGIN
IF (NOT (USER='SYSDBA' OR USER=OLD.USER_NAME))
THEN EXCEPTION E_NO_RIGHT;
END !!
SET TERM ;!!


Y finalmente realizamos el GRANT UPDATE sobre la table USERS, para que sea una tabla PUBLICA.


GRANT UPDATE(PASSWD, GROUP_NAME, UID, GID, FIRST_NAME, MIDDLE_NAME, LAST_NAME)
ON USERS
TO PUBLIC;


Esta modificación tiene una gran falencia, todos los usuarios y sus contraseñas encriptadas, quedarán visibles al PUBLICO, de esta manera es más fácil descargar la lista de usuarios y intentar romperlas a fuerza bruta.

[mauriciolangea]

Tema : InterBase

Pregunta : ¿Como puedo cambiar la contraseña de SYSDBA?

Respuesta :

SYSDBA es la cuenta administrativa por defecto, cuando InterBase/Firebird es instalado por primera vez, y el el único usuraio autorizado. Esta cuenta especializada tiene acceso total a todas las bases de datos del servidor y está por sobre las restricciones de seguridad. Por lo tanto, es extremadamente importante cambiar la contraseña de SYSDBA de la por defecto, la que es "masterkey", por otra que sólo los administradores sepan.

El siguinete procedimiento se asume que no tienes una herramienta gráfica y que debes usar los commandos de consola.

1. Vaya a la máquina servidor y conectese como usuario Administrador o root.
2. Sobre una máquina con windows abra un dialogo de consola (MS-DOS).
3. Cambiese al directorio en donde InterBase/Firebird fue instalado. (Sobre Windows esto sería C:\Archivos de programa\Firebird\bin ó C:\Archivos de programa\Borland\InterBase\bin. Sobre Linux sería /opt/interbase/bin ).
4. Para conectarte al servidor InterBase/Firebird escribe lo siguiente, para conectarte (Las mayúsculas importan):
   

   gsec -user sysdba -password masterkey

   Después deberías ver la utilidad:
   

   GSEC>

5. Escribe el siguiente comando para cambiar la contraseña:
   
   

   GSEC> modify sysdba -pw nuevacontraseña

   Donde "nuevacontraeña" es la nueva contraseña de SYSDBA.
   

6. Ahora sal de GSEC.
   

   GSEC> quit

[Edypu]

BD: MySQL

Autor: MySQL AB
Traductor: MySQL Hispano

Pregunta: Conectar y desconectarse al servidor

Respuesta:

Para conectarse al servidor necesitas el nombre de usuario MySQL y el Password si el servidor se esta ejecutando en una maquian distinta a la que estás conectada , necesitas especificar también el nombre de Host

shell> MySql -h host -u user -p
Enter password : ***********
welcome to the MySQL monitor. Commands en whit ; or \g.
Your MySQL connetion id is 459 to server version : 3.22.20a-log

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> help

El prompt te indica que MySQL ya está listo para las instruciones de commandos.

Algunas instalaciones MySql permiten a los usuarios conectarse como usuarios "anonymuos" (sin nombre) el servidor en el host local. Si este es el caso en tu máquina, deberías ser capaz de conectar a ese servidor invocando mysql sin ninguna opción:

shell>mysql
Bye

Una vez que hayas conectado con éxito, pudes desconectarte en cualquier momento tecleando QUIT en el promt mysql>

mysql>quit

tambien puedes desconectarte usando CTRL + D

[Edypu]

BD: MySQL

Autor: MySQL AB
Traductor: MySQL Hispano

Pregunta: Haciendo consultas
Respuesta:

Asegúrate de que estás conectado al servidor, como se ha discutido en secciones anteriores. El hacerlo no implica que tengas seleccionada ninguna base de datos con la que trabajar, pero está bien. En este punto, es más importante averiguar un poco sobre cómo lanzar consultas que lanzarse directamente a la creación de tablas, cargar datos en ellas y recuperar los datos de las mismas. Esta sección describe los principios básicos de la entrada de comandos, usando varias consultas que puedes probar para familiarizarte con la forma de trabajo de mysql.
Aquí presentamos un comando simple que pide al servidor que nos diga su número de versión y fecha actual. Tecléalo como se muestra a continuación siguiendo el prompt mysql> y pulsa la tecla RETURN:


mysql> SELECT VERSION(), CURRENT_DATE;
+-----------+--------------+
| version() | CURRENT_DATE |
+-----------+--------------+
| 3.22.23b | 2000-01-05 |
+-----------+--------------+
1 row in set (0.06 sec)

mysql>

Esta consulta ilustra muchas cosas sobre mysql:

* Un comando consiste normalmente de una sentencia SQL seguida por un punto y coma. (Existen algunas excepciones donde no es necesario el punto y coma. QUIT, mencionado más adelante, es una de ellas. Conoceremos otras más adelante.)

* Cuando lanzas un comando, mysql lo envía al servidor para su ejecución y muestra los resultados, después imprime otro mysql> para indicar que está listo para otro comando.

* mysql muestra la salida de una consulta como una tabla (filas y columnas). La primera fila contiene etiquetas para las columnas. Las siguientes filas son el resultado de la consulta. Normalmente, las etiquetas de las columnas son los nombres de las columnas que has obtenido de la base de datos. Si pides el valor de una expresión en vez de una columna de una tabla (como en el ejemplo anterior), mysql etiqueta la columna usando la propia expresión.

* mysql muestra el número de filas que se han dado como resultado, y cuánto tiempo llevó la ejecución de la consulta, lo que te da una idea aproximada del rendimiento del servidor. Estos valores son imprecisos porque representan tiempo real (no tiempo de CPU o máquina), y porque están afectados por factores como la carga del servidor y la latencia de la red. (Por cuestiones de brevedad, la línea "rows in set" no se mostrará en los ejemplos posteriores de este capítulo.)

Las palabras clave pueden ser tecleadas en cualquier combinación mayúscula/minúscula. Las siguientes consultas son equivalentes:

mysql> SELECT VERSION(), CURRENT_DATE;
mysql> select version(), current_date;
mysql> SeLeCt vErSiOn(), current_DATE;

He aquí otra consulta. Demuestra que puedes usar mysql como una calculadora sencilla:

mysql> SELECT SIN(PI()/4), (4+1)*5;
+-------------+---------+
| SIN(PI()/4) | (4+1)*5 |
+-------------+---------+
| 0.707107 | 25 |
+-------------+---------+

Los comandos vistos hasta aquí han sido relativamente cortos, sentencias de una sola línea. También puedes insertar múltiples sentencias en una sola línea. Simplemente, termina cada una con un punto y coma:

mysql> SELECT VERSION(); SELECT NOW();

+-----------+
| version() |
+-----------+
| 3.22.23b |
+-----------+

+---------------------+
| NOW() |
+---------------------+
| 2000-01-05 17:33:16 |
+---------------------+

Un comando no necesita ser dado todo en una sóla línea, así pues, los comandos largos que requieran varias lineas no son un problema. mysql determina cuando termina tu sentencia buscando el punto y coma final, no buscando el final de la línea de entrada. (En otras palabras, mysql acepta entrada de libre formato: recoleta las líneas de entrada pero no las ejecutahasta que vea el punto y coma.)

Aquí tenemos un simple ejemplo de múltiples líneas:

mysql> SELECT
-> USER()
-> ,
-> CURRENT_DATE;
+----------------+--------------+
| USER() | CURRENT_DATE |
+----------------+--------------+
| root@localhost | 2000-01-05 |
+----------------+--------------+

[Edypu]

BD: MySQL

Autor: MySQL AB
Traductor: MySQL Hispano

Pregunta: Creando y usando una base de datos

Respuesta:

Ahora que conocemos como escribir y ejecutar sentencias, es tiempo de accesar a una base de datos.

Supongamos que tenemos diversas mascotas en casa (nuestro pequeño zoológico) y deseamos tener registros de los datos acerca de ellas. Podemos hacer esto al crear tablas que guarden esta información, para que posteriormente la consulta de estos datos sea bastante fácil y de manera muy práctica. Esta sección muestra como crear una base de datos, crear una tabla, incorporar datos en una tabla, y recuperar datos de las tablas de diversas maneras

La base de datos "zoológico" será muy simple (deliveradamente), pero no es difícil pensar de situaciones del mundo real en la cual una base de datos similar puede ser usada.

Primeramente usaremos la sentencia SHOW para ver cuáles son las bases de datos existentes en el servidor al que estamos conectados:

mysql> SHOW DATABASES;
+----------+
| Database |
+----------+
| mysql |
| test |
+----------+
2 rows in set (0.00 sec)

mysql>Es probable que la lista de bases de datos que veamos sea diferente en nuestro caso, pero seguramente las bases de datos "mysql" y "test" estarán entre ellas. En particular, la base de datos "mysql" es requerida, ya que ésta tiene la información de los privilegios de los usuarios de MySQL. La base de datos "test" es creada durante la instalación de MySQL con el propósito de servir como área de trabajo para los usuarios que inician en el aprendizaje de MySQL.

Se debe anotar también que es posible que no veamos todas las bases de datos si no tenemos el privilegio SHOW DATABASES. Se recomienda revisar la sección del manual de MySQL dedicada a los comandos GRANT y REVOKE.

Si la base de datos "test" existe, hay que intentar accesar a ella:

mysql> USE test
Database changed
mysql>Observar que USE, al igual que QUIT, no requieren el uso del punto y coma, aunque si se usa éste, no hay ningún problema. El comando USE es especial también de otra manera: éste debe ser usado en una sóla línea.

Podríamos usar la base de datos "test" (si tenemos acceso a ella) para los ejemplos que vienen a continuación, pero cualquier cosa que hagamos puede ser eliminada por cualquier otro usuario que tenga acceso a esta base de datos. Por esta razón, es recomendable que preguntemos al administrador MySQL acerca de la base de datos que podemos usar. Supongamos que deseamos tener una base de datos llamada "zoologico" (nótese que no se está acentuando la palabra) a la cual sólo nosotros tengamos acceso, para ello el administrador necesita ejecutar un comando como el siguiente:

mysql> GRANT ALL on zoologico.* TO MiNombreUsuario@MiComputadora
-> IDENTIFIED BY 'MiContraseña';en donde MiNombreUsuario es el nombre de usuario asignado dentro del contexto de MySQL, MiComputadora es el nombre o la dirección IP de la computadora desde la que nos conectamos al servidor MySQL, y MiContraseña es la contraseña que se nos ha asignado, igualmente, dentro del ambiente de MySQL exclusivamente. Ambos, nombre de usuario y contraseña no tienen nada que ver con el nombre de usuario y contraseña manejados por el sistema operativo (si es el caso).

Si el administrador creó la base de datos al momento de asignar los permisos, podemos hacer uso de ella. De otro modo, nosotros debemos crearla:

mysql> USE zoologico
ERROR 1049: Unknown database 'zoologico'
mysql>El mensaje anterior indica que la base de datos no ha sido creada, por lo tanto necesitamos crearla.

mysql> CREATE DATABASE zoologico;
Query OK, 1 row affected (0.00 sec)

mysql> USE zoologico
Database changed
mysql>Bajo el sistema operativo Unix, los nombres de las bases de datos son sensibles al uso de mayúsculas y minúsculas (no como las palabras clave de SQL), por lo tanto debemos de tener cuidado de escribir correctamente el nombre de la base de datos. Esto es cierto también para los nombres de las tablas.

Al crear una base de datos no se selecciona ésta de manera autómatica; debemos hacerlo de manera explícita, por ello usamos el comando USE en el ejemplo anterior.

La base de datos se crea sólo una vez, pero nosotros debemos seleccionarla cada vez que iniciamos una sesión con mysql. Por ello es recomendable que se indique la base de datos sobre la que vamos a trabajar al momento de invocar al monitor de MySQL. Por ejemplo:

shell>mysql -h casita -u blueman -p zoologico

Enter password: ******
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 17 to server version: 3.23.38-nt

Type 'help;' or '\h' for help. Type '\c' to clear the buffer

mysql>Observar que "zoologico" no es la contraseña que se está proporcionando desde la línea de comandos, sino el nombre de la base de datos a la que deseamos acceder. Si deseamos proporcionar la contraseña en la línea de comandos después de la opción "-p", debemos de hacerlo sin dejar espacios (por ejemplo, -phola123, no como -p hola123). Sin embargo, escribir nuestra contraseña desde la línea de comandos no es recomendado, ya que es bastante inseguro.

[Edypu]

BD: MySQL

Autor: MySQL AB
Traductor: MySQL Hispano

Pregunta: Creando una tabla
Respuesta:

Crear la base de datos es la parte más fácil, pero en este momento la base de datos está vacía, como lo indica el comando SHOW TABLES:
mysql> SHOW TABLES;
Empty set (0.00 sec)La parte un tanto complicada es decidir la estructura que debe tener nuestra base de datos: qué tablas se necesitan y qué columnas estarán en cada tabla.

En principio, necesitamos una tabla que contenga un registro para cada una de nuestras mascotas.

Ésta puede ser una tabla llamada mascotas, y debe contener por lo menos el nombre de cada uno de nuestros animalitos. Ya que el nombre en sí no es muy interesante, la tabla debe contener alguna otra información. Por ejemplo, si más de una persona en nuestra familia tiene una mascota, es probable que tengamos que guardar la información acerca de quien es el dueño de cada mascota. Así mismo, también sería interesante contar con alguna información más descriptiva tal como la especie, y el sexo de cada mascota.

¿Y que sucede con la edad?. Esto puede ser también de interés, pero no es una buena idea almacenar este dato en la base de datos. La edad cambia conforme pasa el tiempo, lo cual significa que debemos de actualizar los registros frecuentemente. En vez de esto, es una mejor idea guardar un valor fijo, tal como la fecha de nacimiento. Entonces, cuando necesitemos la edad, la podemos calcular como la diferencia entre la fecha actual y la fecha de nacimiento. MySQL proporciona funciones para hacer operaciones entre fechas, así que no hay ningún problema.

Al almacenar la fecha de nacimiento en lugar de la edad tenemos algunas otras ventajas:

Podemos usar la base de datos para tareas tales como generar recordatorios para cada cumpleaños próximo de nuestras mascotas. Podemos calcular la edad en relación a otras fechas que la fecha actual. Por ejemplo, si almacenamos la fecha en que murió nuestra mascota en la base de datos, es fácil calcular que edad tenía nuestro animalito cuando falleció. Es probable que estemos pensando en otro tipo de información que sería igualmente útil en la tabla "mascotas", pero para nosotros será suficiente por ahora contar con información de nombre, propietario, especie, nacimiento y fallecimiento.

Usaremos la sentencia CREATE TABLE para indicar como estarán conformados los registros de nuestras mascotas.

mysql> CREATE TABLE mascotas(
-> nombre VARCHAR(20), propietario VARCHAR(20),
-> especie VARCHAR(20), sexo CHAR(1), nacimiento DATE,
-> fallecimento DATE);
Query OK, 0 rows affected (0.02 sec)

mysql>VARCHAR es una buena elección para los campos nombre, propietario, y especie, ya que los valores que almacenarán son de longitud variable. No es necesario que la longitud de estas columnas sea la misma, ni tampoco que sea de 20. Se puede especificar cualquier longitud entre 1 y 255, lo que se considere más adecuado. Si resulta que la elección de la longitud de los campos que hemos hecho no resultó adecuada, MySQL proporciona una sentencia ALTER TABLE que nos puede ayudar a solventar este problema.

El campo sexo puede ser representado en una variedad de formas, por ejemplo, "m" y "f", o tal vez "masculino" y "femenino", aunque resulta más simple la primera opción.

El uso del tipo de dato DATE para los campos nacimiento y fallecimento debe de resultar obvio.

Ahora que hemos creado la tabla, la sentencia SHOW TABLES debe producir algo como:

mysql> SHOW TABLES;
+---------------------+
| Tables_in_zoologico |
+---------------------+
| mascotas |
+---------------------+
1 row in set (0.00 sec)

mysql>Para verificar que la tabla fué creada como nosotros esperabamos, usaremos la sentencia DESCRIBE:

mysql> DESCRIBE mascotas;
+--------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------------+-------------+------+-----+---------+-------+
| nombre | varchar(20) | YES | | NULL | |
| propietario | varchar(20) | YES | | NULL | |
| especie | varchar(20) | YES | | NULL | |
| sexo | char(1) | YES | | NULL | |
| nacimiento | date | YES | | NULL | |
| fallecimento | date | YES | | NULL | |
+--------------+-------------+------+-----+---------+-------+
6 rows in set (0.01 sec)

mysql>Podemos hacer uso de la sentencia DESCRIBE en cualquier momento, por ejempo, si olvidamos los nombres ó el tipo de las columnas en la tabla.

[Edypu]

BD: MySQL

Autor: MySQL AB
Traductor: MySQL Hispano

Pregunta: Cargar datos desde un fichero TXT
Respuesta:

Después de haber creado la tabla, ahora podemos incorporar algunos datos en ella, para lo cual haremos uso de las sentencias INSERT y LOAD DATA.
Supongamos que los registros de nuestras mascotas pueden ser descritos por los datos mostrados en la siguiente tabla.



Nombre Propietario Especie Sexo Nacimiento Fallecimento
Fluffy Arnoldo Gato f 1999-02-04
Mau Juan Gato m 1998-03-17
Buffy Arnoldo Perro f 1999-05-13
FanFan Benito Perro m 2000-08-27
Kaiser Diana Perro m 1998-08-31 1997-07-29
Chispa Omar Ave f 1998-09-11
Wicho Tomás Ave 2000-02-09
Skim Benito Serpiente m 2001-04-29

Debemos observar que MySQL espera recibir fechas en el formato YYYY-MM-DD, que puede ser diferente a lo que nosotros estamos acostumbrados.

Ya que estamos iniciando con una tabla vacía, la manera más fácil de poblarla es crear un archivo de texto que contenga un registro por línea para cada uno de nuestros animalitos para que posteriormente carguemos el contenido del archivo en la tabla únicamente con una sentencia.

Por tanto, debemos de crear un archivo de texto "mascotas.txt" que contenga un registro por línea con valores separados por tabuladores, cuidando que el orden de las columnas sea el mismo que utilizamos en la sentencia CREATE TABLE. Para valores que no conozcamos podemos usar valores nulos (NULL). Para representar estos valores en nuestro archivo debemos usar \N.

Para cargar el contenido del archivo en la tabla mascotas, usaremos el siguiente comando:

mysql> LOAD DATA LOCAL INFILE "mascotas.txt" INTO TABLE mascotas;La sentencia LOAD DATA nos permite especificar cuál es el separador de columnas, y el separador de registros, por default el tabulador es el separador de columnas (campos), y el salto de línea es el separador de registros, que en este caso son suficientes para que la sentencia LOAD DATA lea correctamente el archivo "mascotas.txt".

Si lo que deseamos es añadir un registro a la vez, entonces debemos hacer uso de la sentencia INSERT. En la manera más simple, debemos proporcionar un valor para cada columna en el orden en el cual fueron listados en la sentencia CREATE TABLE. Supongamos que nuestra hermana Diana compra un nuevo hamster nombrado Pelusa. Podemos usar la sentencia INSERT para agregar su registro en nuestra base de datos.

mysql> INSERT INTO mascotas
-> VALUES('Pelusa','Diana','Hamster','f','2000-03-30',NULL);Notar que los valores de cadenas y fechas deben estar encerrados entre comillas. También, con la sentencia INSERT podemos insertar el valor NULL directamente para representar un valor nulo, un valor que no conocemos. En este caso no se usa \N como en el caso de la sentencia LOAD DATA.

De este ejemplo, debemos ser capaces de ver que es un poco más la tarea que se tiene que realizar si inicialmente cargamos los registros con varias sentencias INSERT en lugar de una única sentencia LOAD DATA.

[Edypu]

BD: MySQL

Autor: MySQL AB
Traductor: MySQL Hispano

Pregunta: Calculo con fechas
Respuesta:

MySQL proporciona diversas funciones que se pueden usar para efectuar cálculos sobre fechas, por ejemplo, para calcular edades o extraer partes de una fecha (día, mes, año, etc).

Para determinar la edad de cada una de nuestras mascotas, tenemos que calcular la diferencia de años de la fecha actual y la fecha de nacimiento, y entonces substraer uno si la fecha actual ocurre antes en el calendario que la fecha de nacimiento. Las siguientes consultas muestran la fecha actual, la fecha de nacimiento y la edad para cada mascota.
mysql> SELECT nombre, nacimiento, CURRENT_DATE,
-> (YEAR(CURRENT_DATE) - YEAR(nacimiento))
-> - (RIGHT(CURRENT_DATE,5) < RIGHT(nacimiento,5)) AS edad FROM mascotas;
+--------+------------+--------------+------+
| nombre | nacimiento | CURRENT_DATE | edad |
+--------+------------+--------------+------+
| Fluffy | 1999-02-04 | 2002-12-23 | 3 |
| Mau | 1998-03-17 | 2002-12-23 | 4 |
| Buffy | 1999-05-13 | 2002-12-23 | 3 |
| FanFan | 2000-08-27 | 2002-12-23 | 2 |
| Kaiser | 1989-08-31 | 2002-12-23 | 13 |
| Chispa | 1998-09-11 | 2002-12-23 | 4 |
| Wicho | 2000-02-09 | 2002-12-23 | 2 |
| Skim | 2001-04-29 | 2002-12-23 | 1 |
| Pelusa | 2000-03-30 | 2002-12-23 | 2 |
+--------+------------+--------------+------+
9 rows in set (0.01 sec)Aquí, YEAR( ) obtiene únicamente el año y RIGHT( ) obtiene los cinco caracteres más a la derecha de cada una de las fechas, que representan el mes y el día (MM-DD). La parte de la expresión que compara los valores MM-DD se evalúa a 1 o 0, y permite ajustar el valor de la edad en el caso de que el valor MM-DD de la fecha actual ocurra antes del valor MM-DD de la fecha de nacimiento.

Dado que la expresión en sí es bastante fea, se ha usado un alias (edad) que es el que aparece como etiqueta en la columna que muestra el resultado de la consulta.

Esta consulta debe trabajar bien, pero el resultado puede ser de alguna manera más útil si las filas son presentadas en algún orden. Para ello haremos uso de la cláusula ORDER BY.

Por ejemplo, para ordenar por nombre, usaremos la siguiente consulta:

mysql> SELECT nombre, nacimiento, CURRENT_DATE,
-> (YEAR(CURRENT_DATE) - YEAR(nacimiento))
-> - (RIGHT(CURRENT_DATE,5) < RIGHT(nacimiento,5))
-> AS edad FROM mascotas ORDER BY nombre;
+--------+------------+--------------+------+
| nombre | nacimiento | CURRENT_DATE | edad |
+--------+------------+--------------+------+
| Buffy | 1999-05-13 | 2002-12-23 | 3 |
| Chispa | 1998-09-11 | 2002-12-23 | 4 |
| FanFan | 2000-08-27 | 2002-12-23 | 2 |
| Fluffy | 1999-02-04 | 2002-12-23 | 3 |
| Kaiser | 1989-08-31 | 2002-12-23 | 13 |
| Mau | 1998-03-17 | 2002-12-23 | 4 |
| Pelusa | 2000-03-30 | 2002-12-23 | 2 |
| Skim | 2001-04-29 | 2002-12-23 | 1 |
| Wicho | 2000-02-09 | 2002-12-23 | 2 |
+--------+------------+--------------+------+
9 rows in set (0.00 sec)Para ordenar por edad en lugar de nombre, únicamente tenemos que usar una cláusula ORDER BY diferente:

mysql> SELECT nombre, nacimiento, CURRENT_DATE,
-> (YEAR(CURRENT_DATE) - YEAR(nacimiento))
-> - (RIGHT(CURRENT_DATE,5) < RIGHT(nacimiento,5))
-> AS edad FROM mascotas ORDER BY edad;
+--------+------------+--------------+------+
| nombre | nacimiento | CURRENT_DATE | edad |
+--------+------------+--------------+------+
| Skim | 2001-04-29 | 2002-12-23 | 1 |
| FanFan | 2000-08-27 | 2002-12-23 | 2 |
| Wicho | 2000-02-09 | 2002-12-23 | 2 |
| Pelusa | 2000-03-30 | 2002-12-23 | 2 |
| Fluffy | 1999-02-04 | 2002-12-23 | 3 |
| Buffy | 1999-05-13 | 2002-12-23 | 3 |
| Mau | 1998-03-17 | 2002-12-23 | 4 |
| Chispa | 1998-09-11 | 2002-12-23 | 4 |
| Kaiser | 1989-08-31 | 2002-12-23 | 13 |
+--------+------------+--------------+------+
9 rows in set (0.01 sec)Una consulta similar puede ser usada para determinar la edad que tenía una mascota cuando falleció. Para determinar que animalitos ya fallecieron, la condición es que el valor en el campo fallecimiento no sea nulo (NULL). Entonces, para los registros con valor no-nulo, calculamos la diferencia entre los valores fallecimiento y nacimiento.

mysql> SELECT nombre, nacimiento, fallecimiento,
-> (YEAR(fallecimiento) - YEAR(nacimiento))
-> - (RIGHT(fallecimiento,5) < RIGHT(nacimiento,5))
-> AS edad FROM mascotas WHERE fallecimiento IS NOT NULL;
+--------+------------+---------------+------+
| nombre | nacimiento | fallecimiento | edad |
+--------+------------+---------------+------+
| Kaiser | 1989-08-31 | 1997-07-29 | 7 |
+--------+------------+---------------+------+
1 row in set (0.01 sec)La consulta usa fallecimiento IS NOT NULL, en vez de falleciimiento < > NULL porque NULL es una valor especial. Esto será explicando más a detalle posteriormente.

¿Qué sucede si deseamos conocer cuáles de nuestras mascotas cumplen años el próximo mes? Para este tipo de cálculos, el año y el día son irrelevantes; simplemente tenemos que extraer el valor del mes en la columna nacimiento. Como se mencionó anteriormente, MySQL proporciona diversas funciones para trabajar y manipular fechas, en este caso haremos uso de la función MONTH( ). Para ver como trabaja, vamos a ejecutar una consulta muy simple que muestra tanto el valor de una fecha como el valor que regresa la función MONTH( ).

mysql> SELECT nombre, nacimiento, MONTH(nacimiento) FROM mascotas;
+--------+------------+-------------------+
| nombre | nacimiento | MONTH(nacimiento) |
+--------+------------+-------------------+
| Fluffy | 1999-02-04 | 2 |
| Mau | 1998-03-17 | 3 |
| Buffy | 1999-05-13 | 5 |
| FanFan | 2000-08-27 | 8 |
| Kaiser | 1989-08-31 | 8 |
| Chispa | 1998-09-11 | 9 |
| Wicho | 2000-02-09 | 2 |
| Skim | 2001-04-29 | 4 |
| Pelusa | 2000-03-30 | 3 |
+--------+------------+-------------------+
9 rows in set (0.00 sec)Encontrar los animalitos cuyo cumpleaños es el próximo mes es muy sencillo. Suponiendo que el mes actual es Abril (valor 4), entonces tenemos que buscar los registros cuyo valor de mes sea 5 (Mayo).

mysql> SELECT nombre, nacimiento FROM mascotas WHERE MONTH(nacimiento) = 5;
+--------+------------+
| nombre | nacimiento |
+--------+------------+
| Buffy | 1999-05-13 |
+--------+------------+
1 row in set (0.00 sec)Aquí habrá por supuesto una complicación si el mes actual es Diciembre. No podemos simplemente agregar uno al número del mes (12) y buscar los registros cuyo mes de nacimiento sea 13 porque dicho mes no existe. En vez de esto, tenemos que buscar los animalitos que nacieron en Enero (mes 1).

Sin embargo, lo mejor es que podemos escribir una consulta que funcione no importando cuál sea el mes actual. La función DATE_ADD( ) nos permite agregar un intervalo de tiempo a una fecha dada. Si agregamos un mes al valor regresado por la función NOW( ), y entonces extraemos el valor del mes con la función MONTH( ), el resultado es que siempre obtendremos el mes siguiente.

La consulta que resuelve nuestro problema queda así:

mysql> SELECT nombre, nacimiento FROM mascotas
-> WHERE MONTH(nacimiento) = MONTH(DATE_ADD(NOW(), INTERVAL 1 MONTH));

[Edypu]

BD: MySQL

Autor: MySQL AB
Traductor: MySQL Hispano

Pregunta: Coincidencia de patrones
Respuesta:

MySQL proporciona métodos de coincidencia de patrones basados en SQL estándar, así como también basados en expresiones regulares, de manera similar a las utilerías de Unix tales como vi, grep y sed.
La coincidencia de patrones basada en SQL nos permite usar _ (guión bajo) para un solo caracter y % para un arbitrario número de caracteres. En MySQL, los patrones SQL no son sensibles al uso de mayúsculas y minúsculas.

Es importante notar que no se usan los operadores =, < o > cuando se usan los patrones SQL; en su lugar se usan los operadores LIKE y NOT LIKE.

A continuación se presentan algunos ejemplos.

Para encontrar los nombres que comienzan con b:

mysql> SELECT * FROM mascotas WHERE nombre LIKE "b%";
+--------+-------------+---------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+---------+------+------------+---------------+
| Buffy | Arnoldo | Perro | f | 1999-05-13 | NULL |
+--------+-------------+---------+------+------------+---------------+
1 row in set (0.00 sec)Para encontrar los nombres que finalizan con fy:

mysql> SELECT * FROM mascotas WHERE nombre LIKE "%fy";
+--------+-------------+---------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+---------+------+------------+---------------+
| Fluffy | Arnoldo | Gato | f | 1999-02-04 | NULL |
| Buffy | Arnoldo | Perro | f | 1999-05-13 | NULL |
+--------+-------------+---------+------+------------+---------------+
2 rows in set (0.00 sec)Para encontrar nombres que contienen una s:

mysql> SELECT * FROM mascotas WHERE nombre LIKE "%s%";
+--------+-------------+-----------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+-----------+------+------------+---------------+
| Kaiser | Diana | Perro | m | 1989-08-31 | 1997-07-29 |
| Chispa | Omar | Ave | f | 1998-09-11 | NULL |
| Skim | Benito | Serpiente | m | 2001-04-29 | NULL |
| Pelusa | Diana | Hamster | f | 2000-03-30 | NULL |
+--------+-------------+-----------+------+------------+---------------+
4 rows in set (0.01 sec)El otro tipo de coincidencia de patrones proporcionado por MySQL hace uso de expresiones regulares. Para hacer uso de estos tipos de patrones se tienen que usar los operadores REGEXP y NOT REGEXP ( o RLIKE y NOT RLIKE, los cuáles son sinónimos).

Algunas características de las expresiones regulares son:

El caracter punto (.) coincide con cualquier caracter.
Una clase de caracteres [...] coincide con cualquier caracter dentro de los paréntesis cuadrados. Por ejemplo, [abc] coincide con a, b o c. Para nombrar un rango de caracteres, se usa el guión. [a-z] coincide con cualquier letra minúscula, mientras que [0-9] coincide con cualquier digito.
El caracter asterisco (*) coincide con cero o más instancias de lo que le preceda. Por ejemplo, x* coincide con cualquier número de caracteres x, [0-9]* coincide con cualquier número de digitos, y .* (punto asterisco) coincide con cualquier cosa.
El patrón coincide si éste ocurre en cualquier parte del valor que está siendo evaluado. (Los patrones SQL coinciden únicamente en los valores completos.)
Para indicar el inicio o el final de un valor que está siendo evaluado se usan los caracteres ^ y $ respectivamente.
Para demostrar como se usan las expresiones regulares, se van a mostrar los ejemplos presentados anteriormente con el operador LIKE, ahora con el operador REGEXP.

Para encontrar los nombre que inician con b:

mysql> SELECT * FROM mascotas WHERE nombre REGEXP "^b";
+--------+-------------+---------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+---------+------+------------+---------------+
| Buffy | Arnoldo | Perro | f | 1999-05-13 | NULL |
+--------+-------------+---------+------+------------+---------------+
1 row in set (0.01 sec)Antes de la versión 3.23.4 de MySQL, el operador REGEXP era sensible al uso de mayúsculas y minúsculas, así que dependiendo de la versión de MySQL con la que se está trabajando puede que obtengamos o no algún resultado en la consulta anterior. Se puede usar también la siguiente consulta para buscar los nombres que inician con la letra b, no importando si es mayúscula o minúscula.

mysql> SELECT * FROM mascotas WHERE nombre REGEXP "^[bB]";
+--------+-------------+---------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+---------+------+------------+---------------+
| Buffy | Arnoldo | Perro | f | 1999-05-13 | NULL |
+--------+-------------+---------+------+------------+---------------+
1 row in set (0.00 sec)Desde la versión 3.23.4, para forzar que el operador REGEXP sea sensible al uso de mayúsculas y minúsculas, se tiene que usar la palabra clave BINARY para hacer de una de las cadenas, una cadena binaria. Observar los resultados de la siguientes consultas.

mysql> SELECT * FROM mascotas WHERE nombre REGEXP BINARY "^b";
Empty set (0.00 sec)

mysql> SELECT * FROM mascotas WHERE nombre REGEXP BINARY "^B";
+--------+-------------+---------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+---------+------+------------+---------------+
| Buffy | Arnoldo | Perro | f | 1999-05-13 | NULL |
+--------+-------------+---------+------+------------+---------------+
1 row in set (0.01 sec)Para encontrar los nombres que finalizan con la palabra fy, haremos uso del caracter $.

mysql> SELECT * FROM mascotas WHERE nombre REGEXP "fy$";
+--------+-------------+---------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+---------+------+------------+---------------+
| Fluffy | Arnoldo | Gato | f | 1999-02-04 | NULL |
| Buffy | Arnoldo | Perro | f | 1999-05-13 | NULL |
+--------+-------------+---------+------+------------+---------------+
2 rows in set (0.00 sec)Para encontrar los nombres que contienen una letra s, la consulta sería:

mysql> SELECT * FROM mascotas WHERE nombre REGEXP "s";
+--------+-------------+-----------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+-----------+------+------------+---------------+
| Kaiser | Diana | Perro | m | 1989-08-31 | 1997-07-29 |
| Chispa | Omar | Ave | f | 1998-09-11 | NULL |
| Skim | Benito | Serpiente | m | 2001-04-29 | NULL |
| Pelusa | Diana | Hamster | f | 2000-03-30 | NULL |
+--------+-------------+-----------+------+------------+---------------+
4 rows in set (0.00 sec)

[Edypu]

BD: MySQL

Autor: MySQL AB
Traductor: MySQL Hispano

Pregunta: Conteo de filas
Respuesta:

Las bases de datos son usadas frecuentemente para responder una pregunta, "¿Con qué frecuencia ocurre un cierto tipo de dato en una tabla?". Por ejemplo, tal vez queremos conocer cuántas mascotas tenemos, o cuántas mascotas tiene cada uno de los propietarios.
Contar el número total de animalitos que tenemos es lo mismo que hacer la siguiente pregunta "¿Cuántas filas hay en la tabla mascotas?" ya que hay un registro por mascota. La función COUNT( ) es la que nos ayuda en esta situación.

mysql> SELECT COUNT(*) FROM mascotas;
+----------+
| COUNT(*) |
+----------+
| 9 |
+----------+
1 row in set (0.00 sec)Si deseamos conocer cuántas mascotas tiene cada uno de los propietarios, la consulta es la siguiente:

mysql> SELECT propietario, COUNT(*) FROM mascotas GROUP BY propietario ;
+-------------+----------+
| propietario | COUNT(*) |
+-------------+----------+
| Arnoldo | 2 |
| Benito | 2 |
| Diana | 2 |
| Juan | 1 |
| Omar | 1 |
| Tomás | 1 |
+-------------+----------+
6 rows in set (0.00 sec)Se debe notar que se ha usado una cláusula GROUP BY para agrupar todos los registros de cada propietario. Si no hacemos esto, obtendremos un mensaje de error:

mysql> SELECT propietario, COUNT(*) FROM mascotas;
ERROR 1140: Mixing of GROUP columns (MIN(),MAX(),COUNT()...) with no
GROUP columns is illegal if there is no GROUP BY clauseEn efecto, el uso de la función COUNT( ) en conjunto con la cláusula GROUP BY es muy útil en diversas situaciones. A continuación se muestran algunos ejemplos.

El número de animalitos por especie:

mysql> SELECT especie, COUNT(*) FROM mascotas GROUP BY especie ;
+-----------+----------+
| especie | COUNT(*) |
+-----------+----------+
| Ave | 2 |
| Gato | 2 |
| Hamster | 1 |
| Perro | 3 |
| Serpiente | 1 |
+-----------+----------+
5 rows in set (0.00 sec)El número de animalitos por sexo:

mysql> SELECT sexo, COUNT(*) FROM mascotas GROUP BY sexo:
+------+----------+
| sexo | COUNT(*) |
+------+----------+
| NULL | 1 |
| f | 4 |
| m | 4 |
+------+----------+
3 rows in set (0.01 sec)El número de animalitos por combinación de especie y sexo:

mysql> SELECT especie, sexo, COUNT(*) FROM mascotas GROUP BY especie, sexo ;
+-----------+------+----------+
| especie | sexo | COUNT(*) |
+-----------+------+----------+
| Ave | NULL | 1 |
| Ave | f | 1 |
| Gato | f | 1 |
| Gato | m | 1 |
| Hamster | f | 1 |
| Perro | f | 1 |
| Perro | m | 2 |
| Serpiente | m | 1 |
+-----------+------+----------+
8 rows in set (0.00 sec)No es necesario que se obtengan todos los datos de una tabla cuando se usa la función COUNT( ). Por ejemplo, en la consulta anterior, para ver únicamente los datos de perritos y gatitos, la consulta queda de la siguiente manera:

mysql> SELECT especie, sexo, COUNT(*) FROM mascotas
-> WHERE especie="Perro" OR especie="Gato"
-> GROUP BY especie, sexo;
+---------+------+----------+
| especie | sexo | COUNT(*) |
+---------+------+----------+
| Gato | f | 1 |
| Gato | m | 1 |
| Perro | f | 1 |
| Perro | m | 2 |
+---------+------+----------+
4 rows in set (0.00 sec)O bien, si deseamos el número de animalitos por sexo, y cuyo sexo es conocido:

mysql> SELECT especie, sexo, COUNT(*) FROM mascotas
-> WHERE sexo IS NOT NULL
-> GROUP BY especie, sexo ;
+-----------+------+----------+
| especie | sexo | COUNT(*) |
+-----------+------+----------+
| Ave | f | 1 |
| Gato | f | 1 |
| Gato | m | 1 |
| Hamster | f | 1 |
| Perro | f | 1 |
| Perro | m | 2 |
| Serpiente | m | 1 |
+-----------+------+----------+
7 rows in set (0.00 sec)

[Edypu]

BD: MySQL

Autor: MySQL AB
Traductor: MySQL Hispano

Pregunta: Usando mas de una table
Respuesta:

La tabla mascotas nos ha servido hasta este momento para tener guardados los datos acerca de los animalitos que tenemos. Si deseamos guardar algún otro tipo de información acerca de ellos, tal como los eventos en sus vidas -visitas al veterinario, nacimientos de una camada, etc-
necesitaremos de otra tabla. ¿Cómo deberá estar conformada esta tabla?. Lo que necesitamos es:

El nombre de la mascota para saber a cuál de ellas se refiere el evento.
Una fecha para saber cuando ocurrió el evento.
Una descripción del evento.
Un campo que indique el tipo de evento, si deseamos categorizarlos.
Dadas estas condiciones, la sentencia para crear la tabla eventos queda de la siguiente manera:

mysql> CREATE TABLE eventos(nombre varchar(20), fecha date,
-> tipo varchar(15), descripcion varchar(255));
Query OK, 0 rows affected (0.03 sec)De manera similar a la tabla mascotas, es más fácil cargar los datos de los registros iniciales al crear un archivo de texto delimitado por tabuladores en el que se tenga la siguiente información: nombre fecha tipo descripción

Fluffy 2001-05-15 camada 4 gatitos, 3 hembras, 1 macho
Buffy 2001-06-23 camada 5 perritos, 2 hembras, 3 machos
Buffy 2002-06-19 camada 2 perritos, 1 hembra, 1 macho
Chispa 2000-03-21 veterinario Una pata lastimada
FanFan 2001-08-27 cumpleaños Primera vez que se enfermo de la panza
FanFan 2002-08-03 veterinario Dolor de panza
Whicho 2001-02-09 cumpleaños Remodelación de casaCargamos los datos en este archivo con la siguiente sentencia:

mysql> LOAD DATA LOCAL INFILE "eventos.txt" INTO TABLE eventos;
Query OK, 7 rows affected (0.02 sec)
Records: 7 Deleted: 0 Skipped: 0 Warnings: 0Tomando en cuenta lo que hemos aprendido en la ejecución de consultas sobre la tabla mascotas, debemos de ser capaces de recuperar algunos datos de la tabla eventos; los principios son los mismos. Sin embargo puede suceder que la tabla eventos por sí misma sea insuficiente para darnos las respuestas que necesitamos.

Supongamos que desemos conocer la edad de cada mascota cuando tuvieron una camada. La tabla eventos indica cuando ocurrió dicho evento, pero para calcular la edad de la madre, necesitamos sin duda su fecha de nacimiento. Dado que este dato está almacenado en la tabla mascotas, necesitamos de ambas tablas para realizar esta consulta.

mysql> SELECT mascotas.nombre,
-> (TO_DAYS(fecha) - TO_DAYS(nacimiento))/365 AS edad,
-> descripcion FROM mascotas, eventos
-> WHERE mascotas.nombre=eventos.nombre
-> AND tipo='camada';
+--------+------+---------------------------------+
| nombre | edad | descripcion |
+--------+------+---------------------------------+
| Fluffy | 2.28 | 4 gatitos, 3 hembras, 1 macho |
| Buffy | 2.12 | 5 perritos, 2 hembras, 3 machos |
| Buffy | 3.10 | 2 perritos, 1 hembra, 1 macho |
+--------+------+---------------------------------+
3 rows in set (0.05 sec)Hay diversas cosas que notar acerca de esta consulta:

La cláusula FROM lista dos tablas dado que la consulta necesita información que se encuentra en ambas tablas.
Cuando se combina (junta) información de múltiples tablas, es necesario especificar los registros de una tabla que pueden coincidir con los registros en la otra tabla. En nuestro caso, ambas columnas tienen una columna "nombre". La consulta usa la cláusula WHERE para obtener los registros cuyo valor en dicha columna es el mismo en ambas tablas.
Dado que la columna "nombre" ocurre en ambas tablas, debemos de especificar a cuál de las columnas nos referimos. Esto se hace al anteponer el nombre de la tabla al nombre de la columna.
Nota: La función TO_DAYS( ) regresa el número de días transcurridos desde el año 0 hasta la fecha dada.

No es necesario que se tengan dos tablas diferentes para que se puedan juntar. Algunas veces es útil juntar una tabla consigo misma si se desean comparar registros de la misma tabla. Por ejemplo, para encontrar las posibles parejas entre nuestras mascotas de acuerdo a la especie, la consulta sería la siguiente:

mysql> SELECT m1.nombre, m1.sexo, m2.nombre, m2.sexo, m1.especie
-> FROM mascotas AS m1, mascotas AS m2
-> WHERE m1.especie=m2.especie AND m1.sexo="f" AND m2.sexo="m";
+--------+------+--------+------+---------+
| nombre | sexo | nombre | sexo | especie |
+--------+------+--------+------+---------+
| Fluffy | f | Mau | m | Gato |
| Buffy | f | FanFan | m | Perro |
| Buffy | f | Kaiser | m | Perro |
+--------+------+--------+------+---------+
3 rows in set (0.00 sec)En esta consulta se ha especificado un alias para el nombre de la tabla, y es éste el que se utiliza para referirse a las columnas.

[Edypu]

BD: MySQL

Autor: MySQL AB
Traductor: MySQL Hispano

Pregunta: usando MySql en modo Batch
Respuesta:

En todos los ejemplos mostrados anteriormente, hemos usado mysql de manera interactiva para ejecutar algunas consultas y ver los resultados. Sin embargo, es posible usar mysql en modo batch. Para hacer esto tenemos que poner los comandos que deseamos ejecutar dentro de un archivo, y entonces decirle a mysql que lea los comandos de dicho archivo:
shell> mysql < archivo-batchSi se usa mysql de esta manera, se está creando un pequeño script, y posteriormente se está ejecutando dicho script. Al ejecutar las sentencias y comandos que se encuentran en el script, es posible que suceda algún error.
Si se desea que se continuen ejecutando las demás sentencias, a pesar de que haya ocurrido un error, se tiene que usar la opción --force
shell> mysql --force < archivo-batchAsí mismo, es posible especificar los parámetros de conexión desde la línea de comandos. Por ejemplo:shell> mysql -h casita -u blueman -p < archivo-batch
¿Por qué usar un script?

Aquí hay algunas cuantas razones:

Si se ejecutan un cierto número de consultas frecuentemente (cada día, o cada semana), al hacer un script nos evitamos tener que volver a teclear cada una de las consultas.
Se pueden generar nuevas consultas que sean similares a las existentes al copiar y editar estos scripts.
Al escribir consultas de varias líneas, los scripts ayudan bastante para que no se tengan que escribir todas las líneas nuevamente si se comete algún error.
Si se están ejecutando consultas que producen una gran cantidad de datos, es posible usar un paginador para examinar los resultados de una mejor manera.
shell> mysql < archivo-batch | lessSe puede guardar la salida en un archivo para revisarla posteriormente.
shell> mysql < archivo-batch > salida-del-script.txtSe pueden distribuir los scripts a otras personas para que puedan ejecutar también nuestros comandos y sentencias.
En algunas situaciones no se permite el uso interactivo de mysql. Por ejemplo cuando se ejecuta un cron. En este caso, es indispensable usar el modo batch.
Cabe mencionar que el formato de la salida es diferente (más conciso) cuando se ejecuta mysql en modo batch, que cuando se usa de manera interactiva.

Ver el siguiente ejemplo.

La consulta es: SELECT DISTINCT especie FROM mascotas.

Si se ejecuta en modo interactivo:

mysql> SELECT DISTINCT especie FROM mascotas;
+-----------+
| especie |
+-----------+
| Gato |
| Perro |
| Ave |
| Serpiente |
+-----------+
4 rows in set (0.00 sec)Si se ejecuta en modo batch:

shell> mysql -h casita -u blueman -p < especies-distintas.sql
Enter password: ******
especie
Gato
Perro
Ave
SerpienteDonde el fichero especies-distintas.sql contiene la consulta a ejecutar. Si se desea obtener la salida que proporciona el modo interactivo, se tiene que usar la opción -t.

shell> mysql -t -h casita -u blueman -p < especies-distintas.sql
Enter password: ******
+-----------+
| especie |
+-----------+
| Gato |
| Perro |
| Ave |
| Serpiente |
+-----------+

[Phaedo]

Hola!!
el comando select funciona de la siguiente manera:

SELECT nombre_campo1,nombre_campo2,.... FROM tabla WHERE condicion_que_desees_cumplir ORDER BY nombre_campo(1,2,3,..) ASC (si quieres que sea ascendente) o DESC (si quieres que sea descendente)

Recuerda que para poder ordenarlo por un campo cualquiera, debes seleccionarlo previamente después del SELECT i que si quieres seleccionar todos los campos de la tabla, basta con poner * después del SELECT.

Espero que te ayude.

[sir_joshua]

BD: Oracle

Preguna: Como instalo la base de datos oracle..?

Respuesta: eso depende de sobre que plataforma la quieras instalar, pero pues podrias consultar las guias que hay en :

http://www.oracle-base.com/articles/...gInstallations

y ahi ver los requisitos necesarios y pasos a seguir.... salu2.

[sir_joshua]

BD: ORACLE

PREGUNTA: COMO CREAR UN CAMPO AUTO NUMERICO..?

RESPUESTA:

create table tbl_foo(
id number primary key,
txt varchar2(20)
);

create sequence seq_foo;

create trigger trg_foo
before insert on tbl_foo
for each row
begin
select seq_foo.nextval into :new.id from dual;
end;
/

insert into tbl_foo (txt) values('bar');
insert into tbl_foo (txt) values('baz');
insert into tbl_foo (txt) values('qqq');

select * from tbl_foo;
ID TXT
---------- --------------------
1 bar
2 baz
3 qqq


Ya esta! Ahora, trata de especificar un id arbitrariamente:

insert into tbl_foo (id, txt) values(100, '###');
insert into tbl_foo (id, txt) values(200, '???');
insert into tbl_foo (id, txt) values(300, '!!!');

No funciona, porke es sobre escrito por el trigger!

select * from tbl_foo;
ID TXT
---------- ----------------------------------------------------------------------------------------------------
1 bar
2 baz
3 qqq
4 ###
5 ???
6 !!!

Cambiando el trigger ...

create or replace trigger trg_foo
before insert on tbl_foo
for each row
begin
if :new.id is null then
select seq_foo.nextval into :new.id from dual;
end if;
end;
/

.... Trata otra ves:

insert into tbl_foo (id, txt) values(111, 'This');
insert into tbl_foo (id, txt) values(222, 'should');
insert into tbl_foo (id, txt) values(333, 'work');

De verdad funciona...

select * from tbl_foo;

ID TXT
---------- --------------------------------------
1 bar
2 baz
3 qqq
4 ###
5 ???
6 !!!
111 This
222 should
333 work

[GeoAvila]

Como quitar la contraseña al root de MySQL:

He perdido la contraseña del root
Si has perdido la contraseña que usas como root, es decir, para administrar MySQL, puedes establecer otra, usando el mismo ordenador donde físicamente está instalado el daemon:

Apaga el servidor
Inicia el servidor con la opción --skip-grant-tables.
Conecta con el servidor usando mysql -u root mysql. Con eso no te pedira la password y accederas directamante a la base de datos MySQL que es la que guarda la informacion de usuarios.
cambia la contraseña usando este comando SQL:
mysql> UPDATE user SET Password=PASSWORD('') WHERE User='root';
Ejecuta un nuevo comando SQL:
mysql> FLUSH PRIVILEGES;
Apaga y reinicia el servidor y ya podras usar la nueva password
--------------------------------------------------------------------

[DoKyE]

Como puedo eliminar los registros que tienen valor nulo en una consulta por ejemplo
Select nombre_alumno notas_historia, notas_castellano, notas_ingles where id_alumno= '1' order by id_nota.

me mostrará las notas de 3 ramos, todo OK, el problema es que cuando hagola consulta me muestra espacios entre las notas de los ramos( debe ser por el orden de ingreso, porque primero ingreso todaslas notas de historia depsues todas las de castellano y depues todas las de ingles, y me muestra algo asi:

notas_historia---notas_castellano---notas_ingles
____60____
____36____
____57____
____________________30_____
____________________55_____
____________________60_____
____________________________________64
____________________________________58


Como puedo hacer la consulta para que me muestre la consulta asi:

notas_historia---notas_castellano---notas_ingles
____60_____________30_____________64
____36_____________55_____________58
____57_____________60


sin espacios entre ellas.
Saludos

[metacortex]

Tema:
Manual de Instalación para snort+MySQL+PHP+ACID+IIS en Windows

Ubicación del manual:
http://www.forohxc.com/snort/mswin/s...lugins.win.pdf (25 pág.)

[elangelcaido]

BD: MySQL
Tema: Tabla con todos los paises
Como a mi me llevo mucho trabajo pues para que otros no tengan que currar lo ya currado. Os pongo una tabla (sencilla) en la que se guardan los nombres de todos los paises (puede que me falte alguno )

Código:

CREATE TABLE pais(
id_pais int not null auto_increment PRIMARY KEY,
nombre_pais varchar(100) not null
);

Y ahora el volcado de datos:

Código:

INSERT INTO pais(id_pais,nombre_pais) VALUES('','Afghanistan');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Albania');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Algeria');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Angola');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Antigua Barbuda');	
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Argentina');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Armenia');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Azerbaijan');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Bahamas');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Bahrain');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Bangladesh');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Barbados');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Belarus');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Belize');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Benin');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Bhutan');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Bolivia');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Bosnia and Herzegovina');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Botswana');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Brazil');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Bulgaria');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Burkina Faso');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Burundi');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Cambodia');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Cameroon');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Cape Verde');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Central African Republic');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Chad');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Chile');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','China');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Colombia');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Comoros');
INSERT INTO pais(id_pais,nombre_pais) VALUES('','Democratic Rep. of Congo');

Si hacéis una tabla difrente a la que os puse de ejemplo, para poder usar todos estos inserts que os puse podéis usar un procesador de textos (como EMACS) y "reemplazar" los campos o lo que queráis.