Ir al contenido principal

Sentencias SQL 2

Imagen
Publicadas por raicerk

Hola amigos esta vez les traigo la segunda parte de sentencias SQL, en esta ocacion veremos un análisis mas profundo de algunas estructuras y su utilización

Crear una base de datos

SQL:
CREATE DATABASE pruebas;
Usar una base de datos
PLAIN TEXT
SQL:
USE pruebas;
mysql> use prueba;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A
Ver estructura de una tabla de datos
PLAIN TEXT
SQL:
DESCRIBE Alumnos ;
mysql> describe alumnos;
+-----------+-------------+------+-----+---------+-------+| Field | Type | Null | Key | Default | Extra |
+-----------+-------------+------+-----+---------+-------+| Id | int(11) | YES | | 0 | |
| nombre | varchar(10) | YES | | NULL | |
| apellidos | varchar(30) | YES | | NULL | |
| tlfn | int(10) | YES | | NULL | |
+-----------+-------------+------+-----+---------+-------+4 rows in set (0.00 sec)
mysql>
Ver tablas de datos
SQL:
SHOW TABLES;
mysql> show tables;
+------------------+| Tables_in_prueba |
+------------------+| Notas |
| alumnos |
| mascotas |
+------------------+3 rows in set (0.00 sec)
Borrar tabla de datos
PLAIN TEXT
SQL:
DROP Notas;
Crear una tabla de datos
PLAIN TEXT
SQL:
CREATE TABLE Alumnos(
id INT NOT NULL,
nombre VARCHAR (10) NOT NULL,
apellido VARCHAR (10) NOT NULL,
telefono LONG,
CONSTRAINT alumnosPk1 PRIMARY KEY (id)
);
CREATE TABLE Notas(
id INT NOT NULL,
modulo VARCHAR (10) NOT NULL,
parcial INT NOT NULL,
nota INT NOT NULL CHECK (VALUE BETWEEN 1 AND 10),
CONSTRAINT notasPk1 PRIMARY KEY (id, modulo),
CONSTRAINT notasfk1 FOREIGN KEY (id) REFERENCES Alumnos(id)
);
Insertar datos en una tabla de datos
PLAIN TEXT
SQL:
INSERT INTO Alumnos VALUES(�1',�juan�,�garcia�,�949494949');
Visualizar datos en una tabla de datos
PLAIN TEXT
SQL:
SELECT * FROM Alumnos;
Visualizar datos seleccionados en una tabla de datos
Usamos la sentencia WHERE:
PLAIN TEXT
SQL:
SELECT * FROM Alumnos
WHERE (id> 5 AND (nombre=�alberto�);
mysql> SELECT * FROM alumnos WHERE id < 5 AND nombre="Alberto";
+------+---------+-------------------+-----------+| Id | nombre | apellidos | tlfn |
+------+---------+-------------------+-----------+| 1 | Alberto | Jimenez********** | 67922**** |
+------+---------+-------------------+-----------+1 row in set (0.00 sec)
Visualizar datos seleccionados en una tabla de datos, por orden
Usamos la sentencia ORDER BY, si no indicamos par�metros es ascendente, el contrario es DESC
PLAIN TEXT
SQL:
SELECT apellido, nombre
FROM Alumnos
ORDER BY apellido, nombre
;
Visualizar datos seleccionados en una tabla de datos:
AND Y OR
Ejemplo con AND y OR:
PLAIN TEXT
SQL:
SELECT Alumnos.id, nombre, apellido, telefono, modulo, parcial, nota
FROM Alumnos,Notas
WHERE ((Alumnos.id = Notas.id) AND (modulo LIKE �sistemas�)) OR ((modulo LIKE �analisis�) AND (nota> 5))
ORDER BY Alumnos.id,modulo;
Visualizar datos seleccionados en una tabla de datos sin repetirse
Usamos la sentencia DISTINCT:
PLAIN TEXT
SQL:
SELECT DISTINCT modulo
FROM Notas
WHERE nota> 5;
Visualizar datos seleccionados en una tabla de datos cont�ndolos
Usamos la sentencia COUNT:
PLAIN TEXT
SQL:
SELECT COUNT(nota)
FROM Notas;
mysql> select count(nota) FROM Notas;
+-------------+| count(nota) |
+-------------+| 8 |
+-------------+1 row in set (0.03 sec)
Renombrar nombre de tablas �alias�Usamos la sentencia AS:
PLAIN TEXT
SQL:
SELECT modulo,avg(nota) AS media
FROM Notas AS n
WHERE n.id=3 OR n.id=1 OR n.id=2
GROUP BY modulo
ORDER BY media DESC;
+--------+--------+| modulo | media |
+--------+--------+| ASI | 9.0000 |
| DAI | 7.7143 |
+--------+--------+2 rows in set (0.05 sec)
Visualizar datos seleccionados en una tabla de datos, su m�ximo, m�nimo, media y suma
Usamos las sentencias MAX, MIN ,AVG y SUM:
PLAIN TEXT
SQL:
SELECT MAX(nota)
FROM Notas
WHERE id=1;
SELECT AVG(nota)
FROM Notas
WHERE id=1;
SELECT MIN(nota)
FROM Notas;
SELECT AVG(nota) AS media
FROM Notas
WHERE modulo = �analisis�;
SELECT SUM(nota) AS Suma
FROM Notas;
Borrar datos de una tabla
PLAIN TEXT
SQL:
DELETE * FROM Notas WHERE condicion;
PLAIN TEXT
SQL:
DELETE * FROM Notas WHERE condicion;
SELECT a.id, a.nombre, n.modulo, n.nota
FROM Alumnos a ,Notas n
WHERE a.id = n.id ;
Sentencia LIKE
En entornos no unix los operandos especiales son: * y ?
* Una o varias apariciones
? Una o ninguna apariciones
En entornos unix: % y _
% Una o varias apariciones
_ Una o ninguna apariciones
PLAIN TEXT
SQL:
SELECT *
FROM Alumnos,Notas
WHERE Alumnos.id = Notas.id AND modulo LIKE �%sistemas� OR modulo LIKE �00_%Diurno�ORDER BY apellido;
mysql> select nombre from Personas where nombre like "%, J%";
+---------------------+| nombre |
+---------------------+| HERRERO, JOSE |
| DE LA ROSA, JULIAN |
| FERNANDEZ, JUAN |
| MOTOS, JUAN |
| ARNAZ, JOSE ANTONIO |
+---------------------+5 rows in set (0.02 sec)
Operando b�sicos
< Menor que
> Mayor que
>= Mayor o igual
<= Menor o igual
!= Distinto de
Sentencia SubStr e InStr
SubStr se usa para seleccionar una determinada cadena de texto, por el contrario InStr devuelve un n�mero entero donde encuentra el caracter buscado dentro de una cadena de texto.
PLAIN TEXT
SQL:
SELECT SUBSTR(nombre, INSTR(nombre, �,�)+2) Nombre
FROM Personas;
mysql> SELECT SUBSTR(nombre, INSTR(nombre, ',')+2) Nombre
-> FROM Personas;
+--------------+| Nombre |
+--------------+| CARLOS |
| ALVARO |
| GUILLERMO |
| SANTIAGO |
...
| JOSE ANTONIO |
| PABLO |
+--------------+47 rows in set (0.40 sec)
Sentencia Between
Para evitar hacer repeticiones tales como:
� AND ((nota >= 5) AND (nota <= 8));
Se usa between:
PLAIN TEXT
SQL:
SELECT nombre, apellido, modulo, nota
FROM Alumnos, Notas
WHERE (Notas.id = Alumnos.id) AND (nota BETWEEN 5 AND 8);
Sentencia Round
Sirve para redondear, le podemos indicar cuantos decimales incluiremos.
PLAIN TEXT
SQL:
SELECT ROUND(AVG(importe), 2)
FROM Multas;
mysql> select ROUND(AVG(importe),2) REDONDEO from Multas;
+----------+| REDONDEO |
+----------+| 199.09 |
+----------+1 row in set (0.00 sec)
Sentencia Count
Sirve para contar. Podemos usar el * para que el motor nos escoja la opci�n o ponerlos nosotros mismos.
PLAIN TEXT
SQL:
SELECT count(*) �NUMERO DE MULTAS�FROM Multas;
mysql> select count(ref) "NUMERO DE MULTAS" from Multas;
+------------------+| NUMERO DE MULTAS |
+------------------+| 35 |
+------------------+1 row in set (0.00 sec)
Subselects con IN o NOT IN
Podemos hacer subselects en una misma l�nea pudiendo restringir mucho m�s los datos a seleccionar:
PLAIN TEXT
SQL:
SELECT DISTINCT nombre, apellido
FROM Alumnos
WHERE id IN ( SELECT DISTINCT id
FROM Notas
WHERE nota>=5 ) ;
PLAIN TEXT
SQL:
SELECT nombre,apellido
FROM Alumnos AS A, Notas AS N
WHERE (A.id = N.id) AND (N.nota> ( SELECT AVG(nota) FROM Notas ) ) ;
Si necesitamos hacer muchas selecciones como IN solo devuelve un campo tenemos que hacer GROUP BY:
PLAIN TEXT
SQL:
SELECT MAX(resultado.Suma) AS Maximo
FROM (SELECT modulo, SUM(nota) AS Suma
FROM Notas
GROUP BY modulo) resultado ;

Esperando les haya gustado,investigare nuevas estructuras de datos y consultas y las pondré en en una nueva publicación, nos venos, hasta la próxima programadores.

Y recuerden, para cualquier duda u comentario no olviden escribir en nuestro Twitter @pgramadores o en nuestro Facebook www.facebook.com/pgramadores

 

Etiquetas

Etiquetas:

Entradas más populares de este blog

Pares e impares en C#

Publicadas por raicerk
Hola amigos, hoy comentare un poco de como realizar dos operaciones matemáticas que nos ayudaran en varias cosas o requerimientos en la programacion de un software. Veremos como calcular y el comparar si un numero es par o impar. Para esto usamos el algoritmo básico de una división que nos dice, Al dividir un numero n, si el resto de la división es un 0, el numero n es un par y si es 1 entonces es impar. Como podemos realizar la misma tres matemática en programacion! De la siguiente manera Tenemos : Int n = 2; If( n% 2 == 0) { Console.WriteLine(" el numero "+n+" es par"); } Else { Console.WriteLine(" el numero "+n+" es impar"); } Console.ReadKey( ); El porcentaje dentro del if, evalúa la operación, esa operación o símbolo es conocido como mod, el mod de una división es el residuo de la misma operación y como vimos anteriormente para ver si un numero es par o impar necesitábamos saber si su residuo era 1 u 0. Realicen...
Leer más

Switch y Case en C#

Publicadas por raicerk
Switch es una estructura condicional que compara una variable con una lista de posibles resultados y, cuando esta coincide, ejecuta el código que se encuentra dentro de la opción,  se puede utilizar para generar pequeños menús dentro de una aplicación, como ya vimos en publicaciones anteriores, también funciona como validador. Por ejemplo: static void Main( string [] args) { Console .WriteLine( "Elija una opcion" ); //Mensajes en pantalla Console .WriteLine( "" ); //creo un salto de linea para que se vea mas ordenada la pantalla Console .WriteLine( "****** 1 *****" ); Console .WriteLine( "****** 2 *****" ); Console .WriteLine( "" ); Console .Write( "Ingrese el numero de su opcion: " ); int opcion = Convert .ToInt32( Console .ReadLine()); //declaro una variable y le paso como parametro lo que escriba el usuario Console .WriteLine( "" ); switch (opcion) //ultilizo la variable para la opci...
Leer más

Stack (Pila) en C#

Publicadas por
Haca les traigo un nuevo código, les daré una breve explicación de que es el "Stack" en ingles o "Pila" en español. Una pila (stack en inglés) es una estructura de datos de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Se aplica en multitud de ocasiones en informática debido a su simplicidad y ordenación implícita en la propia estructura. En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objeto apilado (denominado TOS, top of stack en inglés). La operación retirar permite la obtención de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con anterioridad), que pasa a ser el nuevo TOS. Por analogía con objetos cotidianos, una operación apilar equivaldría a colocar un plato sobre una pila de platos, y una operación retirar a retirarlo. Las pilas suelen emplearse en los siguientes contextos: Evaluación de expresio...
Leer más